粘包

粘包

• 粘包现象：

  • TCP属于长连接,当服务端与一个客户端进行了连接以后,其他客户端需要(排队)等待.若服务端想要连接另一个客户端,必须首先断开与第一个客户端的连接。

  • 缓冲区：它是内存空间的一部分。也就是说，在内存空间中预留了一定的存储空间，这些存储空间用来缓冲输入或输出的数据，这部分预留的空间就叫做缓冲区，显然缓冲区是具有一定大小的。缓冲区根据其对应的是输入设备还是输出设备，分为输入缓冲区和输出缓冲区

  • 为什么引入缓冲区：高速设备与低速设备的不匹配，势必会让高速设备花时间等待低速设备，我们可以在这两者之间设立一个缓冲区，也就是一个台阶，怕低速的跟不上

  • 缓冲区(buffer)的作用：

    • 1.可以解除两者的制约关系，数据可以直接送往缓冲区，高速设备不用再等待低速设备，提高了计算机的效率。如：我们使用打印机打印文档，由于打印机的打印速度相对较慢，我们先把文档输出到打印机相应的缓冲区，打印机再自行逐步打印。
    • 可以减少数据的读写次数，如果每次数据只传输一点数据，就需要传送很多次，这样会浪费很多时间，因为开始读写与终止读写所需要的时间很长，如果将数据送往缓冲区，待缓冲区满后再进行传送会大大减少读写次数，这样就可以节省很多时间。

  • 区别于缓存区（cache)：CPU的Cache，它中文名称是高速缓冲存储器，读写速度很快，几乎与CPU一样。由于CPU的运算速度太快，内存的数据存取速度无法跟上CPU的速度，所以在cpu与内存间设置了cache为cpu的数据快取区。当计算机执行程序时，数据与地址管理部件会预测可能要用到的数据和指令，并将这些数据和指令预先从内存中读出送到Cache。一旦需要时，先检查Cache，若有就从Cache中读取，若无再访问内存，现在的CPU还有一级cache，二级cache。

    

  • 总结：也就是说缓冲区是内存中的对应的输入输出，而缓存区是cpu中的。

  • 每个socket(套接字)被创建后,都会分配两个缓冲区: 输入缓冲区和输出缓冲区。

  • 在windows复制路径时，从后往前复制路径会自动添加看不见的符号，从前往后就不会有问题

    •  

       

       

       

       

       

       

       

      1、write()/send()并不立即向网络中传输数据,而是先将数据写入缓冲区中,再由TCP协议将数据从缓冲区发送到目标机器. 一旦将数据写入到缓冲区,函数就已经完成任务可以成功返回了,而不用去考虑数据何时被发送到网络,也不用去考虑数据是否已经到达目标机器,因为这些后续操作都是TCP协议负责的事情.

      2、TCP协议独立于 write()/send() 函数,数据有可能刚被写入缓冲区就发送到网络,也可能在缓冲区中不断积压,多次写入的数据被一次性发送到网络,这取决于当时的网络情况,当前线程是否空闲等诸多因素,不由程序员控制.

      3、read()/recv() 函数也是如此,也从输入缓冲区中读取数据,而不是直接从网络中读取

      4、这些I/O缓冲区特性可整理如下:

          1). I/O缓冲区在每个TCP套接字中单独存在

          2). I/O缓冲区在创建套接字时自动生成

          3). 即使关闭套接字也会继续传送输出缓冲区中遗留的数据

          4). 关闭套接字将丢失输入缓冲区中的数据

          5). 输入/输出缓冲区的默认大小一般是8K(了解:可以通过getsockopt()函数获取)

       

       

• 粘包现象的原因：（UDP不存在粘包）

  • TCP采用优化方法：拆包机制和合包机制
  • 接收方没有及时接收缓冲区的包，造成多个包接收（客户端发送了一段数据，服务端只收了一小部分，服务端下次再收的时候还是从缓冲区拿上次遗留的数据，产生粘包）
  • 发送数据时间间隔很短，数据也很小，会合到一起，产生粘包

• 粘包现象的模拟：

  • 发送方连续发送较小的数据,并且每次发送之间的时间间隔很短,此时,两个消息在输出缓冲区黏在一起了.原因是TCP为了传输效率,做了一个优化算法(Nagle),减少连续的小包发送(因为每个消息被包裹以后,都会有两个过程:组包和拆包,这两个过程是极其消耗时间的,优化算法Magle的目的就是为了减少传输时间)。

     

     

     

    ​x

     

     

     

     

    #服务端

    import socket

    server = socket.socket()

    ip_port = ("192.168.15.28", 8001)

    server.bind(ip_port)

    server.listen()

    conn, addr = server.accept()

    ​

    # 连续接收两次消息

    from_client_msg1 = conn.recv(1024).decode("utf-8")

    print("第一次接收到的消息>>>", from_client_msg1)

    from_client_msg2 = conn.recv(1024).decode("utf-8")

    print("第二次接收到的消息>>>", from_client_msg2)

    conn.close()

    server.close()

    ​

    #客户端

    import socket

    client = socket.socket()

    server_ip_port = ("192.168.15.28", 8001)

    client.connect(server_ip_port)

    # 连续发送两次消息

    client.send('Hello'.encode('utf-8'))

    client.send('World'.encode('utf-8'))

    client.close()

    ​

    #结果

    #第一次接收到的消息>>> HelloWorld

    #第二次接收到的消息>>>

     

     

粘包的解决方案：

• 方案一、粘包问题的根源在于,接收端不知道发送端将要传送的字节流的长度,所以解决粘包的方法就是围绕"如何让发送端在发送数据前,把自己将要发送的字节流总长度让接收端知晓"

  •  

     

     

    xxxxxxxxxx

     

     

     

     

    #解决步骤:

    #a. 发送端把"数据长度"传输给接收端

    #b. 接收端把"确认信息"传输给发送端

    #c. 发送端把"全部数据"传输给接收端

    #d. 接收端使用一个死循环接收完所有数据.

    ​

    #服务端代码

    import socket

    import subprocess

    ​

    server = socket.socket()

    ip_port = ('192.168.15.28',8001)

    server.bind(ip_port)

    server.listen()

    conn,addr = server.accept()

    ​

    while 1:

        from_client_cmd = conn.recv(1024).decode('utf-8')   # a.接收来自客户端的cmd指令

        sub_obj = subprocess.Popen(

            from_client_cmd,    # 客户端的指令

            shell=True,    # 使用shell,就相当于使用cmd窗口

            stdout=subprocess.PIPE,  # 标准错误输出,凡是输入错误指令,错误指令输出的报错信息就会被它拿到

            stderr=subprocess.PIPE,

        )

    ​

        server_cmd_msg = sub_obj.stdout.read()              # b.拿到cmd指令返回值 --> stdout接受到的返回值是bytes类型的,并且windows系统的默认编码为gbk

        cmd_msg_len = str(len(server_cmd_msg))              # c.拿到返回值的长度

        print("cmd返回的正确信息的长度>>>",cmd_msg_len)

        conn.send(cmd_msg_len.encode('gbk'))                # c.把"长度"传输给客户端

        from_client_ack = conn.recv(1024).decode('utf-8')   # d.拿到"确认信息"

    ​

        if from_client_ack == "确认":

            conn.send(server_cmd_msg)                   # e.把"cmd指令返回值"传输给客户端

        else:

            continue

    #客户端

    import socket

    client = socket.socket()

    server_ip_port = ('192.168.15.28',8001)

    client.connect(server_ip_port)

    ​

    while 1:

        cmd = input('请输入要执行的指令>>>')                           # a.用户输入cmd指令

        client.send(cmd.encode('utf-8'))                      # b.把"cmd指令"传输给服务端

        from_server_msglen = int(client.recv(1024).decode('gbk'))      # c.接收cmd指令返回值的"字节流长度"

        print('接收到的信息长度是>>>', from_server_msglen)

        client.send('确认'.encode('utf-8'))                   # d.把"确认信息"传输给服务端

        from_server_stdout = client.recv(from_server_msglen).decode('gbk')   # e.设置最大可接收数据量,同时接收"cmd指令返回值"

        print('接收到的指令返回值是>>>', from_server_stdout)

     

     

• 方案二、通过struct模块将数据实体(要传输的数据)的长度打包成一个"4bytes字符串",并将其传输给接收端.接收端取出这个"4bytes字符串",对其进行解包,解包后的内容就是"数据实体的长度",接收端再通过这个长度来继续接收数据实体.（注意粘包的两个send要写一起，否则缓存区会溢出，关闭连接）

  •  

     

     

    xxxxxxxxxx

     

     

     

     

    #struct模块中最重要的两个函数是:

     #pack() --   具有"打包"功能，struct.pack(format, values)  将value打包成bytes的4个

     #unpack() -- 具有"解包"功能  struct.unpack(format, bytes) 通过bytes反解处具体的value

     #解决流程

        #a.拿到数据实体的长度

        #b.将长度打包成"4bytes字符串"

        #c.将"4bytes字符串"发送给客户端

        #d.发送数据实体

    #服务端

    import socket

    import subprocess

    import struct

    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")

        print("来自客户端的指令是>>>")

    ​

        # 通过subprocess模块拿到指令的返回值

        sub_obj = subprocess.Popen(

           from_client_cmd,         # 客户端的指令

           shell=True,

           stdout=subprocess.PIPE,  # 标准输出:接收正确指令的执行结果

           stderr=subprocess.PIPE,  # 标准错误输出:接收错误指令的执行结果

        )

    ​

        # 通过stdout拿到正确指令的执行结果,即需要发送的"数据实体"

        server_cmd_msg = sub_obj.stdout.read()

        # a.拿到数据实体的长度

        cmd_msg_len = len(server_cmd_msg)

        # b.将长度打包成"4bytes字符串"

        msg_len_stru = struct.pack('i',cmd_msg_len)

        # c.将"4bytes字符串"发送给客户端

        conn.send(msg_len_stru)

        # d.发送数据实体 --> sendall() 循环发送数据,直到数据全部发送成功

        conn.sendall(server_cmd_msg)

    ​

     #客户端

    import socket

    import struct

    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"))

        # a.接收打包后的"4bytes字符串"

        from_server_msglen = client.recv(4)

        # b.解包,拿到"数据实体的长度",即unpack_msglen

        unpack_msglen = struct.unpack('i', from_server_msglen)[0]

    ​

        # c.循环接收数据实体,通过"数据实体的长度"来确定跳出循环的条件

        recv_msg_len = 0    # 统计"数据长度"

        all_msg = b''       # 统计"数据实体"

        while recv_msg_len < unpack_msglen:

            every_recv_data = client.recv(1024)

            # 将每次接收到的"数据实体"进行拼接

            all_msg += every_recv_data

            # 将每次接收到的"数据实体的长度"进行累加

            recv_msg_len += len(every_recv_data)

        print(all_msg.decode("gbk"))

    ​

     

     

二、粘包时的问题：

1、在每次文件传送中，如果每次发送的数据长度是大于1460bytes的就会出现最后的数据总量缺少一部分，原因是涉及到网络带宽，一般是1500bytes，但是由于系统一些报头文件也需要一些，所以只有1460bytes可以，解决方法是每次文件只减少len(content)

粘包的应用

• 大文件的传输

   

   

   

  xxxxxxxxxx

   

   

   

   

  #服务端

  import json

  import struct

  import socket

  sk = socket.socket()

  sk.bind(('127.0.0.1',9001))

  sk.listen()

  ​

  conn,addr = sk.accept()

  len_bytes = conn.recv(4)

  num = struct.unpack('i',len_bytes)[0]

  str_dic = conn.recv(num).decode('utf-8')

  dic = json.loads(str_dic)

  ​

  with open(dic['filename'],'wb') as f:

      while dic['filesize']:

          content = conn.recv(2048)

          f.write(content)

          dic['filesize'] -= len(content)

  #客户端

  import os

  import json

  import struct

  import socket

  sk = socket.socket()

  sk.connect(('127.0.0.1',9001))

  ​

  file_path = input('>>>')

  filename = os.path.basename(file_path)

  filesize = os.path.getsize(file_path)

  dic = {'filename':filename,'filesize':filesize}

  bytes_dic = json.dumps(dic).encode('utf-8')

  ​

  len_bytes = struct.pack('i',len(bytes_dic))

  sk.send(len_bytes)

  sk.send(bytes_dic)

  with open(file_path,'rb') as f:

      while filesize > 2048:

          content = f.read(2048)

          sk.send(content)

          filesize -= 2048

      else:

          content = f.read()

          sk.send(content)

  sk.close()

   

   

• 文件的上传加认证

   

   

   

  xxxxxxxxxx

   

   

   

   

  #服务端

  import json

  import socket

  import struct

  import hashlib

  def get_md5(usr,pwd):

      md5 = hashlib.md5(usr.encode('utf-8'))

      md5.update(pwd.encode('utf-8'))

      return md5.hexdigest()

  ​

  def login(conn):

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

      dic = json.loads(msg)

      with open('userinfo', encoding='utf-8') as f:

          for line in f:

              username, password = line.strip().split('|')

              if username == dic['user'] and password == get_md5(dic['user'], dic['passwd']):

                  res = json.dumps({'flag': True}).encode('utf-8')

                  conn.send(res)

                  return True

          else:

              res = json.dumps({'flag': False}).encode('utf-8')

              conn.send(res)

              return False

  ​

  def upload(conn):

      len_bytes = conn.recv(4)

      num = struct.unpack('i', len_bytes)[0]

      str_dic = conn.recv(num).decode('utf-8')

      dic = json.loads(str_dic)

  ​

      with open(dic['filename'], 'wb') as f:

          while dic['filesize']:

              content = conn.recv(2048)

              f.write(content)

              dic['filesize'] -= len(content)

  ​

  sk = socket.socket()

  sk.bind(('127.0.0.1',9001))

  sk.listen()

  while True:

      try:

          conn,addr = sk.accept()

          ret = login(conn)

          if ret:

              upload(conn)

      except Exception as e:

          print(e)

      finally:

          conn.close()

  sk.close()

  ​

  #客户端

  import os

  import json

  import socket

  import struct

  ​

  def upload(sk):

      # 上传文件

      file_path = input('>>>')

      filename = os.path.basename(file_path)

      filesize = os.path.getsize(file_path)

      dic = {'filename': filename, 'filesize': filesize}

      bytes_dic = json.dumps(dic).encode('utf-8')

      len_bytes = struct.pack('i', len(bytes_dic))

      sk.send(len_bytes)

      sk.send(bytes_dic)

  ​

      with open(file_path, 'rb') as f:

          while filesize > 2048:

              content = f.read(2048)

              sk.send(content)

              filesize -= 2048

          else:

              content = f.read()

              sk.send(content)

  usr = input('username :')

  pwd = input('password :')

  dic = {'operate':'login','user':usr,'passwd':pwd}

  bytes_dic = json.dumps(dic).encode('utf-8')

  sk = socket.socket()

  sk.connect(('127.0.0.1',9001))

  sk.send(bytes_dic)

  ​

  res = sk.recv(1024).decode('utf-8')

  dic = json.loads(res)

  if dic['flag']:

      print('登录成功')

      upload(sk)

  else:

      print('登录失败')

  sk.close()

  ​

   

   

• 验证客户端链接合法性：当别人知道我ip，并且通过端口扫描知道我的相应的端口时，岂不是很危险，就必须进行验证，通过验证成功才能进来。通过 hmac模块加盐/也可以使用hashlib，不过比较麻烦。

   

   

   

  xxxxxxxxxx

   

   

   

   

  #服务端

  #其中os.urandom(n) 是一种bytes类型的随机生成n个字节字符串的方法，而且每次生成的值都不相同。再加上md5等加密的处理，就能够成内容不同长度相同的字符串了。

  from socket import *

  import hmac,os

  secret_key=b'Jedan has a big key!'  #密钥

  def conn_auth(conn):

      print('开始验证新链接的合法性')

      msg=os.urandom(32)#生成一个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):

      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)

   #客服端

  from socket import *

  import hmac,os

  secret_key=b'Jedan has a big key！'

  def conn_auth(conn):

  ​

      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)