全球彩票平台_全球彩票注册平台|官网下载地址

热门关键词: 全球彩票平台,全球彩票注册平台,全球彩官网下载地址

【全球彩票平台】华为顾客端与服务器间粘包难

iPhone客户端服务器间粘包难点一蹴而就代码落成案例是本文要介绍的从头到尾的经过,假诺你的iPhone App要与服务器调换数据,服务器一而再发来三个消息时就可能出现粘包的气象:一号新闻确切接收到了,但二号音讯接收的不完全。你能够品味通过CocoaChina论坛的那篇帖子提供的代码化解Nokia客商端与服务器间粘包难点。

全球彩票平台 1

day8--socket网络编制程序跳级,day8--socket

    socket:socket即便达成服务器和客商端数据的置换,服务器端接收并发送数据,客商端发送并接收数据,并且须求小心的是,在python3中,socket值接收字节。因为顾客端在发送连接给服务器的时候,要更改为字节码;服务器端在重返给顾客端的时候,也要调换为字节码。

    如下所示:

劳务器端:

import socket,os
server = socket.socket()
server.bind(("localhost",9999))
server.listen()

while True:
    conn,addr = server.accept()
    print("new conn:",addr)
    while True:
        data = conn.recv(1024)
        if not data:
            print("客户端已断开!")
            break
        print("执行指令:",data)
        cmd_res = os.popen(data.decode()).read()
        print("before send",len(cmd_res))
        if len(cmd_res) == 0:
            cmd_res = "cmd has no output....."
        conn.send(cmd_res.encode('utf-8'))
        print("send done")

server.close()

    上边是劳动器端,使用os.popen()完结数量的拍卖,不过只可以管理字符串,因而要求decode()成字符串格式,然后发送的时候要转移为字节码,encode()。

客户端:

import socket
client = socket.socket()
client.connect(("localhost",9999))

while True:
    cmd = input(">>:").strip()
    if len(cmd) == 0:
        continue
    client.send(cmd.encode('utf-8'))
    '''服务器端发送为空,客户端是卡主的'''
    cmd_res = client.recv(1024)

    print(cmd_res.decode())

client.close()

    首先运营服务器端,然后运维客商端,如下所示:

    服务器端发送数据:

>>:1
cmd has no output.....
>>:dir
build_server.py  get_ip.py       socket_server.py  客户端创建过程.py
class_method.py  lib           s_server.py         类的方法.py
class的方法.py     property属性.py   static_method.py  人类.py
error_handle.py  s_client.py       动态导入.py         上节内容
get_attr.py     socket_client.py  反射.py

>>:ls
build_server.py
class_method.py
class的方法.py
error_handle.py
get_attr.py
get_ip.py
lib
property属性.py
s_client.py
socket_client.py
socket_server.py
s_server.py
static_method.py
动态导入.py
反射.py
客户端创建过程.py
类的方法.py
人类.py
上节内容

    客商端接收数据:

new conn: ('127.0.0.1', 55324)
执行指令: b'1'
before send 0
send done
/bin/sh: 1: 1: not found
执行指令: b'dir'
before send 249
send done
执行指令: b'ls'
before send 219
send done

    当客商端卡顿的时候,表明服务器端是不曾数据发送过来的,因为客户端无法接收空的多少劳动器端也不能够接收空的数据。那样就能够招致卡顿的情状。

    在吸收接纳的时候,会有三个缓存,缓存不满的时候,是不会发送数据的,客商端就接到不到多少。

    由于缓存的存在,客商端接收数据有时候接到不完全,怎么着制止吗?供给服务器告诉顾客端数据的高低,客商端依据数量的大小来接收数据。

    收发同样大,告诉客商端接收数据的分寸,如下:

劳务器端:

import socket,os,time
server = socket.socket()
server.bind(("localhost",9998))
server.listen()

while True:
    conn,addr = server.accept()
    print("new conn:",addr)
    while True:
        data = conn.recv(1024)
        if not data:
            print("客户端已断开!")
            break
        print("执行指令:",data)
        cmd_res = os.popen(data.decode()).read()
        print("before send",len(cmd_res))
        if len(cmd_res) == 0:
            cmd_res = "cmd has no output....."
        conn.send(str(len(cmd_res)).encode('utf-8'))     #先发送数据的大小给客户端 第一个send()发送数据
        time.sleep(1)    #连续发送数据会造成粘包现象,因此要有区分,不然容易粘包,这里让程序休眠一秒,先另外一个接收执行
        conn.send(cmd_res.encode('utf-8'))     #第二个send()发送数据
        print("send done")

server.close()

    在服务器端上,大家总括了发送给顾客端的数额大小,先把数量的尺寸告知顾客端,接收多大的多少,然后在出殡和埋葬真正的多寡给顾客端。在数据发送的时候,要堤防粘包,因为send()一次同时发送,形成粘包的景况,由此让程序休眠一秒,time.sleep(1),让客商端先接收数据,过了一秒重新接收数据,那样就不会粘包。

    粘包境况如下;

 

>>:1
命令结果大小: b'22cmd has no output.....'
Traceback (most recent call last):
  File "/home/zhuzhu/第七天/s_client.py", line 15, in <module>
    while received_size < int(cmd_res_size.decode()):
ValueError: invalid literal for int() with base 10: '22cmd has no output.....'

 

    顾客端发送数据的时候,服务器重回的时候,由于七个send()同有难题候发送数据造成粘包的景象,会晤世错误。两条数据发送的时候总是到一块儿,变成粘包。一回数据发送链接到一同,为何形成粘包,是因为程序实践的太快,客户端接收数据相当的慢,速度赶在下贰遍发送以前。

 

客户端:

import socket
client = socket.socket()
client.connect(("localhost",9998))

while True:
    cmd = input(">>:").strip()
    if len(cmd) == 0:
        continue
    client.send(cmd.encode('utf-8'))
    '''服务器端发送为空,客户端是卡主的'''
    cmd_res_size = client.recv(1024)     #接收命令结果的长度(服务器发送的)
    print("命令结果大小:",cmd_res_size)

    received_size = 0
    while received_size < int(cmd_res_size.decode()):
        data = client.recv(1024)
        received_size  = len(data)    #每次收到的有可能小于1024,所以必须用len()判断
        print(data.decode())
        print(received_size)
    else:
        print("cmd res receive done......",received_size)

    # cmd_res = client.recv(1024)
    #
    # print(cmd_res.decode())

client.close()

    在客户端中,大家先摄取服务器发来的数量的尺寸,然后开端接收数据,当数码长度小于接收长度时,继续吸收接纳,一向等到未有数据接收停止。

    在顾客端中,接收的数目不确定等于规定的长短。並且要合併格式,大家知道,汉字和保加卡托维兹语的尺寸是分化的,汉字是由3个字节组成,而因为是由四个字节组成的。

    首先运转顾客端,然后运行服务器端,如下:

客户端发送数据:
>>:1
命令结果大小: b'22'
cmd has no output.....
22
cmd res receive done...... 22
>>:ls
命令结果大小: b'275'
build_server.py
class_method.py
class的方法.py
error_handle.py
get_attr.py
get_ip.py
lib
property属性.py
s_client.py
socket_client.py
socket_server.py
s_server.py
static_method.py
动态导入.py
反射.py
客户端创建过程.py
类的方法.py
人类.py
上节内容

275
cmd res receive done...... 275
>>:dir
命令结果大小: b'305'
build_server.py  get_ip.py       socket_server.py  客户端创建过程.py
class_method.py  lib           s_server.py         类的方法.py
class的方法.py     property属性.py   static_method.py  人类.py
error_handle.py  s_client.py       动态导入.py         上节内容
get_attr.py     socket_client.py  反射.py

305
cmd res receive done...... 305

    从接收数据能够看看,假如有中文的话,接收数据的长短是区别等的,就是由于汉语的字节是3个,由此都要调换为联合格式,以后调度服务器端,让服务器发送数据的长短的时候也是比照字节的情势发送长度,如下:

import socket,os,time
server = socket.socket()
server.bind(("localhost",9998))
server.listen()

while True:
    conn,addr = server.accept()
    print("new conn:",addr)
    while True:
        data = conn.recv(1024)
        if not data:
            print("客户端已断开!")
            break
        print("执行指令:",data)
        cmd_res = os.popen(data.decode()).read()
        print("before send",len(cmd_res))
        if len(cmd_res) == 0:
            cmd_res = "cmd has no output....."
        conn.send(str(len(cmd_res.encode('utf-8'))).encode('utf-8'))     #先发送数据的大小给客户端
        time.sleep(1)    #连续发送数据会造成粘包现象,因此要有区分,不然容易粘包,这里让程序休眠一秒,先另外一个接收执行
        conn.send(cmd_res.encode('utf-8'))
        print("send done")

server.close()

    重新开动服务器,运维顾客端发送数据,如下:

客户端输入指令:
>>:1
命令结果大小: b'22'
cmd has no output.....
22
cmd res receive done...... 22
>>:ls
命令结果大小: b'275'
build_server.py
class_method.py
class的方法.py
error_handle.py
get_attr.py
get_ip.py
lib
property属性.py
s_client.py
socket_client.py
socket_server.py
s_server.py
static_method.py
动态导入.py
反射.py
客户端创建过程.py
类的方法.py
人类.py
上节内容

275
cmd res receive done...... 275
>>:dir
命令结果大小: b'305'
build_server.py  get_ip.py       socket_server.py  客户端创建过程.py
class_method.py  lib           s_server.py         类的方法.py
class的方法.py     property属性.py   static_method.py  人类.py
error_handle.py  s_client.py       动态导入.py         上节内容
get_attr.py     socket_client.py  反射.py

305
cmd res receive done...... 305

    从上边能够看看,当调治服务器端发送长度的措施现在,接收数据的长短和服务器告知客商端的长短是如出一辙的。由此,在吸收和发送数据的时候要以字节码格局统一总括长度,格式统一很关键,在socket中,总计长度统一格式为:字节码,发送和接收数据都是以字节码的形式操作。

    socket互连网编制程序,其实便是收发数据,只可以收发字节的花样,要统一字节格式,要开展当下传唤,要报告顾客端数据的分寸。然后接过的时候,依据轻重缓急来接受。接收完结之后在继续展开实施顺序。

    粘包:一遍发送数据粘到一齐。

    怎样消除粘包:

  (1)sleep(),停留一秒,time.sleep(0.5);

劳务器端:

 

import socket,os,time
server = socket.socket()
server.bind(("localhost",9999))
server.listen()

while True:
    conn,addr = server.accept()
    print("new conn:",addr)
    while True:
        data = conn.recv(1024)
        if not data:
            print("客户端已断开!")
            break
        print("执行指令:",data)
        cmd_res = os.popen(data.decode()).read()
        print("before send",len(cmd_res))
        if len(cmd_res) == 0:
            cmd_res = "cmd has no output....."
        conn.send(str(len(cmd_res.encode('utf-8'))).encode('utf-8'))     #先发送数据的大小给客户端
        time.sleep(1)    #连续发送数据会造成粘包现象,因此要有区分,不然容易粘包,这里让程序休眠一秒,先另外一个接收执行
        conn.send(cmd_res.encode('utf-8'))
        print("send done")

server.close()

 

    服务器一回发送数据的时日有距离,那样就会幸免数据发送粘包的境况。可是使用sleep()太low了。

    (2)第二回发送之后,接收数据,接收顾客端发来的第三回数据发送接收成功的音讯,举办第二次发送,那样就能够切断数据的出殡和埋葬

劳动器端:

import socket,os,time
server = socket.socket()
server.bind(("localhost",9998))
server.listen()

while True:
    conn,addr = server.accept()
    print("new conn:",addr)
    while True:
        data = conn.recv(1024)
        if not data:
            print("客户端已断开!")
            break
        print("执行指令:",data)
        cmd_res = os.popen(data.decode()).read()
        print("before send",len(cmd_res))
        if len(cmd_res) == 0:
            cmd_res = "cmd has no output....."
        conn.send(str(len(cmd_res.encode('utf-8'))).encode('utf-8'))     #先发送数据的大小给客户端
        # time.sleep(1)    #连续发送数据会造成粘包现象,因此要有区分,不然容易粘包,这里让程序休眠一秒,先另外一个接收执行
        clicent_ack = conn.recv(1024)     #等待接收数据,让下面的发送send()暂时不执行,要收到客户端的数据大小进行响应。wait to confirm
        print("ack from client:",clicent_ack)
        conn.send(cmd_res.encode('utf-8'))
        print("send done")

server.close()

    服务器端,要想幸免粘包,则在五回发送数据直接增添三个先是次发送数据成功的认同,即抽出成功发送数据的指令,如上面所示,conn.recv()其实也未有啥样意义,正是与世隔膜第二遍发送的实行时间,让第1回发送数据在率先次实施到位之后再拓宽试行;

客户端:

import socket
client = socket.socket()
client.connect(("localhost",9998))

while True:
    cmd = input(">>:").strip()
    if len(cmd) == 0:
        continue
    client.send(cmd.encode('utf-8'))
    '''服务器端发送为空,客户端是卡主的'''
    cmd_res_size = client.recv(1024)     #接收命令结果的长度(服务器发送的)
    print("命令结果大小:",cmd_res_size)
    client.send("准备好接收了,loser,可以发了".encode('utf-8'))

    received_size = 0
    while received_size < int(cmd_res_size.decode()):
        data = client.recv(1024)
        received_size  = len(data)    #每次收到的有可能小于1024,所以必须用len()判断
        print(data.decode())
        print(received_size)
    else:
        print("cmd res receive done......",received_size)

    # cmd_res = client.recv(1024)
    #
    # print(cmd_res.decode())

client.close()

    客商端上,数据接收完成以往,发送一条指令,即让服务器接着发送第二条指令。第一条指令是发送数据的深浅,第二条指令是发送数据;

    下边就一挥而就了粘包的情况。

 

    其实,socket在发送和便是数据的时候都以联合签名的,要想隔开,只好进展成功验证,先隔离不让前面send()推行,唯有首先次发送成功以往,而且经过认证,再来举办第二次实行。

socket:socket 正是兑现服务器和顾客端数据的交流,服务器端接收并发送数据,顾客端发送并接收数据,...

劳务器端:

 

与 服务器 间粘包难题消除代码达成案例是本文要介绍的剧情,要是您的 OPPO App要与 服务器 交流数据,服务器一连发来七个消...

客户端代码

 

 

void CNetClient::HandleMsg( char *buf ,int nSize )  {          m_nRecvByteCount  = nSize;          if( m_RecvTimer.GetMilliseconds( ) >= 1000 )          {              // 保存最近十次的网络包流量大小              m_RecvByte.AddToTail( m_nRecvByteCount );              if( m_RecvByte.Count( ) > 10 )                  m_RecvByte.Remove( 0 );              m_nRecvByteCount = 0;              m_RecvTimer.Start( );          }      m_PackBuffer.Put( buf,nSize);       int packsize=0;       int bufsize=m_PackBuffer.TellPut() - m_PackBuffer.TellGet();      while ( TRUE )      {          PACKET_COMMAND *pPack = ( PACKET_COMMAND *)m_PackBuffer.PeekGet( );          if (pPack)          {                          // 查看包头是否完整                          if( bufsize<PACKET_HEAD_SIZE)                          {                              break;                              }                          packsize=pPack->GetSize();                          // 查看是否是完整的网络包                          if( bufsize<packsize )                          {                              break;                              }                            if (!packsize || packsize>sizeof(PACKET_COMMAND))                  {                      m_PackBuffer.SeekGet(SEEK_HEAD,0 );                      m_PackBuffer.SeekPut(SEEK_HEAD,0 );                      break;                  }                                    PACKET_COMMAND pack;                  m_PackBuffer.Get( &pack, packsize);                  HandlePacket(&pack,packsize);                            bufsize = m_PackBuffer.TellPut() - m_PackBuffer.TellGet();                  if (!bufsize)                  {                      m_PackBuffer.SeekGet(SEEK_HEAD,0);                      m_PackBuffer.SeekPut(SEEK_HEAD,0);                      break;                  }          }      }      if ( m_PackBuffer.TellGet() == m_PackBuffer.TellPut() )      {          m_PackBuffer.SeekGet(SEEK_HEAD,0);          m_PackBuffer.SeekPut(SEEK_HEAD,0);      }      } 

服务端接收

    从接收数据可以看出,假使有普通话的话,接收数据的尺寸是分化的,正是出于中文的字节是3个,因此都要退换为统一格式,未来调节服务器端,让服务器发送数据的尺寸的时候也是比照字节的花样发送长度,如下:

客户端:

小结:iPhone客户端服务器间粘包难题消除代码落成案例的剧情介绍完了,希望经过本文的就学能对你持有支持!

全球彩票平台 2

    服务器端发送数据:

    粘包:三回发送数据粘到一块儿。

客商端连接服务端后,服务端举行认证不通过。

import socket,os,time
server = socket.socket()
server.bind(("localhost",9999))
server.listen()

while True:
    conn,addr = server.accept()
    print("new conn:",addr)
    while True:
        data = conn.recv(1024)
        if not data:
            print("客户端已断开!")
            break
        print("执行指令:",data)
        cmd_res = os.popen(data.decode()).read()
        print("before send",len(cmd_res))
        if len(cmd_res) == 0:
            cmd_res = "cmd has no output....."
        conn.send(str(len(cmd_res.encode('utf-8'))).encode('utf-8'))     #先发送数据的大小给客户端
        time.sleep(1)    #连续发送数据会造成粘包现象,因此要有区分,不然容易粘包,这里让程序休眠一秒,先另外一个接收执行
        conn.send(cmd_res.encode('utf-8'))
        print("send done")

server.close()

    重新开动服务器,运营客商端发送数据,如下:

全球彩票平台 3

 

    在顾客端中,接收的数据不显著等于规定的长短。而且要合併格式,我们清楚,汉字和葡萄牙共和国语的尺寸是差别等的,汉字是由3个字节组成,而因为是由四个字节组成的。

 1 # -*- coding: utf-8 -*-
 2 
 3 # 声明字符编码
 4 # coding:utf-8
 5 
 6 import socketserver
 7 import struct
 8 import os
 9 import hmac
10 
11 BUFFER_SIZE = 1024
12 BIND_IP_PORT = ('172.16.6.5', 9999)
13 AUTO_KEY = b"bc892ed2-8b2c-11e8-a328-f40669b72fef"
14 
15 
16 class Communication(socketserver.BaseRequestHandler):
17     """ 通讯类型 """
18 
19     def handle(self):
20         # print(self.client_address)
21         # print(self.request)
22         cl, pl = self.client_address
23         print("[%s:%s]客户端已连接" % (cl, pl))
24         # 合法验证
25         if conn_auth(self.request) == True:
26             # 循环接收客户端信息
27             while True:
28                 try:
29                     # 等待客户端消息
30                     # 数据粘包处理
31                     # 数据的前四位存储的是数据的大小
32                     # 先接收四个字节
33                     length_data = self.request.recv(4)
34                     if not length_data: break
35 
36                     content_length = struct.unpack('i', length_data)[0]
37 
38                     print("接收客户端[%s][%d]大小的数据" % (self.client_address, content_length))
39                     recv_size = 0
40                     recv_msg = b''
41                     # 循环获取数据
42                     while recv_size < content_length:
43                         recv_msg  = self.request.recv(BUFFER_SIZE)
44                         recv_size = len(recv_msg)
45                     print("[%s]>>%s" % (self.client_address, recv_msg.decode('utf-8')))
46                     # 服务器回复客户端
47                     server_msg = input("<<")
48 
49                     server_send_length = struct.pack('i', len(server_msg))
50 
51                     self.request.sendall(server_send_length)
52                     self.request.sendall(server_msg.encode("utf-8"))
53                 except Exception as e:
54                     print("[%s]客户端异常关闭" % self.client_address)
55                     print(e)
56         else:
57             print("客户端【%s:%s】非法接入" % (cl, pl))
58 
59 
60 def conn_auth(conn):
61     # 合法性验证
62     msg = os.urandom(32)
63     conn.sendall(msg)
64     h = hmac.new(AUTO_KEY, msg)
65     digest = h.digest()
66     respone = conn.recv(len(digest))
67     return hmac.compare_digest(respone, digest)
68 
69 
70 if __name__ == "__main__":
71     server = socketserver.ThreadingTCPServer(BIND_IP_PORT, Communication)
72     server.serve_forever()

    在顾客端中,接收的数量不自然等于规定的长短。并且要联合格式,大家清楚,汉字和塞尔维亚语的长度是区别等的,汉字是由3个字节组成,而因为是由三个字节组成的。

import socket,os,time
server = socket.socket()
server.bind(("localhost",9998))
server.listen()

while True:
    conn,addr = server.accept()
    print("new conn:",addr)
    while True:
        data = conn.recv(1024)
        if not data:
            print("客户端已断开!")
            break
        print("执行指令:",data)
        cmd_res = os.popen(data.decode()).read()
        print("before send",len(cmd_res))
        if len(cmd_res) == 0:
            cmd_res = "cmd has no output....."
        conn.send(str(len(cmd_res)).encode('utf-8'))     #先发送数据的大小给客户端 第一个send()发送数据
        time.sleep(1)    #连续发送数据会造成粘包现象,因此要有区分,不然容易粘包,这里让程序休眠一秒,先另外一个接收执行
        conn.send(cmd_res.encode('utf-8'))     #第二个send()发送数据
        print("send done")

server.close()
 1 # -*- coding: utf-8 -*-
 2 
 3 # 声明字符编码
 4 # coding:utf-8
 5 
 6 import socketserver
 7 
 8 BUFFER_SIZE = 1024
 9 ADDRESS_IP = ('172.16.6.5', 7777)
10 
11 
12 class Communication(socketserver.BaseRequestHandler):
13 
14     def handle(self):
15         print(self.request)  # ------->
16         print(self.client_address)
17         while True:
18             try:
19                 client_msg = self.request.recv(BUFFER_SIZE)
20                 if not client_msg:
21                     break
22 
23                 print("客户端【%s】>>%s" % (self.client_address, client_msg))
24                 self.request.sendall(client_msg.upper())
25             except Exception as e:
26                 print(e)
27                 break
28 
29 
30 if __name__ == "__main__":
31     server = socketserver.ThreadingTCPServer(ADDRESS_IP, Communication)
32     server.serve_forever()
new conn: ('127.0.0.1', 55324)
执行指令: b'1'
before send 0
send done
/bin/sh: 1: 1: not found
执行指令: b'dir'
before send 249
send done
执行指令: b'ls'
before send 219
send done

 

  案例:写三个服务端,顾客端。服务端验证客商端是或不是是合法的,验证通过的客商端才干不荒谬进行报导。

    客商端发送数据的时候,服务器再次回到的时候,由于七个send()同期发送数据产生粘包的情景,会冒出谬误。两条数据发送的时候总是到一齐,变成粘包。两回数据发送链接到一齐,为何变成粘包,是因为程序实行的太快,顾客端接收数据相当的慢,速度赶在下叁回发送此前。

    当客商端卡顿的时候,表达服务器端是不曾多少发送过来的,因为顾客端无法接收空的多寡劳务器端也不可能接收空的数目。那样就能促成卡顿的动静。

如上客商端接收的结果为何不是一体化的粗略表达

    粘包意况如下;

    socket:socket尽管完结服务器和客商端数据的置换,服务器端接收并发送数据,顾客端发送并接收数据,而且须要注意的是,在python3中,socket值接收字节。因为顾客端在出殡和埋葬连接给服务器的时候,要转移为字节码;服务器端在回去给顾客端的时候,也要改换为字节码。

   用法很简短,在服务端代码中,创设二个类,让那一个类承接BaseRequestHandler 然后在类中落到实处父类方法handle ,客商端代码不需做改动。详见代码

    首先运转客商端,然后运行服务器端,如下:

劳动器端:

 服务端

 

    收发同样大,告诉顾客端接收数据的分寸,如下:

 1 # -*- coding: utf-8 -*-
 2 
 3 # 声明字符编码
 4 # coding:utf-8
 5 
 6 import socket
 7 import struct
 8 import os, hmac
 9 
10 BUFFER_SIZE = 1024
11 BIND_IP_PORT = ('172.16.6.5', 9999)
12 AUTO_KEY = b"bc892ed2-8b2c-11e8-a328-f40669b72fef"
13 
14 
15 def client_Tcp():
16     client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
17 
18     client.connect(BIND_IP_PORT)
19 
20     # 合法性验证
21     conn_auth(client)
22     while True:
23 
24         msg = input('>>').strip()
25         if not msg: continue
26         if msg == 'quit': break
27 
28         server_send_length = struct.pack('i', len(msg))
29         client.send(server_send_length)
30         client.send(msg.encode('utf-8'))
31         # # 第一种方式:解决粘包问题
32         # content_length = client.recv(BUFFER_SIZE)
33         # # 规定好第一次发来的内容是内容大小,给服务器回复个OK
34         # client.send(b"OK")
35         # content_length = int(content_length.decode('utf-8'))
36         # 第二种方式:解决粘包问题
37         # 先接收四个字节
38         length_data = client.recv(4)
39         content_length = struct.unpack('i', length_data)[0]
40 
41         print("准备接收服务端[%d]大小的数据" % content_length)
42         recv_size = 0
43         recv_msg = b''
44         # 循环获取数据
45         while recv_size < content_length:
46             recv_msg  = client.recv(BUFFER_SIZE)
47             recv_size = len(recv_msg)
48 
49         print("<< %s" % (recv_msg.decode('utf-8')))
50 
51     client.close()
52 
53 
54 def conn_auth(conn):
55     msg = conn.recv(32)
56     h = hmac.new(AUTO_KEY, msg)
57     digest = h.digest()
58     conn.sendall(digest)
59 
60 
61 if __name__ == "__main__":
62     client_Tcp()

服务器端:

>>:1
命令结果大小: b'22cmd has no output.....'
Traceback (most recent call last):
  File "/home/zhuzhu/第七天/s_client.py", line 15, in <module>
    while received_size < int(cmd_res_size.decode()):
ValueError: invalid literal for int() with base 10: '22cmd has no output.....'

在上述案例中自己输入第二个指令dir 结果收到的依然第壹遍的开始和结果

>>:1
cmd has no output.....
>>:dir
build_server.py  get_ip.py       socket_server.py  客户端创建过程.py
class_method.py  lib           s_server.py         类的方法.py
class的方法.py     property属性.py   static_method.py  人类.py
error_handle.py  s_client.py       动态导入.py         上节内容
get_attr.py     socket_client.py  反射.py

>>:ls
build_server.py
class_method.py
class的方法.py
error_handle.py
get_attr.py
get_ip.py
lib
property属性.py
s_client.py
socket_client.py
socket_server.py
s_server.py
static_method.py
动态导入.py
反射.py
客户端创建过程.py
类的方法.py
人类.py
上节内容

    上边就化解了粘包的意况。

本文由全球彩票平台发布于全球彩票平台操作系统,转载请注明出处:【全球彩票平台】华为顾客端与服务器间粘包难

TAG标签: 全球彩票平台
Ctrl+D 将本页面保存为书签,全面了解最新资讯,方便快捷。