一. 引入
通过上一篇博客《python语法之socket初探》,我们已经懂得了一些基本的socket编程规范,本篇博客旨在实现UDP与TCP的两个小例子,时间服务器(ntp)、基于TCP套接字制作远程运行命令;粘包的产生与解决;及其TCP并发问题的解决。
二. 时间服务器(ntp)
什么是时间服务器?
时间服务器是一种计算机网络仪器,它从参考时钟获取实际时间,再利用计算机网络把时间信息传递给用户。这里通过基于UDP套接字编程来实现ntp。
服务端:
# author:dayin
# Date:2019/7/29 0029
import socket
import time
ip_port = ('127.0.0.1', 8080)
Buffer_size = 1024
server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
server.bind(ip_port)
while True:
msg, addr = server.recvfrom(Buffer_size)
print('接收客户端程序【{}:{}】消息=====>>> {}'.format(addr[0], addr[1], msg))
time_fmt = msg.decode('utf8')
if not time_fmt:
time_fmt = '%Y-%m-%d %X'
try:
back_msg = time.strftime(time_fmt)
# 发送时间信息给客户端
server.sendto(back_msg.encode('utf8'), addr)
except Exception as e:
server.sendto('错误输入'.encode('utf8'), addr)
print(e)
continue
客户端:
# author:dayin
# Date:2019/7/29 0029
import socket
ip_port = ('127.0.0.1', 8080)
Buffer_size = 1024
client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
while True:
msg = input('请输入时间格式(例%Y %m %d)>>: ').strip()
client.sendto(msg.encode('utf8'), ip_port)
back_msg, addr = client.recvfrom(Buffer_size)
print('当前时间为:', back_msg.decode('utf8'))
运行结果如下图:
客户端:
服务端:
三. 远程运行命令
通过基于TCP套接字编程,实现远程运行在Centos服务端的程序,使其执行一些简单的命令,如 ifconfig pwd 等简单的命令,并将命令结果返回给Windows客户端程序。
服务端:
# author:dayin
import socket
import subprocess
ip_port = ('192.168.38.132', 8080)
backlog = 5
buffer_size = 1024
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind(ip_port)
server.listen(backlog)
# 链接循环
while True:
print('====>>>等待客户端连接')
conn, addr = server.accept()
# 消息循环
while True:
msg = conn.recv(buffer_size)
print('====>>>收到客户端命令: {}'.format(msg))
if not msg: break
# 执行命令,这里使用了subprocess库来执行命令,将正确的命令结果放在 stdout管道中,错误的命令结果放在stderr中
res = subprocess.Popen(msg.decode('utf8'), shell=True, stderr=subprocess.PIPE, stdout=subprocess.PIPE,
stdin=subprocess.PIPE)
back_msg = res.stdout.read()
error_msg = res.stderr.read()
if error_msg:
back_msg = error_msg
# 有的命令没有返回结果,需要判断一下,否则会出现服务端和客户端阻塞.
if not back_msg:
back_msg = '命令执行成功!'.encode('utf8')
conn.send(back_msg)
客户端:
# author:dayin
import socket
ip_port = ('192.168.38.132', 8080)
buffer_size = 1024
client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect(ip_port)
# 消息循环
while True:
cmd = input('请输入命令:')
if not cmd: continue
if cmd == 'quit': break
client.send(cmd.encode('utf8'))
msg = client.recv(buffer_size)
print('接收到服务端命令结果为:{}'.format(msg.decode('utf8')))
运行结果如下图:
启动服务端,在此之前,最好是关闭防火墙。
启动客户端,并执行 ls pwd ifconfig 命令。
四. 粘包现象
-
粘包现象的产生:
由上两图可知,当第一次输入 pwd命令时,命令返回了正确的结果,当输入完 cat /etc/passwd 命令之后,再次输入 pwd 命令时,返回的结果却是上一次 cat /etc/passwd 命令结果的残留,这种现象我们称为粘包。 -
什么是粘包?
在解释什么是粘包之前,首先需要明白socket收发消息的原理。发送端可以是一K一K地发送数据,而接收端的应用程序可以两K两K地提走数据,当然也有可能一次提走3K或6K数据,或者一次只提走几个字节的数据,也就是说,应用程序所看到的数据是一个整体,或说是一个流(stream),一条消息有多少字节对应用程序是不可见的,因此TCP协议是面向流的协议,这也是容易出现粘包问题的原因。而UDP是面向消息的协议,每个UDP段都是一条消息,应用程序必须以消息为单位提取数据,不能一次提取任意字节的数据,这一点和TCP是很不同的。怎样定义消息呢?可以认为对方一次性send的数据为一个消息,需要明白的是当对方send一条信息的时候,无论底层怎样分段分片,TCP协议层会把构成整条消息的数据段排序完成后才呈现在内核缓冲区。例如基于tcp的套接字客户端往服务端上传文件,发送时文件内容是按照一段一段的字节流发送的,在接收方看了,根本不知道该文件的字节流从何处开始,在何处结束。总的来说,只有TCP有粘包现象,UDP永远不会粘包。所谓粘包问题主要还是因为接收方不知道消息之间的界限,不知道一次性提取多少字节的数据所造成的。
此外,发送方引起的粘包是由TCP协议本身造成的,TCP为提高传输效率,发送方往往要收集到足够多的数据后才发送一个TCP段。若连续几次需要send的数据都很少,通常TCP会根据优化算法把这些数据合成一个TCP段后一次发送出去,这样接收方就收到了粘包数据。
- TCP(transport control protocol,传输控制协议)是面向连接的,面向流的,提供高可靠性服务。收发两端(客户端和服务器端)都要有一一成对的socket,因此,发送端为了将多个发往接收端的包,更有效的发到对方,使用了优化方法(Nagle算法),将多次间隔较小且数据量小的数据,合并成一个大的数据块,然后进行封包。这样,接收端,就难于分辨出来了,必须提供科学的拆包机制。 即面向流的通信是无消息保护边界的。
- UDP(user datagram protocol,用户数据报协议)是无连接的,面向消息的,提供高效率服务。不会使用块的合并优化算法,, 由于UDP支持的是一对多的模式,所以接收端的skbuff(套接字缓冲区)采用了链式结构来记录每一个到达的UDP包,在每个UDP包中就有了消息头(消息来源地址,端口等信息),这样,对于接收端来说,就容易进行区分处理了。 即面向消息的通信是有消息保护边界的。
- tcp是基于数据流的,于是收发的消息不能为空,这就需要在客户端和服务端都添加空消息的处理机制,防止程序卡住,而udp是基于数据报的,即便是你输入的是空内容(直接回车),那也不是空消息,udp协议会帮你封装上消息头。
- 发生粘包的两种情况:
-
发送端需要等缓冲区满才发送出去,造成粘包(发送数据时间间隔很短,数据了很小,会合到一起,产生粘包),实验如下:
服务端:
# author:dayin
from socket import *
ip_port = ('127.0.0.1', 8080)
tcp_socket_server = socket(AF_INET, SOCK_STREAM)
tcp_socket_server.bind(ip_port)
tcp_socket_server.listen(5)
conn, addr = tcp_socket_server.accept()
data1 = conn.recv(10)
data2 = conn.recv(10)
print('----->', data1.decode('utf-8'))
print('----->', data2.decode('utf-8'))
conn.close()
客户端:
# author:dayin
import socket
BUFSIZE = 1024
ip_port = ('127.0.0.1', 8080)
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
res = s.connect_ex(ip_port)
s.send('hello'.encode('utf-8'))
s.send('chendayin'.encode('utf-8'))
s.close()
实验结果如下:
以上可知,发生了粘包现象。
- 接收方不及时接收缓冲区的包,造成多个包接收(客户端发送了一段数据,服务端只收了一小部分,服务端下次再收的时候还是从缓冲区拿上次遗留的数据,产生粘包) 。实验如下:
服务端:
# author:dayin
from socket import *
ip_port = ('127.0.0.1', 8080)
tcp_socket_server = socket(AF_INET, SOCK_STREAM)
tcp_socket_server.bind(ip_port)
tcp_socket_server.listen(5)
conn, addr = tcp_socket_server.accept()
data1 = conn.recv(2) # 一次没有收完整
data2 = conn.recv(10) # 下次收的时候,会先取旧的数据,然后取新的
print('----->', data1.decode('utf-8'))
print('----->', data2.decode('utf-8'))
conn.close()
客户端:
# author:dayin
import socket
BUFSIZE = 1024
ip_port = ('127.0.0.1', 8080)
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
res = s.connect(ip_port)
s.send('hello world'.encode('utf-8'))
s.close()
实验结果如下:
以上可知,发生了粘包现象。
五. 解决粘包方法
- 问题的根源在于,接收端不知道发送端将要传送的字节流的长度,所以解决粘包的方法就是围绕,如何让发送端在发送数据前,把自己将要发送的字节流总大小让接收端知晓,然后接收端来一个死循环接收完所有数据。
- 方法1:
服务端:
# author:dayin
import socket
import subprocess
ip_port = ('192.168.38.132', 8080)
backlog = 5
buffer_size = 1024
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind(ip_port)
server.listen(backlog)
# 链接循环
while True:
print('====>>>等待客户端连接')
conn, addr = server.accept()
# 消息循环
while True:
try:
msg = conn.recv(buffer_size)
print('====>>>收到客户端命令: {}'.format(msg))
if not msg: break
# 执行命令,这里使用了subprocess库来执行命令,将正确的命令结果放在 stdout管道中,错误的命令结果放在stderr中
res = subprocess.Popen(msg.decode('utf8'), shell=True, stderr=subprocess.PIPE, stdout=subprocess.PIPE,
stdin=subprocess.PIPE)
back_msg = res.stdout.read()
error_msg = res.stderr.read()
if error_msg:
back_msg = error_msg
# 有的命令没有返回结果,需要判断一下,否则会出现服务端和客户端阻塞.
if not back_msg:
back_msg = '命令执行成功!'.encode('utf8')
length = str(len(back_msg))
conn.send(length.encode('utf8'))
data = conn.recv(buffer_size)
if data.decode('utf8') == 'recv_ready':
conn.sendall(back_msg)
except Exception as e:
print(e)
conn.close()
break
conn.close()
客户端:
# author:dayin
import socket
ip_port = ('192.168.38.132', 8080)
buffer_size = 1024
client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect(ip_port)
# 消息循环
while True:
cmd = input('请输入命令:')
if not cmd: continue
if cmd == 'quit': break
client.send(cmd.encode('utf8'))
data_length = client.recv(buffer_size).decode('utf8')
length = int(data_length)
client.send('recv_ready'.encode('utf8'))
data = b''
recv_size = 0
while recv_size < length:
data += client.recv(buffer_size)
recv_size += len(data)
print('接收到服务端的命令结果为:{}'.format(data.decode('utf8')))
实验结果如下图所示:
客户端:
服务端:
由上图可知,成功解决了,粘包的问题。不过,这一种方法有局限性,程序的运行速度远快于网络传输速度,所以在发送一段字节前,先用send去发送该字节流长度,这种方式会放大网络延迟带来的性能损耗。
-
方法2:
为字节流加上自定义固定长度报头,报头中包含字节流长度,然后一次send到对端,对端在接收时,先从缓存中取出定长的报头,然后再取真实数据我们可以把报头做成字典,字典里包含将要发送的真实数据的详细信息,然后json序列化,然后用struct将序列化后的数据长度打包成4个字节(4个字节足够用了)。过程如下:
发送时:
先发报头长度
再编码报头内容然后发送
最后发真实内容
接收时:
先取报头长度,用struct取出来
根据取出的长度,收取报头内容,然后解码,反序列化
从反序列化的结果中取出待取数据的详细信息,然后去取真实的数据内容
服务端:
# author:dayin
import socket
import subprocess
import json
import struct
ip_port = ('192.168.38.132', 8080)
backlog = 5
buffer_size = 1024
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind(ip_port)
server.listen(backlog)
# 链接循环
while True:
print('====>>>等待客户端连接')
conn, addr = server.accept()
# 消息循环
while True:
try:
msg = conn.recv(buffer_size)
print('====>>>收到客户端命令: {}'.format(msg))
if not msg: break
# 执行命令,这里使用了subprocess库来执行命令,将正确的命令结果放在 stdout管道中,错误的命令结果放在stderr中
res = subprocess.Popen(msg.decode('utf8'), shell=True, stderr=subprocess.PIPE, stdout=subprocess.PIPE,
stdin=subprocess.PIPE)
back_msg = res.stdout.read()
error_msg = res.stderr.read()
if error_msg:
back_msg = error_msg
# 有的命令没有返回结果,需要判断一下,否则会出现服务端和客户端阻塞.
if not back_msg:
back_msg = '命令执行成功!'.encode('utf8')
headers = {'data_size': len(back_msg)}
head_json = json.dumps(headers)
head_json_bytes = head_json.encode('utf8')
conn.send(struct.pack('i', len(head_json_bytes))) # 先发报头的长度
conn.send(head_json_bytes) # 再发报头
conn.sendall(back_msg) # 在发真实的内容
except Exception as e:
print(e)
conn.close()
break
conn.close()
客户端:
# author:dayin
import socket
import struct
import json
ip_port = ('192.168.38.132', 8080)
buffer_size = 1024
client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect(ip_port)
# 消息循环
while True:
cmd = input('请输入命令:')
if not cmd: continue
if cmd == 'quit': break
client.send(cmd.encode('utf8'))
head = client.recv(4)
head_json_len = struct.unpack('i', head)[0]
head_json = json.loads(client.recv(head_json_len).decode('utf-8'))
data_len = head_json['data_size']
data = b''
recv_size = 0
while recv_size < data_len:
data += client.recv(buffer_size)
recv_size += len(data)
print('接收到服务端的命令结果为:{}'.format(data.decode('utf8')))
实验运行结果如下:
客户端:
服务端:
以上,两种方法,均可以作为TCP发生粘包现象的解决方法。
六. TCP并发问题的解决
-
使用socket模块,我们并不能像UDP一样,一个服务端可以同时跟多个客户端进行通信,也就是不具有并发性,如何解决这个问题呢?我们可以使用 socketserver这个模块,实现TCP的并发。
基于tcp的套接字,关键就是两个循环,一个链接循环,一个通信循环
socketserver模块中分两大类:server类(解决链接问题)和request类(解决通信问题)
-
具体实现请看,如下代码:
服务端:
# author:dayin
import socketserver
class Myserver(socketserver.BaseRequestHandler):
def handle(self):
print('conn is ', self.request) # conn
print('addr is ', self.client_address) # addr
while True:
try:
# 收消息
data = self.request.recv(1024)
print('收到客户端消息:', data)
# 发消息
self.request.sendall(data.upper())
except Exception as e:
print(e)
break
if __name__ == '__main__':
ip_port = ('127.0.0.1', 8080)
s = socketserver.ThreadingTCPServer(ip_port, Myserver)
s.serve_forever()
客户端:
# author:dayin
import socket
client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect(('127.0.0.1', 8080))
while True:
message = input('>>>请输入发送给服务端消息:')
if not message: continue
client.send(message.encode())
rev_msg = client.recv(1024)
print('收到服务器消息:{}'.format(rev_msg.decode()))
client.close()
实验结果如下图所示:
第一个客户端:
第二个客户端:
服务端:
以上,实现了TCP的并发。
PS: 实现TCP并发的关键点在于服务端,通过socketserver模块,定义一个类,并且继承自
socketserver.BaseRequestHandler,并重写类中的 handle方法,通过剖析源码,发现该方法,体现了TCP的链接循环,在链接循环内部,再通过一个循环,实现了通信循环。
end…