基于tcp协议的套接字通信：远程执行命令

要解决粘包问题:
    TCP:流式协议
    特点：
        1、数据流没有开头也没有结果，像水流一样
        2、TCP协议有一个nagle算法，
            nagle算法会将数据量较小，并且时间间隔较短的数据合成一条数据发送，
            这么做可以减少网络IO次数，进而提升传输效率

1.struct模块

#1、把整型数字转成bytes类型

#2、转成的bytes是固定长度的

import struct

import json

header_dic = {

    'total_size': 31222222222121,

    'md5': '123svsaef123sdfasdf',

    'filename': 'a.txt'

}

#序列化：内存中的数据结构----》转成一种中间格式（字符串）----》存到文件中

header_json=json.dumps(header_dic)

print(header_json,type(header_json))

#编码：编码后的结果为bytes类型

header_bytes=header_json.encode('utf-8')

header_size=len(header_bytes)

print(header_size)  #

#打包

obj=struct.pack('i',header_size)

print(obj,len(obj))  # b'Q\x00\x00\x00' 4

#解包

obj2=struct.unpack('i',obj)

print(obj2)  # (81,)

打印结果：

{"total_size": 31222222222121, "md5": "123svsaef123sdfasdf", "filename": "a.txt"} <class 'str'>

81

b'Q\x00\x00\x00' 4

(81,)

result

2.通讯整个流程：

'''

流程：

    服务端：制作报头,把报头信息丢到报头字典里，字典序列化得到json字符串，encode得到bytes

          ---->发报头长度(struct.pack打成4个bytes)--->发送报头---->发真实数据

    客户端：先接收4个bytes:struct.unpack解包报头长度--->接收报头-->

             解析报头：decode得到字符串，反序列化得到报头--->根据报头内的信息，收取真实的数据

'''

3.具体代码如下：

服务端：

from socket import *

import subprocess

import struct

import json

server=socket(AF_INET,SOCK_STREAM)

server.bind(('127.0.0.1',8080))

server.listen(5)               #半连接池：限制的是请求数，而不是连接数

while True:

    conn,client_addr=server.accept() #(连接对象，客户端的ip和端口)  conn：tcp三次握手的一个产物，可以用来收发消息

    print(client_addr)     #此处client_addr的作用是可以知道哪个客户端建的链接，和通讯无关

    while True:

        try:

            cmd=conn.recv(1024)   #cmd为bytes类型，

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

                                 shell=True,

                                 stdout=subprocess.PIPE,

                                 stderr=subprocess.PIPE

                                 )

            stdout=obj.stdout.read()  #拿到系统执行的结果（subprocess执行的是window系统命令，解码需要gbk）

            stderr=obj.stderr.read()

            # 1、制作报头

            header_dic={

                'total_size':len(stdout) + len(stderr),

                'md5':'123svsaef123sdfasdf',

                'filename':'a.txt'

            }

            header_json = json.dumps(header_dic)         #json序列化报头

            header_bytes = header_json.encode('utf-8')   #字符串类型---->bytes类型，发送

            # 2、先发送报头的长度

            header_size=len(header_bytes)

            conn.send(struct.pack('i',header_size))

            # 3、发送报头

            conn.send(header_bytes)

            # 4、发送真实的数据

            conn.send(stdout)     #send只能发bytes类型

            conn.send(stderr)

        except ConnectionResetError:

            break

    conn.close()

server.close()

客户端：

from socket import *

import struct

import json           

client=socket(AF_INET,SOCK_STREAM)

client.connect(('127.0.0.1',8080))

# print(client)

while True:

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

    if not cmd:continue

    client.send(cmd.encode('utf-8'))     #把命令结果发给服务器

    #1、先收报头的长度根据报头内的信息，收取真实的数据

    header_size=struct.unpack('i',client.recv(4))[0]    #bytes类型，想拿到报头长度要对bytes进行解出

    #2、接收报头

    header_bytes=client.recv(header_size)   #对应服务端的发送报头

    #3、解析报头

    header_json=header_bytes.decode('utf-8')    #bytes类型---->字符串类型

    header_dic=json.loads(header_json)         #反序列化拿到报头

    print(header_dic)

    total_size=header_dic[ 'total_size']

    # print(total_size) #1025

    #4、接收数据

    recv_size=0

    res=b''

    while recv_size < total_size:

        recv_data=client.recv(1024)

        res+=recv_data

        recv_size+=len(recv_data)

    print(res.decode('gbk'))

client.close()

巴特西

基于tcp协议的套接字通信：远程执行命令

最新文章

热门文章