python-day30--粘包

一、 什么是粘包

1.须知：只有TCP有粘包现象，UDP永远不会粘包

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

二、两种情况下会发生粘包。

1.发送数据时间间隔很短，数据了很小，会合到一起，产生粘包

 from socket import *
 import time
 phone=socket(AF_INET,SOCK_STREAM)
 phone.connect(('127.0.0.1',8080))

 phone.send('helloworld'.encode('utf-8'))
 phone.send('egon'.encode('utf-8'))

客户端

2.接收方不及时接收缓冲区的包，造成多个包接收（客户端发送了一段数据，服务端只收了一小部分，服务端下次再收的时候还是从缓冲区拿上次遗留的数据，产生粘包）

from socket import *
import time
phone=socket(AF_INET,SOCK_STREAM)
phone.connect(('127.0.0.1',8080))

phone.send('helloworld'.encode('utf-8'))
time.sleep(5)
phone.send('egon'.encode('utf-8'))

客户端

from socket import *
phone=socket(AF_INET,SOCK_STREAM)
phone.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
phone.bind(('127.0.0.1',8080))
phone.listen(5)
conn,client_addr=phone.accept()

data1=conn.recv(8)
print('data1: ',data1)
data2=conn.recv(20)
print('data2:',data2)
data3=conn.recv(20)
print('data3:',data3)
# 结果
# data1:  b'hellowor'
# data2: b'ld'
# data3: b'egon'

服务端

三、

拆包的发生情况

当发送端缓冲区的长度大于网卡的MTU时，tcp会将这次发送的数据拆成几个数据包发送出去。

补充问题一：为何tcp是可靠传输，udp是不可靠传输

基于tcp的数据传输请参考我的另一篇文章http://www.cnblogs.com/linhaifeng/articles/5937962.html，tcp在数据传输时，发送端先把数据发送到自己的缓存中，然后协议控制将缓存中的数据发往对端，对端返回一个ack=1，发送端则清理缓存中的数据，对端返回ack=0，则重新发送数据，所以tcp是可靠的

而udp发送数据，对端是不会返回确认信息的，因此不可靠

补充问题二：send(字节流)和recv(1024)及sendall

recv里指定的1024意思是从缓存里一次拿出1024个字节的数据

send的字节流是先放入己端缓存，然后由协议控制将缓存内容发往对端，如果待发送的字节流大小大于缓存剩余空间，那么数据丢失，用sendall就会循环调用send，数据不会丢失

四、解决粘包的low比处理方法

 import socket
 import subprocess
 import struct
 phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #买手机
 phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) #就是它，在bind前加
 phone.bind(('127.0.0.1',8082)) #绑定手机卡
 phone.listen(5) #开机

 print('starting...')
 while True: #链接循环
     conn,client_addr=phone.accept() #等电话 （链接，客户的的ip和端口组成的元组）
     print('-------->',conn,client_addr)
     #收，发消息
     while True:#通信循环
         try:
             cmd=conn.recv(1024)
             if not cmd:break #针对linux
             #执行cmd命令，拿到cmd的结果，结果应该是bytes类型
             #。。。。
             res = subprocess.Popen(cmd.decode('utf-8'), shell=True,
                                    stdout=subprocess.PIPE,
                                    stderr=subprocess.PIPE)
             stdout=res.stdout.read()
             stderr=res.stderr.read()
             #先发报头(转成固定长度的bytes类型)
             header = struct.pack('i',len(stdout)+len(stderr))
             conn.send(header)
             #再发送命令的结果5
             conn.send(stdout)
             conn.send(stderr)
         except Exception:
             break
     conn.close() #挂电话
 phone.close() #关机

服务端

 import socket
 import struct
 phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #买手机
 phone.connect(('127.0.0.1',8082)) #绑定手机卡
 #发，收消息
 while True:
     cmd=input('>>: ').strip()
     if not cmd:continue
     phone.send(cmd.encode('utf-8'))
     #先收报头
     header_struct=phone.recv(4)
     unpack_res = struct.unpack('i', header_struct)
     total_size=unpack_res[0]
     #再收数据
     recv_size=0 #10241=10240+1
     total_data=b''
     while recv_size < total_size:
         recv_data=phone.recv(1024)
         recv_size+=len(recv_data)
         total_data+=recv_data
     print(total_data.decode('gbk'))
 phone.close()

客户端

五、完美解决tcp协议粘包问题

 import socket
 import subprocess
 import struct
 import json
 phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #买手机
 phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) #就是它，在bind前加
 phone.bind(('127.0.0.1',8082)) #绑定手机卡
 phone.listen(5) #开机

 print('starting...')
 while True: #链接循环
     conn,client_addr=phone.accept() #等电话 （链接，客户的的ip和端口组成的元组）
     print('-------->',conn,client_addr)

     #收，发消息
     while True:#通信循环
         try:
             cmd=conn.recv(1024)
             if not cmd:break #针对linux
             #执行cmd命令，拿到cmd的结果，结果应该是bytes类型
             #。。。。
             res = subprocess.Popen(cmd.decode('utf-8'), shell=True,
                                    stdout=subprocess.PIPE,
                                    stderr=subprocess.PIPE)
             stdout=res.stdout.read()
             stderr=res.stderr.read()
             #制作报头
             header_dic = {
                 'total_size': len(stdout)+len(stderr),
                 'filename': None,
                 'md5': None}

             header_json = json.dumps(header_dic)
             header_bytes = header_json.encode('utf-8')
             #发送阶段
             #先发报头长度
             conn.send(struct.pack('i',len(header_bytes)))
             #再发报头
             conn.send(header_bytes)

             #最后发送命令的结果
             conn.send(stdout)
             conn.send(stderr)
         except Exception:
             break
     conn.close() #挂电话
 phone.close() #关机

服务端

 import socket
 import struct
 import json
 phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #买手机
 phone.connect(('127.0.0.1',8082)) #绑定手机卡

 #发，收消息
 while True:
     cmd=input('>>: ').strip()
     if not cmd:continue

     phone.send(cmd.encode('utf-8'))
     #先收报头的长度
     header_len=struct.unpack('i',phone.recv(4))[0]

     #再收报头
     header_bytes=phone.recv(header_len)
     header_json=header_bytes.decode('utf-8')
     header_dic=json.loads(header_json)
     total_size=header_dic['total_size']

     #最后收数据
     recv_size=0 #10241=10240+1
     total_data=b''
     while recv_size < total_size:
         recv_data=phone.recv(1024)
         recv_size+=len(recv_data)
         total_data+=recv_data
     print(total_data.decode('gbk'))
 phone.close()

客户端