粘包现象

让我们基于tcp先制作一个远程执行命令的程序

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

shell=True,

stderr=subprocess.PIPE,

stdout=subprocess.PIPE)

的结果编码是以当前所在的系统为准的,如果是windows,那么res.stdout.read()独处的就是GBK编码的,在接收端需要用GBK编码

且只能从管道里读一次结果

 

只有TCP有粘包现象,udp永远你不会粘包,  tcp协议是面向流的协议, udp是面向消息的协议

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

tcp为提高传输效率,tcp优化算法会把一些数据合成一个tcp段后一次发送出去,这样接收方就收到了粘包数据

 

tcp在数据传输时,发送端先把数据发送到自己的缓存中,然后协议控制将缓存中的数据发往对端,对端返回一个ack=1,发送端则清理缓存中的数据,对端返回ack=0,则重新发送数据,所以tcp是可靠的

而udp发送数据,对端是不会返回确认信息的,因此不可靠

 

使用tcp协议远程执行命令

from socket import *

import subprocess

 

ip_port=('127.0.0.1',8080)
BUFSIZE=1024

 

tcp_socket_server=socket(AF_INET,SOCK_STREAM)

tcp_socket_server.bind(ip_port)

tcp_socket_server.listen(5)

 

while True:

 

    conn,addr=tcp_socket_server.accept()

    print('客户端‘,addr)

    

    while True:

        cmd=conn.recv(BUFSIZE)

        if len(cmd) == 0:break

   

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

                                             stdout=subprocess.PIPE,

                                             stdin=subprocess.PIPE,

                                              stderr=subprocess.PIPE)       

      stderr=res.stderr.read()

      stdout=res.stdout.read()

       conn,send(stderr)

       conn,send(stdout)

 

客户端

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)

 

while True:

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

    if len(msg) == 0:break

 

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

    act_res=s.recv(BUFSIZE)

 

    print(act_res.decode('utf-8'),end=")

上述程序基于tcp的socket,在运行时会发生粘包

 

小面基于udp制作一个远程执行命令的程序

 from socket import *

import subprocess

 

ip_port=('127.0.0.1',8080)

bufsize=1024

 

udp_server=socket(AF_INET,SOCK=DGRAM)

udp_server.bind(ip_port)

 

while True:

    cmd,addr=udp_server.recvfrom(bufsize)

    print('用户命令’,cmd)

    

    res=subprocess.Popen(cmd.decode('utf-8'),shell=True,stderr=subpross.PIPE,stdout=subprocess.PIPE)

    stderr=res.stderr.read()

    stdout=res.stdout.read()

 

    udp_server.sendto(stderr,addr)

    udp_server.sendto(stdout,addr)

udp_server.close()

客户端

from socket import *

ip_port=('127.0.0.1',8080)

bufsize=1024

 

udp_client=socket(AF_INET,SOCK_DGRAM)

 

while True:

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

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

 

    data,addr=udp_client.recvfrom(bufsize)

    print(data.decode('utf-8'),end=")

以上基于udp的socket,在运行时永远不会发生粘包

 

 

 

 

 

 

解决粘包的办法

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

 low版解决方法

from socket import *

import subprocess

ip_port=('127.0.0.1',8080)

s=socket(AF_INET,SOCK.STREAM)

s.setsockopt(SOL_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,

                                         stdout=subprocess.PIPE,

                                         stderr=subprocess.PIPE)

           err=res.stderr.read()

           if err:

                  ret=err

           else:

                ret=res.stdout.read()

           data_length=len(ret)

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

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

            if data == 'recv_ready'

                    conn.sendall(ret)

        conn.close()

客户端

import socket,time

s=scoket.socket(socket.AF_INET,socket.SOCK.STRAM)

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

 

while True:

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

    if len(msg) ==0:break

    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.deode('utf-8'))

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

 

海峰老师解决粘包的方法

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

 

posted @ 2018-06-25 20:02  m-cai  阅读(154)  评论(0编辑  收藏  举报