python3.6入门到高阶(全栈) day28----黏包处理

1、缓冲区和subprocess模块

　　1.1  缓冲区( 当send()内容超过输入缓冲区大小或recv()接收内容超过输出缓冲区大小时旧版本(py3.5以前)是会直接报错的, py3.5以后如果出错内部机制会直接处理错误, 处理方式类似于sendall()的方式循环发送去缓存区. )

　　　　

　　每个 socket 被创建后，都会分配两个缓冲区，输入缓冲区和输出缓冲区。

　　write()/send() 并不立即向网络中传输数据，而是先将数据写入缓冲区中，再由TCP协议将数据从缓冲区发送到目标机器。一旦将数据写入到缓冲区，函数就可以成功返回，不管它们有没有到达目标机器，也不管它们何时被发送到网络，这些都是TCP协议负责的事情。

　　TCP协议独立于 write()/send() 函数，数据有可能刚被写入缓冲区就发送到网络，也可能在缓冲区中不断积压，多次写入的数据被一次性发送到网络，这取决于当时的网络情况、当前线程是否空闲等诸多因素，不由程序员控制。

　　read()/recv() 函数也是如此，也从输入缓冲区中读取数据，而不是直接从网络中读取。

　　2.2  解释器调用系统指令----> subprocess

1 import subprocess      # 解释器操作cmd的模块
 2 recv_msg = input("输入cmd命令: ")
 3 cmd_obj = subprocess.Popen(
 4     recv_msg,       # 输入的cmd指令,"dir", "ipconfig" ......
 5     shell=True,     # shell = True, 即相当于使用cmd窗口
 6     stdout=subprocess.PIPE,      # 标准输出信息都在PIPE管道中
 7     stderr=subprocess.PIPE,      # 出错信息也在PIPE管道中
 8 )
 9 cmd_msg = cmd_obj.stdout.read().decode("gbk")        # 对象调用里面的stdout属性, 并读取出来.(和计算机交互一般都以GBK编码解码)   
10 print(cmd_msg)

2、黏包

　　产生黏包的原因? 主要还是因为接收方不知道消息之间的界限，不知道一次性提取多少字节的数据所造成的

　　现象1: 连续send两个比较小点的数据时, 在网速各方面都很流畅情况下是不会产生黏包现象的(用time.sleep模拟), 当网速或其他原因造成上传速度变慢, TCP内部的Nagle算法和延迟ACK机制, 会减少大量小包的连续发送, 所以会将比较小的连续发送的数据合并成一个比较大的包, 这是第一种黏包;

　　现象2: send()给缓冲区扔了太多数据, 超过缓冲区的大小就会报错, 每个IP包一般最大为1500b, 如果超过这个值就会被拆包发送, 第一次剩下的数据有可能和第二次发送的数据一起连在一起被接收, 这就是第二种黏包;

3、如何解决黏包现象?

　　3.1 了解一下struct模块 ----> 其实就是定义一种结构，里面包含不同类型的数据(int,char,bool等等)，方便对某一结构对象进行处理。该模块的主要作用就是对python基本类型值与一个四位二进制数类型间的转化.

　　struct模块支持打包哪些数据类型?

　　struct.pack()  可以将struct支持的数据类型打包成一个对应长度二进制的数, 如果给 "int" 类型的数字打包的话, 结果就是一个4位二进制的数. 

　　struct.unpack()  将打包成的二进制数解包回来, 结果是一个元组. 

1 import struct
2 numb = 152856900
3 numb_bytes = struct.pack("i",numb)      # 把int 类型的numb打包成一个4位二进制的数(不管多大多小的数转化后的结果都是4位),
4                                         # "i"表示是一个整数  b'Dix1c	'
5 print(numb_bytes)
6 
7 numb = struct.unpack("i",numb_bytes)    # 结果是一个元组形式. (152856900,)
8 print(numb)

如何解决黏包现象?   ---->  让接收方知道自己要接收的字节流总长度, 然后按这个长度接收就行.

　　　　第一种方案: 发送方先把字节流的总长度发给接收方, 接收方在接到总长度后给发送方传达一个确认信息, 发送方开始传数据, 接收方循环接收数据, 直到接受到的字节总长度等于发送方发来的字节流总长度.

1 import socket
 2 import subprocess
 3 
 4 
 5 # 服务端(发送方)
 6 server = socket.socket()
 7 ip_port = ("192.168.12.42",8520)
 8 server.bind(ip_port)
 9 server.listen(4)
10 conn,addr = server.accept()
11 
12 while 1:
13     recv_msg = str(conn.recv(1024),"utf8")
14     cmd_obj = subprocess.Popen(
15         recv_msg,
16         shell=True,
17         stdout=subprocess.PIPE,
18         stderr=subprocess.PIPE,
19     )
20     cmd_msg = cmd_obj.stdout.read() * 20
21     cmd_msg_len = bytes(str(len(cmd_msg)),"utf8")
22     conn.send(cmd_msg_len)              # 先发送一个总的字节长度
23     has_send = 0
24     while has_send < len(cmd_msg):      # 发送方循环发送
25         every_send = cmd_msg[has_send:has_send + 1024]
26         conn.send(every_send)
27         has_send += len(every_send)
28 
29 
30 # 客户端(接收方)
31 client = socket.socket()
32 ip_port = ("192.168.12.42",8520)
33 client.connect(ip_port)
34 
35 while 1:
36     cmd_msg = bytes(input("请输入cmd指令: "),"utf8")
37     client.send(cmd_msg)
38     recv_msg_len = int(str(client.recv(1024),"utf8"))
39     print(recv_msg_len)
40     has_recv = bytes()              # 接收到总的字节流长度
41     while len(has_recv) < recv_msg_len:         # 循环接收,直到字节流的长度相等
42         has_recv += client.recv(1024)
43     print(str(has_recv,"gbk"))
44     print(len(has_recv))

第二种方案: 通过struck模块将需要发送的内容的长度进行打包，打包成一个4字节长度的数据发送到对端，对端只要取出前4个字节，然后对这四个字节的数据进行解包，拿到你要发送的内容的长度，然后通过这个长度来继续接收我们实际要发送的内容(不好理解看代码, 简单)。

1 import socket
 2 import subprocess
 3 import struct
 4 
 5 
 6 # 客户端(发送方)
 7 server = socket.socket()
 8 ip_port = ("192.168.12.42",8520)
 9 server.bind(ip_port)
10 server.listen(4)
11 conn,addr = server.accept()
12 
13 while 1:
14     recv_msg = str(conn.recv(1024),"utf8")
15     cmd_obj = subprocess.Popen(
16         recv_msg,
17         shell=True,
18         stdout=subprocess.PIPE,
19         stderr=subprocess.PIPE,
20     )
21     cmd_msg = cmd_obj.stdout.read()
22     numb_b = struct.pack("i",len(cmd_msg))
23     conn.send(numb_b + cmd_msg)        # 把   总字节流长度 + 字节内容  发给接收方,接收方接收前4个字节拿到总字节长度, 
24                                        #  然后按照总字节流长度来接收.
25 
26 
27 # 客户端(接收方)
28 import socket
29 import struct
30 
31 client = socket.socket()
32 ip_port = ("192.168.12.42",8520)
33 client.connect(ip_port)
34 
35 while 1:
36     cmd_msg = bytes(input("请输入cmd指令: "),"utf8")
37     client.send(cmd_msg)
38     numb_b = client.recv(4)
39     numb_len = struct.unpack("i",numb_b)[0]
40     msg = client.recv(numb_len)
41     print(str(msg,"gbk"))