基于UDP的套接字、粘包问题

时间：2023-03-09 06:47:36
基于UDP的套接字、粘包问题

一、基于UDP的套接字

UDP服务端

ss = socket()   #创建一个服务器的套接字

ss.bind()       #绑定服务器套接字

inf_loop:       #服务器无限循环

    cs = ss.recvfrom()/ss.sendto() # 对话(接收与发送)

ss.close()                         # 关闭服务器套接字

UDP客户端

cs = socket()   # 创建客户套接字

comm_loop:      # 通讯循环

    cs.sendto()/cs.recvfrom()   # 对话(发送/接收)

cs.close()                      # 关闭客户套接字

简单示例：

服务端：

基于UDP的套接字、粘包问题
# -*- coding: utf-8 -*-

# __author__ = "maple"

import socket

ip_port=('127.0.0.1',9000)

BUFSIZE=1024

udp_server_client=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)

udp_server_client.bind(ip_port)

while True:

    msg,addr = udp_server_client.recvfrom(BUFSIZE)

    print('recv: ',msg,addr)

    udp_server_client.sendto(msg.upper(),addr)

udp_server_client.close()
基于UDP的套接字、粘包问题

客户端：

基于UDP的套接字、粘包问题
# -*- coding: utf-8 -*-

# __author__ = "maple"

import socket

ip_port=('127.0.0.1',9000)

BUFSIZE=1024

udp_server_client=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)

print(udp_server_client._io_refs)

while True:

    msg = input('>>>:').strip()

    if not msg:continue

    udp_server_client.sendto(msg.encode('utf-8'),ip_port)

    back_msg,addr = udp_server_client.recvfrom(BUFSIZE)

    print(back_msg.decode('utf-8'),addr)

udp_server_client.close()
基于UDP的套接字、粘包问题

二、tcp和udp发送接受数据的区别

1、收发消息的原理

发消息，都是将数据发送到自己端的发送缓存中。

收消息，都是从自己端的环从中收取数据。

1. tcp：send发送数据，recv接受数据。

2. udp：sendto发送数据，recvfrom接受数据。

2、send与sendto的区别

tcp是基于数据流的，而udp是基于数据报的：

  1. send(bytes_data):发送数据流，数据流bytes_data若为空，自己这段的缓冲区也为空，操作系统不会控制tcp协议发空包

  2. sendinto(bytes_data,ip_port)：发送数据报，bytes_data为空，还有ip_port,所有即便是发送空的bytes_data,数据报其实也不是空的，自己这端的缓冲区收到内容，操作系统就会控制udp协议发包。

3、recv与recvfrom的区别

1.tcp协议：

（1）如果收消息缓冲区里的数据为空，那么recv就会阻塞（阻塞很简单，就是一直在等着收）

（2）只不过tcp协议的客户端send一个空数据就是真的空数据，客户端即使有无穷个send空，也跟没有一个样。

（3）tcp基于链接通信

  • 基于链接，则需要listen（backlog），指定半连接池的大小
  • 基于链接，必须先运行的服务端，然后客户端发起链接请求
  • 对于mac系统：如果一端断开了链接，那另外一端的链接也跟着完蛋recv将不会阻塞，收到的是空(解决方法是：服务端在收消息后加上if判断，空消息就break掉通信循环)
  • 对于windows/linux系统：如果一端断开了链接，那另外一端的链接也跟着完蛋recv将不会阻塞，收到的是空(解决方法是：服务端通信循环内加异常处理，捕捉到异常后就break掉通讯循环)

验证（1）：客户端发送空

验证（2）：客户端直接终止程序

#_*_coding:utf-8_*_

import subprocess

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,addr=phone.accept()

while True:

    data=conn.recv(1024)

    print('from client msg is ',data)

    conn.send(data.upper())

服务端

　　

#_*_coding:utf-8_*_

import subprocess

from socket import *

phone=socket(AF_INET,SOCK_STREAM)

phone.connect(('127.0.0.1',8080))

while True:

    msg=input('>>: ')

    phone.send(msg.encode('utf-8'))

    print('Client message has been sent')

    data=phone.recv(1024)

    print('from server msg is ',data.decode('utf-8'))

phone.close()

客户端

　　

.udp协议

（1）如果如果收消息缓冲区里的数据为“空”，recvfrom也会阻塞

（2）只不过udp协议的客户端sendinto一个空数据并不是真的空数据（包含：空数据+地址信息，得到的报仍然不会为空），所以客户端只要有一个sendinto（不管是否发送空数据，都不是真的空数据），服务端就可以recvfrom到数据。

（3）udp无链接

  • 无链接，因而无需listen（backlog），更加没有什么连接池之说了
  • 无链接，udp的sendinto不用管是否有一个正在运行的服务端，可以己端一个劲的发消息，只不过数据丢失
  • recvfrom收的数据小于sendinto发送的数据时，在mac和linux系统上数据直接丢失，在windows系统上发送的比接收的大直接报错
  • 只有sendinto发送数据没有recvfrom收数据，数据丢失

验证（1）：客户端发送空，看服务端结果

#_*_coding:utf-8_*_

、from socket import *

ip_port=('127.0.0.1',9003)

bufsize=1024

udp_server=socket(AF_INET,SOCK_DGRAM)

udp_server.bind(ip_port)

while True:

    data1,addr=udp_server.recvfrom(bufsize)

    print(data1)

服务端

　　

from socket import *

ip_port=('127.0.0.1',9003)

bufsize=1024

udp_client=socket(AF_INET,SOCK_DGRAM)

while True:

    msg=input('>>: ')

    udp_client.sendto(msg.encode('utf-8'),ip_port) #发送空,发现服务端可以接收空

客户端

　　验证（2）：分别运行服务端

#_*_coding:utf-8_*_

from socket import *

ip_port=('127.0.0.1',9003)

bufsize=1024

udp_server=socket(AF_INET,SOCK_DGRAM)

udp_server.bind(ip_port)

data1,addr=udp_server.recvfrom(1)

print('第一次收了 ',data1)

data2,addr=udp_server.recvfrom(1)

print('第二次收了 ',data2)

data3,addr=udp_server.recvfrom(1)

print('第三次收了 ',data3)

print('--------结束----------')

服务端

　　

from socket import *

ip_port=('127.0.0.1',9003)

bufsize=1024

udp_client=socket(AF_INET,SOCK_DGRAM)

udp_client.sendto(b'hello',ip_port)

udp_client.sendto(b'world',ip_port)

udp_client.sendto(b'egon',ip_port)

客户端

　　验证（3）：不运行服务端，单独运行客户端，没有问题，但是消息丢了

#_*_coding:utf-8_*_

from socket import *

ip_port=('127.0.0.1',9003)

bufsize=1024

udp_server=socket(AF_INET,SOCK_DGRAM)

udp_server.bind(ip_port)

data1,addr=udp_server.recvfrom(bufsize)

print('第一次收了 ',data1)

data2,addr=udp_server.recvfrom(bufsize)

print('第二次收了 ',data2)

data3,addr=udp_server.recvfrom(bufsize)

print('第三次收了 ',data3)

print('--------结束----------')

服务端

　　

from socket import *

import time

ip_port=('127.0.0.1',9003)

bufsize=1024

udp_client=socket(AF_INET,SOCK_DGRAM)

udp_client.sendto(b'hello',ip_port)

udp_client.sendto(b'world',ip_port)

udp_client.sendto(b'egon',ip_port)

print('客户端发完消息啦')

time.sleep(100)

客户端

　　

注意：

1.你单独运行上面的udp的客户端，你发现并不会报错，相反tcp却会报错，因为udp协议只负责把包发出去，对方收不收，我根本不管，而tcp是基于链接的，必须有一个服务端先运行着，客户端去跟服务端建立链接然后依托于链接才能传递消息，任何一方试图把链接摧毁都会导致对方程序的崩溃。

2.上面的udp程序，你注释任何一条客户端的sendinto，服务端都会卡住，为什么？因为服务端有几个recvfrom就要对应几个sendinto，哪怕是sendinto(b'')那也要有。

三、粘包及解决办法

1、粘包

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

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

此外，发送方引起的粘包是由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时才会清除缓冲区内容。数据是可靠的，但是会粘包。

两种情况下会发生粘包：

发送端需要等缓冲区满才发送出去，造成粘包（发送数据时间间隔很短，数据了很小，会合到一起，产生粘包）

#_*_coding:utf-8_*_

from socket import *

ip_port=('127.0.0.1',8080)

tcp_socket_server=socket(AF_INET,SOCK_STREAM)

tcp_socket_server.bind(ip_port)

tcp_socket_server.listen(5)

conn,addr=tcp_socket_server.accept()

data1=conn.recv(10)

data2=conn.recv(10)

print('----->',data1.decode('utf-8'))

print('----->',data2.decode('utf-8'))

conn.close()

服务端

　　

#_*_coding:utf-8_*_

import socket

BUFSIZE=1024

ip_port=('127.0.0.1',8080)

s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

res=s.connect_ex(ip_port)

s.send('hello'.encode('utf-8'))

s.send('feng'.encode('utf-8'))

客户端

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

#_*_coding:utf-8_*_

from socket import *

ip_port=('127.0.0.1',8080)

tcp_socket_server=socket(AF_INET,SOCK_STREAM)

tcp_socket_server.bind(ip_port)

tcp_socket_server.listen(5)

conn,addr=tcp_socket_server.accept()

data1=conn.recv(2) #一次没有收完整

data2=conn.recv(10)#下次收的时候,会先取旧的数据,然后取新的

print('----->',data1.decode('utf-8'))

print('----->',data2.decode('utf-8'))

conn.close()

服务端

　　

#_*_coding:utf-8_*_

import socket

BUFSIZE=1024

ip_port=('127.0.0.1',8080)

s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

res=s.connect_ex(ip_port)

s.send('hello feng'.encode('utf-8'))

 客户端

　　

拆包的发生情况

当发送端缓冲区的长度大于网卡的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，数据不会丢失

2、解决办法

方法一（low版）：

问题的根源在于，接收端不知道发送端将要传送的字节流的长度，所以解决粘包的方法就是围绕，如何让发送端在发送数据前，把自己将要发送的字节流总大小让接收端知晓，然后接收端来一个死循环接收完所有数据。

low版本的解决方法

#_*_coding:utf-8_*_

import socket,subprocess

ip_port=('127.0.0.1',8080)

s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

s.bind(ip_port)

s.listen(5)

while True:

    conn,addr=s.accept()

    print('客户端',addr)

    while True:

        msg=conn.recv(1024)

        if not msg:break

        res=subprocess.Popen(msg.decode('utf-8'),shell=True,\

                            stdin=subprocess.PIPE,\

                         stderr=subprocess.PIPE,\

                         stdout=subprocess.PIPE)

        err=res.stderr.read()

        if err:

            ret=err

        else:

            ret=res.stdout.read()

        data_length=len(ret)

        conn.send(str(data_length).encode('utf-8'))

        data=conn.recv(1024).decode('utf-8')

        if data == 'recv_ready':

            conn.sendall(ret)

    conn.close()

 服务端

　　

#_*_coding:utf-8_*_

import socket,time

s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

res=s.connect_ex(('127.0.0.1',8080))

while True:

    msg=input('>>: ').strip()

    if len(msg) == 0:continue

    if msg == 'quit':break

    s.send(msg.encode('utf-8'))

    length=int(s.recv(1024).decode('utf-8'))

    s.send('recv_ready'.encode('utf-8'))

    send_size=0

    recv_size=0

    data=b''

    while recv_size < length:

        data+=s.recv(1024)

        recv_size+=len(data)

    print(data.decode('utf-8'))

客户端

　　

为何low：

程序的运行速度远快于网络传输速度，所以在发送一段字节前，先用send去发送该字节流长度，这种方式会放大网络延迟带来的性能损耗。

方法二：

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

struct模块

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

>>> struct.pack('i',1111111111111)

。。。。。。。。。

struct.error: 'i' format requires -2147483648 <= number <= 2147483647 #这个是范围

基于UDP的套接字、粘包问题

import socket,struct,json

import subprocess

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',8080))

phone.listen(5)

while True:

    conn,addr=phone.accept()

    while True:

        cmd=conn.recv(1024)

        if not cmd:break

        print('cmd: %s' %cmd)

        res=subprocess.Popen(cmd.decode('utf-8'),

                             shell=True,

                             stdout=subprocess.PIPE,

                             stderr=subprocess.PIPE)

        err=res.stderr.read()

        print(err)

        if err:

            back_msg=err

        else:

            back_msg=res.stdout.read()

        conn.send(struct.pack('i',len(back_msg))) #先发back_msg的长度

        conn.sendall(back_msg) #在发真实的内容

    conn.close()

服务端（自定制报头）

　　

#_*_coding:utf-8_*_

import socket,time,struct

s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

res=s.connect_ex(('127.0.0.1',8080))

while True:

    msg=input('>>: ').strip()

    if len(msg) == 0:continue

    if msg == 'quit':break

    s.send(msg.encode('utf-8'))

    l=s.recv(4)

    x=struct.unpack('i',l)[0]

    print(type(x),x)

    # print(struct.unpack('I',l))

    r_s=0

    data=b''

    while r_s < x:

        r_d=s.recv(1024)

        data+=r_d

        r_s+=len(r_d)

    # print(data.decode('utf-8'))

    print(data.decode('gbk')) #windows默认gbk编码

客户端（自定制报头）

　　

我们可以把报头做成字典，字典里包含将要发送的真实数据的详细信息，然后json序列化，然后用struck将序列化后的数据长度打包成4个字节（4个自己足够用了）

发送时：

先发报头长度

再编码报头内容然后发送

最后发真实内容

接收时：

先手报头长度，用struct取出来

根据取出的长度收取报头内容，然后解码，反序列化

从反序列化的结果中取出待取数据的详细信息，然后去取真实的数据内容

import socket,struct,json

import subprocess

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',8080))

phone.listen(5)

while True:

    conn,addr=phone.accept()

    while True:

        cmd=conn.recv(1024)

        if not cmd:break

        print('cmd: %s' %cmd)

        res=subprocess.Popen(cmd.decode('utf-8'),

                             shell=True,

                             stdout=subprocess.PIPE,

                             stderr=subprocess.PIPE)

        err=res.stderr.read()

        print(err)

        if err:

            back_msg=err

        else:

            back_msg=res.stdout.read()

        headers={'data_size':len(back_msg)}

        head_json=json.dumps(headers)

        head_json_bytes=bytes(head_json,encoding='utf-8')

        conn.send(struct.pack('i',len(head_json_bytes))) #先发报头的长度

        conn.send(head_json_bytes) #再发报头

        conn.sendall(back_msg) #在发真实的内容

    conn.close()

服务端：定制稍微复杂一点的报头

　　

from socket import *

import struct,json

ip_port=('127.0.0.1',8080)

client=socket(AF_INET,SOCK_STREAM)

client.connect(ip_port)

while True:

    cmd=input('>>: ')

    if not cmd:continue

    client.send(bytes(cmd,encoding='utf-8'))

    head=client.recv(4)

    head_json_len=struct.unpack('i',head)[0]

    head_json=json.loads(client.recv(head_json_len).decode('utf-8'))

    data_len=head_json['data_size']

    recv_size=0

    recv_data=b''

    while recv_size < data_len:

        recv_data+=client.recv(1024)

        recv_size+=len(recv_data)

    print(recv_data.decode('utf-8'))

    #print(recv_data.decode('gbk')) #windows默认gbk编码

客户端

　　

基于UDP的套接字、粘包问题
 1 from socket import *

 2 import struct,json

 3

 4 ip_port=('127.0.0.1',8080)

 5 client=socket(AF_INET,SOCK_STREAM)

 6 client.connect(ip_port)

 7

 8 while True:

 9     cmd=input('>>: ')

10     if not cmd:continue

11     client.send(bytes(cmd,encoding='utf-8'))

12

13     head=client.recv(4)

14     head_json_len=struct.unpack('i',head)[0]

15     head_json=json.loads(client.recv(head_json_len).decode('utf-8'))

16     data_len=head_json['data_size']

17

18     recv_size=0

19     recv_data=b''

20     while recv_size < data_len:

21         recv_data+=client.recv(1024)

22         recv_size+=len(recv_data)

23

24     print(recv_data.decode('utf-8'))

25     #print(recv_data.decode('gbk')) #windows默认gbk编码

相关文章