python网络编程2-黏包问题

一、复习

# ip地址：一台机器在网络上的位置
# 公网ip 私网ip
# TCP协议：可靠，面向连接的，耗时长
            #三次握手
            #四次挥手
# UDP协议：不可靠，无连接，效率高
# ARP协议：通过ip找mac的过程
# ip协议属于网络osi中的网络层
# TCP协议和UDP协议属于传输层
# arp协议属于数据链路层

二、黏包（第一条和第二条数据合并发送）

tcp：不会丢包会黏包

udp：会丢包不会黏包

tcp黏包案例：

server_tcp端：

#server端
import socket
sk=socket.socket()
sk.bind(('127.0.0.1',8090))
sk.listen()

conn,addr=sk.accept()
while True:
    cmd=input('>>>')
    conn.send(cmd.encode('utf-8'))
    ret1=conn.recv(1024).decode('utf-8')
    ret2 = conn.recv(1024).decode('utf-8')
    print(ret1)
    print(ret2)

conn.close()
sk.close()

client_tcp端：

#client端
import socket
import subprocess
sk=socket.socket()

sk.connect(('127.0.0.1',8090))
while True:
    cmd=sk.recv(1024).decode('utf-8')
    ret=subprocess.Popen(cmd,shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
    std_out='stdout:'+(ret.stdout.read()).decode('gbk')
    std_err='stderr:'+(ret.stderr.read()).decode('gbk')
    sk.send(std_out.encode('utf-8'))
    sk.send(std_err.encode('utf-8'))
sk.close()

运行结果：

udp丢包案例：（udp起server和client）

server_udp端：

import socket
sk = socket.socket(type=socket.SOCK_DGRAM)
ip_port = ('127.0.0.1',8090)
sk.bind(ip_port)
msg, addr = sk.recvfrom(10240)
while True:
    cmd = input('>>>')
    if cmd == 'q':
        break
    sk.sendto(cmd.encode('utf-8'),addr)
    msg1,addr = sk.recvfrom(20480)
    print(msg1.decode('utf-8'))
    msg2, addr = sk.recvfrom(20480)
    print(msg2.decode('utf-8'))
sk.close()

client_udp端：

import socket
import subprocess
sk = socket.socket(type=socket.SOCK_DGRAM)
ip_port = ('127.0.0.1',8090)
sk.sendto(b'hi',ip_port)
while True:
    cmd,addr = sk.recvfrom(1024)
    cmd = cmd.decode('utf-8')
    ret = subprocess.Popen(cmd,shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
    std_out = 'stdout:'+(ret.stdout.read()).decode('gbk')
    std_err = 'stderr:'+(ret.stderr.read()).decode('gbk')
    print(std_out)
    print(std_err)
    sk.sendto(std_out.encode('utf-8'),addr)
    sk.sendto(std_err.encode('utf-8'),addr)
sk.close() #不会黏包，会丢包

运行结果：

运行结果显示，如果udp的接收数据量大小满足发送数据量大小，那么就不会丢包，若是不满足发送数据量大小，则就会报错。而不是丢包

三 、黏包的触发

情况一：发送方的缓存机制：发送端要等缓冲区满才发送出去。造成黏包（发送数据时间间隔很短，数据很小，会合并一起造成粘包）

如：

#server端
import socket
sk=socket.socket()
sk.bind(('127.0.0.1',8080))
sk.listen()
conn,addr=sk.accept()
ret=conn.recv(12)
ret2=conn.recv(12)
print(ret)
print(ret2)
conn.close()
sk.close()

#关闭时会发空消息
# 多个send小的数据连在一起，可能会发生黏包现象，是tcp内部的优化算法引起的

#client端
import socket
sk=socket.socket()
sk.connect(('127.0.0.1',8080))
sk.send(b'hello')
import time
# time.sleep(0.01)
sk.send(b'world')
sk.send(b'dd')
sk.close()

运行结果：（有时会黏包有时不会）

情况二：接收方的缓冲机制

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

如：

# server端
import socket
sk=socket.socket()
sk.bind(('127.0.0.1',8080))
sk.listen()

conn,addr=sk.accept()
ret=conn.recv(2)
ret2=conn.recv(10)
print(ret)
print(ret2)
conn.close()
sk.close()

# 黏包的本职问题：不知道发送数据的长度
#  连续的小数据包会被合并

# client端
import socket
sk=socket.socket()
sk.connect(('127.0.0.1',8080))

sk.send(b'hello,egg')
sk.close()

运行结果：

总结

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

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

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

四、黏包的解决方案

解决方案一：

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

# server
# server 下发命令 给client
import socket
sk=socket.socket()
sk.bind(('127.0.0.1',8080))
sk.listen()
conn,addr=sk.accept()
while True:
    cmd=input(">>>")
    if cmd=='q':
        conn.send(b'q')
        break
    conn.send(cmd.encode('gbk'))
    num=conn.recv(1024).decode('utf-8')
    conn.send(b'ok')
    res=conn.recv(int(num)).decode('gbk')
    print(res)
conn.close()
sk.close()

# client
# 接收server端的命令后在自己的机器上执行
import socket
import subprocess

sk=socket.socket()
sk.connect(('127.0.0.1',8080))
while True:
    cmd=sk.recv(1024).decode('gbk')
    if cmd=='q':
        break
    res=subprocess.Popen(cmd,shell=True,
                         stdout=subprocess.PIPE,
                         stderr=subprocess.PIPE)
    std_out=res.stdout.read()
    std_err=res.stderr.read()
    sk.send(str((len(std_out)+len(std_err))).encode('utf-8'))
    sk.recv(1024)  #ok
    sk.send(std_out)
    sk.send(std_err)
sk.close()


# 好处：确定我到底要接收多大的数据
# recv的大小一般不超过4096
# 要在文件中配置一个配置项：就是每次recv的大小 buffer=4096
# 当我们发送大数据量的时候，要明确的告诉接收方要发送多大数据以便接收方能准确接收到所有数据
# 多用在文件传输过程中
    #大文件的传输一定是按照字节读 每次读固定的字节
    # 传输的过程中 一边读一边传 接收端：一边收一边写
    # send大文件之前，告知大小。大小-4096-4096....-->0  文件传输完
    # recv大文件，先接受大小。再recv2048.不会丢 大小-2048-2048  -->0  文件接收完
# 不好的地方：多了一次交互
# 5个g数据
# send 和sendto在超过一定范围后，都会报错

运行结果：

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

解决方案进阶

刚刚的方法，问题在于我们我们在发送

我们可以借助一个模块，这个模块可以把要发送的数据长度转换成固定长度的字节。这样客户端每次接收消息之前只要先接受这个固定长度字节的内容看一看接下来要接收的信息大小，那么最终接受的数据只要达到这个值就停止，就能刚好不多不少的接收完整的数据了。

struct模块

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

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

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

# server 下发命令 给client
import socket
import struct
sk=socket.socket()
sk.bind(('127.0.0.1',8080))
sk.listen()
conn,addr=sk.accept()
while True:
    cmd=input(">>>")
    if cmd=='q':
        conn.send(b'q')
        break
    conn.send(cmd.encode('gbk'))
    num=conn.recv(4) #4  2048
    num = struct.unpack('i', num)[0]
    res=conn.recv(int(num)).decode('gbk')  #2048
    print(res)
conn.close()
sk.close()

# 连续send两个小数据
# 两个recv，第一个recv特别小
# 远程执行命令的程序：ipconfig--> 2000，只接收1024.就会缓存，下次继续接收上次未接收完的数据

#连续send两个小数据2+8=10
# 2
# 8
#两个recv，第一个recv特别小
# recv（数据的长度）
# 接收server端的命令后在自己的机器上执行
import socket
import subprocess
import struct

sk=socket.socket()
sk.connect(('127.0.0.1',8080))
while True:
    cmd=sk.recv(1024).decode('gbk')
    if cmd=='q':
        break
    res=subprocess.Popen(cmd,shell=True,
                         stdout=subprocess.PIPE,
                         stderr=subprocess.PIPE)
    std_out=res.stdout.read()
    std_err=res.stderr.read()
    len_num=len(std_out)+len(std_err)
    num_by=struct.pack('i',len_num)
    sk.send(num_by)  # 4  2048
    sk.send(std_out)  # 1024
    sk.send(std_err)   #1024
sk.close()

运行结果：

五、ftp发送视频

sever：

import socket
import struct
import json
buffer=1024
# ip地址和端口号需要写在配置文件中
sk=socket.socket()
sk.bind(('127.0.0.1',8080))
sk.listen()

conn,addr=sk.accept()
# 接收
head_len=conn.recv(4)   # 报头长度
head_len=struct.unpack('i',head_len)[0]
head_json=conn.recv(head_len).decode('utf-8')
head=json.loads(head_json)
filesize=head['filesize']
with open(head['filename'],'wb') as f:
    while filesize:
        print(filesize)
        if filesize>=buffer:
            content=conn.recv(buffer)
            f.write(content)
            filesize-=buffer
        else:
            content=conn.recv(filesize)
            f.write(content)
            filesize=0
            break
f.close()
conn.close()
sk.close()

#发送端
import socket
import os
import json
import struct
sk=socket.socket()
sk.connect(('127.0.0.1',8080))
# 发送文件
buffer=2046
# 改成4096文件大小会变：发送和接收时间不匹配
# 读操作快，写速度慢。缓冲数据多

head={'filepath':r'E:\test',
      'filename': '[反贪风暴3]BD国语.mp4',
      'filesize':None}
file_path=os.path.join(head['filepath'],head['filename'])
filesize=os.path.getsize(file_path)
head['filesize']=filesize
json_head=json.dumps(head) #字典转成了字符串
byte_head=json_head.encode('utf-8')  # 字符串转成了bytes
head_len=len(byte_head)   # 报头的长度
pack_len=struct.pack('i',head_len)
sk.send(pack_len)  # 先发报头的长度
sk.send(byte_head)  # 再发送bytes类型的报头
with open(file_path,'rb') as f:
    while filesize:
        print(filesize)
        if filesize>=buffer:
            content=f.read(buffer)   # 每次读取出来的大小
            sk.send(content)
            filesize-=buffer
        else:
            content=f.read(filesize)
            sk.send(content)
            filesize=0
            break
f.close()
sk.close()

参考自https://www.cnblogs.com/Eva-J/articles/8244551.html#_label5