python/socket编程之粘包

python/socket编程之粘包

粘包:

只有TCP有尿包现象,UDP永远不会粘包。

首先需要掌握一个socket收发消息的原理

发送端可以是1k,1k的发送数据而接受端的应用程序可以2k,2k的提取数据,当然也有可能是3k或者多k提取数据,也就是说,应用程序是不可见的,因此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时才会清除缓冲区内容。数据是可靠的,但是会粘包。

    两种情况下会发生粘包:

1.发送端需要等本机的缓冲区满了以后才发送出去,造成粘包(发送数据时间间隔很端,数据很小,会合在一个起,产生粘包)

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

粘包实例:

服务端
import socket
import subprocess
din=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
ip_port=(‘127.0.0.1‘,8080)
din.bind(ip_port)
din.listen(5)
conn,deer=din.accept()
data1=conn.recv(1024)
data2=conn.recv(1024)
print(data1)
print(data2)
客户端
import socket
import subprocess
din=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
ip_port=(‘127.0.0.1‘,8080)
din.connect(ip_port)
din.send(‘helloworld‘.encode(‘utf-8‘))
din.send(‘sb‘.encode(‘utf-8‘))

low比的解决粘包的方法:

在客户端发送下边添加一个时间睡眠,就可以避免粘包现象。在服务端接收的时候也要进行时间睡眠,才能有效的避免粘包情况

#客户端
import socket
import time
import subprocess
din=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
ip_port=(‘127.0.0.1‘,8080)
din.connect(ip_port)
din.send(‘helloworld‘.encode(‘utf-8‘))
time.sleep(3)
din.send(‘sb‘.encode(‘utf-8‘))
#服务端
import socket
import time
import subprocess
din=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
ip_port=(‘127.0.0.1‘,8080)
din.bind(ip_port)
din.listen(5)
conn,deer=din.accept()
data1=conn.recv(1024)
time.sleep(4)
data2=conn.recv(1024)
print(data1)
print(data2)

大声解决粘包的方法:

为字节流加上自定义固定长度报头,报头中包含字节流长度,然后依次send到对端,对端在接受时,先从缓存中取出定长的报头,然后再取真是数据。

使用struct模块

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

struct模块

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

>>> res=struct.pack(‘i‘,1111111111111)  #打包成固定长度的bytes

>>> struct.unpack(“I”,res)             #解包

采用自定义报头的形式:

#服务端
import socket      #导入模块
import struct      #导入模块
import subprocess  #导入模块
din=socket.socket(socket.AF_INET,socket.SOCK_STREAM)   #基于网路家族以数据流的形式传输
ip=(‘127.0.0.1‘,8080)   #标识服务端唯一的地址
din.bind(ip)            #绑定地址
din.listen(5)           #设置链接缓冲池最大数量
while True:
    conn,addr=din.accept()   #等待链接进入
    print(‘------>‘,addr)
    while True:
        try:                 #开始捕捉异常
            cmd=conn.recv(1024)   #把接收的内容赋值给变量cmd
            res=subprocess.Popen(cmd.decode(‘utf-8‘),shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)    #设置一个管道,以shell的方式写入,判断如果是正确的命令就放到标准输出的管道中,否则就放到错误输出的管道中
            dui=res.stdout.read()    #读取标准输出管道中的内容赋值给dui
            cuo=res.stderr.read()    #读取错误输出管道中的内容赋值给cuo
            data_bat=len(dui)+len(cuo)  #把dui和cuo的内容长度相加赋值给data_bat
            conn.send(struct.pack(‘i‘,data_bat))  #通过模块模仿报头形式发送给客户端
            conn.send(dui)    #把dui的发送给客户端
            conn.send(cuo)    #把cuo的发送给客户端
        except Exception:     #结束捕捉异常
            break             #跳出
    conn.close()              #断开链接
din.close()                   #关闭基于网络家族传输的链接
#客户端
import socket
import struct
din=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
ip_port=(‘127.0.0.1‘,8080)
din.connect(ip_port)
while True:
    cmd=input(‘请输入命令:‘).strip()
    if not cmd:continue
    din.send(bytes(cmd,encoding=‘utf-8‘))
    baotou=din.recv(4)
    data_size=struct.unpack(‘i‘,baotou)[0]
    rec_size=0
    rec_data=b‘‘
    while rec_size < data_size:
        data=din.recv(1024)
        rec_size+=len(data)
        rec_data+=data

    print(rec_data.decode(‘gbk‘))

din.close()

牛逼报头的形式:

服务端import struct
import socket
import json
import subprocess
din=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
ip=(‘127.0.0.1‘,8080)
din.bind(ip)
din.listen(5)
while True:
    conn,addr=din.accept()
    print(‘------->>>‘)
    while True:
        try:
            dr=conn.recv(1024)
            res=subprocess.Popen(dr.decode(‘utf-8‘),shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
            dui=res.stdout.read()
            cuo=res.stderr.read()
            data_lik=len(dui)+len(cuo)
            head_dic={‘data_lik‘:data_lik}
            head_json=json.dumps(head_dic)
            head_bytes=head_json.encode(‘utf-8‘)
            head_len=len(head_bytes)
            #发送报头长度
            conn.send(struct.pack(‘i‘,head_len))
            # 发送报头
            conn.send(head_bytes)
            #发送真是数据
            conn.send(dui)
            conn.send(cuo)
        except Exception:
            break
    conn.close()
din.close()
客户端import struct
import socket
import json
din=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
ip=(‘127.0.0.1‘,8080)
din.connect(ip)
while True:
    run=input(‘请输入命令:‘)
    if not run:continue
    din.send(bytes(run,encoding=‘utf-8‘))
    data=din.recv(4)
    head_len=struct.unpack(‘i‘,data)[0]

    head_bytes=din.recv(head_len)
    head_json=head_bytes.decode(‘utf-8‘)
    head_dic=json.loads(head_json)

    data_lik=head_dic[‘data_lik‘]
    recv_size=0
    recv_data=b‘‘
    while recv_size < data_lik:
        data=din.recv(1024)
        recv_size+=len(data)
        recv_data+=data
        print(recv_data.decode(‘gbk‘))
din.close()
时间: 2024-12-26 21:57:49

python/socket编程之粘包的相关文章

Socket编程--TCP粘包问题

TCP是个流协议,它存在粘包问题 产生粘包的原因是: TCP所传输的报文段有MSS的限制,如果套接字缓冲区的大小大于MSS,也会导致消息的分割发送. 由于链路层最大发送单元MTU,在IP层会进行数据的分片. 应用层调用write方法,将应用层的缓冲区中的数据拷贝到套接字的发送缓冲区.而发送缓冲区有一个SO_SNDBUF的限制,如果应用层的缓冲区数据大小大于套接字发送缓冲区的大小,则数据需要进行多次的发送. 粘包问题的解决 ①:发送定长包 这里需要封装两个函数: ssize_t readn(int

java socket编程解决粘包和丢包问题

##socket 丢包粘包解决方式 采用固定头部长度(一般为4个字节),包头保存的是包体的长度 header+body 包头+包体 思路是:先读出一个包头,得到包体的长度,解析出包体 public class SocketServer { public static void main(String args[]) { ServerSocket serverSocket; try { serverSocket = new ServerSocket(); serverSocket.bind(new

Python—socket编程和黏包问题

TCP协议与UDP协议 TCP(transport control protocol,传输控制协议)是面向连接的,面向流的,提供高可靠性服务.收发两端(客户端和服务器端)都要有一一成对的socket,因此,发送端为了将多个发往接收端的包,更有效的发到对方,使用了优化方法(Nagle算法),将多次间隔较小且数据量小的数据,合并成一个大的数据块,然后进行封包.这样,接收端,就难于分辨出来了,必须提供科学的拆包机制. 即面向流的通信是无消息保护边界的. UDP(user datagram protoc

python socket编程入门(编写server实例)+send 与sendall的区别与使用方法

python 编写server的步骤: 1. 第一步是创建socket对象.调用socket构造函数.如: socket = socket.socket( family, type ) family参数代表地址家族,可为AF_INET或AF_UNIX.AF_INET家族包括Internet地址,AF_UNIX家族用于同一台机器上的进程间通信. type参数代表套接字类型,可为SOCK_STREAM(流套接字)和SOCK_DGRAM(数据报套接字). 2. 第二步是将socket绑定到指定地址.这

PYTHON SOCKET编程简介

原文地址: PYTHON SOCKET编程详细介绍 Python 提供了两个基本的 socket 模块. 第一个是 Socket,它提供了标准的 BSD Sockets API. 第二个是 SocketServer, 它提供了服务器中心类,可以简化网络服务器的开发. 下面讲的是Socket模块功能 1.Socket 类型 套接字格式: socket(family,type[,protocal]) 使用给定的地址族.套接字类型.协议编号(默认为0)来创建套接字. socket类型 描述 socke

python Socket编程-python API 与 Linux Socket API之间的关系

python socket编程 服务端 #!/usr/bin/env python # coding=utf-8 from socket import * HOST = '' PORT = 2345 BUFSIZE = 1024 ADDR = (HOST,PORT) #创建AF_INET地址族,TCP的套接字 with socket(AF_INET,SOCK_STREAM) as tcpSerSock: #绑定ip和端口 tcpSerSock.bind(ADDR) #监听端口,是否有请求 tcp

Python Socket 编程——聊天室演示样例程序

上一篇 我们学习了简单的 Python TCP Socket 编程,通过分别写服务端和client的代码了解主要的 Python Socket 编程模型.本文再通过一个样例来加强一下对 Socket 编程的理解. 聊天室程序需求 我们要实现的是简单的聊天室的样例,就是同意多个人同一时候一起聊天.每一个人发送的消息全部人都能接收到,类似于 QQ 群的功能,而不是点对点的 QQ 好友之间的聊天.例如以下图: 图来自:http://www.ibm.com/developerworks/linux/tu

python socket编程 TCP

python socket编程 TCP by wuxy server.py import socket import commands BUF_SIZE = 1024 server_addr = ('127.0.0.1',8888) server = socket.socket(socket.AF_INET,socket.SOCK_STREAM) server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) server.bind(se

python socket编程 UDP

python socket编程 UDP by 伍雪颖 server.py import socket BUF_SIZE = 1024 server_addr = ('127.0.0.1',8888) server = socket.socket(socket.AF_INET,socket.SOCK_DGRAM) server.bind(server_addr) while True: print "waiting for data" data,client_addr = server.