学习python课程第二十八天

 一.  什么是粘包现象 :

　　须知: 只有TCP有粘包现象,UDP永远不会粘包. 这是socket收发消息的原理导致的.

　　

　　对于TCP协议发送端可以是一K一K地发送数据，而接收端的应用程序可以两K两K地提走数据，当然也有可能一次提走3K或6K数据，或者一次只提走几个字节的数据，也就是说，应用程序所看到的数据是一个整体，或

　　说是一个流（stream），一条消息有多少字节对应用程序是不可见的，因此TCP协议是面向流的协议，这也是容易出现粘包问题的原因。

　　UDP是面向消息的协议，每个UDP段都是一条消息，应用程序必须以消息为单位提取数据，不能一次提取任意字节的数据，这一点和TCP是很不同的。怎样定义消息呢？可以认为对方一次性write/send的数据为一个

　　消息，需要明白的是当对方send一条信息的时候，无论底层怎样分段分片，TCP协议层会把构成整条消息的数据段排序完成后才呈现在内核缓冲区。

　　例如, 基于TCP协议的套接字客户端往服务端上传文件, 发送时文件内容是按照一段一段的字节流发送的,在

　　接收方看来,根本不知道该文件的字节流从何处开始,在何处结束.

　　所谓的粘包问题主要还是因为接收方不知道消息之间的界限,不知道一次性提取多少字节的数据所造成的.

　　此外,发送方引起的粘包是由TCP协议本身造成的,TCP为提高传输效率,发送方往往要收集到足够多的数据

　　后才发送一个TCP段. 若连续几次需要send的数据都很少,通常TCP会根据优化算法把这些数据合成一个

　　TCP段后一次发送出去,这样接收方就收到了粘包数据.

　　TCP(transport control protocol,传输控制协议) 是面向连接的. 面向流的. 提供高可靠性服务, 收发两端.

　　(客户端和服务器端) 都要有----成对的socket,因此, 发送端为了将多个发送接收端的包, 更有效的发到对方,

　　使用了优化方法 (Nagle算法) , 将多次间隔较小且数据量小的数据, 合并成一个大的数据块. 然后进行封包.

　　这样,接收端就难于分辨出来了. 必须提供科学的拆包机制, 即面向流的通信是无消息保护边界的.

　　UDP(user datagram protocol, 用户数据报协议) 是无法连接的, 面向消息的. 提供高效率服务. 不会使用块

　　的合并优化算法, 由于UDP支持的是一对多的模式,所以接收端的skbuff(套接字缓冲区) 采用了链式结构来

　　记录每一个到达的UDP包,在每个UDP包中就有了消息头(消息来源地址,端口等信息), 这样, 对于接收端来说

　　就容易进行区分处理了.即面向消息的通信是有消息保护边界的.

　　TCP是基于数据流的. 于是收发的消息不能为空, 这就需要在客户端和服务端都添加空消息的处理机制,防止

　　程序卡主,而UDP是基于数据报的,即便是你输入的是空内容(直接回车),那也不是空消息,UDP协议会帮你封

　　装上消息头,实验略

　　有两种情况会发生粘包问题:

　　　　1. 发送端需要等缓冲区满才发送出去, 造成粘包 (发送数据时间间隔很短,数据量很小,会合到一起.产生

　　　　　　粘包)

　　　　2. 接受方不及时接受缓冲区的包,造成多个包接收 (客户端发送了一段数据,服务端只收了一小部分,服

　　　　　　务端下次再收的时候还是从缓冲区拿上次遗留的数据,产生粘包)

　　　　

　　解决粘包问题:

　　　　我们通过上面的分析发现.粘包问题出现的最根本原因就是接收方不知道该提取多少字节,那么想要解决

　　　　粘包问题就变得很简单了.让接收方知道提取多少字节, 粘包问题不就解决了.那么如何让接收方知道应

　　　　该提取多少字节呢?

　　　　我们可以很容易的就确定要发送的数据长度,问题的关键在于,长度不是固定的(例子:148bytes和10014

　　　　bytes)类似这种的应该如何发送呢?

　　　　这时,我们就要用到模块来帮助我们实现了.

　　　　首先, 我们来学习一下struct模块的使用.

　　　　该模块可以把一个数据类型.如数字,转成固定长度的bytes

　　　　

　　struct模块可以将不定长度的数字转换成固定长度的bytes类型,那么我们就可以通过struct模块将我们要发送

　　的数据长度打包成一个固定长度的bytes然后发送过去, 这样接收方就只需要接受固定长度的bytes然后反解

　　出要发送数据的长度就解决了粘包问题

　　代码示例:

　　　　服务端

　　　　

　　　　from socket import *
　　　　import subprocess
　　　　import struct

　　　　# 创建服务端套接字对象
　　　　server = socket(AF_INET, SOCK_STREAM)
　　　　# 绑定ip和端口号
　　　　server.bind(('127.0.0.1', 8080))
　　　　# 进入监听状态
　　　　server.listen(5)

　　　　# 循环接收客户端连接请求
　　　　while True:
　　　　　　conn, client_addr = server.accept() # (连接对象，客户端的ip和端口)
　　　　　　print(client_addr)
　　　　# 循环与客户端进行通讯
　　　　while True:
　　　　　　try:
　　　　　　　　cmd = conn.recv(1024)
　　　　　　　　obj = subprocess.Popen(cmd.decode('utf-8'),
　　　　　　　　　　　　　　　　　　shell=True,
　　　　　　　　　　　　　　　　　　stdout=subprocess.PIPE,
　　　　　　　　　　　　　　　　　　stderr=subprocess.PIPE
　　　　　　　　　　　　　　　　　　)
　　　　　　　　stdout = obj.stdout.read()
　　　　　　　　stderr = obj.stderr.read()

　　　　　　　　# 1、制作固定长度的报头
　　　　　　　　total_size = len(stdout) + len(stderr)
　　　　　　　　header = struct.pack('i', total_size)

　　　　　　　　# 2、发送报头
　　　　　　　　conn.send(header)

　　　　　　　　# 3、发送真实的数据
　　　　　　　　conn.send(stdout)
　　　　　　　　conn.send(stderr)
　　　　　　except ConnectionResetError:
　　　　　　　　break

　　　　　　# 回收资源
　　　　　conn.close()
　　　　server.close()

　　　　客户端

　　　　

　　　　from socket import *
　　　　import struct

　　　　# 创建客户端套接字对象
　　　　client = socket(AF_INET, SOCK_STREAM)
　　　　# 连接服务端ip和端口号
　　　　client.connect(('127.0.0.1', 8080))

　　　　# 循环与服务端进行通讯
　　　　while True:
　　　　　　cmd = input('>>>: ').strip()
　　　　　　if not cmd: continue
　　　　　　client.send(cmd.encode('utf-8'))
　　　　　　# 1、先收固定长度的报头
　　　　　　header = client.recv(4)
　　　　　　# 2、解析报头
　　　　　　total_size = struct.unpack('i', header)[0]
　　　　　　print(total_size) # 1025
　　　　　　# 3、根据报头内的信息，收取真实的数据
　　　　　　recv_size = 0
　　　　　　res = b''
　　　　　　while recv_size < total_size:
　　　　　　　　recv_data = client.recv(1024)
　　　　　　　　res += recv_data
　　　　　　　　recv_size += len(recv_data)

　　　　　　print(res.decode('gbk'))
　　　　client.close()

　　　　

　　至此, 粘包问题确实解决了.但是解决的但是解决的不够完美.我们只发送了数据长度,让接受方知道该接收

　　多少数据, 那么我们是不是可以把对数据的描述信息等一起发送过去呢?

　　自定义报头:

　　服务端 

　　

　　

　　　　from socket import *
　　　　import subprocess
　　　　import struct
　　　　import json

　　　　server = socket(AF_INET, SOCK_STREAM)
　　　　server.bind(('127.0.0.1', 8080))
　　　　server.listen(5)

　　　　while True:
　　　　　　conn, client_addr = server.accept() # (连接对象，客户端的ip和端口)
　　　　　　print(client_addr)
　　　　　　while True:
　　　　　　　　try:
　　　　　　　　　　cmd = conn.recv(1024)
　　　　　　　　　　obj = subprocess.Popen(cmd.decode('utf-8'),
　　　　　　　　　　　　　　　　　　　　　　shell=True,
　　　　　　　　　　　　　　　　　　　　　　stdout=subprocess.PIPE,
　　　　　　　　　　　　　　　　　　　　　　stderr=subprocess.PIPE
　　　　　　　　　　　　　　　　　　　　　　)
　　　　　　　　　　stdout = obj.stdout.read()
　　　　　　　　　　stderr = obj.stderr.read()

　　　　　　　　　　# 1、制作报头
　　　　　　　　　　header_dic = {
　　　　　　　　　　　　'total_size': len(stdout) + len(stderr),
　　　　　　　　　　　　'md5': '123svsaef123sdfasdf',
　　　　　　　　　　　　'filename': 'a.txt'
　　　　　　　　　　　　　　}
　　　　　　　　　　# 将字典形式的报头转换为字符串形式
　　　　　　　　　　header_json = json.dumps(header_dic)
　　　　　　　　　　# 将字符串形式的报头转换成bytes格式
　　　　　　　　　　header_bytes = header_json.encode('utf-8')

　　　　　　　　　　# 2、先发送报头的长度
　　　　　　　　　　# 获取bytes格式报头的长度
　　　　　　　　　　header_size = len(header_bytes)
　　　　　　　　　　# 将长度打包成固定长度发送过去
　　　　　　　　　　conn.send(struct.pack('i', header_size))

　　　　　　　　　　# 3、发送报头
　　　　　　　　　　conn.send(header_bytes)

　　　　　　　　　　# 4、发送真实的数据
　　　　　　　　　　conn.send(stdout)
　　　　　　　　　　conn.send(stderr)
　　　　　　　　except ConnectionResetError:
　　　　　　　　　　break

　　　　　　conn.close()
　　　　server.close()

　　　　客户端

　　　　

　　　　

　　　　from socket import *
　　　　import struct
　　　　import json

　　　　client = socket(AF_INET, SOCK_STREAM)
　　　　client.connect(('127.0.0.1', 8080))
　　　　# print(client)

　　　　while True:
　　　　　　cmd = input('>>>: ').strip()
　　　　　　if not cmd: continue
　　　　　　client.send(cmd.encode('utf-8'))
　　　　　　# 1、先收报头的长度
　　　　　　header_size = struct.unpack('i', client.recv(4))[0]

　　　　　　# 2、接收报头
　　　　　　header_bytes = client.recv(header_size)

　　　　　　# 3、解析报头
　　　　　　# 将bytes类型的报头转换为json字符串形式
　　　　　　header_json = header_bytes.decode('utf-8')
　　　　　　# 将json字符串形式的报头转为字典形式
　　　　　　header_dic = json.loads(header_json)
　　　　　　total_size = header_dic['total_size']
　　　　　　# 4、根据报头内的信息，收取真实的数据

　　　　　　recv_size = 0
　　　　　　res = b''
　　　　　　while recv_size < total_size:
　　　　　　　　recv_data = client.recv(1024)
　　　　　　　　res += recv_data
　　　　　　　　recv_size += len(recv_data)

　　　　　　# 这里用gbk解码的原因: subprocess模块是将命令在cmd中执行, windows的cmd中, 默认字符编

　　　　　　　　码为gbk, 所以应该用gbk解码
　　　　　　print(res.decode('gbk'))
　　　　client.close()