Python网络编程——基于tcp协议实现远程执行命令、udp协议没有粘包问题、解决粘包问题、socketserver模块的基本使用（基于tcp协议、基于udp协议的使用）
基于tcp协议实现远程执行命令
服务端
# 服务端应该满足两个特点：
# 1、一直对外提供服务
# 2、并发地服务多个客户端
import subprocess
from socket import *
server = socket(AF_INET, SOCK_STREAM)
server.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1) # 就是它，在bind前加
server.bind(('127.0.0.1', 8082))
server.listen(5)
# 服务端应该做两件事
# 第一件事：循环地从板连接池中取出链接请求与其建立双向链接，拿到链接对象
while True:
conn, client_addr = server.accept()
# 第二件事：拿到链接对象，与其进行通信循环
while True:
try:
cmd = conn.recv(1024)
if len(cmd) == 0:
break
obj = subprocess.Popen(cmd.decode('utf-8'),
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE
)
stdout_res = obj.stdout.read()
stderr_res = obj.stderr.read()
print(len(stdout_res)+len(stderr_res))
# conn.send(stdout_res+stderr_res) # ???
conn.send(stdout_res)
conn.send(stderr_res)
# with open("1.mp4",mode='rb') as f:
# for line in f:
# conn.send(line)
except Exception:
break
conn.close()
客户端
from socket import *
client = socket(AF_INET, SOCK_STREAM)
client.connect(('127.0.0.1', 8082))
while True:
cmd = input('请输入命令>>：').strip()
if len(cmd) == 0:
continue
client.send(cmd.encode('utf-8'))
# 解决粘包问题思路：
# 1、拿到数据的总大小total_size
# 2、recv_size=0,循环接收，每接收一次，recv_size+=接收的长度
# 3、直到recv_size=total_size，结束循环
cmd_res = client.recv(1024) # 本次接收，最大接收1024Bytes
print(cmd_res.decode('utf-8')) # 强调：windows系统用gbk
# 粘包问题出现的原因
# 1、tcp是流式协议，数据像水流一样粘在一起，没有任何边界区分
# 2、收数据没收干净，有残留，就会下一次结果混淆在一起
# 解决的核心法门就是：每次都收干净，不要任何残留
udp协议没有粘包问题
udp服务端
import socket
server=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
server.bind(('127.0.0.1',8080))
res1=server.recvfrom(2) # b"hello"
print(res1)
res2=server.recvfrom(3) # b"world"
print(res2)
server.close()
udp客户端
import socket
client=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
client.sendto(b'hello',('127.0.0.1',8080))
client.sendto(b'world',('127.0.0.1',8080))
client.close()
解决粘包问题
客户端
# 服务端应该满足两个特点：
# 1、一直对外提供服务
# 2、并发地服务多个客户端
import subprocess
import struct
from socket import *
server = socket(AF_INET, SOCK_STREAM)
server.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1) # 就是它，在bind前加
server.bind(('127.0.0.1', 8083))
server.listen(5)
# 服务端应该做两件事
# 第一件事：循环地从板连接池中取出链接请求与其建立双向链接，拿到链接对象
while True:
conn, client_addr = server.accept()
# 第二件事：拿到链接对象，与其进行通信循环
while True:
try:
cmd = conn.recv(1024)
if len(cmd) == 0:
break
obj = subprocess.Popen(cmd.decode('utf-8'),
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE
)
stdout_res = obj.stdout.read()
stderr_res = obj.stderr.read()
total_size = len(stdout_res)+len(stderr_res)
# 1、先发头信息（固定长度的bytes）：对数据描述信息
# int->固定长度的bytes
header = struct.pack('i', total_size)
conn.send(header)
# 2、再发真实的数据
conn.send(stdout_res)
conn.send(stderr_res)
except Exception:
break
conn.close()
服务端
import struct
from socket import *
client = socket(AF_INET, SOCK_STREAM)
client.connect(('127.0.0.1', 8083))
while True:
cmd = input('请输入命令>>：').strip()
if len(cmd) == 0:
continue
client.send(cmd.encode('utf-8'))
# 解决粘包问题思路：
# 一、先收固定长度的头：解析出数据的描述信息，包括数据的总大小total_size
header = client.recv(4)
total_size = struct.unpack('i', header)[0]
# 二、根据解析出的描述信息，接收真实的数据
# 2、recv_size=0,循环接收，每接收一次，recv_size+=接收的长度
# 3、直到recv_size=total_size，结束循环
recv_size = 0
while recv_size < total_size:
recv_data = client.recv(1024)
recv_size += len(recv_data)
print(recv_data.decode('utf-8'), end='')
else:
print()
# 粘包问题出现的原因
# 1、tcp是流式协议，数据像水流一样粘在一起，没有任何边界区分
# 2、收数据没收干净，有残留，就会下一次结果混淆在一起
# 解决的核心法门就是：每次都收干净，不要任何残留
解决粘包问题(终极版)
服务端
# 服务端应该满足两个特点：
# 1、一直对外提供服务
# 2、并发地服务多个客户端
import subprocess
import struct
import json
from socket import *
server = socket(AF_INET, SOCK_STREAM)
server.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1) # 就是它，在bind前加
server.bind(('127.0.0.1', 8083))
server.listen(5)
# 服务端应该做两件事
# 第一件事：循环地从板连接池中取出链接请求与其建立双向链接，拿到链接对象
while True:
conn, client_addr = server.accept()
# 第二件事：拿到链接对象，与其进行通信循环
while True:
try:
cmd = conn.recv(1024)
if len(cmd) == 0:
break
obj = subprocess.Popen(cmd.decode('utf-8'),
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE
)
stdout_res = obj.stdout.read()
stderr_res = obj.stderr.read()
total_size = len(stdout_res)+len(stderr_res)
# 1、制作头
header_dic = {
"filename": "a.txt",
"total_size": total_size,
"md5": "123123xi12ix12"
}
json_str = json.dumps(header_dic)
json_str_bytes = json_str.encode('utf-8')
# 2、先把头的长度发过去
x = struct.pack('i', len(json_str_bytes))
conn.send(x)
# 3、发头信息
conn.send(json_str_bytes)
# 4、再发真实的数据
conn.send(stdout_res)
conn.send(stderr_res)
except Exception:
break
conn.close()
客户端
import struct
import json
from socket import *
client = socket(AF_INET, SOCK_STREAM)
client.connect(('127.0.0.1', 8083))
while True:
cmd = input('请输入命令>>：').strip()
if len(cmd) == 0:
continue
client.send(cmd.encode('utf-8'))
# 接收端
# 1、先手4个字节，从中提取接下来要收的头的长度
x = client.recv(4)
header_len = struct.unpack('i', x)[0]
# 2、接收头，并解析
json_str_bytes = client.recv(header_len)
json_str = json_str_bytes.decode('utf-8')
header_dic = json.loads(json_str)
print(header_dic)
total_size = header_dic["total_size"]
# 3、接收真实的数据
recv_size = 0
while recv_size < total_size:
recv_data = client.recv(1024)
recv_size += len(recv_data)
print(recv_data.decode('utf-8'), end='')
else:
print()
# 粘包问题出现的原因
# 1、tcp是流式协议，数据像水流一样粘在一起，没有任何边界区分
# 2、收数据没收干净，有残留，就会下一次结果混淆在一起
# 解决的核心法门就是：每次都收干净，不要任何残留
测试
import json
import struct
header_dic = {
"filename": "a.txt",
"total_size": 12312312122222222222222222222222223123123123123121222222222222222222222222231231231231231212222222222222222222222222312312312312312122222222222222222222222223123123123123121222222222222222222222222231231231231231212222222222222222222222222312312312312312122222222222222222222222223123123123123121222222222222222222222222231231231231231212222222222222222222222222312312312312312122222222222222222222222223123123123123121222222222222222222222222231231231231231212222222222222222222222222312312312312312122222222222222222222222223123123123123121222222222222222222222222231231231231231212222222222222222222222222312312312311231231212222222222222222222222222312312312312312122222222222222222222222223123123123123121222222222222222222222222231231231231231212222222222222222222222222312312312312312122222222222222222222222223123123123123121222222222222222222222222231231231231231212222222222222222222222222312312312312312122222222222222222222222223123123123123121222222222222222222222222231231231231231212222222222222222222222222312312312312312122222222222222222222222223123123123123121222222222222222222222222231231231231231212222222222222222222222222312312312312312122222222222222222222222223123123123123121222222222222222222222222231231231231231212222222222222222222222222312312312312312122222222222222222222222223123123123123121222222222222222222222222231231231231231212222222222222222222222222312312312312312122222222222222222222222223123123123123121222222222222222222222222231231232312122222222222222222222222223123123,
"md5": "123123xi12ix12",
"asf": "123123xi12ix12",
"asf1": "123123xi12ix12",
"asf2": "123123xi12ix12",
"asf3": "123123xi12ix12",
}
json_str = json.dumps(header_dic)
json_str_bytes = json_str.encode('utf-8')
print(len(json_str_bytes))
# res=struct.pack('i',999999999)
# print(res,len(res))
# res=struct.pack('i',len(json_str_bytes))
socketserver模块的基本使用
基于tcp协议的使用
客户端
import socketserver
class MyRequestHandle(socketserver.BaseRequestHandler):
def handle(self):
# 如果tcp协议，self.request=>conn
print(self.client_address)
while True:
try:
msg = self.request.recv(1024)
if len(msg) == 0:
break
self.request.send(msg.upper())
except Exception:
break
self.request.close()
# 服务端应该做两件事
# 第一件事：循环地从半连接池中取出链接请求与其建立双向链接，拿到链接对象
s = socketserver.ThreadingTCPServer(('127.0.0.1', 8889), MyRequestHandle)
s.serve_forever()
# 等同于
# while True:
# conn,client_addr=server.accept()
# 启动一个线程(conn,client_addr)
# 第二件事：拿到链接对象，与其进行通信循环===>handle
客户端
from socket import *
client = socket(AF_INET, SOCK_STREAM)
client.connect(('127.0.0.1', 8889))
while True:
msg = input('请输入命令>>：').strip()
if len(msg) == 0:
continue
client.send(msg.encode('utf-8'))
res = client.recv(1024)
print(res.decode('utf-8'))
基于udp协议的使用
服务端
import socketserver
class MyRequestHanlde(socketserver.BaseRequestHandler):
def handle(self):
client_data = self.request[0]
server = self.request[1]
client_address = self.client_address
print('客户端发来的数据%s' % client_data)
server.sendto(client_data.upper(), client_address)
s = socketserver.ThreadingUDPServer(("127.0.0.1", 8888), MyRequestHanlde)
s.serve_forever()
# 相当于:只负责循环地收
# while True:
# data,client_addr=server.recvfrom(1024)
# 启动一个线程处理后续的事情(data,client_addr)
客户端
import socket
client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # 流式协议=》tcp协议
while True:
msg = input('>>>: ').strip()
client.sendto(msg.encode('utf-8'), ('115.29.65.16', 8888))
res = client.recvfrom(1024)
print(res)
client.close()
Python网络编程——基于tcp协议实现远程执行命令、udp协议没有粘包问题、解决粘包问题、socketserver模块的基本使用（基于tcp协议、基于udp协议的使用）的更多相关文章
- day32基于tcp协议的远程执行命令
客户端 from socket import *import structimport json client = socket(AF_INET, SOCK_STREAM)client.connect ...
- Python网络编程03 /缓存区、基于TCP的socket循环通信、执行远程命令、socketserver通信
Python网络编程03 /缓存区.基于TCP的socket循环通信.执行远程命令.socketserver通信 目录 Python网络编程03 /缓存区.基于TCP的socket循环通信.执行远程命 ...
- Python网络编程02 /基于TCP、UDP协议的socket简单的通信、字符串转bytes类型
Python网络编程02 /基于TCP.UDP协议的socket简单的通信.字符串转bytes类型 目录 Python网络编程02 /基于TCP.UDP协议的socket简单的通信.字符串转bytes ...
- python 网络编程 TCP/IP socket UDP
TCP/IP简介 虽然大家现在对互联网很熟悉,但是计算机网络的出现比互联网要早很多. 计算机为了联网,就必须规定通信协议,早期的计算机网络,都是由各厂商自己规定一套协议,IBM.Apple和Micro ...
- python网络编程01 /C/S架构|B/S架构、网络通信原理、五层协议、七层协议简述、端口映射技术
python网络编程01 /C/S架构|B/S架构.网络通信原理.五层协议.七层协议简述.端口映射技术 目录 python网络编程01 /C/S架构|B/S架构.网络通信原理.五层协议.七层协议简述. ...
- python网络编程05 /TCP阻塞机制
python网络编程05 /TCP阻塞机制 目录 python网络编程05 /TCP阻塞机制 1.什么是拥塞控制 2.拥塞控制要考虑的因素 3.拥塞控制的方法: 1.慢开始和拥塞避免 2.快重传和快恢 ...
- python网络编程，通过服务名称和会话类型（tcp，udp）获取端口号，简单的异常处理
作为一个php程序员,同时有对网络方面感兴趣,php就比较蛋疼了,所以就抽了些时间看python 之前学python基础因为工作原因,断断续续的看了个基础,差不多是可以写代码了 最近在看<pyt ...
- python 网络编程(远程执行命令与粘包)
远程执行命令 先来学习一个新模块 , 一会用到的.. 新模块: subprocess 执行系统命令 r = subprocess.Popen('ls',shell=True,stdout=subpro ...
- python网络编程-socket编程
一.服务端和客户端 BS架构 (腾讯通软件:server+client) CS架构 (web网站) C/S架构与socket的关系: 我们学习socket就是为了完成C/S架构的开发 二.OSI七层 ...
- python网络编程
Socket是网络编程的一个抽象的概念. 通常我们用一个Socket表示"打开了一个网络链接",而打开一个Socket需要知道目标计算机的IP地址和端口号,再指定协议类型即可. 套 ...
随机推荐
- W1R3S-1项目实战
前言 您受聘在W1R3S.inc单个服务器上进行渗透测试,并报告所有发现.他们要求您获得root访问权限并找到标志(位于/root目录中). 难以获得低特权外壳:初级/中级 获得特权升级的难度:初级/ ...
- Kubernetes(k8s) Web-UI界面(一)：部署和访问仪表板(Dashboard)
目录 一.系统环境 二.前言 三.仪表板(Dashboard)简介 四.部署Kubernetes仪表板(Dashboard) 五.访问Kubernetes仪表板(Dashboard) 5.1 使用to ...
- Redis缓存同步1-策略介绍
缓存数据同步策略示意图 在大多数情况下,我们通过浏览器查询到的数据都是缓存数据,如果缓存数据与数据库的数据存在较大差异的话,可能会产生比较严重的后果的.所以,我们应该也必须保证数据库数据.缓存数据的一 ...
- 即构低延迟直播产品L3，打造更优质的实时互动体验
以短视频.直播为代表的音视频互动,正成为互联网主流的交互方式.拿直播举例,它从一种娱乐形式,逐渐融合于教育.娱乐.电商.旅游等多种生态中.未来,直播还将成为像水.电一样的基础设施. 然而,仅仅可进行音 ...
- Spring相关API
ApplicationContext的继承体系 applicationContext applicationContext:接口类型,代表应用上下文,可以通过其实例获得Spring容器中的Bean A ...
- LCD与OLED的相爱相杀
目前市面的显示技术主要分为LCD与OLED. 本文主要记录对LCD与OLED的学习. 导言:介绍一些专业名词和术语. 像素点:是指在由一个数字序列表示的图像中的一个最小单位,称为像素. 一张图片在显示 ...
- 2021-3-29 Enter按下事件
先在构造器中添加keydown事件 tBoxPsw.KeyDown += TBoxPsw_KeyDown; 在事件中添加按下enter按钮所触发的方法 private void TBoxPsw_Key ...
- 行行AI人才直播第14期：【国内第二波人工智能进入者、连续创业者】土豆《土豆利用GPT成功融资两次的提示词和故事》
行行AI人才(海南行行智能科技有限公司)是博客园和顺顺智慧共同运营的AI行业人才全生命周期服务平台. 此刻,ChatGPT的火热程度已经无需多言.一时间,追逐大模型成了国内AI行业的标准动作,&quo ...
- Cilium系列-8-绕过 IPTables 连接跟踪
系列文章 Cilium 系列文章 前言 将 Kubernetes 的 CNI 从其他组件切换为 Cilium, 已经可以有效地提升网络的性能. 但是通过对 Cilium 不同模式的切换/功能的启用, ...
- win10安装mysql-8.0.19-winx64
第一步:去官网下载安装 (重点)第二步:先解压,然后在mysql下创建一个my.ini文件,更改my.ini文件里面的两行安装目录,第二行加上\data,my.ini文件不能多或少一个符号,内容见文章 ...