一、socket是什么
Socket是应用层与TCP/UDP协议族通信的中间软件抽象层，可以理解为一组接口，把复杂的TCP/UDP协议隐藏在Socket接口后面。遵循socket的规定去编程，那么写出的程序就是遵循TCP/UDP标准的。
套接字的分类：基于文件的（AF_UNIX）和面向网络的（AF_INET）
套接字地址：主机+端口号
二、套接字工作流程
要创建套接字，必须使用socket.socket()函数
tcpSock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) #基于TCP套接字
udpSock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) #基于UDP套接字
套接字对象（内置）方法：
服务端套接字函数
s.bind() 绑定(主机,端口号)到套接字
s.listen() 开始TCP监听
s.accept() 被动接受TCP客户的连接,(阻塞式)等待连接的到来
客户端套接字函数
s.connect() 主动初始化TCP服务器连接
s.connect_ex() connect()函数的扩展版本,出错时返回出错码,而不是抛出异常
公共用途的套接字函数
s.recv() 接收TCP数据
s.send() 发送TCP数据(send在待发送数据量大于己端缓存区剩余空间时,数据丢失,不会发完)
s.sendall() 发送完整的TCP数据(本质就是循环调用send,sendall在待发送数据量大于己端缓存区剩余空间时,数据不丢失,循环调用send直到发完)
s.recvfrom() 接收UDP数据
s.sendto() 发送UDP数据
s.getpeername() 连接到当前套接字的远端的地址
s.getsockname() 当前套接字的地址
s.getsockopt() 返回指定套接字的参数
s.setsockopt() 设置指定套接字的参数
s.close() 关闭套接字
面向锁的套接字方法
s.setblocking() 设置套接字的阻塞与非阻塞模式
s.settimeout() 设置阻塞套接字操作的超时时间
s.gettimeout() 得到阻塞套接字操作的超时时间
面向文件的套接字的函数
s.fileno() 套接字的文件描述符
s.makefile() 创建一个与该套接字相关的文件三、基于TCP的套接字
TCP是基于连接的，必须先启动服务器，然后再启动客户端去连接服务器
TCP服务器
ss = socket() #创建服务器套接字
ss.bind() #把地址绑定到套接字
ss.listen() #监听链接
inf_loop: #服务器无限循环
cs = ss.accept() #接受客户端链接
comm_loop: #通讯循环
cs.recv()/cs.send() #对话(接收与发送)
cs.close() #关闭客户端套接字
ss.close() #关闭服务器套接字(可选)TCP客户端
cs = socket() # 创建客户套接字
cs.connect() # 尝试连接服务器
comm_loop: # 通讯循环
cs.send()/cs.recv() # 对话(发送/接收)
cs.close() # 关闭客户套接字创建TCP客户端
from socket import *
from time import ctime
HOST = '127.0.0.1' # 本机IP
PORT = 3000 # 端口号
BUFSIZ = 1024 # 缓冲区
ADDR = (HOST, PORT)
# tcpSock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) #创建TCP/IP套接字
# udpSock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) #创建UDP/IP套接字
tcpSerSock = socket(AF_INET, SOCK_STREAM) # TCP服务器套接字
tcpSerSock.bind(ADDR) # 将套接字绑定到服务器地址
tcpSerSock.listen(5) # 开启TCP监听器的调用
while True:#循环建立连接
print('waiting for connecting ....')
conn, addr = tcpSerSock.accept() # 等待客户端发起TCP连接
print('...connection from :', addr)
while True:#循环接受这个连接发来的消息
try: # 防止客户端异常中断，不然会报错：ConnectionResetError: [WinError 10054] 远程主机强迫关闭了一个现有的连接。
data = conn.recv(BUFSIZ)
if not data:break # 防止客户端正常中断，此时循环接收为空
conn.send(('[{}] {}'.format(ctime(), data)).encode('utf-8')) # 格式化返回客户端发送的消息
except Exception:
break
conn.close()
tcpSerSock.close()创建TCP客户端
from socket import *
HOST = '127.0.0.1' # 服务器的主机号和端口号
PORT = 3000
BUFSIZ = 1024
ADDR = (HOST, PORT)
tcpCliSock = socket(AF_INET, SOCK_STREAM) #TCP客户端套接字
tcpCliSock.connect(ADDR) # 主动连接到TCP服务器
while True:
data = input('>>')
if not data:#如果本客户端发送的消息是空的，则跳出此次循环
continue
tcpCliSock.send(data.encode('utf-8'))
data = tcpCliSock.recv(BUFSIZ)
print(data.decode('utf-8'))
tcpCliSock.close()四、基于UDP的套接字
UDP服务器
ss = socket() #创建UDP服务器套接字
ss.bind() #绑定服务器套接字
inf_loop： #服务器无线循环
cs = ss.revefrom()/ss.sendto() #对话（发送/接受）
ss.close()UDP客户端
cs = socket() #创建客户端套接字
comm_loop: #通信循环
cs.sendto()/recvfrom() #对话（发送/接收）
cs.close() #关闭创建UDP服务器
from socket import *
ip_port = ('127.0.0.1', 8000)
BUFSIZE = 1024
udpSerSocket = socket(AF_INET, SOCK_DGRAM)
udpSerSocket.bind(ip_port)
while True:
msg, addr = udpSerSocket.recvfrom(BUFSIZE)
print(msg, addr)
udpSerSocket.sendto(msg.upper(), addr)创建UDP客户端
from socket import *
ip_port = ('127.0.0.1', 8000)
BUFSIZE = 1024
udpCliSocket = socket(AF_INET, SOCK_DGRAM)
while True:
msg = input('>>:').strip()
if not msg:continue
udpCliSocket.sendto(msg.encode('utf-8'), ip_port)
back_msg, addr = udpCliSocket.recvfrom(BUFSIZE)
print(back_msg.decode('utf-8'), addr)五、粘包
只有TCP协议才会粘包，UDP协议不会粘包。
UDP协议不用建立连接，面向消息的，既是sendto的是空消息，UDP协议也会帮你封装报头，这样对于接收端来说，就可以区分消息的边界了。即面向消息的通信是有消息保护边界的。数据可以丢失，数据是不可靠的，不会粘包。
TCP协议需要建立连接，三次握手四次挥手，面向数据流。发送发发送文件是按照一段一段的字节流发送的，接收方不知道字节流的边界。TCP协议的包不会丢失，这次没有收完包，下次接受会继续上次接受，己端总是在收到ACK确认是才会清楚缓冲区内容。数据是可靠的，但会粘包。
两种情况下会发生粘包：
（1）发送端需要等缓冲区满才发送出去，造成粘包（发送数据时间间隔很短，数据了很小，会合到一起，产生粘包）
（2）接收方不及时接收缓冲区的包，造成多个包接收（客户端发送了一段数据，服务端只收了一小部分，服务端下次再收的时候还是从缓冲区拿上次遗留的数据，产生粘包）
六、基于TCP执行远程代码（可能会有粘包）
server:
from socket import *
import subprocess
ip_port = ('127.0.0.1', 8000)
back_log = 5
buffer_size = 1024
tcp_server = socket(AF_INET, SOCK_STREAM)
tcp_server.bind(ip_port)
tcp_server.listen(back_log)
while True:
conn, addr = tcp_server.accept()
print('新的客户端连接：', addr)
while True:
try:# 防止客户端异常中断
cmd = conn.recv(buffer_size)
if not cmd: break # 防止客户端正常中断，，此时循环接收为空
print('收到的命令：', cmd)
# 处理收到的命令
res = subprocess.Popen(cmd.decode('utf-8'), shell=True,
stdout=subprocess.PIPE,
stdin=subprocess.PIPE,
stderr=subprocess.PIPE)
err = res.stderr.read()
if err:
cmd_res = err
else:
cmd_res = res.stdout.read()
# 发送命令结果
conn.send(cmd_res)
except Exception as e:
print(e)
break
conn.close()client:
from socket import *
ip_port = ('127.0.0.1', 8000)
back_log = 5
buffer_size = 1024
tcp_client = socket(AF_INET, SOCK_STREAM)
tcp_client.connect(ip_port)
while True:
cmd = input('>>:').strip()
if not cmd: continue
if cmd == 'quit': break # 退出命令
# 发送命令
tcp_client.send(cmd.encode('utf-8'))
# 接受命令结果
cmd_res = tcp_client.recv(buffer_size)
print('命令的执行结果：', cmd_res.decode('gbk'))
tcp_client.close() # 正常关闭掉连接七、基于UDP执行远程代码（不会有粘包）
server:
from socket import *
import subprocess
ip_port = ('127.0.0.1', 8000)
buffer_size = 1024
udp_server = socket(AF_INET, SOCK_DGRAM)
udp_server.bind(ip_port)
while True:
cmd, addr = udp_server.recvfrom(buffer_size)
# 处理命令
print('收到的命令：', cmd)
# 处理收到的命令
res = subprocess.Popen(cmd.decode('utf-8'), shell=True,
stdout=subprocess.PIPE,
stdin=subprocess.PIPE,
stderr=subprocess.PIPE)
err = res.stderr.read()
if err:
cmd_res = err
else:
cmd_res = res.stdout.read()
if not cmd_res:#如果执行的命令没有返回值
cmd_res = '执行成功'.encode('gbk')
udp_server.sendto(cmd_res, addr)client:
from socket import *
ip_port = ('127.0.0.1', 8000)
buffer_size = 1024
udp_client = socket(AF_INET, SOCK_DGRAM)
while True:
cmd = input('>>:').strip()
print('cmd', cmd)
if cmd == 'quit':break
udp_client.sendto(cmd.encode('utf-8'), ip_port)
cmd_res, addr = udp_client.recvfrom(buffer_size)
print(cmd_res.decode('gbk'))
udp_client.close()八、TCP解决粘包（方法一）
server:
from socket import *
import subprocess
ip_port = ('127.0.0.1', 8000)
back_log = 5
buffer_size = 1024
tcp_server = socket(AF_INET, SOCK_STREAM)
tcp_server.bind(ip_port)
tcp_server.listen(back_log)
while True:
conn, addr = tcp_server.accept()
print('新的客户端连接：', addr)
while True:
try:# 防止客户端异常中断
cmd = conn.recv(buffer_size)
if not cmd: break # 防止客户端正常中断，，此时循环接收为空
print('收到的命令：', cmd)
# 处理收到的命令
res = subprocess.Popen(cmd.decode('utf-8'), shell=True,
stdout=subprocess.PIPE,
stdin=subprocess.PIPE,
stderr=subprocess.PIPE)
err = res.stderr.read()
if err:
cmd_res = err
else:
cmd_res = res.stdout.read()
# 发送命令结果
if not cmd_res:
cmd_res = '执行成功'.encode('gbk')
# 解决粘包
length = len(cmd_res)
conn.send(str(length).encode('utf-8'))#发送长度
client_ready = conn.recv(buffer_size) # 接收client发送的ready信号,此时可以发送
if client_ready == b'ready':
conn.send(cmd_res)
except Exception as e:
print(e)
break
conn.close()client:
from socket import *
ip_port = ('127.0.0.1', 8000)
back_log = 5
buffer_size = 1024
tcp_client = socket(AF_INET, SOCK_STREAM)
tcp_client.connect(ip_port)
while True:
cmd = input('>>:').strip()
if not cmd: continue
if cmd == 'quit': break # 退出命令
# 发送命令
tcp_client.send(cmd.encode('utf-8'))
# 解决粘包
length = tcp_client.recv(buffer_size)#接收server发送来的长度
tcp_client.send(b'ready')#给server发送ready信号,server收到后就会发送信息
length = int(length.decode('utf-8'))
recv_size = 0
recv_msg = b''#用来拼接接收的数据
while recv_size < length: #只要收到的数据长度小于length，那么就会继续接收
recv_msg += tcp_client.recv(buffer_size)
recv_size = len(recv_msg)
print('命令的执行结果：', recv_msg.decode('gbk'))#windows系统是gbk编码，不是utf-8
tcp_client.close() # 正常关闭掉连接九、TCP解决粘包（方法二 利用struct模块）
server:
from socket import *
import subprocess
import struct
ip_port = ('127.0.0.1', 8000)
back_log = 5
buffer_size = 1024
tcp_server = socket(AF_INET, SOCK_STREAM)
tcp_server.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)#解决TCP协议中四次挥手的time_wait状态在占用地址问题
tcp_server.bind(ip_port)
tcp_server.listen(back_log)
while True:
conn, addr = tcp_server.accept()
print('新的客户端连接：', addr)
while True:
try:# 防止客户端异常中断
cmd = conn.recv(buffer_size)
if not cmd: break # 防止客户端正常中断，，此时循环接收为空
print('收到的命令：', cmd)
# 处理收到的命令
res = subprocess.Popen(cmd.decode('utf-8'), shell=True,
stdout=subprocess.PIPE,
stdin=subprocess.PIPE,
stderr=subprocess.PIPE)
err = res.stderr.read()
if err:
cmd_res = err
else:
cmd_res = res.stdout.read()
# 发送命令结果
if not cmd_res:
cmd_res = '执行成功'.encode('gbk')
# 解决粘包
data_length = struct.pack('i', len(cmd_res))#利用struct模块得到数据长度
conn.send(data_length) #发送长度
conn.sendall(cmd_res)#发送真是数据内容
except Exception as e:
print(e)
break
conn.close()client:
from socket import *
import struct
ip_port = ('127.0.0.1', 8000)
back_log = 5
buffer_size = 1024
tcp_client = socket(AF_INET, SOCK_STREAM)
tcp_client.connect(ip_port)
while True:
cmd = input('>>:').strip()
if not cmd: continue
if cmd == 'quit': break # 退出命令
# 发送命令
tcp_client.send(cmd.encode('utf-8'))
# 解决粘包
data_length = tcp_client.recv(4)
length = struct.unpack('i', data_length)[0]#得到数据长度
recv_size = 0
recv_msg = b'' # 用来拼接接收的数据
while recv_size < length: # 只要收到的数据长度小于length，那么就会继续接收
recv_msg += tcp_client.recv(buffer_size)
recv_size = len(recv_msg)
print('命令的执行结果：', recv_msg.decode('gbk'))#windows系统是gbk编码，不是utf-8
tcp_client.close() # 正常关闭掉连接十、把报头做成字典，字典里包含将要发送的真实数据的详细信息（利用json模块）
server:
from socket import *
import subprocess, struct, json
ip_port = ('127.0.0.1', 8000)
back_log = 5
buffer_size = 1024
tcp_server = socket(AF_INET, SOCK_STREAM)
tcp_server.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)#解决TCP协议中四次挥手的time_wait状态在占用地址问题
tcp_server.bind(ip_port)
tcp_server.listen(back_log)
while True:
conn, addr = tcp_server.accept()
print('新的客户端连接：', addr)
while True:
try:# 防止客户端异常中断
cmd = conn.recv(buffer_size)
if not cmd: break # 防止客户端正常中断，，此时循环接收为空
print('收到的命令：', cmd)
# 处理收到的命令
res = subprocess.Popen(cmd.decode('utf-8'), shell=True,
stdout=subprocess.PIPE,
stdin=subprocess.PIPE,
stderr=subprocess.PIPE)
err = res.stderr.read()
if err:
cmd_res = err
else:
cmd_res = res.stdout.read()
# 发送命令结果
if not cmd_res:
cmd_res = '执行成功'.encode('gbk')
# 解决粘包
headers = {'data_size':len(cmd_res)}
head_json = json.dumps(headers) #序列化
head_json_bytes = bytes(head_json, encoding='utf-8') #转成bytes,用于传输
conn.send(struct.pack('i', len(head_json_bytes)))#发送报头长度，用struck将报头长度这个数字转成固定长度:4个字节
conn.send(head_json_bytes) # 发送报头的字节格式
conn.sendall(cmd_res)#发送真实数据内容
except Exception as e:
print(e)
break
conn.close()client:
from socket import *
import struct, json
ip_port = ('127.0.0.1', 8000)
back_log = 5
buffer_size = 1024
tcp_client = socket(AF_INET, SOCK_STREAM)
tcp_client.connect(ip_port)
while True:
cmd = input('>>:').strip()
if not cmd: continue
if cmd == 'quit': break # 退出命令
# 发送命令
tcp_client.send(cmd.encode('utf-8'))
# 解决粘包
head = tcp_client.recv(4) #先收报头4个bytes,得到报头长度的字节格式，server端用struck将报头长度这个数字转成固定长度:4个字节，故此处接收4个bytes
head_json_len = struct.unpack('i', head)[0] #利用struct提取报头的长度
head_json = json.loads(tcp_client.recv(head_json_len).decode('utf-8')) #得到报头的字节格式，并反序列化得到报头
data_len = head_json['data_size'] #从报头中得到真实数据长度
recv_size = 0
recv_msg = b'' # 用来拼接接收的数据
while recv_size < data_len: # 只要收到的数据长度小于length，那么就会继续接收
recv_msg += tcp_client.recv(buffer_size)
recv_size = len(recv_msg)
print('命令的执行结果：', recv_msg.decode('gbk'))#windows系统是gbk编码，不是utf-8
tcp_client.close() # 正常关闭掉连接
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
