详解python中TCP协议中的粘包问题

#服务端
import socket
import subprocess
sever = socket.socket()
sever.bind(('127.0.0.1', 33521))
sever.listen()
while True:
 client, address = sever.accept()
 while True:
  try:
   cmd = client.recv(1024).decode('utf-8')
   p1 = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr= subprocess.PIPE)
   data = p1.stdout.read()
   err_data = p1.stderr.read()
   client.send(data)
   client.send(err_data)
  except ConnectionResetError:
   print('connect broken')
   client.close()
   break
sever.close()
​
​
​
#客户端
import socket
client = socket.socket()
client.connect(('127.0.0.1', 33521))
while True:
 cmd = input('请输入指令(Q\q退出)>>:').strip().lower()
 if cmd == 'q':
  break
 client.send(cmd.encode('utf-8'))
 data = client.recv(1024)
 print(data.decode('gbk'))
client.close()

import struct
s = 123456789
res = struct.pack('i', s)
print(res)
​
res2 = struct.unpack('i', res)
print(res2)
print(res2[0])

#服务器端
import socket
import subprocess
import struct
sever = socket.socket()
sever.bind(('127.0.0.1', 33520))
sever.listen()
while True:
 client, address = sever.accept()
 while True:
  try:
   cmd = client.recv(1024).decode('utf-8')
   #利用子进程模块启动程序
   p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
   #管道输出的信息有正确和错误的
   data = p.stdout.read()
   err_data = p.stderr.read()
   #先将数据的长度发送给客户端
   length = len(data)+len(err_data)
   #利用struct模块将数据的长度信息转化成固定的字节
   len_data = struct.pack('i', length)
   #以下将信息传输给客户端
   #1.数据的长度
   client.send(len_data)
   #2.正确的数据
   client.send(data)
   #2.错误管道的数据
   client.send(err_data)
  except Exception as e:
   client.close()
   print('连接中断。。。。')
   break
   
​
#客户端   
import socket
import struct
​
client = socket.socket()
client.connect(('127.0.0.1', 33520))
while True:
 cmd = input('请输入指令>>:').strip().encode('utf-8')
 client.send(cmd)
 #1.先接收传过来数据的长度是多少，我们通过struct模块固定了字节长度为4
 length = client.recv(4)
 #将struct的字节再转回去整型数字
 len_data = struct.unpack('i', length)
 print(len_data)
 len_data = len_data[0]
 print('数据长度为%s:' % len_data)
​
 all_data = b''
 recv_size = 0
 #2.接收真实的数据
 #循环接收直到接收到数据的长度等于数据的真实长度（总长度）
 while recv_size < len_data:
  data = client.recv(1024)
  recv_size += len(data)
  all_data += data
​
 print('接收长度%s' % recv_size)
 print(all_data.decode('gbk'))

#服务器端
import socket
import subprocess
import datetime
import json
import struct
sever = socket.socket()
sever.bind(('127.0.0.1', 33520))
sever.listen()
while True:
 client, address = sever.accept()
 while True:
  try:
   cmd = client.recv(1024).decode('utf-8')
   #启动子进程
   p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
   #得到子进程运行的数据
   data = p.stdout.read() #子进程运行正确的输出管道数据，数据读出来后是字节
   err_data = p.stderr.read() #子进程运行错误的输出管道数据
   #计算数据的总长度
   length = len(data) + len(err_data)
   print('数据总长度：%s' % length)
​
   #先需要发送报头信息，以下为创建报头信息（至第一次发送）
​
​
   #需要添加时间信息
   time_info = datetime.datetime.now()
   #设置一个字典将一些额外的信息和长度信息放进去然后json序列化，报头字典
   masthead = {}
   #将时间数据放入报头字典中
   masthead['time'] = str(time_info) #时间格式不能被json序列化，所以将其转化为字符串形式
   masthead['length'] = length
​
   #将报头字典json序列化
   json_masthead = json.dumps(masthead)   #得到json格式的报头
   # 将json格式的报头编码成字节形式
   masthead_data = json_masthead.encode('utf-8')
   #利用struct将报头编码的字节的长度转成固定的字节(4个字节）
   masthead_length = struct.pack('i', len(masthead_data))
​
​
   #1.发送报头的长度（第一次发送）
   client.send(masthead_length)
   #2.发送报头信息(第二次发送）
   client.send(masthead_data)
   #3.发送真实数据（第三次发送）
   client.send(data)
   client.send(err_data)
  except ConnectionResetError:
   print('客户端断开连接。。。')
   client.close()
   break
   
   
   
#客户端
import socket
import struct
import json
client = socket.socket()
client.connect(('127.0.0.1', 33520))
while True:
 cmd = input('请输入cmd指令(Q\q退出)>>:').strip()
 if cmd == 'q':
  break
​
 #发送CMD指令至服务器
 client.send(cmd.encode('utf-8'))
​
​
 #1.第一次接收，接收报头信息的长度，由于struct模块固定长度为4字节，括号内直接填4
 len_masthead = client.recv(4)
 #利用struct反解报头长度，由于是元组形式，取值得到整型数字masthead_length
 masthead_length = struct.unpack('i', len_masthead)[0]
​
​
 #2.第二次接收，接收报头信息，接收长度为报头长度masthead_length 被编码成字节形式的json格式的字典,
 # 解字符编码得到json格式的字典masthead_data
 masthead_data = client.recv(masthead_length).decode('utf-8')
 #得到报头字典masthead
 masthead = json.loads(masthead_data)
 print('执行时间%s' % masthead['time'])
 #通过报头字典得到数据长度
 data_length = masthead['length']
​
 #3.第三次接收，接收真实数据，真实数据长度为data_length
 # data = client.recv(data_length) #有可能真实数据长度太大会撑爆内存。
 #所以循环读取数据
 all_data = b''
 length = 0
 #循环直到长度大于等于数据长度
 while length < data_length:
  data = client.recv(1024)
  length += len(data)
  all_data += data
 print('数据的总长度：%s' % data_length)
​
 #我的电脑是Windows系统，所以用gbk解码系统发出的信息
 print(all_data.decode('gbk'))