网络编程进阶¶
2025-03-032025-03-03
网络通信三要素¶
-
IP地址：网络中每一台计算机的唯一标识，通过IP地址找到指定的计算机。
-
端口：用于标识进程的逻辑地址，通过端口找到指定进程。
-
协议：定义通信规则，符合协议则可以通信，不符合不能通信。一般有TCP协议和UDP协议。
运输层协议¶
数据传输方式¶
计算机之间有很多数据传输方式，各有优缺点，常用的有两种：SOCK_STREAM 和 SOCK_DGRAM。
-
SOCKSTREAM 表示面向连接的数据流的传输方式。数据可以准确无误地到达另一台计算机，如果损坏或丢失，可以重新发送，但效率相对较慢。常见的 http 协议就使用 SOCKSTREAM 传输数据，因为要确保数据的正确性，否则网页不能正常解析。
-
SOCKDGRAM 表示无连接的数据报文的传输方式。计算机只管传输数据，不作数据校验，如果数据在传输中损坏，或者没有到达另一台计算机，是没有办法补救的。也就是说，数据错了就错了，无法重传。因为 SOCKDGRAM 所做的校验工作少，所以效率比 SOCK_STREAM 高。
TCP协议¶
TCP（Transmission Control Protocol，传输控制协议）是一种面向连接的、可靠的、基于字节流的通信协议，数据在传输前要建立连接，传输完毕后还要断开连接。
TCP客户端在收发数据前要与TCP服务器建立连接。建立连接的目的是保证IP地址、端口、物理链路等正确无误，为数据的传输开辟通道。
比较重要的字段有：
- 序号：Seq（Sequence Number），序号占32位，用来标识从计算机A发送到计算机B的数据包的序号，计算机发送数据时对此进行标记。
- 确认号：Ack（Acknowledge Number），确认号占32位，客户端和服务器端都可以发送，Ack = Seq + 1。
- 标志位：Flags，每个标志位占用1Bit，共有6个，分别为 URG、ACK、PSH、RST、SYN、FIN，具体含义如下：
| 标志位 | 描述 |
|---|---|
| URG | 紧急指针（urgent pointer）有效。 |
| ACK | 确认序号有效。此处的ACK与上面的确认好Ack不是同一个，不要混淆了。 |
| PSH | 接收方应该尽快将这个报文交给应用层。 |
| RST | 重置连接。 |
| SYN | 发起一个新连接。 |
| FIN | 释放一个连接。 |
TCP客户端和TCP服务端在建立连接时就要进行三次握手，同样，在TCP客户端和TCP服务端在断开连接时，则要进行四次挥手。
建立连接是非常重要的，它是数据正确传输的前提；而断开连接同样重要，它让计算机释放不再使用的资源。
三次握手¶
TCP建立连接时要传输三个数据包，俗称三次握手（Three-way Handshaking）。TCP连接必须是一方主动打开，另一方被动打开的。
握手之前主动打开连接的客户端结束CLOSED阶段，被动打开的服务器端也结束CLOSED阶段，并进入LISTEN阶段。
1. 首先客户端向服务器端发送一段TCP报文，其中：
标记位为 SYN，表示请求建立新连接，
序号为 seq=x（x为随机数），
随后客户端进入 SYN-SENT 阶段。
2. 服务器端接收到来自客户端的TCP报文之后，结束LISTEN阶段，并返回一段TCP报文，其中：
标志位为SYN和ACK，表示确认客户端的报文Seq序号有效，服务器能正常接收客户端数据并同意创建新连接，
序号为 seq=y（y为随机数）
确认号为 Ack=x+1，表示收到客户端的序号Seq并将其值加1作为自己确认号Ack的值；随后服务器端进入SYN-RCVD阶段。
3. 客户端接收服务器端的TCP确认报文之后，明确了数据传输是正常的，结束SYN-SENT阶段。并返回最后一段TCP报文。其中：
标志位为ACK，表示确认收到服务器端同意连接的信号，
序号为 Seq=x+1，表示收到服务器端的确认号Ack，并将其值作为自己的序号值，
确认号为 Ack=y+1，表示收到服务器端序号Seq，并将其值加1作为自己的确认号Ack的值，
随后客户端进入ESTABLISHED阶段。
最后握手完成，建立连接完成，开始双方互相传输数据。
举个例子：诸葛亮与周瑜合作，明天一起攻打曹操。
那么为什么要三次握手呢？看上面的例子，如果只进行了2次握手的话，诸葛亮就不知道周瑜已经收到了他的信息，所以担心之下第二天不出兵，这样的话，周瑜第一天就要吐血了，大喊：诸葛村夫，骗了我呀！！！
四次挥手¶
TCP关闭连接时要传输四个数据包，俗称四次挥手（Four-Way Wavehand）。
连接的释放必须是一方主动释放，另一方被动释放。
1. 首先客户端想要释放连接，向服务器端发送一段TCP报文，其中：
标记位为FIN，表示请求释放连接，
序号为Seq=x（x为随机数，假设为200），
随后客户端进入FIN-WAIT-1阶段，即半关闭阶段，并且停止在客户端到服务器端方向上发送数据（注意：可以发送报文），
但是客户端仍然能接收从服务器端传输过来的数据。
2. 服务器端接收到从客户端发出的TCP报文之后，确认了客户端想要释放连接，随后服务器端结束ESTABLISHED阶段，进入CLOSE-WAIT阶段（半关闭状态）并返回一段TCP报文，其中：
标记位为ACK，表示接收到客户端发送的释放连接的请求，
序号为Seq=y（y为随机数，假设为300），
确认号为Ack=x+1（即201），表示是在收到客户端报文的基础上，将其序号Seq值加1作为本段报文确认号Ack的值，
随后服务器端开始准备释放服务器端到客户端方向上的连接。
客户端收到从服务器端发出的TCP报文之后，确认了服务器收到了客户端发出的释放连接请求，随后客户端进入FIN-WAIT-2阶段。
3. 服务器端发出ACK确认报文之后，经过CLOSED-WAIT阶段，做好了释放连接准备，再次向客户端发出一段TCP报文，其中：
标记位为FIN，ACK，表示已经准备好释放连接了。
序号为Seq=z（z为随机数，假设为400），
确认号为Ack=x+1（即201），表示是在收到客户端报文的基础上，将其序号Seq值加1作为本段报文确认号Ack的值。
随后服务器端进入LAST-ACK阶段。并且停止发送数据，但是服务器端仍然能够接收从客户端传输过来的数据。
4. 客户端收到从服务器端发出的TCP报文，确认了服务器端已做好释放连接的准备，进入TIME-WAIT阶段，并向服务器端发送一段报文，其中：
标记位为ACK，表示接收到服务器准备好释放连接的信号，
序号为Seq=x+1（即201），表示是在收到了服务器端报文的基础上，将其确认号Ack值作为本段报文序号的值。
确认号为Ack=z+1（即401），表示是在收到了服务器端报文的基础上，将其序号Seq值作为本段报文确认号的值。
最后挥手完成，取消连接完成，双方断开通信。
客户端最后一次发送 ACK包后进入 TIME_WAIT 状态，而不是直接进入 CLOSED 状态关闭连接，这是为什么呢？
TCP 是面向连接的传输方式，必须保证数据能够正确到达目标机器，不能丢失或出错，而网络是不稳定的，随时可能会毁坏数据，所以机器A每次向机器B发送数据包后，都要求机器B”确认“，回传ACK包，告诉机器A我收到了，这样机器A才能知道数据传送成功了。
如果机器B没有回传ACK包，机器A会重新发送，直到机器B回传ACK包。
客户端最后一次向服务器回传ACK包时，有可能会因为网络问题导致服务器收不到，服务器会再次发送 FIN 包，如果这时客户端完全关闭了连接，那么服务器无论如何也收不到ACK包了，所以客户端需要等待片刻、确认对方收到ACK包后才能进入CLOSED状态。
那么，要等待多久呢？数据包在网络中是有生存时间的，超过这个时间还未到达目标主机就会被丢弃，并通知源主机。
这称为报文最大生存时间（MSL，Maximum Segment Lifetime）。
TIME_WAIT 要等待 2MSL 才会进入 CLOSED 状态。ACK 包到达服务器需要 MSL 时间，服务器重传 FIN 包也需要 MSL 时间，2MSL 是数据包往返的最大时间，如果 2MSL 后还未收到服务器重传的 FIN 包，就说明服务器已经收到了 ACK 包。
举个例子：诸葛亮与周瑜合作完成，打算一起退兵。
[wavehand 1] 诸葛亮：“你好，周瑜，我这边已经拿下荆州，要撤兵了。”
[wavehand 2] 周瑜：“好的，等我拿下江夏，也撤兵了。”
[wavehand 3] 周瑜：“我已拿下江夏，要撤兵了。”
[wavehand 4] 诸葛亮：“OK，合作愉快！”
那么为什么要四次挥手呢？看上面的例子，如果只进行了3次挥手的话，诸葛亮就不知道周瑜要撤兵了，所以一直等待周瑜退兵的信号，结果周瑜跑了，诸葛亮等来了司马懿！
十种状态¶
UDP协议¶
UDP（User Datagram Protocol，用户数据报协议）不可靠的、无连接的协议，采用报文传输数据，传输效率高（发送前时延小），支持一对一、一对多、多对一和多对多的交互通信、尽最大努力服务，无拥塞控制。使用UDP的应用：域名系统 (DNS)；视频流；IP语音(VoIP)。
UDP的报头部分一共只有8个字节，总长度不超过65,535字节，正好放进一个IP数据包。
TCP和UDP有哪些区别?
1、TCP面向连接（如打电话要先拨号建立连接）;UDP是无连接的，即发送数据之前不需要建立连接
2、TCP提供可靠的服务。也就是说，通过TCP连接传送的数据，无差错，不丢失，不重复，且按序到达;UDP尽最大努力交付，即不保证可靠交付
3、TCP面向字节流，实际上是TCP把数据看成一连串无结构的字节流;UDP是面向报文的
UDP没有拥塞控制，因此网络出现拥塞不会使源主机的发送速率降低（对实时应用很有用，如IP电话，实时视频会议等）
4、每一条TCP连接只能是点到点的;UDP支持一对一，一对多，多对一和多对多的交互通信
5、TCP首部开销20字节;UDP的首部开销小，只有8个字节
6、TCP的逻辑通信信道是全双工的可靠信道，UDP则是不可靠信道
socket编程¶
socket 的原意是“插座”，在计算机通信领域，socket 被翻译为“套接字”（IP+port），它是计算机之间进行通信的一种约定或一种方式。通过 socket 这种约定，一台计算机可以接收其他计算机的数据，也可以向其他计算机发送数据。 我们把插头插到插座上就能从电网获得电力供应，同样，为了与远程计算机进行数据传输，需要连接到因特网，而 socket 就是用来连接到因特网的工具。
Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的套接字相关函数就是全部，让Socket去组织数据，以符合指定的协议，如TCP或UDP就可以完成通信过程了。
套接字类型¶
套接字起源于 20 世纪 70 年代加利福尼亚大学伯克利分校版本的 Unix,即人们所说的 BSD Unix。 因此,有时人们也把套接字称为“伯克利套接字”或“BSD 套接字”。一开始,套接字被设计用在同 一台主机上多个应用程序之间的通讯。这也被称进程间通讯,或 IPC。套接字主要有两种类型（或两个家族）,分别是基于文件型的和基于网络型的。
-
基于文件类型的AF_UNIX
unix一切皆文件，基于文件的套接字调用的就是底层的文件系统来取数据，两个套接字进程运行在同一机器，可以通过访问同一个文件系统间接完成本机通信。
-
基于网络类型的AF_INET
Python 内置了2个常用模块提供给我们完成socket编程。
- 低级别的网络服务支持基本的 Socket，它提供了标准的 BSD Sockets API，可以访问底层操作系统 Socket 接口的全部方法。
- 高级别的网络服务模块 SocketServer， 它提供了服务器中心类，可以简化网络服务器的开发。
此处，我们先学习socket模块。
socket模块¶
import socket
"""
创建套接字对象
socket.socket(socket_family,socket_type,protocal=0)
socket_family 可以是 AF_UNIX 或 AF_INET。
socket_type 可以是 SOCK_STREAM 或 SOCK_DGRAM。protocol 一般不填,默认值为 0。
"""
# 获取tcp/ip套接字
# tcpsk = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 获取udp/ip套接字
# udpsk = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sk = socket.socket()
常用函数¶
服务端套接字函数¶
| 函数 | 描述 |
|---|---|
| s.bind(address) | 将套接字绑定到地址, 在AF_INET下,以元组（host,port）的形式表示地址. |
| s.listen(backlog) | 开始监听TCP传入连接。backlog指定在拒绝连接之前，操作系统可以挂起的最大连接数量。该值至少为1，大部分应用程序设为5就可以了。 |
| s.accept() | 接受TCP连接并返回（conn,address）,其中conn是新的套接字对象，可以用来接收和发送数据。address是连接客户端的地址。 |
客户端套接字函数¶
| 函数 | 描述 |
|---|---|
| s.connect(address) | 连接到address处的套接字。一般address的格式为元组（hostname,port），如果连接出错，返回socket.error错误。 |
| s.connect_ex(adddress) | connect()函数的扩展版本，成功返回0，出错返回errno出错码，而不是抛出异常 |
公共套接字函数¶
| 公共socket函数 | |
|---|---|
| s.recv(bufsize[,flag]) | 接受TCP套接字的数据。数据以字符串形式返回，bufsize指定要接收的最大数据量。flag提供有关消息的其他信息，通常可以忽略。 |
| s.send(string[,flag]) | 发送TCP数据。将string中的数据发送到连接的套接字。返回值是要发送的字节数量，该数量可能小于string的字节大小。 |
| s.sendall(string[,flag]) | 完整发送TCP数据。将string中的数据发送到连接的套接字，但在返回之前会尝试发送所有数据。成功返回None，失败则抛出异常。 |
| s.recvfrom(bufsize[.flag]) | 接受UDP套接字的数据。与recv()类似，但返回值是（data,address）。其中data是包含接收数据的字符串，address是发送数据的套接字地址。 |
| s.sendto(string[,flag],address) | 发送UDP数据。将数据发送到套接字，address是形式为（ipaddr，port）的元组，指定远程地址。返回值是发送的字节数。 |
| s.close() | 关闭套接字。 |
| s.getpeername() | 返回连接套接字的远程地址。返回值通常是元组（ipaddr,port）。 |
| s.getsockname() | 返回套接字自己的地址。通常是一个元组(ipaddr,port) |
| s.setsockopt(level,optname,value) | 设置给定套接字选项的值。 |
| s.getsockopt(level,optname[.buflen]) | 返回套接字选项的值。 |
| s.settimeout(timeout) | 设置套接字操作的超时期，timeout是一个浮点数，单位是秒。值为None表示没有超时期。一般，超时期应该在刚创建套接字时设置，因为它们可能用于连接的操作（如connect()） |
| s.gettimeout() | 返回当前超时期的值，单位是秒，如果没有设置超时期，则返回None。 |
| s.setblocking(flag) | 如果flag为0，则将套接字设为非阻塞模式，否则将套接字设为阻塞模式（默认值）。非阻塞模式下，如果调用recv()没有发现任何数据，或send()调用无法立即发送数据，那么将引起socket.error异常。 |
| s.fileno() | 返回套接字的文件描述符。 |
| s.makefile() | 创建一个与该套接字相关连的文件 |
实现基于tcp协议的socket通信¶
先从服务器端说起。服务器端先初始化socket得到套接字对象，然后绑定端口(bind)，对端口进行监听(listen)，调用accept阻塞，等待客户端连接。在这时如果有个客户端初始化一个socket得到套接字对象，然后连接服务器(connect)成功，这时客户端与服务器端的连接就建立了(socket内部帮我们完成了三次握手)。客户端发送数据请求，服务器端接收请求并处理请求，然后把回应数据发送给客户端，客户端读取数据，最后关闭连接，通信结束（同样的，socket内部帮我们完成了四次挥手）。
server.py
import socket
# 实例化socket对象
# socket.socket(socket_family,socket_type,protocal=0)
# tcpsk = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # 获取tcp/ip套接字
# udpsk = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # 获取udp/ip套接字
sk = socket.socket()
# 绑定ip和端口 (ip, port)，参数是元组
sk.bind( ("127.0.0.1", 9000) ) # 127.0.0.1 默认代表本机ip，将来也可以是外网IP地址
# 开启监听 (等待客户端访问)，可以不填，也可以写5上去
sk.listen(5)
# 程序加阻塞,直到tcp协议的三次握手建立完毕,执行下面代码
conn,addr = sk.accept()
print(conn,addr)
# 最大接受1024个字节 等待数据时,程序加了阻塞,收到数据之后,程序在向下执行
msg = conn.recv(1024)
print(msg.decode("utf-8"))
# send 负责发送，只能发送二进制的字节流
conn.send("hello, socket!".encode("utf-8"))
# 关闭此次连接 [走四次挥手]
conn.close()
# 关闭socket对象 [退还占用的端口]
sk.close()
"""
< socket.socket fd=4, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 9000), raddr=('127.0.0.1', 34794)>
('127.0.0.1', 34794)
"""
client.py，代码：
import socket
# 差生一个socket对象
sk = socket.socket()
# 建立连接，指定socket服务端的IP与端口，参数是元组
sk.connect( ("127.0.0.1",9000) )
# 发送消息(发送的数据是二进制字节流)
sk.send("hi~python".encode("utf-8"))
# 等待接收消息 (发送完之后,程序添加阻塞,最大字节数1024,等待接收)
res = sk.recv(1024)
print(res.decode("utf-8"))
# 关闭连接
sk.close()
进阶版本：循环发消息与不断接收客户端连接
server.py，代码：
import socket
sk=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
# 在bind方法之前加上这句话，可以让一个端口重复使用
phone.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
sk.bind(('127.0.0.1',9000))
sk.listen(5)
while True: # 新增接收链接循环,可以不断接收客户端连接
conn,addr=sk.accept()
# print(conn)
# print(addr)
print(f'接到来自{addr[0]}的连接')
while True: # 新增通信循环,可以不断的通信, 收发消息
msg=conn.recv(1024) # 接收消息
# if len(msg) == 0:break # 如果不加,那么正在链接的客户端突然断开,recv便不再阻塞,死循环发生
print(msg,type(msg))
conn.send(msg.upper()) # 发消息
conn.close() # 断开连接
sk.close() # 释放socket对象
client.py，代码：
import socket
sk=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
sk.connect_ex( ('127.0.0.1',9000) ) # 拨电话
while True: # 新增通信循环, 客户端可以不断发收消息
msg=input('>>: ').strip()
if len(msg) == 0: continue
sk.send(msg.encode('utf-8')) # 发消息( 只能发送字节类型 )
message=sk.recv(1024) # 收消息
print(message.decode('utf-8'))
sk.close() # 关闭socket对象
实现基于udp协议的socekt通信¶
udp是无链接的，先启动哪一端都不会报错
server.py，代码：
# 循环发送消息udp
import socket
sk = socket.socket(type=socket.SOCK_DGRAM)
# 绑定地址
sk.bind( ("127.0.0.1",9000) )
while True:
msg,cli_addr = sk.recvfrom(1024)
print(cli_addr)
print(msg.decode("utf-8"))
message = input(">>>")
sk.sendto(message.encode("utf-8"),cli_addr)
# 关闭udp链接
sk.close()
client.py，代码：
import socket
sk = socket.socket(type=socket.SOCK_DGRAM)
while True:
# 请输入你要写入的数据
message = input(">>>")
sk.sendto(message.encode(),("127.0.0.1",9000))
# 接受数据
msg,ser_addr = sk.recvfrom(1024)
print(msg.decode())
# 关闭udp连接
sk.close()
由于udp无连接，所以可以同时多个客户端去跟服务端通信
server.py，代码：
import socket
udpsk=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
udpsk.bind(('127.0.0.1',9000))
while True:
content, addr=udpsk.recvfrom(1024)
print(f"来自[{addr[0]}:{addr[1]}]的一条消息:\033[1;44m{content.decode('utf-8')}\033[0m")
message = input('回复消息: ').strip()
udpsk.sendto(message.encode('utf-8'), ('127.0.0.1',9000))
client.py，代码：
import socket
udpsk = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
friends = {
'xiaoming':('127.0.0.1',8081),
'xiaobai':('127.0.0.1',8081),
'xiaohei':('127.0.0.1',8081),
'xiaolong':('127.0.0.1',8081),
}
while True:
name = input('请选择聊天对象: ').strip()
while True:
content = input('>>: ').strip()
if content == 'quit':break
if not content or not name or name not in friends: continue
udpsk.sendto(content.encode('utf-8'),friends[name])
message,addr=udpsk.recvfrom(1024)
print(f"来自[{addr[0]}:{addr[1]}]的一条消息:\033[1;44m{message.decode('utf-8')}\033[0m")
udpsk.close()
黏包问题¶
server.py，代码：
# 服务端
import socket
import time
# 把当前主机注册到网络
sk = socket.socket()
sk.bind(("127.0.0.1",9000))
sk.listen()
conn,addr = sk.accept()
conn.send("hello,".encode("utf-8"))
# time.sleep(1)
conn.send("world".encode("utf-8"))
conn.recv(1024)
conn.close()
sk.close()
client.py，代码：
import time
import socket
sk = socket.socket()
sk.connect(("127.0.0.1",9000))
time.sleep(0.1)
print(sk.recv(10))
print(sk.recv(10))
sk.send(b'hello')
sk.close()
上面所出现的问题就是粘包问题，所谓粘包问题主要还是因为接收方不知道消息之间的界限，不知道一次性提取多少字节的数据所造成的，粘包是由TCP协议本身是面向流（stream）造成的，所以只有TCP协议有粘包现象，而UDP是面向消息的协议，所以永远不会粘包。
黏包现象一:
在发送端,由于两个数据短,发送的时间隔较短,所以在发送端形成黏包
黏包现象二:
在接收端,由于两个数据几乎同时被发送到对方的缓存中,所有在接收端形成了黏包
发送包时间间隔短 或者 接受不及时,就会黏包
核心是因为tcp对数据无边界截取,不会按照发送的顺序判断
解决方案¶
简单解决方案¶
发送数据时，在统计本次完整数据的长度，先把长度发送给对端，然后对端接受到长度以后，按长度提取数据。
server.py，代码：
# 服务端
import socket
import time
# 把当前主机注册到网络
sk = socket.socket()
#在bind方法之前加上这句话，可以让一个端口重复使用
sk.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
sk.bind(("127.0.0.1",9001))
sk.listen()
conn,addr = sk.accept()
conn.send("6".encode("utf-8"))
conn.send("hello,".encode("utf-8"))
# time.sleep(1)
conn.send("world".encode("utf-8"))
conn.recv(1024)
conn.close()
sk.close()
client.py，代码：
# 客户端
import time
import socket
sk = socket.socket()
sk.connect(("127.0.0.1",9001))
time.sleep(0.1)
# 是为了接受字符6 #sk.recv(1).decode("utf-8") 字符串
n = int(sk.recv(1).decode("utf-8"))
print(n,type(n))
print(sk.recv(n))
print(sk.recv(10))
sk.send(b'hahaha')
sk.close()
使用Struct模块来解决¶
为字节流加上自定义固定长度报头，报头中包含字节流长度，然后一次send到对端，对端在接收时，先从缓存中取出定长的报头，然后再取真实数据。
struct常用方法：
快速使用¶
普通数据打包和解包，代码：
import struct
import binascii
data = (1, 'abcabc'.encode(), 2.7)
print("源数据:", data)
# (函数式)打包
packed_data = struct.pack('i3sf',*data) # 3s表示3个字节长度的字符串，abcabc是6个字节长度了，会存在丢失的情况。
# (对象式)打包
s1 = struct.Struct('i3sf')
# packed_data = s1.pack(*data)
print("打包后数据格式", type(packed_data))
print("打包后数据 :", packed_data)
print("打包后数据 :", binascii.hexlify(packed_data))
# (函数式)解包
unpacked_data = struct.unpack('i3sf',packed_data)
# (对象式)解包
# unpacked_data = s1.unpack(packed_data)
print("解包后数据格式:", type(unpacked_data))
print("解包后数据: ",unpacked_data)
# 使用struct打包数据,和解包数据的格式必须一致.
# 使用struct打包和解包数据的过程中,针对数值都会出现精度丢失的问题
# 使用struct打包和解包数据时,如果字符串超过格式指定的长度,则会出现内容丢失的情况
二进制数据打包和解包，代码：
import struct,binascii,ctypes
values1 = (1, 'abc'.encode(), 2.7)
s1 = struct.Struct('I3sf') # I 表示int，3s表示三个字符长度的字符串，f 表示 float
values2 = ('defg'.encode(), 101)
s2 = struct.Struct('4sI')
prebuffer = ctypes.create_string_buffer(s1.size+s2.size)
print('Before :', binascii.hexlify(prebuffer)) # Before : b'0000000000000000000000000000000000000000'
# 数据打包
s1.pack_into(prebuffer, 0, *values1)
s2.pack_into(prebuffer, s1.size, *values2) # s1.size 因为前面数据位已经被第一段数据占用了,此处要空出s1.size的长度
print('After pack:', binascii.hexlify(prebuffer))
print(s1.unpack_from(prebuffer, 0))
print(s2.unpack_from(prebuffer, s1.size)) # s1.size 因为前面数据位已经被第一段数据占用了,此处要空出s1.size的长度
打包格式¶
struct模块的常⻅的格式符意义如下：
| Format | C Type | Python | 字节数 |
|---|---|---|---|
| x | pad byte | no value | 1 |
| c | char | string of length 1 | 1 |
| b | signed char | 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 or long | 4 |
| l | long | integer | 4 |
| L | unsigned long | long | 4 |
| q | long long | long | 8 |
| Q | unsigned long long | long | 8 |
| f | float | float | 4 |
| d | double | float | 8 |
| s | char[] | string | |
| p | char[] | string | |
| P | void * | long | |
server.py，代码：
import socket,struct,json
sk=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
sk.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) #就是它，在bind前加
sk.bind(('127.0.0.1',8080))
sk.listen(5)
while True:
conn,addr=sk.accept()
while True:
content=conn.recv(1024)
if not content: break
print(f'content: {content}')
message = input(">>>:")
conn.send(struct.pack('i',len(message))) # 先发内容长度
conn.sendall(message) # 再发送内容
conn.close()
sk.close()
client.py，代码：
import socket,time,struct
sk=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
sk.connect_ex(('127.0.0.1',8080))
while True:
msg=input('>>: ').strip()
if len(msg) == 0: continue
if msg == 'quit': break
sk.send(msg.encode('utf-8'))
l=sk.recv(4)
x=struct.unpack('i',l)[0]
print(type(x),x)
r_s=0
data=b''
while r_s < x:
r_d=sk.recv(1024)
data+=r_d
r_s+=len(r_d)
print(data.decode('utf-8'))
消息头¶
消息头部可以包含信息，例如：协议版本号，指令等，当然也可以把消息长度合并到消息头部里，唯一的要求是包头长度必须是固定的（否则无法准确解包），包体则可变长。接下来我们自定义的一个包头：
| 版本号（ver） | 消息长度（bodySize） | 指令（cmd） |
|---|---|---|
版本号，消息长度，指令数据类型都是无符号32位整型变量，于是这个消息长度固定为3*4=12字节。示例代码：
import struct,json
if __name__ == '__main__':
# 假设version就是版本号,body就是数据包, cmd就是消息ID[当然,这里除了body以外,都是举例而已,可有可无.]
version = 1
body = json.dumps({"content": "hello"})
# print(body)
# print(body.__len__())
cmd = 101
header = (version, body.__len__(), cmd)
print(header)
# 消息头打包
headPack = struct.pack("3i", *header)
print(headPack)
print(len(headPack)) # 12
# 消息头解包
version, body_length, cmd = struct.unpack('iii', headPack)
print(f"version={version}, body_length={body_length}, cmd={cmd}")
综合案例¶
SSH跳板机简单版本¶
server.py，代码：
import socket
import subprocess
import time
import struct
sock = socket.socket()
sock.bind(("127.0.0.1",8899))
sock.listen(5)
while True:
client_sock,addr = sock.accept()
print("客户端%s建立连接"%str(addr))
while 1:
try:
cmd = client_sock.recv(1024) # data字节串
except Exception:
print("客户端%s退出"%str(addr))
client_sock.close()
break
print("执行命令：",cmd.decode("gbk"))
# 版本1：内存问题
# cmd_res_bytes = subprocess.getoutput(cmd.decode("gbk")).encode()
# client_sock.send(cmd_res_bytes)
# 版本2：粘包问题
# cmd_res_bytes = subprocess.getoutput(cmd.decode("gbk")).encode()
# cmd_res_bytes_len = bytes(str(len(cmd_res_bytes)),"utf8")
# client_sock.sendall(cmd_res_bytes_len)
# client_sock.sendall(cmd_res_bytes)
# 版本3：粘包解决方案
# result_str = subprocess.getoutput(cmd.decode("gbk"))
# result_bytes = bytes(result_str, encoding='utf8')
# res_len = struct.pack('i',len(result_bytes))
# client_sock.sendall(res_len)
# client_sock.sendall(result_bytes)
# cmd_res_bytes = subprocess.getoutput(cmd.decode("gbk")).encode()
# cmd_res_bytes_len = bytes(str(len(cmd_res_bytes)),"utf8")
# res_len = struct.pack('i', len(cmd_res_bytes))
# client_sock.sendall(res_len)
# client_sock.sendall(cmd_res_bytes)
client.py，代码：
import socket
import time
import struct
ip_port=("127.0.0.1",8899)
sk=socket.socket()
sk.connect(ip_port)
while 1:
data = input("输入执行命令>>>")
sk.send(data.encode())
# 版本1 内存问题
# res = sk.recv(1024)
# print("字节长度：",len(res))
# print("执行命令结果:%s"%(res.decode()))
# 版本2 粘包问题
# # time.sleep(5)
# res_len = sk.recv(1024)
# data = sk.recv(int(res_len.decode()))
# print(res_len)
# print(data.decode())
# 版本3：粘包解决方案
# length_msg = sk.recv(4)
# length = struct.unpack('i', length_msg)[0]
# msg = sk.recv(length).decode()
# print("执行命令结果：",msg)
测试命令：
文件上传¶
server.py，代码：
import socket
import struct
import json
import os
base_dir = os.path.dirname(os.path.abspath(__file__))
base_dir = os.path.join(base_dir, 'download')
class MYTCPServer:
address_family = socket.AF_INET
socket_type = socket.SOCK_STREAM
allow_reuse_address = False
max_packet_size = 8192
coding='utf-8'
request_queue_size = 5
server_dir='file_upload'
def __init__(self, server_address, bind_and_activate=True):
"""Constructor. May be extended, do not override."""
self.server_address=server_address
self.socket = socket.socket(self.address_family,
self.socket_type)
if bind_and_activate:
try:
self.server_bind()
self.server_activate()
except:
self.server_close()
raise
def server_bind(self):
"""Called by constructor to bind the socket.
"""
if self.allow_reuse_address:
self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.socket.bind(self.server_address)
self.server_address = self.socket.getsockname()
def server_activate(self):
"""Called by constructor to activate the server.
"""
self.socket.listen(self.request_queue_size)
def server_close(self):
"""Called to clean-up the server.
"""
self.socket.close()
def get_request(self):
"""Get the request and client address from the socket.
"""
return self.socket.accept()
def close_request(self, request):
"""Called to clean up an individual request."""
request.close()
def run(self):
print('server is running .......')
while True:
self.conn,self.client_addr=self.get_request()
print('from client ',self.client_addr)
while True:
try:
head_struct = self.conn.recv(4)
if not head_struct:break
head_len = struct.unpack('i', head_struct)[0]
head_json = self.conn.recv(head_len).decode(self.coding)
head_dic = json.loads(head_json)
print(head_dic)
cmd=head_dic['cmd']
if hasattr(self,cmd):
func=getattr(self,cmd)
func(head_dic)
except Exception:
break
def put(self,args):
"""
文件长传
:param args:
:return:
"""
file_path=os.path.normpath(os.path.join(
base_dir, args['filename']))
filesize=args['filesize']
recv_size=0
print('----->',file_path)
with open(file_path,'wb') as f:
while recv_size < filesize:
recv_data=self.conn.recv(2048)
f.write(recv_data)
recv_size += len(recv_data)
else:
print('recvsize:%s filesize:%s' %(recv_size,filesize))
def get(self, args):
""" 下载文件
1 检测服务端文件是不是存在
2 文件信息 打包发到客户端
3 发送文件
"""
filename = args['filename']
dic = {}
if os.path.isfile(base_dir + '/' + filename):
dic['filesize'] = os.path.getsize(base_dir + '/' + filename)
dic['isfile'] = True
else:
dic['isfile'] = False
str_dic = json.dumps(dic) # 字典转str
bdic = str_dic.encode(self.coding) # str转bytes
dic_len = len(bdic) # 计算bytes的长度
bytes_len = struct.pack('i', dic_len) #
self.conn.send(bytes_len) # 发送长度
self.conn.send(bdic) # 发送字典
# 文件存在发送真实文件
if dic['isfile']:
with open(base_dir + '/' + filename, 'rb') as f:
while dic['filesize'] > 2048:
content = f.read(2048)
self.conn.send(content)
dic['filesize'] -= len(content)
else:
content = f.read(2048)
self.conn.send(content)
dic['filesize'] -= len(content)
print('下载完成')
tcpserver1=MYTCPServer(('127.0.0.1',9000))
tcpserver1.run()
client.py，代码：
import socket
import struct
import json
import os
import time
base_dir = os.path.dirname(os.path.abspath(__file__))
base_dir = os.path.join(base_dir, 'local_dir')
class MYTCPClient(object):
address_family = socket.AF_INET
socket_type = socket.SOCK_STREAM
allow_reuse_address = False
max_packet_size = 8192
coding = 'utf-8'
request_queue_size = 5
def __init__(self, server_address, connect=True):
self.server_address = server_address
self.socket = socket.socket(self.address_family,
self.socket_type)
if connect:
try:
self.client_connect()
except:
self.client_close()
raise
def client_connect(self):
self.socket.connect(self.server_address)
def client_close(self):
self.socket.close()
def run(self):
while True:
inp = input(">>: ").strip()
if not inp: continue
l = inp.split()
cmd = l[0]
if hasattr(self, cmd):
func = getattr(self, cmd)
func(l)
def put(self, args):
cmd = args[0]
filename = args[1]
filename = base_dir + '/' + filename
print(filename)
if not os.path.isfile(filename):
print('file:%s is not exists' % filename)
return
else:
filesize = os.path.getsize(filename)
head_dic = {'cmd': cmd, 'filename': os.path.basename(filename), 'filesize': filesize}
print(head_dic)
head_json = json.dumps(head_dic)
head_json_bytes = bytes(head_json, encoding=self.coding)
head_struct = struct.pack('i', len(head_json_bytes))
self.socket.send(head_struct)
self.socket.send(head_json_bytes)
send_size = 0
t1 = time.time()
# with open(filename,'rb') as f:
# for line in f:
# self.socket.send(line)
# send_size+=len(line)
# else:
# print('upload successful')
# t2 = time.time()
with open(filename, 'rb') as f:
while head_dic['filesize'] > 2048:
content = f.read(2048)
self.socket.send(content)
head_dic['filesize'] -= len(content)
else:
content = f.read(2048)
self.socket.send(content)
head_dic['filesize'] -= len(content)
t2 = time.time()
print(t2 - t1)
def get(self, args):
cmd = args[0]
filename = args[1]
dic = {'cmd': cmd, 'filename': filename}
"""发送dic的步骤
字典转str
str转bytes
计算bytes的长度
发送长度
发送字典
"""
str_dic = json.dumps(dic) # 字典转str
bdic = str_dic.encode(self.coding) # str转bytes
dic_len = len(bdic) # 计算bytes的长度
bytes_len = struct.pack('i', dic_len) #
self.socket.send(bytes_len) # 发送长度
self.socket.send(bdic) # 发送字典
# 接受 准备下载的文件信息
dic_len = self.socket.recv(4)
dic_len = struct.unpack('i', dic_len)[0]
dic = self.socket.recv(dic_len).decode(self.coding)
dic = json.loads(dic)
# 文件存在准备下载
if dic['isfile']:
t1 = time.time()
with open(base_dir + '/' + filename, 'wb') as f:
while dic['filesize'] > 2048:
content = self.socket.recv(2048)
f.write(content)
dic['filesize'] -= len(content)
else:
while dic['filesize']:
content = self.socket.recv(2048)
f.write(content)
dic['filesize'] -= len(content)
t2 = time.time()
print(t2 - t1)
else:
print('文件不存在！')
client = MYTCPClient(('127.0.0.1', 9000))
client.run()
socketserver模块¶
socketserver是基于原有socket模块又进行了一层封裝，为了实现tcp通信中server端的并发而构建的模块。
socketserver模块中分两大类：server类（解决链接问题）和request类（解决通信问题）
基本使用¶
server.py，代码：
import socketserver
# 自定义一个类 MyServer
class MyServer(socketserver.BaseRequestHandler):
# handle 方法是每当有一个客户端发起connect来接之后,自动执行handle
def handle(self):
print("--->执行这句话")
# ip 端口号 | 自定义类
server = socketserver.ThreadingTCPServer(("127.0.0.1",9000), MyServer)
# 循环调用
server.serve_forever()
client.py，代码：
TCP服务端并发处理¶
server.py，代码：
import socketserver
# 自定义一个类 MyServer
class MyServer(socketserver.BaseRequestHandler):
# handle 方法是每当有一个客户端发起connect来接之后,自动执行handle
def handle(self):
print("--->执行这句话")
'''
print(self.request) # conn
print(self.client_address) # addr
'''
conn = self.request
while True:
msg = conn.recv(1024).decode("utf-8")
print(msg)
conn.send(msg.upper().encode("utf-8"))
# conn = self.request
# ip 端口号 | 自定义类
server = socketserver.ThreadingTCPServer(("127.0.0.1",9000),MyServer)
# 循环调用
server.serve_forever()
client.py，代码：
import socket
sk = socket.socket()
sk.connect( ("127.0.0.1",9000))
while True:
sk.send(b'hello')
msg = sk.recv(1024)
print(msg)
sk.close()
综合案例：FTPServer¶
server.py，代码：
import socketserver
import struct
import json
import os
class FtpServer(socketserver.BaseRequestHandler):
coding='utf-8'
server_dir='file_upload'
max_packet_size=1024
BASE_DIR=os.path.dirname(os.path.abspath(__file__))
def handle(self):
print(self.request)
while True:
data=self.request.recv(4)
data_len=struct.unpack('i',data)[0]
head_json=self.request.recv(data_len).decode(self.coding)
head_dic=json.loads(head_json)
# print(head_dic)
cmd=head_dic['cmd']
if hasattr(self,cmd):
func=getattr(self,cmd)
func(head_dic)
def put(self,args):
file_path = os.path.normpath(os.path.join(
self.BASE_DIR,
self.server_dir,
args['filename']
))
filesize = args['filesize']
recv_size = 0
print('----->', file_path)
with open(file_path, 'wb') as f:
while recv_size < filesize:
recv_data = self.request.recv(self.max_packet_size)
f.write(recv_data)
recv_size += len(recv_data)
print('recvsize:%s filesize:%s' % (recv_size, filesize))
ftpserver=socketserver.ThreadingTCPServer(('127.0.0.1',8080),FtpServer)
ftpserver.serve_forever()
client.py，代码：
import socket
import struct
import json
import os
class MYTCPClient:
address_family = socket.AF_INET
socket_type = socket.SOCK_STREAM
allow_reuse_address = False
max_packet_size = 8192
coding='utf-8'
request_queue_size = 5
def __init__(self, server_address, connect=True):
self.server_address=server_address
self.socket = socket.socket(self.address_family,
self.socket_type)
if connect:
try:
self.client_connect()
except:
self.client_close()
raise
def client_connect(self):
self.socket.connect(self.server_address)
def client_close(self):
self.socket.close()
def run(self):
while True:
inp=input(">>: ").strip()
if not inp:continue
l=inp.split()
cmd=l[0]
if hasattr(self,cmd):
func=getattr(self,cmd)
func(l)
def put(self,args):
cmd=args[0]
filename=args[1]
if not os.path.isfile(filename):
print('file:%s is not exists' %filename)
return
else:
filesize=os.path.getsize(filename)
head_dic={'cmd':cmd,'filename':os.path.basename(filename),'filesize':filesize}
print(head_dic)
head_json=json.dumps(head_dic)
head_json_bytes=bytes(head_json,encoding=self.coding)
head_struct=struct.pack('i',len(head_json_bytes))
self.socket.send(head_struct)
self.socket.send(head_json_bytes)
send_size=0
with open(filename,'rb') as f:
for line in f:
self.socket.send(line)
send_size+=len(line)
print(send_size)
else:
print('upload successful')
client=MYTCPClient(('127.0.0.1',8080))
client.run()