网络编程 - 粘包

1.粘包：
    多个包 多个命令的结果 粘到一起了  因为recv 1024限制了 导致的结果
    参考：http://www.cnblogs.com/linhaifeng/articles/6129246.html

粘包底层原理分析：
    1.运行一个软件 和 哪几个硬件 有关
        硬盘 内存 cpu
    2.启动程序：
        硬盘程序 加载到 内存 启一个软件就占一个内存空间
        os 就有一个内存空间
        os的内存空间 和 软件的内存空间  彼此互相隔离
        
    须知：只有TCP有粘包现象，UDP永远不会粘包。
    所谓粘包问题主要还是因为接收方不知道消息之间的界限，不知道一次性提取多少字节的数据所造成的。

    3.send recv 底层原理
        send 应用程序的代码 把自己的数据 发出去 存放到自己的内存空间里
            发到os的内存里调网卡发数据
            程序的内存和os的内存两个内存互相隔离
                数据copy给os的内存
            send 发给了 自己的os的内存   os会照着tcp协议去发
        recv 通知os 去调网卡 收数据
            1.send发到数据到服务端os的内存  # 慢
            2.os的内存 copy 给程序  # 快
        站在应用程序角度上：
            send: 1.数据发给本地的os   # 耗时短一些
            recv：1.通知os收数据 2.os内存数据copy到应用程序内存中  # 耗时长一些
   
   4.send recv 总结：
        1：不管是recv还是send都不是直接接收对方的数据，而是操作自己的操作系统内存--->不是一个send对应一个recv # 一发可以对应多收 一收对应多发
        2.：recv：
                wait data 耗时非常长
                copy data
            send：
                copy data
        3.数据量比较小 时间间隔比较短 就合并成一个包 再发 
            使用了优化方法（Nagle算法）

   5.recv 有关部门建议的不要超过 8192，再大反而会出现影响收发速度和不稳定的情况

服务端

'''
解决粘包的办法：
    明确知道对方给我发的包的长度
'''
import time
import socket
server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
server.bind(('127.0.0.1',8080))
server.listen(5)
print('strating...')

conn,addr=server.accept()

# 第一次接收5
# res1 = conn.recv(2)
# res2 = conn.recv(2)
res1 = conn.recv(5)
print('第一次：',res1)
time.sleep(6)
#第二次接收
res3 = conn.recv(6).decode('utf-8')
print('第二次：',res3)

'''
第一次： b'helloworld'
第二次： b''
'''

'''
第一次： b'hello'
第二次： b'world'
'''

'''
第一次： b'h'
第二次： b'ello' 
'''

'''
第一次： b'h'
第二次： b'elloworld'  # 客户端粘了 服务端粘了
'''

客户端

'''
粘包不一定会发生：
    数据量比较小 时间比较短 才会发生粘包

粘包是tcp协议底层优化算法决定的！（Nagle算法）
'''
import socket
import time
client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
client.connect(('127.0.0.1',8080))

client.send('hello'.encode('utf-8'))
time.sleep(5) # 解决了粘包 low
client.send('我们'.encode('utf-8'))
# 两个粘成一个包

 

2.简单版 - 解决粘包

strcut 模块的使用

import struct
import json
res = struct.pack('i',429496)
print(res,type(res),len(res))  # 数字转成了 bytes 型
# b'\xb8\x8d\x06\x00' <class 'bytes'> 4

# client.recv(4)
obj = struct.unpack('i',res)
print(obj)

# res = struct.pack('i',1231213123123)  # 数据 不合理  若是发一个文件的话 就有可能 很大

# q Q d 是8位  i l L 是4位
res = struct.pack('d',120000223232123123123121231)
print(res,type(res),len(res))
# b'{\x00\x00\x00' <class 'bytes'> 4

参考： http://blog.csdn.net/w83761456/article/details/21171085
      http://www.cnblogs.com/linhaifeng/articles/6129246.html

header_dic = {
    'filename': 'a.txt',
    'md5': 'xxxxxxx',
    'total_size': 1231231321321232132131232321321321321323221231312123123213213
}
header_json = json.dumps(header_dic)
print(header_json,type(header_json))
header_bytes = header_json.encode('utf-8')
print(header_bytes,type(header_bytes))
print(len(header_bytes))  # 会变

res = struct.pack('i',len(header_bytes))  # 固定长度
print(res,len(res))
data = struct.unpack('i',res)
print(data)

服务端

import subprocess
import socket
import struct
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
# phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) # 重用ip和端口 任然存在4次挥手的状态 解决办法
phone.bind(('127.0.0.1',8080))
phone.listen(0)
print('strating...')
while True:
    conn,client_addr = phone.accept()
    print(client_addr)

    while True:
        try:
            # 1.收命令
            cmd = conn.recv(8096) # 8096 一次接收完  # 系统规定不能超过8096个
            if not cmd:break
            print('客户端数据：',cmd)

            # 2.执行命令，拿到结果
            obj = subprocess.Popen(cmd.decode('utf-8'), shell=True, # 客户端用 utf-8发的
                                   stdout=subprocess.PIPE,
                                   stderr=subprocess.PIPE)
            stdout = obj.stdout.read()
            stderr = obj.stderr.read()

            # 3.把命令的结果返回给客户端
            # 第一步：制作固定长度的报头
            print(len(stdout) + len(stderr))
            total_size = len(stdout) + len(stderr)
            header = struct.pack('i',total_size)
            # 第二部：把报头发给客户端
            conn.send(header)
            # 第三步：再发真实的数据
            # conn.send(stdout+stderr) # 有效率问题的 这里 之后 可以优化
            conn.send(stdout)
            conn.send(stderr)  # 这样会自动粘包 比 + 号的效率高
        except ConnectionResetError:
            break
    conn.close()

phone.close()

客户端

'''
粘包现象 解决了 仔细想想 是有问题的 报头里面 应该 包含对真实数据的描述 就不能这样了
'''
import socket
import struct
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.connect(('127.0.0.1',8080))
while True:
    # 1.发命令
    cmd = input('msg>>>:').strip()  # dir ls
    if not cmd:continue
    phone.send(cmd.encode('utf-8'))

    # 2.拿到命令的结果，并打印  8096 再大 就没 意义了
    # 第一步 先收报头 收到有用的信息
    obj = phone.recv(4)
    # total_size = 10241
    # 第二步：从报头中解析出对真实数据的描述 数据的长度
    total_size = struct.unpack('i', obj)[0]  # i 表示 整数
    # data = phone.recv(1024)   # 这里是个坑 有可能会大于1024 接收数据量的最大限制
    # 第三步：接收真实的数据
    # data = phone.recv(526)   # 这里是个坑 从自己的os的内存里 拿数据 不可能无限大 所以 那个数字不可能无限大
    # data=phone.recv(526)
    # data=phone.recv(526)
    recv_size = 0
    recv_data = b''
    while recv_size < total_size:
        res = phone.recv(526)
        recv_data += res
        recv_size+=len(res)

    print(recv_data.decode('gbk'))

    # print(data.decode('gbk'))   # linux:utf-8  windows:gbk

phone.close()

 

3.终极版 - 解决粘包

服务端

import subprocess
import socket
import struct
import json
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.bind(('127.0.0.1',8080))
phone.listen(5)
print('strating...')
while True:
    conn,client_addr = phone.accept()
    print(client_addr)

    while True:
        try:
            # 1.收命令
            cmd = conn.recv(8096) # 8096 一次接收完
            if not cmd:break
            print('客户端数据：',cmd)

            # 2.执行命令，拿到结果
            obj = subprocess.Popen(cmd.decode('utf-8'), shell=True, # 客户端用 utf-8发的
                                   stdout=subprocess.PIPE,
                                   stderr=subprocess.PIPE)
            stdout = obj.stdout.read()
            stderr = obj.stderr.read()

            # 3.把命令的结果返回给客户端

            # 第一步：制作固定长度的报头  # 将字典转成 str 转成 bytes  用到了序列化
            header_dic = {
                'filename':'a.txt',
                'md5':'xxxxxxx',
                'total_size': len(stdout)+len(stderr)
            }
            header_json = json.dumps(header_dic)
            header_bytes = header_json.encode('utf-8')   # 这里不知道 多长 会粘包！！

            # 第二步先发送报头的长度
            conn.send(struct.pack('i',len(header_bytes)))

            # 第三步：再发报头
            conn.send(header_bytes)

            # 第四部：在发真实的数据
            conn.send(stdout)
            conn.send(stderr)  # 这样会自动粘包 比 + 号的效率高
        except ConnectionResetError:
            break
    conn.close()

phone.close()

客户端

'''
思路：
    1.处理报头 准备发送的字典 先发报头的长度 再收报头 得到数据的长度 在收数据
    做字典 能容纳 很多信息量
    解决了：1.报头信息量少 2.i 格式有限的 解决了
'''
import json
import socket
import struct
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.connect(('127.0.0.1',8080))
while True:
    # 1.发命令
    cmd = input('msg>>>:').strip()  # dir ls
    if not cmd:continue
    phone.send(cmd.encode('utf-8'))

    # 2.拿到命令的结果，并打印
    # 第一步 先收报头的长度
    obj = phone.recv(4)
    header_size = struct.unpack('i',obj)[0]

    # 第二步：在收报头
    header_bytes = phone.recv(header_size)

    # 第三步：从报头中解析出对真实数据的描述
    header_json = header_bytes.decode('utf-8')
    header_dic = json.loads(header_json)
    print(header_dic)
    total_size = header_dic['total_size']

    # 第四步：接收真实的数据
    recv_size = 0
    recv_data = b''
    while recv_size < total_size:
        res = phone.recv(526)
        recv_data += res
        recv_size+=len(res)

    print(recv_data.decode('gbk'))  # linux:utf-8  windows:gbk


phone.close()