python——socket编程
一 客户端/服务器架构
1.硬件C/S架构(打印机)
2.软件C/S架构
C/S架构：客户端(client)/服务端(server)架构
互联网中处处是C/S架构
如黄色网站是服务端，你的浏览器是客户端（B/S架构也是C/S架构的一种）
腾讯作为服务端为你提供视频，你得下个腾讯视频客户端才能看它的视频）
软件CS架构：浏览器，qq,微信等
硬件CS架构：打印机
3.B/S架构
浏览器(browser)/服务端(server)架构
C/S架构和B/S架构区别：https://www.cnblogs.com/limengda/p/10482526.html
C/S架构与socket的关系：
我们学习socket就是为了完成C/S架构的开发
二 网络通信的整个流程
还记得上面我说过的那个'网'吗，在这一节就给大家讲解，有些同学对网络是既熟悉又陌生，熟悉是因为我们都知道，我们安装一个路由器，拉一个网线，或者用无限路由器，连上网线或者连上wifi就能够上网购物、看片片、吃鸡了，但是这一系列的神操作到底是怎么让我们上网了呢？让我们起底揭秘！由于网络的内容非常的多，本篇博客主要是学socket网络编程，所以我把网络这方面的内容放到了我另外一篇博客上，这个博客很简单，不是什么深入研究类的博客，没有学过网络的或者说对网络不太熟悉的同学可以去看看，地址是https://blog.csdn.net/zangba9624/article/details/114008653，有网络基础的同学，可以直接往下面学习，如果你自认上学时是个学渣，也可以过去大致溜一眼~~~将来你面向的是开发，所有网络这一块对你来讲就是大致知道就可以了，但是以后想在技术上有深造，那么就需要你深入的研究一下网络了，内容非常多，学海无涯~~
别忘了端口+IP能够确定一台电脑上的某一个应用程序~~
三 网络通信的整个流程
那么我们通过下面的代码简单看一下socket到底是个什么样子
实例1：
服务端：
import socket
server = socket.socket() # 创建socket对象，创建了一个手机
ip_port = ('10.64.29.55', 5000) # 给程序设置一个ip地址和端口号，插卡
server.bind(ip_port) # 绑定ip地址和端口，插卡
server.listen() # 监听ip地址和端口，简称开机
conn, addr = server.accept() # 等待建立连接 conn是连接通道，addr是客户端的地址
from_client_mag = conn.recv(1024) # 服务端通过conn连接来收发消息，通过recv方法，recv里面的参数是字节（B），1024B=1KB
print(from_client_mag)
conn.send(b'helli,client') # 回复消息，通过send方法，由于接收的消息是字节类型的，所以也要发送字节类型的
conn.close() # 关闭通道
server.close() # 关闭socket对象，关机客户端：
import socket
client = socket.socket() # 创建socket对象，创建了一个手机
server_ip_port = ('10.64.29.55', 5000) # 找到服务端的ip地址和端口号
client.connect(server_ip_port) #连接服务端的应用程序，通过connect方法，参数是服务端的ip地址和端口，打电话
client.send(b'hello') #发消息，用send方法，但是调用者是clent的socket对象
from_server_msg=client.recv(1024)
print(from_server_msg)
client.close()实例2，实例1传输的是字节，实例2传输的是中文，需要utf-8编解码
服务端：
import socket
server = socket.socket() # 创建socket对象，创建了一个手机
ip_port = ('10.64.29.55', 5000) # 给程序设置一个ip地址和端口号，插卡
server.bind(ip_port) # 绑定ip地址和端口，插卡
server.listen() # 监听ip地址和端口，简称开机
conn, addr = server.accept() # 等待建立连接 conn是连接通道，addr是客户端的地址，阻塞程序
from_client_msg = conn.recv(1024) # 服务端通过conn连接来收发消息，通过recv方法，recv里面的参数是字节（B），1024B=1KB
print('慧说：',from_client_msg.decode('utf-8'))
to_client_msg = input('尤说:')
conn.send(to_client_msg.encode('utf-8')) # 回复消息，通过send方法，由于接收的消息是字节类型的，所以也要发送字节类型的
conn.close() # 关闭通道
server.close() # 关闭socket对象，关机客户端
import socket
client = socket.socket() # 创建socket对象，创建了一个手机
server_ip_port = ('10.64.29.55', 5000) # 找到服务端的ip地址和端口号
client.connect(server_ip_port) #连接服务端的应用程序，通过connect方法，参数是服务端的ip地址和端口，打电话
to_server_msg = input('慧说:')
client.send(to_server_msg.encode('utf-8'))
client.send(b'hello') #发消息，用send方法，但是调用者是clent的socket对象
from_server_msg=client.recv(1024)
print('尤说：',from_server_msg.decode('utf-8'))
client.close()注意：先运行server，然后再运行client，然后你会发现client这个文件再输出台的地方让你输入内容，你输入一个内容然后回车，你会发现server那边的控制台就输出了以client发送的内容
练习题
==============================================
1.server端：接收时间戳时间，转换成格式化时间
client端：每隔10秒中把时间戳发给server端，time.time()
server端
import socket
import time
server = socket.socket() # 创建socket对象，创建了一个手机
ip_port = ('10.64.29.55', 5000) # 给程序设置一个ip地址和端口号，插卡
server.bind(ip_port) # 绑定ip地址和端口，插卡
server.listen() # 监听ip地址和端口，简称开机
conn, addr = server.accept() # 等待建立连接 conn是连接通道，addr是客户端的地址
while 1:
from_client_mag = conn.recv(1024) # 服务端通过conn连接来收发消息，通过recv方法，recv里面的参数是字节（B），1024B=1KB
time_strf = time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(float(from_client_mag.decode('utf-8'))))
print(time_strf)客户端
import socket
import time
client = socket.socket() # 创建socket对象，创建了一个手机
server_ip_port = ('10.64.29.55', 5000) # 找到服务端的ip地址和端口号
client.connect(server_ip_port) #连接服务端的应用程序，通过connect方法，参数是服务端的ip地址和端口，打电话
while 1:
client.send(str(time.time()).encode('utf-8')) #发消息，用send方法，但是调用者是clent的socket对象
time.sleep(10)
client.close() 2. 一直对话的程序
server收一个发一个
client发一个收一个
四 网络通信协议(互联网协议)
网络通信协议是网络传输的灵魂，非常重要，协议即准则，准则是传输消息的格式要求，那么我们从电脑上发出一个消息，到底是以什么样的消息格式发到了对方的手上呢，来看一看这里>>>，https://blog.csdn.net/zangba9624/article/details/114077737
五 socket
结合上图来看，socket在哪一层呢，我们继续看下图
socket在内的五层通讯流程：
Socket又称为套接字，它是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。当我们使用不同的协议进行通信时就得使用不同的接口，还得处理不同协议的各种细节，这就增加了开发的难度，软件也不易于扩展(就像我们开发一套公司管理系统一样，报账、会议预定、请假等功能不需要单独写系统，而是一个系统上多个功能接口，不需要知道每个功能如何去实现的)。于是UNIX BSD就发明了socket这种东西，socket屏蔽了各个协议的通信细节，使得程序员无需关注协议本身，直接使用socket提供的接口来进行互联的不同主机间的进程的通信。这就好比操作系统给我们提供了使用底层硬件功能的系统调用，通过系统调用我们可以方便的使用磁盘（文件操作），使用内存，而无需自己去进行磁盘读写，内存管理。socket其实也是一样的东西，就是提供了tcp/ip协议的抽象，对外提供了一套接口，同过这个接口就可以统一、方便的使用tcp/ip协议的功能了。
其实站在你的角度上看，socket就是一个模块。我们通过调用模块中已经实现的方法建立两个进程之间的连接和通信。也有人将socket说成ip+port，因为ip是用来标识互联网中的一台主机的位置，而port是用来标识这台机器上的一个应用程序。 所以我们只要确立了ip和port就能找到一个应用程序，并且使用socket模块来与之通信。
六 套接字socket的发展史及分类
套接字起源于 20 世纪 70 年代加利福尼亚大学伯克利分校版本的 Unix,即人们所说的 BSD Unix。 因此,有时人们也把套接字称为“伯克利套接字”或“BSD 套接字”。一开始,套接字被设计用在同 一台主机上多个应用程序之间的通讯。这也被称进程间通讯,或 IPC。套接字有两种（或者称为有两个种族）,分别是基于文件型的和基于网络型的。
基于文件类型的套接字家族
套接字家族的名字：AF_UNIX
unix一切皆文件，基于文件的套接字调用的就是底层的文件系统来取数据，两个套接字进程运行在同一机器，可以通过访问同一个文件系统间接完成通信
基于网络类型的套接字家族
套接字家族的名字：AF_INET
(还有AF_INET6被用于ipv6，还有一些其他的地址家族，不过，他们要么是只用于某个平台，要么就是已经被废弃，或者是很少被使用，或者是根本没有实现，所有地址家族中，AF_INET是使用最广泛的一个，python支持很多种地址家族，但是由于我们只关心网络编程，所以大部分时候我们只使用AF_INET)
七、基于TCP和UDP两个协议下socket的通讯流程
1.套接字工作流程
一个生活中的场景。你要打电话给一个朋友，先拨号，朋友听到电话铃声后提起电话，这时你和你的朋友就建立起了连接，就可以讲话了。等交流结束，挂断电话结束此次交谈。 生活中的场景就解释了这工作原理。
图3
先从服务器端说起。服务器端先初始化Socket，然后与端口绑定(bind)，对端口进行监听(listen)，调用accept阻塞，等待客户端连接。在这时如果有个客户端初始化一个Socket，然后连接服务器(connect)，如果连接成功，这时客户端与服务器端的连接就建立了。客户端发送数据请求，服务器端接收请求并处理请求，然后把回应数据发送给客户端，客户端读取数据，最后关闭连接，一次交互结束
socket()模块函数用法
socket()函数
1 import socket
2 socket.socket(socket_family,socket_type,protocal=0)
3 socket_family 可以是 AF_UNIX 或 AF_INET以确定协议簇。socket_type 可以是 SOCK_STREAM 或 SOCK_DGRAM，以确定是tcp还是UDP。protocol 一般不填,默认值为 0。
4
5 获取tcp/ip套接字
6 tcpSock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) #socket.SOCK_STREAM是面向流的，TCP协议
7
8 获取udp/ip套接字
9 udpSock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
10
11 由于 socket 模块中有太多的属性。我们在这里破例使用了'from module import *'语句。使用 'from socket import *',我们就把 socket 模块里的所有属性都带到我们的命名空间里了,这样能 大幅减短我们的代码。
12 例如tcpSock = socket(AF_INET, SOCK_STREAM)各个参数的含义见https://blog.csdn.net/mpp_king/article/details/80222304
服务端套接字函数 s.bind() 绑定(主机,端口号)到套接字 s.listen() 开始TCP监听 s.accept() 被动接受TCP客户的连接,(阻塞式)等待连接的到来 客户端套接字函数 s.connect() 主动初始化TCP服务器连接 s.connect_ex() connect()函数的扩展版本,出错时返回出错码,而不是抛出异常 公共用途的套接字函数 s.recv() 接收TCP数据 s.send() 发送TCP数据(send在待发送数据量大于己端缓存区剩余空间时,数据丢失,不会发完) s.sendall() 发送完整的TCP数据(本质就是循环调用send,sendall在待发送数据量大于己端缓存区剩余空间时,数据不丢失,循环调用send直到发完) s.recvfrom() 接收UDP数据 s.sendto() 发送UDP数据，note:sendto()函数和send()函数的不同在于，sendto()第二个参数是recvfrom()返回的第二个参数即地址 s.getpeername() 连接到当前套接字的远端的地址 s.getsockname() 当前套接字的地址 s.getsockopt() 返回指定套接字的参数 s.setsockopt() 设置指定套接字的参数 s.close() 关闭套接字 面向锁的套接字方法 s.setblocking() 设置套接字的阻塞与非阻塞模式 s.settimeout() 设置阻塞套接字操作的超时时间 s.gettimeout() 得到阻塞套接字操作的超时时间 面向文件的套接字的函数 s.fileno() 套接字的文件描述符 s.makefile() 创建一个与该套接字相关的文件
2.TCP和UDP对比
TCP（Transmission Control Protocol）可靠的、面向连接的协议（eg:打电话）、传输效率低全双工通信（发送缓存&接收缓存）、面向字节流。使用TCP的应用：Web浏览器；文件传输程序。
UDP（User Datagram Protocol）不可靠的、无连接的服务，传输效率高（发送前时延小），一对一、一对多、多对一、多对多、面向报文(数据包)，尽最大努力服务，无拥塞控制。使用UDP的应用：域名系统 (DNS)；视频流；IP语音(VoIP)。
直接看图对比其中差异
继续往下看
TCP和UDP下socket差异对比图：
上面的图只是让大家感受一下TCP和UDP协议下，socket工作流程的不同，两者之间的差异是tcp需要连接，udp不需要，有些同学是不是有些迷糊，老师，这里面的bind、listen啥的都是什么东西啊，我感觉人生是迷茫的！calm down！下面我们就分开两者，细细学习！
3.TCP协议下的socket
来吧！先上图！
基于TCP的socket通讯流程图片：
对应代码段：
*****tcp server流程
import socket
server = socket.socket() #创建服务器套接字
ip_port = ('ip', port) # 给程序设置一个ip地址和端口号，插卡
server.bind(ip_port) # 绑定ip地址和端口，插卡
server.bind() #把地址绑定到套接字
server.listen() #监听链接
inf_loop: #服务器无限循环
conn = server.accept() #接受客户端链接
comm_loop: #通讯循环
conn.recv(BUFER_SIZE)/conn.send(to_client_msg.decode('utf-8')) #对话(接收与发送)
if condition： #退出循环
break
conn.close() #关闭客户端套接字
server.close() #关闭服务器套接字(可选)
*****tcp 流程
import socket
client = socket.socket() # 创建客户套接字
client.connect() # 尝试连接服务器
omm_loop: # 通讯循环
client.send(to_server_msg.decode('utf-8'))/client.recv(1024) # 对话(发送/接收)
if condition： #退出循环
break
client.close() # 关闭客户套接字虽然上图将通讯流程中的大致描述了一下socket各个方法的作用，但是还是要总结一下通讯流程(下面一段内容)
先从服务器端说起。服务器端先初始化Socket，然后与端口绑定(bind)，对端口进行监听(listen)，调用accept阻塞，等待客户端连接。在这时如果有个客户端初始化一个Socket，然后连接服务器(connect)，如果连接成功，这时客户端与服务器端的连接就建立了。客户端发送数据请求，服务器端接收请求并处理请求，然后把回应数据发送给客户端，客户端读取数据，最后关闭连接，一次交互结束
加上链接循环与通信循环的举例
#_*_coding:utf-8_*_
import socket
ip_port=('127.0.0.1',8081)#电话卡
BUFSIZE=1024
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #买手机
s.bind(ip_port) #手机插卡
s.listen(5) #手机待机
while True: #新增接收链接循环,可以不停的接电话
conn,addr=s.accept() #手机接电话
# print(conn)
# print(addr)
print('接到来自%s的电话' %addr[0])
while True: #新增通信循环,可以不断的通信,收发消息
msg=conn.recv(BUFSIZE) #听消息,听话
# if len(msg) == 0:break #如果不加,那么正在链接的客户端突然断开,recv便不再阻塞,死循环发生
print(msg,type(msg))
conn.send(msg.upper()) #发消息,说话
conn.close() #挂电话
s.close() #手机关机这里为什么要有两个 while 循环？
如果没有第一个while循环，你会发现：第一个连接的客户端可以和服务端收发消息，但是第二个连接的客户端发消息服务端是收不到的
原因解释：
tcp属于长连接，长连接就是一直占用着这个链接，这个连接的端口被占用了，第二个客户端过来连接的时候，他是可以连接的，但是处于一个占线的状态，就只能等着去跟服务端建立连接，除非一个客户端断开了(优雅的断开可以，如果是强制断开就会报错，因为服务端的程序还在第一个循环里面)，然后就可以进行和服务端的通信了。
#_*_coding:utf-8_*_
__author__ = 'Linhaifeng'
import socket
ip_port=('127.0.0.1',8081)
BUFSIZE=1024
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.connect_ex(ip_port) #拨电话
while True: #新增通信循环,客户端可以不断发收消息
msg=input('>>: ').strip()
if len(msg) == 0:continue
s.send(msg.encode('utf-8')) #发消息,说话(只能发送字节类型)
feedback=s.recv(BUFSIZE) #收消息,听话
print(feedback.decode('utf-8'))
s.close() #挂电话
问题：
有的同学在重启服务端时可能会遇到
这个是由于你的服务端仍然存在四次挥手的time_wait状态在占用地址（如果不懂，请深入研究1.tcp三次握手，四次挥手 2.syn洪水攻击 3.服务器高并发情况下会有大量的time_wait状态的优化方法）
解决方法：
#加入一条socket配置，重用ip和端口
phone=socket(AF_INET,SOCK_STREAM)
phone.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #就是它，在bind前加
phone.bind(('127.0.0.1',8080))发现系统存在大量TIME_WAIT状态的连接，通过调整linux内核参数解决，
vi /etc/sysctl.conf
编辑文件，加入以下内容：
net.ipv4.tcp_syncookies = 1
net.ipv4.tcp_tw_reuse = 1
net.ipv4.tcp_tw_recycle = 1
net.ipv4.tcp_fin_timeout = 30
然后执行 /sbin/sysctl -p 让参数生效。
net.ipv4.tcp_syncookies = 1 表示开启SYN Cookies。当出现SYN等待队列溢出时，启用cookies来处理，可防范少量SYN攻击，默认为0，表示关闭；
net.ipv4.tcp_tw_reuse = 1 表示开启重用。允许将TIME-WAIT sockets重新用于新的TCP连接，默认为0，表示关闭；
net.ipv4.tcp_tw_recycle = 1 表示开启TCP连接中TIME-WAIT sockets的快速回收，默认为0，表示关闭。
net.ipv4.tcp_fin_timeout 修改系統默认的 TIMEOUT 时间但是如果你加上了上面的代码之后还是出现这个问题：OSError: [WinError 10013] 以一种访问权限不允许的方式做了一个访问套接字的尝试。那么只能换端口了，因为你的电脑不支持端口重用。
记住一点，用socket进行通信，必须是一收一发对应好。
关于setsockopt可以看这篇文章。关于setsockopt的使用
提一下：网络相关或者需要和电脑上其他程序通信的程序才需要开一个端口。
4.UDP协议下的socket
基于UDP的socket通讯流程:
先从服务器端说起。服务器端先初始化Socket，然后与端口绑定(bind)，recvform接收消息，这个消息有两项，消息内容和对方客户端的地址，然后回复消息时也要带着你收到的这个客户端的地址，发送回去，最后关闭连接，一次交互结束
*****UDP server流程
import socket
server = socket.socket() #创建服务器套接字
ip_port = ('ip', port) # 给程序设置一个ip地址和端口号，插卡
server.bind(ip_port) # 绑定ip地址和端口，插卡
inf_loop: #服务器无限循环
server.recvfrom(BUFER_SIZE)/server.sendto(to_client_msg.decode('utf-8'),addr) #对话(接收与发送),addr为server.recvfrom()返回的第二个参数
if condition： #退出循环
break
server.close() #关闭服务器套接字(可选)
*****UDP 流程
import socket
client = socket.socket() # 创建客户套接字
ip_port = ('ip', port) # 给程序设置一个ip地址和端口号，插卡
omm_loop: # 通讯循环
client.sendto(to_server_msg.decode('utf-8'),ip_port)/client.recvfrom(1024) # 对话(发送/接收)
if condition： #退出循环
break
client.close() # 关闭客户套接字qq聊天室
服务器：
#_*_coding:utf-8_*_
import socket
ip_port=('127.0.0.1',8081)
udp_server_sock=socket.socket(socket.AF_INET,socket.SOCK_DGRAM) #买手机
udp_server_sock.bind(ip_port)
while True:
qq_msg,addr=udp_server_sock.recvfrom(1024)
print('来自[%s:%s]的一条消息:\033[1;44m%s\033[0m' %(addr[0],addr[1],qq_msg.decode('utf-8')))
back_msg=input('回复消息: ').strip()
udp_server_sock.sendto(back_msg.encode('utf-8'),addr)
udp服务端客户端1：
#_*_coding:utf-8_*_
import socket
BUFSIZE=1024
udp_client_socket=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
qq_name_dic={
'狗哥alex':('127.0.0.1',8081),
'瞎驴':('127.0.0.1',8081),
'一棵树':('127.0.0.1',8081),
'武大郎':('127.0.0.1',8081),
}
while True:
qq_name=input('请选择聊天对象: ').strip()
while True:
msg=input('请输入消息,回车发送: ').strip()
if msg == 'quit':break
if not msg or not qq_name or qq_name not in qq_name_dic:continue
udp_client_socket.sendto(msg.encode('utf-8'),qq_name_dic[qq_name])
back_msg,addr=udp_client_socket.recvfrom(BUFSIZE)
print('来自[%s:%s]的一条消息:\033[1;44m%s\033[0m' %(addr[0],addr[1],back_msg.decode('utf-8')))
udp_client_socket.close()
接下来，给大家说一个真实的例子，也就是实际当中应用的，那么这是个什么例子呢？就是我们电脑系统上的时间，windows系统的时间是和微软的时间服务器上的时间同步的，而mac本是和苹果服务商的时间服务器同步的，这是怎么做的呢，首先他们的时间服务器上的时间是和国家同步的，你们用我的系统，那么你们的时间只要和我时间服务器上的时间同步就行了，对吧，我时间服务器是不是提供服务的啊，相当于一个服务端，我们的电脑就相当于客户端，就是通过UDP来搞的。
我们自制一个时间服务器（ntp时间同步）的代码示例：
#_*_coding:utf-8_*_
from socket import *
from time import strftime
ip_port=('127.0.0.1',9000)
bufsize=1024
udp_server=socket(AF_INET,SOCK_DGRAM)
udp_server.bind(ip_port)
while True:
msg,addr=udp_server.recvfrom(bufsize)
print('===>',msg)
if not msg:
time_fmt='%Y-%m-%d %X'
else:
time_fmt=msg.decode('utf-8')
back_msg=strftime(time_fmt)
udp_server.sendto(back_msg.encode('utf-8'),addr)
udp_server.close()
ntp服务端#_*_coding:utf-8_*_
from socket import *
ip_port=('127.0.0.1',9000)
bufsize=1024
tcp_client=socket(AF_INET,SOCK_DGRAM)
while True:
msg=input('请输入时间格式(例%Y %m %d)>>: ').strip()
tcp_client.sendto(msg.encode('utf-8'),ip_port)
data=tcp_client.recv(bufsize)
print(data.decode('utf-8'))
tcp_client.close()
ntp客户端TCP协议和UDP协议下socket的基本使用ok了，那我们来深入分析一下socket。(这一块的内容初学者不要看，对socket有些了解的同学可以研究一下，切记看不懂很正常，不要深究，现阶段你们就是学习应用为主！)>>>>看这里>>>>socket原理剖析，里面包含socket中各个方法的作用和方法中的参数。
这里我列出两个简易描述socket各个参数和方法的图，共大家参考：
socket类型：
socket各个方法的解释：
connect()和connect_ex()https://www.cnblogs.com/lucio1128/p/12464302.html
八 粘包现象
说粘包之前，我们先说两个内容，1.缓冲区、2.windows下cmd窗口调用系统指令
8.1 缓冲区（下面粘包现象的图里面还有关于缓冲区的解释）
每个 socket 被创建后，都会分配两个缓冲区，输入缓冲区和输出缓冲区。
write()/send() 并不立即向网络中传输数据，而是先将数据写入缓冲区中，再由TCP协议将数据从缓冲区发送到目标机器。一旦将数据写入到缓冲区，函数就可以成功返回，不管它们有没有到达目标机器，也不管它们何时被发送到网络，这些都是TCP协议负责的事情。
TCP协议独立于 write()/send() 函数，数据有可能刚被写入缓冲区就发送到网络，也可能在缓冲区中不断积压，多次写入的数据被一次性发送到网络，这取决于当时的网络情况、当前线程是否空闲等诸多因素，不由程序员控制。
read()/recv() 函数也是如此，也从输入缓冲区中读取数据，而不是直接从网络中读取。
这些I/O缓冲区特性可整理如下：
1.I/O缓冲区在每个TCP套接字中单独存在；
2.I/O缓冲区在创建套接字时自动生成；
3.即使关闭套接字也会继续传送输出缓冲区中遗留的数据；
4.关闭套接字将丢失输入缓冲区中的数据。输入输出缓冲区的默认大小一般都是 8K，可以通过 getsockopt() 函数获取：
1.unsigned optVal;
2.int optLen = sizeof(int);
3.getsockopt(servSock, SOL_SOCKET, SO_SNDBUF,(char*)&optVal, &optLen);
4.printf("Buffer length: %d\n", optVal);
8.2调用系统指令
让我们基于tcp先制作一个远程执行命令的程序（1：执行错误命令 2：执行ls 3：执行ifconfig）
注意注意注意：
import subprocess
cmd = input('请输入指令>>>')
res = subprocess.Popen(
cmd, #字符串指令：'dir','ipconfig',等等
shell=True, #使用shell，就相当于使用cmd窗口
stderr=subprocess.PIPE, #标准错误输出，凡是输入错误指令，错误指令输出的报错信息就会被它拿到
stdout=subprocess.PIPE, #标准输出，正确指令的输出结果被它拿到
)
print(res.stdout.read().decode('gbk'))
print(res.stderr.read().decode('gbk'))的结果的编码是以当前所在的系统为准的，如果是windows，那么res.stdout.read()读出的就是GBK编码的，在接收端需要用GBK解码
且只能从管道里读一次结果
注意：命令ls -l ; lllllll ; pwd 的结果是既有正确stdout结果，又有错误stderr结果
8.3 粘包现象（两种）
MTU是Maximum Transmission Unit的缩写。意思是网络上传送的最大数据包。MTU的单位是字节。 MTU限制的是数据链路层的payload，也就是上层协议的大小，例如IP，ICMP等。。大部分网络设备的MTU都是1500个字节，也就是1500B。如果本机一次需要发送的数据比网关的MTU大，大的数据包就会被拆开来传送，这样会产生很多数据包碎片，增加丢包率，降低网络速度 关于MTU大家可以看看这篇文章 https://yq.aliyun.com/articles/222535
tcp粘包演示(一)
先从上面粘包现象中的第一种开始：接收方没有及时接收缓冲区的包，造成多个包接收（客户端发送了一段数据，服务端只收了一小部分，服务端下次再收新的命令时的时候还是从缓冲区拿上次遗留的数据，产生粘包）
server端代码示例：
from socket import *
import subprocess
ip_port=('127.0.0.1',8080)
BUFSIZE=1024
tcp_socket_server=socket(AF_INET,SOCK_STREAM)
tcp_socket_server.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
tcp_socket_server.bind(ip_port)
tcp_socket_server.listen(5)
while True:
conn,addr=tcp_socket_server.accept()
print('客户端>>>',addr)
while True:
cmd=conn.recv(BUFSIZE)
if len(cmd) == 0:break
res=subprocess.Popen(cmd.decode('gbk'),shell=True,
stdout=subprocess.PIPE,
stdin=subprocess.PIPE,
stderr=subprocess.PIPE)
stderr=res.stderr.read()
stdout=res.stdout.read()
conn.send(stderr)
conn.send(stdout)
tcp_server.pyimport socket
ip_port = ('127.0.0.1',8080)
size = 1024
tcp_sk = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
res = tcp_sk.connect(ip_port)
while True:
msg=input('>>: ').strip()
if len(msg) == 0:continue
if msg == 'quit':break
tcp_sk.send(msg.encode('utf-8'))
act_res=tcp_sk.recv(size)
print('接收的返回结果长度为>',len(act_res))
print('std>>>',act_res.decode('gbk')) #windows返回的内容需要用gbk来解码，因为windows系统的默认编码为gbk
tcp_client.pytcp粘包演示(二)
发送数据时间间隔很短，数据也很小，会合到一起，产生粘包
server端代码示例：（如果两次发送有一定的时间间隔，那么就不会出现这种粘包情况，试着在两次发送的中间加一个time.sleep(1)）
from socket import *
ip_port=('127.0.0.1',8080)
tcp_socket_server=socket(AF_INET,SOCK_STREAM)
tcp_socket_server.bind(ip_port)
tcp_socket_server.listen(5)
conn,addr=tcp_socket_server.accept()
data1=conn.recv(10)
data2=conn.recv(10)
print('----->',data1.decode('utf-8'))
print('----->',data2.decode('utf-8'))
conn.close()import socket
BUFSIZE=1024
ip_port=('127.0.0.1',8080)
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
# res=s.connect_ex(ip_port)
res=s.connect(ip_port)
s.send('hi'.encode('utf-8'))
s.send('meinv'.encode('utf-8'))
tcp_server.py示例二的结果：全部被第一个recv接收了
udp粘包演示：注意：udp是面向包的，所以udp是不存在粘包的
在udp的代码中，我们在server端接收返回消息的时候，我们设置的recvfrom(1024)，那么当我输入的执行指令为‘dir’的时候，dir在我当前文件夹下输出的内容大于1024，然后就报错了，报的错误也是下面这个：
解释原因：是因为udp是面向报文的，意思就是每个消息是一个包，你接收端设置接收大小的时候，必须要比你发的这个包要大，不然一次接收不了就会报这个错误，而tcp不会报错，这也是为什么tcp会丢包的原因之一，这个和我们上面缓冲区那个错误的报错原因是不一样的。
TCP会粘包、UDP永远不会粘包
发送端可以是一K一K地发送数据，而接收端的应用程序可以两K两K地提走数据，当然也有可能一次提走3K或6K数据，或者一次只提走几个字节的数据，也就是说，应用程序所看到的数据是一个整体，或说是一个流（stream），一条消息有多少字节对应用程序是不可见的，因此TCP协议是面向流的协议，这也是容易出现粘包问题的原因。而UDP是面向消息的协议，每个UDP段都是一条消息，应用程序必须以消息为单位提取数据，不能一次提取任意字节的数据，这一点和TCP是很不同的。怎样定义消息呢？可以认为对方一次性write/send的数据为一个消息，需要明白的是当对方send一条信息的时候，无论底层怎样分段分片，TCP协议层会把构成整条消息的数据段排序完成后才呈现在内核缓冲区。
例如基于tcp的套接字客户端往服务端上传文件，发送时文件内容是按照一段一段的字节流发送的，在接收方看了，根本不知道该文件的字节流从何处开始，在何处结束
所谓粘包问题主要还是因为接收方不知道消息之间的界限，不知道一次性提取多少字节的数据所造成的。
此外，发送方引起的粘包是由TCP协议本身造成的，TCP为提高传输效率，发送方往往要收集到足够多的数据后才发送一个TCP段。若连续几次需要send的数据都很少，通常TCP会根据优化算法把这些数据合成一个TCP段后一次发送出去，这样接收方就收到了粘包数据。
1.TCP（transport control protocol，传输控制协议）是面向连接的，面向流的，提供高可靠性服务。收发两端（客户端和服务器端）都要有一一成对的socket，因此，发送端为了将多个发往接收端的包，更有效的发到对方，使用了优化方法（Nagle算法），将多次间隔较小且数据量小的数据，合并成一个大的数据块，然后进行封包。这样，接收端，就难于分辨出来了，必须提供科学的拆包机制。 即面向流的通信是无消息保护边界的。
2.UDP（user datagram protocol，用户数据报协议）是无连接的，面向消息的，提供高效率服务。不会使用块的合并优化算法，, 由于UDP支持的是一对多的模式，所以接收端的skbuff(套接字缓冲区）采用了链式结构来记录每一个到达的UDP包，在每个UDP包中就有了消息头（消息来源地址，端口等信息），这样，对于接收端来说，就容易进行区分处理了。 即面向消息的通信是有消息保护边界的。
3.tcp是基于数据流的，于是收发的消息不能为空，这就需要在客户端和服务端都添加空消息的处理机制，防止程序卡住，而udp是基于数据报的，即便是你输入的是空内容（直接回车），那也不是空消息，udp协议会帮你封装上消息头，实验略
udp的recvfrom是阻塞的，一个recvfrom(x)必须对唯一一个sendinto(y),收完了x个字节的数据就算完成,若是y>x数据就丢失，这意味着udp根本不会粘包，但是会丢数据，不可靠tcp的协议数据不会丢，没有收完包，下次接收，会继续上次继续接收，己端总是在收到ack时才会清除缓冲区内容。数据是可靠的，但是会粘包。
send(字节流)和recv(1024)及sendall
recv里指定的1024意思是从缓存里一次拿出1024个字节的数据
send的字节流是先放入己端缓存，然后由协议控制将缓存内容发往对端，如果待发送的字节流大小大于缓存剩余空间，那么数据丢失，用sendall就会循环调用send，数据不会丢失
拆包的发生情况
当发送端缓冲区的长度大于网卡的MTU时，tcp会将这次发送的数据拆成几个数据包发送出去。
8.4 解决粘包现象
解决方案（一）：
问题的根源在于，接收端不知道发送端将要传送的字节流的长度，所以解决粘包的方法就是围绕，如何让发送端在发送数据前，把自己将要发送的字节流总大小让接收端知晓，然后接收端发一个确认消息给发送端，然后发送端再发送过来后面的真实内容，接收端再来一个死循环接收完所有数据。
看代码示例：
import socket,subprocess
ip_port=('127.0.0.1',8080)
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.bind(ip_port)
s.listen(5)
while True:
conn,addr=s.accept()
print('客户端',addr)
while True:
msg=conn.recv(1024)
if not msg:break
res=subprocess.Popen(msg.decode('utf-8'),shell=True,\
stdin=subprocess.PIPE,\
stderr=subprocess.PIPE,\
stdout=subprocess.PIPE)
err=res.stderr.read()
if err:
ret=err
else:
ret=res.stdout.read()
data_length=len(ret)
conn.send(str(data_length).encode('utf-8'))
data=conn.recv(1024).decode('utf-8')
if data == 'recv_ready':
conn.sendall(ret)
conn.close()
tcp_server.pyimport socket,time
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
res=s.connect_ex(('127.0.0.1',8080))
while True:
msg=input('>>: ').strip()
if len(msg) == 0:continue
if msg == 'quit':break
s.send(msg.encode('utf-8'))
length=int(s.recv(1024).decode('utf-8'))
s.send('recv_ready'.encode('utf-8'))
send_size=0
recv_size=0
data=b''
while recv_size < length:
data+=s.recv(1024)
recv_size+=len(data)
print(data.decode('utf-8'))
tcp_server.py
解决方案（二）：
通过struck模块将需要发送的内容的长度进行打包，打包成一个4字节长度的数据发送到对端，对端只要取出前4个字节，然后对这四个字节的数据进行解包，拿到你要发送的内容的长度，然后通过这个长度来继续接收我们实际要发送的内容。不是很好理解是吧？哈哈，没关系，看下面的解释~~
为什么要说一下这个模块呢，因为解决方案（一）里面你发现，我每次要先发送一个我的内容的长度，需要接收端接收，并切需要接收端返回一个确认消息，我发送端才能发后面真实的内容，这样是为了保证数据可靠性，也就是接收双方能顺利沟通，但是多了一次发送接收的过程，为了减少这个过程，我们就要使struck来发送你需要发送的数据的长度，来解决上面我们所说的通过发送内容长度来解决粘包的问题。
关于struck的介绍：
了解c语言的人，一定会知道struct结构体在c语言中的作用，不了解C语言的同学也没关系，不影响，其实它就是定义了一种结构，里面包含不同类型的数据(int,char,bool等等)，方便对某一结构对象进行处理。而在网络通信当中，大多传递的数据是以二进制流（binary data）存在的。当传递字符串时，不必担心太多的问题，而当传递诸如int、char之类的基本数据的时候，就需要有一种机制将某些特定的结构体类型打包成二进制流的字符串然后再网络传输，而接收端也应该可以通过某种机制进行解包还原出原始的结构体数据。python中的struct模块就提供了这样的机制，该模块的主要作用就是对python基本类型值与用python字符串格式表示的C struct类型间的转化（This module performs conversions between Python values and C structs represented as Python strings.）。
struck模块的使用：struct模块中最重要的两个函数是pack()打包, unpack()解包。
pack()：#我在这里只介绍一下'i'这个int类型，上面的图中列举除了可以打包的所有的数据类型，并且struck除了pack和uppack两个方法之外还有好多别的方法和用法
import struct
a=12
# 将a变为二进制
bytes=struct.pack('i',a)
struct.pack('i',1111111111111) 如果int类型数据太大会报错struck.errorstruct.error: 'i' format requires -2147483648 <= number <= 2147483647 #这个是范围unpack()：
# 注意，unpack返回的是tuple !!
a,=struct.unpack('i',bytes) #将bytes类型的数据解包后，拿到int类型数据先看一段伪代码示例
import json,struct
#假设通过客户端上传1T:1073741824000的文件a.txt
#为避免粘包,必须自定制报头
header={'file_size':1073741824000,'file_name':'/a/b/c/d/e/a.txt','md5':'8f6fbf8347faa4924a76856701edb0f3'} #1T数据,文件路径和md5值
#为了该报头能传送,需要序列化并且转为bytes，因为bytes只能将字符串类型的数据转换为bytes类型的，所有需要先序列化一下这个字典，字典不能直接转化为bytes
head_bytes=bytes(json.dumps(header),encoding='utf-8') #序列化并转成bytes,用于传输
#为了让客户端知道报头的长度,用struck将报头长度这个数字转成固定长度:4个字节
head_len_bytes=struct.pack('i',len(head_bytes)) #这4个字节里只包含了一个数字,该数字是报头的长度
#客户端开始发送
conn.send(head_len_bytes) #先发报头的长度,4个bytes
conn.send(head_bytes) #再发报头的字节格式
conn.sendall(文件内容) #然后发真实内容的字节格式
#服务端开始接收
head_len_bytes=s.recv(4) #先收报头4个bytes,得到报头长度的字节格式
x=struct.unpack('i',head_len_bytes)[0] #提取报头的长度
head_bytes=s.recv(x) #按照报头长度x,收取报头的bytes格式
header=json.loads(json.dumps(header)) #提取报头
#最后根据报头的内容提取真实的数据,比如
real_data_len=s.recv(header['file_size'])
s.recv(real_data_len)
伪代码（含解释）下面看正式的代码：
import socket,struct,json
import subprocess
phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) #忘了这是干什么的了吧，地址重用？想起来了吗~
phone.bind(('127.0.0.1',8080))
phone.listen(5)
while True:
conn,addr=phone.accept()
while True:
cmd=conn.recv(1024)
if not cmd:break
print('cmd: %s' %cmd)
res=subprocess.Popen(cmd.decode('utf-8'),
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
err=res.stderr.read()
if err:
back_msg=err
else:
back_msg=res.stdout.read()
conn.send(struct.pack('i',len(back_msg))) #先发back_msg的长度
conn.sendall(back_msg) #在发真实的内容
#其实就是连续的将长度和内容一起发出去，那么整个内容的前4个字节就是我们打包的后面内容的长度，对吧
conn.close(
tcp_server.py（自定制报头）import socket,time,struct
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
res=s.connect_ex(('127.0.0.1',8080))
while True:
msg=input('>>: ').strip()
if len(msg) == 0:continue
if msg == 'quit':break
s.send(msg.encode('utf-8')) #发送给一个指令
l=s.recv(4) #先接收4个字节的数据，因为我们将要发送过来的内容打包成了4个字节，所以先取出4个字节
x=struct.unpack('i',l)[0] #解包，是一个元祖，第一个元素就是我们的内容的长度
print(type(x),x)
# print(struct.unpack('I',l))
r_s=0
data=b''
while r_s < x: #根据内容的长度来继续接收4个字节后面的内容。
r_d=s.recv(1024)
data+=r_d
r_s+=len(r_d)
# print(data.decode('utf-8'))
print(data.decode('gbk')) #windows默认gbk编码
tcp_client.py（自定制报头）复杂一些的代码示例：
import socket,struct,json
import subprocess
phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
phone.bind(('127.0.0.1',8080))
phone.listen(5)
while True:
conn,addr=phone.accept()
while True:
cmd=conn.recv(1024)
if not cmd:break
print('cmd: %s' %cmd)
res=subprocess.Popen(cmd.decode('utf-8'),
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
err=res.stderr.read()
print(err)
if err:
back_msg=err
else:
back_msg=res.stdout.read()
headers={'data_size':len(back_msg)}
head_json=json.dumps(headers) #用于计算头的byte
head_json_bytes=bytes(head_json,encoding='utf-8')
conn.send(struct.pack('i',len(head_json_bytes))) #先发报头的长度
conn.send(head_json_bytes) #再发报头
conn.sendall(back_msg) #在发真实的内容
conn.close()
tcp_server.pyfrom socket import *
import struct,json
ip_port=('127.0.0.1',8080)
client=socket(AF_INET,SOCK_STREAM)
client.connect(ip_port)
while True:
cmd=input('>>: ')
if not cmd:continue
client.send(bytes(cmd,encoding='utf-8'))
head=client.recv(4)
head_json_len=struct.unpack('i',head)[0]
head_json=json.loads(client.recv(head_json_len).decode('utf-8'))
data_len=head_json['data_size']
recv_size=0
recv_data=b''
while recv_size < data_len:
recv_data+=client.recv(1024)
recv_size+=len(recv_data)
#print(recv_data.decode('utf-8'))
print(recv_data.decode('gbk')) #windows默认gbk编码
tcp_client.pyFTP上传下载文件的代码（简易版）
import socket
import struct
import json
sk = socket.socket()
# buffer = 4096 # 当双方的这个接收发送的大小比较大的时候，就像这个4096，就会丢数据，这个等我查一下再告诉大家，改小了就ok的，在linux上也是ok的。
buffer = 1024 #每次接收数据的大小
sk.bind(('127.0.0.1',8090))
sk.listen()
conn,addr = sk.accept()
#接收
head_len = conn.recv(4)
head_len = struct.unpack('i',head_len)[0] #解包
json_head = conn.recv(head_len).decode('utf-8') #反序列化
head = json.loads(json_head)
filesize = head['filesize']
with open(head['filename'],'wb') as f:
while filesize:
if filesize >= buffer: #>=是因为如果刚好等于的情况出现也是可以的。
content = conn.recv(buffer)
f.write(content)
filesize -= buffer
else:
content = conn.recv(buffer)
f.write(content)
break
conn.close()
sk.close()
tcp_server.pyimport os
import json
import socket
import struct
sk = socket.socket()
sk.connect(('127.0.0.1',8090))
buffer = 1024 #读取文件的时候，每次读取的大小
head = {
'filepath':r'D:\打包程序', #需要下载的文件路径，也就是文件所在的文件夹
'filename':'xxx.mp4', #改成上面filepath下的一个文件
'filesize':None,
}
file_path = os.path.join(head['filepath'],head['filename'])
filesize = os.path.getsize(file_path)
head['filesize'] = filesize
# json_head = json.dumps(head,ensure_ascii=False) #字典转换成字符串
json_head = json.dumps(head) #字典转换成字符串
bytes_head = json_head.encode('utf-8') #字符串转换成bytes类型
print(json_head)
print(bytes_head)
#计算head的长度，因为接收端先接收我们自己定制的报头，对吧
head_len = len(bytes_head) #报头长度
pack_len = struct.pack('i',head_len)
print(head_len)
print(pack_len)
sk.send(pack_len) #先发送报头长度
sk.send(bytes_head) #再发送bytes类型的报头
#即便是视频文件，也是可以按行来读取的，也可以readline，也可以for循环，但是读取出来的数据大小就不固定了，影响效率，有可能读的比较小，也可能很大，像视频文件一般都是一行的二进制字节流。
#所有我们可以用read，设定一个一次读取内容的大小，一边读一边发，一边收一边写
with open(file_path,'rb') as f:
while filesize:
if filesize >= buffer: #>=是因为如果刚好等于的情况出现也是可以的。
content = f.read(buffer) #每次读取出来的内容
sk.send(content)
filesize -= buffer #每次减去读取的大小
else: #那么说明剩余的不够一次读取的大小了，那么只要把剩下的读取出来发送过去就行了
content = f.read(filesize)
sk.send(content)
break
sk.close()
tcp_client.pyFTP上传下载文件的代码（升级版）
import socket
import struct
import json
import subprocess
import os
class MYTCPServer:
address_family = socket.AF_INET
socket_type = socket.SOCK_STREAM
allow_reuse_address = False
max_packet_size = 8192
coding='utf-8'
request_queue_size = 5
server_dir='file_upload'
def __init__(self, server_address, bind_and_activate=True):
"""Constructor. May be extended, do not override."""
self.server_address=server_address
self.socket = socket.socket(self.address_family,
self.socket_type)
if bind_and_activate:
try:
self.server_bind()
self.server_activate()
except:
self.server_close()
raise
def server_bind(self):
"""Called by constructor to bind the socket.
"""
if self.allow_reuse_address:
self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.socket.bind(self.server_address)
self.server_address = self.socket.getsockname()
def server_activate(self):
"""Called by constructor to activate the server.
"""
self.socket.listen(self.request_queue_size)
def server_close(self):
"""Called to clean-up the server.
"""
self.socket.close()
def get_request(self):
"""Get the request and client address from the socket.
"""
return self.socket.accept()
def close_request(self, request):
"""Called to clean up an individual request."""
request.close()
def run(self):
while True:
self.conn,self.client_addr=self.get_request()
print('from client ',self.client_addr)
while True:
try:
head_struct = self.conn.recv(4)
if not head_struct:break
head_len = struct.unpack('i', head_struct)[0]
head_json = self.conn.recv(head_len).decode(self.coding)
head_dic = json.loads(head_json)
print(head_dic)
#head_dic={'cmd':'put','filename':'a.txt','filesize':123123}
cmd=head_dic['cmd']
if hasattr(self,cmd):
func=getattr(self,cmd)
func(head_dic)
except Exception:
break
def put(self,args):
file_path=os.path.normpath(os.path.join(
self.server_dir,
args['filename']
))
filesize=args['filesize']
recv_size=0
print('----->',file_path)
with open(file_path,'wb') as f:
while recv_size < filesize:
recv_data=self.conn.recv(self.max_packet_size)
f.write(recv_data)
recv_size+=len(recv_data)
print('recvsize:%s filesize:%s' %(recv_size,filesize))
tcpserver1=MYTCPServer(('127.0.0.1',8080))
tcpserver1.run()
server.pyimport socket
import struct
import json
import os
class MYTCPClient:
address_family = socket.AF_INET
socket_type = socket.SOCK_STREAM
allow_reuse_address = False
max_packet_size = 8192
coding='utf-8'
request_queue_size = 5
def __init__(self, server_address, connect=True):
self.server_address=server_address
self.socket = socket.socket(self.address_family,
self.socket_type)
if connect:
try:
self.client_connect()
except:
self.client_close()
raise
def client_connect(self):
self.socket.connect(self.server_address)
def client_close(self):
self.socket.close()
def run(self):
while True:
inp=input(">>: ").strip()
if not inp:continue
l=inp.split()
cmd=l[0]
if hasattr(self,cmd):
func=getattr(self,cmd)
func(l)
def put(self,args):
cmd=args[0]
filename=args[1]
if not os.path.isfile(filename):
print('file:%s is not exists' %filename)
return
else:
filesize=os.path.getsize(filename)
head_dic={'cmd':cmd,'filename':os.path.basename(filename),'filesize':filesize}
print(head_dic)
head_json=json.dumps(head_dic)
head_json_bytes=bytes(head_json,encoding=self.coding)
head_struct=struct.pack('i',len(head_json_bytes))
self.socket.send(head_struct)
self.socket.send(head_json_bytes)
send_size=0
with open(filename,'rb') as f:
for line in f:
self.socket.send(line)
send_size+=len(line)
print(send_size)
else:
print('upload successful')
client=MYTCPClient(('127.0.0.1',8080))
client.run()
client.py九 验证客户端的链接合法性（了解）
首先，我们来探讨一下，什么叫验证合法性， 举个例子：有一天，我开了一个socket服务端，只想让咱们这个班的同学使用，但是有一天，隔壁班的同学过来问了一下我开的这个服务端的ip和端口，然后他是不是就可以去连接我了啊，那怎么办，我是不是不想让他连接我啊，我需要验证一下你的身份，这就是验证连接的合法性，再举个例子，就像我们上面说的你的windows系统是不是连接微软的时间服务器来获取时间的啊，你的mac能到人家微软去获取时间吗，你愿意，人家微软还不愿意呢，对吧，那这时候，你每次连接我来获取时间的时候，我是不是就要验证你的身份啊，也就是你要带着你的系统信息，我要判断你是不是我微软的windows，对吧，如果是mac，我是不是不让你连啊，这就是连接合法性。如果验证你的连接是合法的，那么如果我还要对你的身份进行验证的需求，也就是要验证用户名和密码，那么我们还需要进行身份认证。连接认证>>身份认证>>ok你可以玩了。
如果你想在分布式系统中实现一个简单的客户端链接认证功能，又不像SSL那么复杂，那么利用hmac+加盐的方式来实现，直接看代码！
note:验证得时候，首先从服务端发送一个消息
#_*_coding:utf-8_*_
__author__ = 'Linhaifeng'
from socket import *
import hmac,os
secret_key=b'Jedan has a big key!'
def conn_auth(conn):
'''
认证客户端链接
:param conn:
:return:
'''
print('开始验证新链接的合法性')
msg=os.urandom(32)
conn.sendall(msg)
h=hmac.new(secret_key,msg)
digest=h.digest()
respone=conn.recv(len(digest))
return hmac.compare_digest(respone,digest)
def data_handler(conn,bufsize=1024):
if not conn_auth(conn):
print('该链接不合法,关闭')
conn.close()
return
print('链接合法,开始通信')
while True:
data=conn.recv(bufsize)
if not data:break
conn.sendall(data.upper())
def server_handler(ip_port,bufsize,backlog=5):
'''
只处理链接
:param ip_port:
:return:
'''
tcp_socket_server=socket(AF_INET,SOCK_STREAM)
tcp_socket_server.bind(ip_port)
tcp_socket_server.listen(backlog)
while True:
conn,addr=tcp_socket_server.accept()
print('新连接[%s:%s]' %(addr[0],addr[1]))
data_handler(conn,bufsize)
if __name__ == '__main__':
ip_port=('127.0.0.1',9999)
bufsize=1024
server_handler(ip_port,bufsize)
服务端客户端（合法）
from socket import *
import hmac,os
secret_key=b'Jedan has a big key！'
def conn_auth(conn):
'''
验证客户端到服务器的链接
:param conn:
:return:
'''
msg=conn.recv(32)
h=hmac.new(secret_key,msg)
digest=h.digest()
conn.sendall(digest)
def client_handler(ip_port,bufsize=1024):
tcp_socket_client=socket(AF_INET,SOCK_STREAM)
tcp_socket_client.connect(ip_port)
conn_auth(tcp_socket_client)
while True:
data=input('>>: ').strip()
if not data:continue
if data == 'quit':break
tcp_socket_client.sendall(data.encode('utf-8'))
respone=tcp_socket_client.recv(bufsize)
print(respone.decode('utf-8'))
tcp_socket_client.close()
if __name__ == '__main__':
ip_port=('127.0.0.1',9999)
bufsize=1024
client_handler(ip_port,bufsize)
客户端介绍代码中使用的两个方法：
1、os.urandom(n)
其中os.urandom(n) 是一种bytes类型的随机生成n个字节字符串的方法，而且每次生成的值都不相同。再加上md5等加密的处理，就能够成内容不同长度相同的字符串了。
使用方法：
import os
from hashlib import md5
for i in range(10):
print md5(os.urandom(24)).hexdigest()2、hmac： 我们完全可以用hashlib来实现，但是学个新的吗，没什么不好的，这个操作更方便一些。
Python自带的hmac模块实现了标准的Hmac算法，我们首先需要准备待计算的原始消息message，随机key，哈希算法，这里采用MD5，使用hmac的代码如下：
import hmac
message = b'Hello world'
key = b'secret'
h = hmac.new(key,message,digestmod='MD5')
print(h.hexdigest())
比较两个密文是否相同，可以用hmac.compare_digest(密文、密文)，然会True或者False。可见使用hmac和普通hash算法非常类似。hmac输出的长度和原始哈希算法的长度一致。需要注意传入的key和message都是bytes类型，str类型需要首先编码为bytes。
def hmac_md5(key, s):
return hmac.new(key.encode('utf-8'), s.encode('utf-8'), 'MD5').hexdigest()
class User(object):
def __init__(self, username, password):
self.username = username
self.key = ''.join([chr(random.randint(48, 122)) for i in range(20)]) #chr()返回值是当前整数对应的 ASCII 字符
self.password = hmac_md5(self.key, password)
十 socketserver模块实现并发
为什么要讲socketserver？我们之前写的tcp协议的socket是不是一次只能和一个客户端通信，如果用socketserver可以实现和多个客户端通信。它是在socket的基础上进行了一层封装，也就是说底层还是调用的socket，在py2.7里面叫做SocketServer也就是大写了两个S，在py3里面就小写了。后面我们要写的FTP作业，需要用它来实现并发，也就是同时可以和多个客户端进行通信，多个人可以同时进行上传下载等。
那么我们先看socketserver怎么用呢，然后在分析，先看下面的代码
import socketserver #1、引入模块
class MyServer(socketserver.BaseRequestHandler): #2、自己写一个类，类名自己随便定义，然后继承socketserver这个模块里面的BaseRequestHandler这个类
def handle(self): #3、写一个handle方法，必须叫这个名字
#self.request #6、self.request 相当于一个conn
self.request.recv(1024) #7、收消息
msg = '亲，学会了吗'
self.request.send(bytes(msg,encoding='utf-8')) #8、发消息
self.request.close() #9、关闭连接
# 拿到了我们对每个客户端的管道，那么我们自己在这个方法里面的就写我们接收消息发送消息的逻辑就可以了
pass
if __name__ == '__mian__':
#thread 线程，现在只需要简单理解线程，别着急，后面很快就会讲到啦，看下面的图
server = socketserver.ThreadingTCPServer(('127.0.0.1',8090),MyServer)#4、使用socketserver的ThreadingTCPServer这个类，将IP和端口的元祖传进去，还需要将上面咱们自己定义的类传进去，得到一个对象，相当于我们通过它进行了bind、listen
server.serve_forever() #5、使用我们上面这个类的对象来执行serve_forever()方法，他的作用就是说，我的服务一直开启着，就像京东一样，不能关闭网站，对吧，并且serve_forever()帮我们进行了accept
#注意：
#有socketserver 那么有socketclient的吗？
#当然不会有，我要作为客户去访问京东的时候，京东帮我也客户端了吗，客户端是不是在我们自己的电脑啊，并且socketserver对客户端没有太高的要求，只需要自己写一些socket就行了。
socketserver源码分析：https://mp.csdn.net/editor/html/114661221
举个例子：还是上面的FTP文件传输的例子
import socketserver
import struct
import json
import os
class FtpServer(socketserver.BaseRequestHandler):
coding='utf-8'
server_dir='file_upload'
max_packet_size=1024
BASE_DIR=os.path.dirname(os.path.abspath(__file__))
def handle(self):
print(self.request)
while True:
data=self.request.recv(4)
data_len=struct.unpack('i',data)[0]
head_json=self.request.recv(data_len).decode(self.coding)
head_dic=json.loads(head_json)
# print(head_dic)
cmd=head_dic['cmd']
if hasattr(self,cmd):
func=getattr(self,cmd)
func(head_dic)
def put(self,args):
file_path = os.path.normpath(os.path.join(
self.BASE_DIR,
self.server_dir,
args['filename']
))
filesize = args['filesize']
recv_size = 0
print('----->', file_path)
with open(file_path, 'wb') as f:
while recv_size < filesize:
recv_data = self.request.recv(self.max_packet_size)
f.write(recv_data)
recv_size += len(recv_data)
print('recvsize:%s filesize:%s' % (recv_size, filesize))
ftpserver=socketserver.ThreadingTCPServer(('127.0.0.1',8080),FtpServer)
ftpserver.serve_forever()
FtpServerimport socket
import struct
import json
import os
class MYTCPClient:
address_family = socket.AF_INET
socket_type = socket.SOCK_STREAM
allow_reuse_address = False
max_packet_size = 8192
coding='utf-8'
request_queue_size = 5
def __init__(self, server_address, connect=True):
self.server_address=server_address
self.socket = socket.socket(self.address_family,
self.socket_type)
if connect:
try:
self.client_connect()
except:
self.client_close()
raise
def client_connect(self):
self.socket.connect(self.server_address)
def client_close(self):
self.socket.close()
def run(self):
while True:
inp=input(">>: ").strip()
if not inp:continue
l=inp.split()
cmd=l[0]
if hasattr(self,cmd):
func=getattr(self,cmd)
func(l)
def put(self,args):
cmd=args[0]
filename=args[1]
if not os.path.isfile(filename):
print('file:%s is not exists' %filename)
return
else:
filesize=os.path.getsize(filename)
head_dic={'cmd':cmd,'filename':os.path.basename(filename),'filesize':filesize}
print(head_dic)
head_json=json.dumps(head_dic)
head_json_bytes=bytes(head_json,encoding=self.coding)
head_struct=struct.pack('i',len(head_json_bytes))
self.socket.send(head_struct)
self.socket.send(head_json_bytes)
send_size=0
with open(filename,'rb') as f:
for line in f:
self.socket.send(line)
send_size+=len(line)
print(send_size)
else:
print('upload successful')
client=MYTCPClient(('127.0.0.1',8080))
client.run()
FtpClient十 网络编程的作业
好了同学们，到了这儿，我们的网络编程socket就讲完了，大致就是这些内容，给大家留个作业：（你的努力的成果你自己是看的到的~！）
加粗的是必须要做的，倾斜的是比较有难度的，大家别放松呀。
1. 多用户同时登陆
2. 用户登陆，加密认证
3. 上传/下载文件，保证文件一致性
4. 传输过程中现实进度条
5. 不同用户家目录不同，且只能访问自己的家目录
6. 对用户进行磁盘配额、不同用户配额可不同
7. 用户登陆server后，可在家目录权限下切换子目录
8. 查看当前目录下文件，新建文件夹
9. 删除文件和空文件夹
10. 充分使用面向对象知识
11. 支持断点续传
看一下流程图：
