python学习之socket&黏包

7.4 socket

【重要】

避免学习各层的接口,以及协议的使用, socket已经封装好了所有的接口，直接使用这些接口或者方法即可,方便快捷,提升开发效率。

socket在python中就是一个模块，通过使用学习模块提供的功能,建立两个进程之间的连接和通信（ip+port）。

流程图

服务器端先初始化socket，然后绑定bind端口，对端口进行监听listen，调用accept夯住程序，等待客户端连接；客户端初始化socket，connect服务器，连接成功后，客户端向服务器端发送数据，服务器端接收后返回数据，客户端读取数据，请求关闭，一次交互结束。

socket模块

循环通信

# 服务器端

import socket

server = socket.socket()  # 创建server服务端,可以不写，默认是socket.AF_INET,socket.SOCK_STREAM

server.bind(('127.0.0.1',8003))  # 绑定IP地址和端口

server.listen(5)  # 设置最大连接数

print('listening')

conn,addr = server.accept() # 进入监听状态

while 1:

    from_client_data = conn.recv(1024).decode('utf-8')  # 设置最大字节数

    if from_client_data.upper() == 'Q':   #判断对方是否要求关闭连接

        break

    else:

        print(f"来自{addr}的消息:\033[1;32m{from_client_data}\033[0m")

        se = input('>>>').encode('utf-8')

        conn.send(se)

conn.close()  # 关闭连接

server.close()  # 关闭服务端

# 客户端

import socket

client = socket.socket()   # 可以不写，默认是socket.AF_INET,socket.SOCK_STREAM

client.connect(('127.0.0.1',8003)) # 与服务器建立连接,ip地址与端口号必须要与服务器端一致

while 1:

    se = input('>>>')

    if se.upper() == 'Q':

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

        break

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

    from_server_data = client.recv(1024) # 设置最大字节数

    print(f"来自服务器的消息：\033[1;32m {from_server_data.decode('utf-8')}\033[0m")

client.close()

服务器一直监听版【重要】

# 服务器端

import socket

server = socket.socket()

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

server.listen(5)

print('listening')

while 1:

    conn,addr = server.accept()

    while 1:

        try :

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

            if from_client_data.upper() == 'Q':

                break

            else:

                print(f"来自{addr}的消息:\033[1;32m{from_client_data}\033[0m")

                se = input('>>>').encode('utf-8')

                conn.send(se)

        except ConnectionResetError:

            break

    conn.close()

server.close()

# 客户端

import socket

client = socket.socket()

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

while 1:

    se = input('>>>')

    if se.upper() == 'Q':

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

        break

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

    from_server_data = client.recv(1024).decode('utf-8')

    print(f"来自服务器的消息：\033[1;32m{from_server_data}\033[0m")

client.close()

# 这里要注意多client同时访问server时，会按照顺序，断开一个连接后继续下一个连接

远程执行命令

subprocess应用，创建进程

import subprocess

obj = subprocess.Popen('dir',

                         shell=True,

                         stdout=subprocess.PIPE,

                         stderr=subprocess.PIPE,

                         )

print(obj.stdout.read().decode('gbk'))  # 正确命令

print('error:',obj.stderr.read().decode('gbk'))  # 错误命令

远程使用

import socket

import subprocess

server = socket.socket()

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

server.listen(5)

print('listening')

while 1:

    conn,addr = server.accept()

    while 1:

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

        if rec.upper() == 'Q':

            break

        else:

            obj = subprocess.Popen(rec,

                                   shell=True,

                                   stdout=subprocess.PIPE,

                                   stderr=subprocess.PIPE,

                                   )

            se = obj.stdout.read().decode('gbk')+obj.stderr.read().decode('gbk')

            conn.send(se.encode('utf-8'))

    conn.close()

server.closed()

import socket

client = socket.socket()

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

while 1:

    se = input('请输入命令')

    if se.upper() == 'Q':

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

        break

    else:

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

    re = client.recv(1024).decode('utf-8')

    print(re)

client.close()

# 如果返回的数据过多，会有黏包现象

7.5 黏包

产生原因

缓冲区

如果没有缓冲区，收发数据会受到网络波动的影响，影响数据的上传和下载

虽然缓冲区解决了上传下载的传输的效率问题，但是黏包问题

产生条件

1.recv会产生黏包。如果recv接受的数据 < 缓冲区的数据，缓冲区中接受不完的数据会与后边recv的数据黏在一起，流式数据

2.连续send少量的数据，先到缓存区。由于Nagle的算法，发送端发送的数据如果比较小，会暂存在缓冲区，再加上应用层给TCP传送数据很快的话，就会把两个应用层数据包黏在一起，TCP最后只发一个TCP数据包给接收端

解决方案

struct模块

按照指定的格式把一个python类型转换成固定长度的bytes字节流

格式	C语言类型	Python类型	标准尺寸
x	填充字节	没有值
c	char	string of length 1	1
b	signed	integer	1
B	unsigned char	integer	1
?	_Bool	bool	1
h	short	integer	2
H	unsigned short	integer	2
i	int	integer	4
I	unsigned int	integer	4
l	long	integer	4
L	unsigned long	long	4
q	long long	long	8
Q	unsigned long long	long	8
n	ssize_t	intter
N	size_t	intter
f	float	float	4
d	double	float	8
s	char[]	string
p	char[]	string
P	void *	long

import struct

# 将一个数字转化成等长度的bytes类型。

ret = struct.pack('q', 154365400024634546545646546)

print(ret, type(ret), len(ret))

# 通过unpack反解回来

ret1 = struct.unpack('i',ret)[0]

print(ret1)

方案一：

1.在第二次向对方发送数据之前，先把缓冲区的数据全部取出

2.如何限制循环次数?当接收数据的总字节数数等于发送数据的总字节数时，停止循环；

3.服务端先send要发送数据的总字节数；

4.发送端制作报头，固定头部长度，使用struct模块，pack转换成等长度4个字节bytes类型，发送到接收端，接收端再使用unpack将字节数转换回来；

代码实现

服务器端

import socket

import subprocess

import struct

server = socket.socket()

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

server.listen(5)

print('listening')

# 接收连接

while 1:

    conn,addr = server.accept()

    while 1:

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

        obj = subprocess.Popen(rec,

                               shell=True,

                               stdout=subprocess.PIPE,

                               stderr=subprocess.PIPE,

                               )

        se = obj.stdout.read().decode('gbk')+obj.stderr.read().decode('gbk')

        # 制作报头

        total_size = len(se)

        # 将长度不固定的int类型报头，转成固定长度bytes4个字节

        # 将一个数字转换成等长度的bytes类型

        total_size_bytes = struct.pack('i',total_size)

        # 发送报头

        conn.send(total_size_bytes)

        # 发送原始数据

        conn.send(se.encode('gbk'))

    conn.close()

server.closed()

客户端

import struct

import socket

client = socket.socket()

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

# 发送消息

while 1:

    se = input('请输入命令')

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

    # 1-接收报头

    head_bytes = client.recv(4)

    # 2-将报头反解回int类型

    total_size = struct.unpack('i',head_bytes)[0]   #unpack返回的一个元组，里边只有一个反解的元素

    # 3-循环接收数据

    total_data = b''  #设定一个初始值

    while len(total_data.decode('gbk')) < total_size:

        total_data += client.recv(1024)

    print(total_data.decode('gbk'))

client.close()

存在的问题：

数据量较大的数据，使用struct时会报错；

报头信息不可能只含有数据的大小；

方案二：

为了解决以上问题，我们引入方案二：

自定义一种传输报文：

将传送数据的信息汇集成字典，字典中记录了传输数据的MD5值，filename以及filesize,使用json模块把字典转换成bytes类型，将其加到传输数据流的字典头；
记录字典bytes的长度，使用struct模块转成4字节的固定长度，然后把它作为长度头加到数据流的最开始；
将 [长度头+字典头+传输数据] 一起发送给对方
对方接到数据流之后，首先取4个字节，求出字典头的长度；取字典头长度的数据，进行格式转换，得到字典；
循环接收数据，将得到的数据流与字典中的MD5进行校验，校验通过，转码显示数据，校验不通过，则不显示；