day27 粘包及粘包的解决方案

1.   粘包现象

　　先了解一个词MTU

MTU是Maximum Transmission Unit的缩写。意思是网络上传送的最大数据包。MTU的单位是字节。 大部分网络设备的MTU都是1500个字节，
也就是1500B。如果本机一次需要发送的数据比网关的MTU大，大的数据包就会被拆开来传送，这样会产生很多数据包碎片，增加丢包率，降低网络速度

　　超出缓冲区大小会报下面的错误，或者udp协议的时候，你的一个数据包的大小超过了你一次recv能接受的大小，也会报下面的错误，tcp不会，但是超出缓存区大小的时候，肯定会报这个错误。

　　

2.   模拟粘包现象

产生粘包的两种情况:

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

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

 会产生粘包现象就是因为,接收方不知到发过来的数据长度,从那边是开始,那边是长度,以及接收方和发送方的缓存及优化机制,这是tcp socket类型才会出现的,因为tcp是面向流式数据,而udp 不会,

因为udp是面向包的数据形式,消息有边界,就算你发的是空消息(回车),也能发送,而tcp是不能发送回车的,如果数据长度大于udp 一次性能够发送的,他就会报错,直接弃包

 下面,模拟一下产生粘包

import socket
import subprocess
server=socket.socket()
ip_port=("127.0.0.1",8099)
server.bind(ip_port)
server.listen()

conn,addr=server.accept()
while 1:
    from_client_cmd=conn.recv(1024).decode("utf-8")  #接收客户端发来的指令

    sub_obj=subprocess.Popen(
                from_client_cmd,
                shell=True,
                stdout=subprocess.PIPE,
                stderr=subprocess.PIPE,
                             )
                #四个参数,输入指令,显示窗口,标准化输出,错误显示
                #subprocess read()之后得到的是bytes类型
    cmd_ret=sub_obj.stdout.read()          #指令执行的结果
    print("结果长度",len(cmd_ret))
    conn.send(cmd_ret)                 #把结果发送给客户端

import socket

client=socket.socket()
server_ip_port=("127.0.0.1",8099)
client.connect(server_ip_port)


while 1:
    client_cmd=input("请输入系统指令:")  #向服务端发送指令
    client.send(client_cmd.encode("utf-8"))

    from_server_msg=client.recv(1024).decode("gbk")  #服务端执行指令之后返回的内容
    print(from_server_msg)                         #打印出来发现和实际上的不一样(内容不全)

3.    粘包的解决方案一

利用的原理是把数据长度先告接收方,接收方接到长度产生应答,服务端确认接收方接到消息长度之后再发送数据

import socket
import subprocess

server=socket.socket()
ip_port = ('127.0.0.1',8001)
server.bind(ip_port)

server.listen()
conn,addr=server.accept()
while 1:
    from_client_cmd=conn.recv(1024).decode("utf-8") #接收客户端发来的指令

    sub_obj=subprocess.Popen(
        from_client_cmd,
        shell=True,
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE,
    )

    sub_ret=sub_obj.stdout.read()          #执行指令得到结果
    a=str(len(sub_ret)).encode("utf-8")   #把指令内容的长度转换成字符串发给客户端
    print(a)
    conn.send(a)               

    a=conn.recv(1024).decode("utf-8")             #确认客户端接收到了返回内容的长度
    if a=="ok":
        conn.send(sub_ret)                      #发送指令的结果
    else:
        print("客户端没有收到消息")

import socket

client = socket.socket()
server_ip_port = ('127.0.0.1',8001)
client.connect(server_ip_port)

while 1:
    cmd=input("请输入指令")
    client.send(cmd.encode("utf-8"))

    from_server_leng=client.recv(1024).decode('utf-8')
    client.send(b"ok")

    from_server_msg=client.recv(int(from_server_leng)).decode("gbk")
    print(from_server_msg)

4.    粘包解决方案二

和方案一大致类似,就是针对数据比较大的,切片进行

import socket

client = socket.socket()
server_ip_port = ('127.0.0.1',8001)
client.connect(server_ip_port)

while 1:
    cmd=input("请输入指令")
    client.send(cmd.encode("utf-8"))

    from_server_leng=client.recv(1024).decode('utf-8')
    client.send(b"ok")

    from_server_msg=client.recv(int(from_server_leng)).decode("gbk")
    print(from_server_msg)

import subprocess
import socket

server_ip_port=("127.0.0.1",8009)
client=socket.socket()
client.connect(server_ip_port)

all_recv_len = 0         #接到的数据长度
all_data_byte = b''         #接到的数据

while 1:
    cmd=input("请输入你的指令")
    client.send(cmd.encode("utf-8"))

    data_len=client.recv(1024).decode("utf-8")#接到字符串的长度,解码
    print(data_len)
    data_real_len=int(data_len)   #转换成整形

    client.send(b"ok")   #根服务端说接到了数据长度

    while all_recv_len < data_real_len:
        ever_rec_msg=client.recv(1024)     #每次接收一段的信息
        ever_rec_len=len(ever_rec_msg)    #每接一段的长度
        all_recv_len+=ever_rec_len      #所接收总长度的累计
        all_data_byte+=ever_rec_msg    #接收的总信息

    print(all_data_byte.decode("gbk"))

5.    粘包解决方案三

原理是:利用struct模块把消息长度的转换成四个字节,并发在消息前,接收方先接四个字节的内容,通过转换的到消息的长度,再根据接收到的长度去接收内容

import subprocess
import socket

server_ip_port=("127.0.0.1",8009)
client=socket.socket()
client.connect(server_ip_port)

all_recv_len = 0         #接到的数据长度
all_data_byte = b''         #接到的数据

while 1:
    cmd=input("请输入你的指令")
    client.send(cmd.encode("utf-8"))

    data_len=client.recv(1024).decode("utf-8")#接到字符串的长度,解码
    print(data_len)
    data_real_len=int(data_len)   #转换成整形

    client.send(b"ok")   #根服务端说接到了数据长度

    while all_recv_len < data_real_len:
        ever_rec_msg=client.recv(1024)     #每次接收一段的信息
        ever_rec_len=len(ever_rec_msg)    #每接一段的长度
        all_recv_len+=ever_rec_len      #所接收总长度的累计
        all_data_byte+=ever_rec_msg    #接收的总信息

    print(all_data_byte.decode("gbk"))

import socket
import subprocess
import struct

server=socket.socket()
ip_port=("127.0.0.1",9000)
server.bind(ip_port)

server.listen()

conn,sddr=server.accept()
while 1:
    c_cmd=conn.recv(1024).decode("utf-8")  #接收指令


    sub_obj=subprocess.Popen(
        c_cmd,
        shell=True,
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE,
    )
    ret_cmd=sub_obj.stdout.read() #指令返回结果
    data_len=len(ret_cmd)  #得到结果长度

    a=struct.pack("i",data_len)   #把结果长度打包成4个字节

    conn.send(a+ret_cmd)        #把结果长度以前四个字节和真实内容拼接

 注:以上三种方案,其实就是先告诉消息的头和尾,让节后送方知道哪里是起始,哪里是结束

总结一下:粘包成因

TCP（transport control protocol，传输控制协议）是面向连接的，面向流的，提供高可靠性服务。
收发两端（客户端和服务器端）都要有一一成对的socket，因此，发送端为了将多个发往接收端的包，更有效的发到对方，使用了优化方法（Nagle算法），将多次间隔较小且数据量小的数据，合并成一个大的数据块，然后进行封包。
这样，接收端，就难于分辨出来了，必须提供科学的拆包机制。 即面向流的通信是无消息保护边界的。 
对于空消息：tcp是基于数据流的，于是收发的消息不能为空，这就需要在客户端和服务端都添加空消息的处理机制，防止程序卡住，而udp是基于数据报的，即便是你输入的是空内容（直接回车），也可以被发送，udp协议会帮你封装上消息头发送过去。 
可靠黏包的tcp协议：tcp的协议数据不会丢，没有收完包，下次接收，会继续上次继续接收，己端总是在收到ack时才会清除缓冲区内容。数据是可靠的，但是会粘包。

tcp 的拆包机制:

当发送端缓冲区的长度大于网卡的MTU时，tcp会将这次发送的数据拆成几个数据包发送出去。 
MTU是Maximum Transmission Unit的缩写。意思是网络上传送的最大数据包。MTU的单位是字节。 大部分网络设备的MTU都是1500。如果本机的MTU比网关的MTU大，大的数据包就会被拆开来传送，这样会产生很多数据包碎片，增加丢包率，降低网络速度。

socket数据传输过程中的用户态与内核态说明

发送端可以是一K一K地发送数据，而接收端的应用程序可以两K两K地提走数据，当然也有可能一次提走3K或6K数据，或者一次只提走几个字节的数据。
也就是说，应用程序所看到的数据是一个整体，或说是一个流（stream），一条消息有多少字节对应用程序是不可见的，因此TCP协议是面向流的协议，这也是容易出现粘包问题的原因。
而UDP是面向消息的协议，每个UDP段都是一条消息，应用程序必须以消息为单位提取数据，不能一次提取任意字节的数据，这一点和TCP是很不同的。
怎样定义消息呢？可以认为对方一次性write/send的数据为一个消息，需要明白的是当对方send一条信息的时候，无论底层怎样分段分片，TCP协议层会把构成整条消息的数据段排序完成后才呈现在内核缓冲区。

例如基于tcp的套接字客户端往服务端上传文件，发送时文件内容是按照一段一段的字节流发送的，在接收方看了，根本不知道该文件的字节流从何处开始，在何处结束

此外，发送方引起的粘包是由TCP协议本身造成的，TCP为提高传输效率，发送方往往要收集到足够多的数据后才发送一个TCP段。若连续几次需要send的数据都很少，通常TCP会根据优化算法把这些数据合成一个TCP段后一次发送出去，这样接收方就收到了粘包数据。

6.udp为什么不会产生粘包

UDP（user datagram protocol，用户数据报协议）是无连接的，面向消息的，提供高效率服务。 
不会使用块的合并优化算法，, 由于UDP支持的是一对多的模式，所以接收端的skbuff(套接字缓冲区）采用了链式结构来记录每一个到达的UDP包，在每个UDP包中就有了消息头（消息来源地址，端口等信息），这样，对于接收端来说，就容易进行区分处理了。 即面向消息的通信是有消息保护边界的。 
对于空消息：tcp是基于数据流的，于是收发的消息不能为空，这就需要在客户端和服务端都添加空消息的处理机制，防止程序卡住，而udp是基于数据报的，即便是你输入的是空内容（直接回车），也可以被发送，udp协议会帮你封装上消息头发送过去。 
不可靠不黏包的udp协议：udp的recvfrom是阻塞的，一个recvfrom(x)必须对唯一一个sendinto(y),收完了x个字节的数据就算完成,若是y;x数据就丢失，这意味着udp根本不会粘包，但是会丢数据，不可靠。

 用UDP协议发送时，用sendto函数最大能发送数据的长度为：65535- IP头(20) – UDP头(8)＝65507字节。用sendto函数发送数据时，如果发送数据长度大于该值，则函数会返回错误。（丢弃这个包，不进行发送） 

    用TCP协议发送时，由于TCP是数据流协议，因此不存在包大小的限制（暂不考虑缓冲区的大小），这是指在用send函数时，数据长度参数不受限制。而实际上，所指定的这段数据并不一定会一次性发送出去，如果这段数据比较长，会被分段发送，如果比较短，可能会等待和下一次数据一起发送。

总结

黏包现象只发生在tcp协议中：

1.从表面上看，黏包问题主要是因为发送方和接收方的缓存机制、tcp协议面向流通信的特点。

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

7   .关于struct

例

import struct

num=123131
num_str=struct.pack("i",num)
print(num_str)   #b'xfbxe0x01x00'
print(len(num_str))

a=struct.unpack("i",num_str)[0]
print(a)        # (123131,)  返回的是元组

8    .关于获取shcket缓冲区的方法

import socket
from socket import SOL_SOCKET,SO_REUSEADDR,SO_SNDBUF,SO_RCVBUF
# from socket import SOL_SOCKET,SO_REUSEADDR,SO_SNDBUF,SO_RCVBUF
sk=socket.socket(type=socket.SOCK_DGRAM)

sk.bind(("127.0.0.1",8090))
print('>>>>', (sk.getsockopt(SOL_SOCKET, SO_SNDBUF))/1024)
print(sk.getsockopt(SOL_SOCKET,SO_SNDBUF))
#>>>> 8.0
# 8192

9    .验证连接的合法性

#_*_coding:utf-8_*_
from socket import *
import hmac,os

secret_key=b'linhaifeng bang bang bang'
def conn_auth(conn):
    '''
    认证客户端链接
    :param conn:
    :return:
    '''
    print('开始验证新链接的合法性')
    msg=os.urandom(32)
    conn.sendall(msg)
    h=hmac.new(secret_key,msg)
    digest=h.digest()
    respone=conn.recv(len(digest))
    return hmac.compare_digest(respone,digest)

def data_handler(conn,bufsize=1024):
    if not conn_auth(conn):
        print('该链接不合法,关闭')
        conn.close()
        return
    print('链接合法,开始通信')
    while True:
        data=conn.recv(bufsize)
        if not data:break
        conn.sendall(data.upper())

def server_handler(ip_port,bufsize,backlog=5):
    '''
    只处理链接
    :param ip_port:
    :return:
    '''
    tcp_socket_server=socket(AF_INET,SOCK_STREAM)
    tcp_socket_server.bind(ip_port)
    tcp_socket_server.listen(backlog)
    while True:
        conn,addr=tcp_socket_server.accept()
        print('新连接[%s:%s]' %(addr[0],addr[1]))
        data_handler(conn,bufsize)

if __name__ == '__main__':
    ip_port=('127.0.0.1',9999)
    bufsize=1024
    server_handler(ip_port,bufsize)

服务端

#_*_coding:utf-8_*_
__author__ = 'Linhaifeng'
from socket import *

def client_handler(ip_port,bufsize=1024):
    tcp_socket_client=socket(AF_INET,SOCK_STREAM)
    tcp_socket_client.connect(ip_port)

    while True:
        data=input('>>: ').strip()
        if not data:continue
        if data == 'quit':break

        tcp_socket_client.sendall(data.encode('utf-8'))
        respone=tcp_socket_client.recv(bufsize)
        print(respone.decode('utf-8'))
    tcp_socket_client.close()

if __name__ == '__main__':
    ip_port=('127.0.0.1',9999)
    bufsize=1024
    client_handler(ip_port,bufsize)

客户端(非法:不知道加密方式)

#_*_coding:utf-8_*_
__author__ = 'Linhaifeng'
from socket import *
import hmac,os

secret_key=b'linhaifeng bang bang bang1111'
def conn_auth(conn):
    '''
    验证客户端到服务器的链接
    :param conn:
    :return:
    '''
    msg=conn.recv(32)
    h=hmac.new(secret_key,msg)
    digest=h.digest()
    conn.sendall(digest)

def client_handler(ip_port,bufsize=1024):
    tcp_socket_client=socket(AF_INET,SOCK_STREAM)
    tcp_socket_client.connect(ip_port)

    conn_auth(tcp_socket_client)

    while True:
        data=input('>>: ').strip()
        if not data:continue
        if data == 'quit':break

        tcp_socket_client.sendall(data.encode('utf-8'))
        respone=tcp_socket_client.recv(bufsize)
        print(respone.decode('utf-8'))
    tcp_socket_client.close()

if __name__ == '__main__':
    ip_port=('127.0.0.1',9999)
    bufsize=1024
    client_handler(ip_port,bufsize)