python基础-tcp粘包、解决方案、subprocess执行shell命令

2024-08-31 22:38
文章标签 python 基础 解决方案 命令 shell tcp 执行 subprocess 粘包

本文主要是介绍python基础-tcp粘包、解决方案、subprocess执行shell命令，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

      • subprocess
      • 引入socket粘包问题
      • 粘包现象
        • 客户端粘包
        • 服务端粘包
        • 粘包解决方案1
          • structpack
        • 粘包解决方案2

subprocess

平时我们在dos命令窗口中
这里写图片描述

那么我们在python中也有一个方法subprocess实现同样的效果

import subprocessobj=subprocess.Popen('dir',shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE,)print(obj.stdout.read().decode('gbk'))
print(obj.stdout.read().decode('gbk'))print(obj.stderr.read().decode("gbk"))

输出如下：

E:\python\python_sdk\python.exe "E:/python/py_pro/1 作业（粘包问题）/subprocess模块.py"驱动器 E 中的卷没有标签。卷的序列号是 A449-5D34E:\python\py_pro\1 作业（粘包问题） 的目录2017/11/28  15:46    <DIR>          .
2017/11/28  15:46    <DIR>          ..
2017/11/28  15:46               289 subprocess模块.py
2017/11/28  13:39                72 tcp的nagle算法
2017/11/28  13:39               282 客户端.py
2017/11/28  13:39               946 服务端.py4 个文件          1,589 字节2 个目录 119,030,386,688 可用字节Process finished with exit code 0

我们看到stdout只打印一次，因为第一次已经从管道取完，第二次就不会取出了

我们改下上面的代码改查如下：

obj=subprocess.Popen('dirr',shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE,)

然后输出如下：

E:\python\python_sdk\python.exe "E:/python/py_pro/1 作业（粘包问题）/subprocess模块.py"'dirr' 不是内部或外部命令，也不是可运行的程序
或批处理文件。Process finished with exit code 0

引入socket粘包问题

我们接下来写一个例子，需求是在客户端输入dos命令，然后在服务端接受结果，然后返回给客户端
我们先来看下服务端代码

import subprocess
from socket import *
server=socket(AF_INET,SOCK_STREAM)server.bind(('127.0.0.1',8081))
server.listen(5)
while True:conn, addr=server.accept()print(conn)while True:try:cmd=conn.recv(8096)if not cmd:break #针对linux#执行命令cmd=cmd.decode('utf-8')#调用模块，执行命令，并且收集命令的执行结果，而不是打印obj = subprocess.Popen(cmd, shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE,)stdout=obj.stdout.read()stderr=obj.stderr.read()print(stdout.decode('gbk'))#发送命令的结果conn.send(stdout+stderr)except ConnectionResetError:breakconn.close()server.close()

接下来看客户端代码：

from socket import *client=socket(AF_INET,SOCK_STREAM)
client.connect(('127.0.0.1',8081))while True:cmd=input('>>: ').strip()if not cmd:continueclient.send(cmd.encode('utf-8'))data=client.recv(1024)print(data.decode('gbk'))client.close()

接下来我们进行测试启动服务端，在启动客户端
在客户端输入dir指令，然后就在服务端接收到如下信息
这里写图片描述

服务端在 conn.send(stdout+stderr)发送指令到客户端，如下是输出信息
这里写图片描述

以上代码是有问题的？如果我们在客户端重新输入一个dos指令tasklist，我们再来看看有什么不同的输出信息呢？
服务端输出了tasklist的全部信息
这里写图片描述

然而客户端输出了tasklist的部分信息
这里写图片描述

原因是什么呢？
我们在服务端

cmd=conn.recv(8096)

然而我们在客户端

data=client.recv(1024)

当我们输入dir，在服务端能一次性的接收，服务端在发给列表时候，客户端也能一次性的取出来
但是我们输入tasklist,服务端能一次性取，然而服务端在发给客户端时候，客户端由于只能接受1024，所以就不会从缓存中一下取完大于1024的那部分数据

其实客户端，服务端recv(大小)的方式都是不可取的，这个例子只是引出一个概念就是粘包

粘包现象

发送端可以是一K一K地发送数据，而接收端的应用程序可以两K两K地提走数据，当然也有可能一次提走3K或6K数据，或者一次只提走几个字节的数据，也就是说，应用程序所看到的数据是一个整体，或说是一个流（stream），一条消息有多少字节对应用程序是不可见的，因此TCP协议是面向流的协议，这也是容易出现粘包问题的原因。而UDP是面向消息的协议，每个UDP段都是一条消息，应用程序必须以消息为单位提取数据，不能一次提取任意字节的数据，这一点和TCP是很不同的。怎样定义消息呢？可以认为对方一次性write/send的数据为一个消息，需要明白的是当对方send一条信息的时候，无论底层怎样分段分片，TCP协议层会把构成整条消息的数据段排序完成后才呈现在内核缓冲区。

例如基于tcp的套接字客户端往服务端上传文件，发送时文件内容是按照一段一段的字节流发送的，在接收方看了，根本不知道该文件的字节流从何处开始，在何处结束

所谓粘包问题主要还是因为接收方不知道消息之间的界限，不知道一次性提取多少字节的数据所造成的。

此外，发送方引起的粘包是由TCP协议本身造成的，TCP为提高传输效率，发送方往往要收集到足够多的数据后才发送一个TCP段。若连续几次需要send的数据都很少，通常TCP会根据优化算法把这些数据合成一个TCP段后一次发送出去，这样接收方就收到了粘包数据。

TCP（transport control protocol，传输控制协议）是面向连接的，面向流的，提供高可靠性服务。收发两端（客户端和服务器端）都要有一一成对的socket，因此，发送端为了将多个发往接收端的包，更有效的发到对方，使用了优化方法（Nagle算法），将多次间隔较小且数据量小的数据，合并成一个大的数据块，然后进行封包。这样，接收端，就难于分辨出来了，必须提供科学的拆包机制。 即面向流的通信是无消息保护边界的。
UDP（user datagram protocol，用户数据报协议）是无连接的，面向消息的，提供高效率服务。不会使用块的合并优化算法，, 由于UDP支持的是一对多的模式，所以接收端的skbuff(套接字缓冲区）采用了链式结构来记录每一个到达的UDP包，在每个UDP包中就有了消息头（消息来源地址，端口等信息），这样，对于接收端来说，就容易进行区分处理了。 即面向消息的通信是有消息保护边界的。
tcp是基于数据流的，于是收发的消息不能为空，这就需要在客户端和服务端都添加空消息的处理机制，防止程序卡住，而udp是基于数据报的，即便是你输入的是空内容（直接回车），那也不是空消息，udp协议会帮你封装上消息头，实验略

udp的recvfrom是阻塞的，一个recvfrom(x)必须对唯一一个sendinto(y),收完了x个字节的数据就算完成,若是y>x数据就丢失，这意味着udp根本不会粘包，但是会丢数据，不可靠

tcp的协议数据不会丢，没有收完包，下次接收，会继续上次继续接收，己端总是在收到ack时才会清除缓冲区内容。数据是可靠的，但是会粘包。

此外，发送方引起的粘包是由TCP协议本身造成的，TCP为提高传输效率，发送方往往要收集到足够多的数据后才发送一个TCP段。若连续几次需要send的数据都很少，通常TCP会根据优化算法把这些数据合成一个TCP段后一次发送出去，这样接收方就收到了粘包数据。

TCP（transport control protocol，传输控制协议）是面向连接的，面向流的，提供高可靠性服务。收发两端（客户端和服务器端）都要有一一成对的socket，因此，发送端为了将多个发往接收端的包，更有效的发到对方，使用了优化方法（Nagle算法），将多次间隔较小且数据量小的数据，合并成一个大的数据块，然后进行封包。这样，接收端，就难于分辨出来了，必须提供科学的拆包机制。 即面向流的通信是无消息保护边界的。

客户端粘包

发送端需要等缓冲区满才发送出去，造成粘包（发送数据时间间隔很短，数据了很小，会合到一起，产生粘包）

服务端：

import time
from socket import *
server=socket(AF_INET,SOCK_STREAM)
server.bind(('127.0.0.1',8082))server.listen(5)conn,addr=server.accept()res1=conn.recv(1024)
print(res1)

客户端：

import time
from socket import *client=socket(AF_INET,SOCK_STREAM)
client.connect(('127.0.0.1',8082))client.send(b'hello')
client.send(b'world')

启动服务端、启动客户端
然后在服务端输出如下信息：

b'helloworld'

以上的例子就是一个粘包现象，将客户端的hello和world打包发送给服务端

服务端粘包

接收方不及时接收缓冲区的包，造成多个包接收（客户端发送了一段数据，服务端只收了一小部分，服务端下次再收的时候还是从缓冲区拿上次遗留的数据，产生粘包）
服务端：

import time
from socket import *
server=socket(AF_INET,SOCK_STREAM)
server.bind(('127.0.0.1',8082))server.listen(5)conn,addr=server.accept()res1=conn.recv(2)
print(res1)res1=conn.recv(1024)
print(res1)res1=conn.recv(1024)
print(res1)

客户端：

import time
from socket import *client=socket(AF_INET,SOCK_STREAM)
client.connect(('127.0.0.1',8082))client.send(b'hello')
time.sleep(1)
client.send(b'world')

服务端输出如下：

E:\python\python_sdk\python.exe "E:/python/py_pro/2 粘包现象/服务端.py"
b'he'
b'llo'
b'world'
粘包解决方案1

我们知道python只定义了6种数据类型，字符串，整数，浮点数，列表，元组，字典。但是C语言中有些字节型的变量，在python中该如何实现呢？这点颇为重要，特别是要在网络上进行数据传输的话。
struct.pack用于将Python的值根据格式符，转换为字符串（因为Python中没有字节(Byte)类型，可以把这里的字符串理解为字节流，或字节数组）。其函数原型为：struct.pack(fmt, v1, v2, …)，参数fmt是格式字符串，关于格式字符串的相关信息下面有所介绍。v1, v2, …表示要转换的python值。下面的例子将两个整数转换为字符串（字节流）:

问题的根源在于，接收端不知道发送端将要传送的字节流的长度，所以解决粘包的方法就是围绕，如何让发送端在发送数据前，把自己将要发送的字节流总大小让接收端知晓，然后接收端来一个死循环接收完所有数据

struct.pack
import struct#帮我们把数字转成固定长度的bytes类型
res=struct.pack('i',68999)
print(res,len(res))res1=struct.unpack('i',res)
print(res1[0])re2 = struct.pack("ii",2,3)
print(len(re2))

输出如下：

b'\x87\r\x01\x00' 4
68999
8

接下来看下解决粘包的第一种方案

服务端

import subprocess
import struct
from socket import *
server=socket(AF_INET,SOCK_STREAM)
server.bind(('127.0.0.1',8085))
server.listen(5)
while True:conn,addr=server.accept()print(addr)while True:try:cmd=conn.recv(8096)if not cmd:break #针对linux#执行命令cmd=cmd.decode('utf-8')print(cmd,"==========")#调用模块，执行命令，并且收集命令的执行结果，而不是打印obj = subprocess.Popen(cmd, shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE,)stdout=obj.stdout.read()stderr=obj.stderr.read()print("stdout-----------",len(stdout),len(stderr))#第一步：制作报头：total_size=len(stdout)+len(stderr)header=struct.pack('i',total_size)#第二步：先发报头（固定长度）conn.send(header)#第三步：发送命令的结果conn.send(stdout)conn.send(stderr)except ConnectionResetError:breakconn.close()server.close()

客户端：

import struct
from socket import *client=socket(AF_INET,SOCK_STREAM)
client.connect(('127.0.0.1',8085))while True:cmd=input('>>: ').strip()if not cmd:continueclient.send(cmd.encode('utf-8'))#第一步：收到报头header=client.recv(4)total_size=struct.unpack('i',header)[0]#第二步：收完整真实的数据recv_size=0res=b''while recv_size < total_size:recv_data=client.recv(1024)res+=recv_data#控制条件recv_size+=len(recv_data)print(res.decode('gbk'))client.close()
粘包解决方案2

接下来看下解决粘包的第二种方案
服务端：

import subprocess
import struct
import json
from socket import *
server=socket(AF_INET,SOCK_STREAM)
server.bind(('127.0.0.1',8089))server.listen(5)
while True:conn,addr=server.accept()print(addr)while True:try:cmd=conn.recv(8096)if not cmd:break #针对linux#执行命令cmd=cmd.decode('utf-8')#调用模块，执行命令，并且收集命令的执行结果，而不是打印obj = subprocess.Popen(cmd, shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE,)stdout=obj.stdout.read()stderr=obj.stderr.read()# 1：先制作报头，报头里放：数据大小, md5, 文件header_dic = {'total_size':len(stdout)+len(stderr),'md5': 'xxxxxxxxxxxxxxxxxxx','filename': 'xxxxx','xxxxx':'123123'}header_json = json.dumps(header_dic)header_bytes = header_json.encode('utf-8')header_size = struct.pack('i', len(header_bytes))print(len(header_bytes),header_size)# 2: 先发报头的长度conn.send(header_size)# 3：先发报头conn.send(header_bytes)# 4：再发送真实数据conn.send(stdout)conn.send(stderr)except ConnectionResetError:breakconn.close()server.close()

客户端：

import struct
import json
from socket import *client=socket(AF_INET,SOCK_STREAM)
client.connect(('127.0.0.1',8089))while True:cmd=input('>>: ').strip()if not cmd:continueclient.send(cmd.encode('utf-8'))# 1:先收报头长度obj = client.recv(4)header_size = struct.unpack('i', obj)[0]# 2：先收报头，解出报头内容header_bytes = client.recv(header_size)header_json = header_bytes.decode('utf-8')header_dic = json.loads(header_json)print(header_dic)total_size = header_dic['total_size']# 3:循环收完整数据recv_size=0res=b''while recv_size < total_size:recv_data=client.recv(1024)res+=recv_datarecv_size+=len(recv_data)print(res.decode('gbk'))client.close()

这篇关于python基础-tcp粘包、解决方案、subprocess执行shell命令的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1125190。

相关文章

Linux join命令的使用及说明

Linux join命令的使用及说明

《Linuxjoin命令的使用及说明》`join`命令用于在Linux中按字段将两个文件进行连接,类似于SQL的JOIN,它需要两个文件按用于匹配的字段排序,并且第一个文件的换行符必须是LF,`jo... 目录一. 基本语法二. 数据准备三. 指定文件的连接key四.-a输出指定文件的所有行五.-o指定输出
阅读更多...
Linux jq命令的使用解读

Linux jq命令的使用解读

《Linuxjq命令的使用解读》jq是一个强大的命令行工具,用于处理JSON数据,它可以用来查看、过滤、修改、格式化JSON数据,通过使用各种选项和过滤器,可以实现复杂的JSON处理任务... 目录一. 简介二. 选项2.1.2.2-c2.3-r2.4-R三. 字段提取3.1 普通字段3.2 数组字段四.
阅读更多...
Linux kill正在执行的后台任务 kill进程组使用详解

Linux kill正在执行的后台任务 kill进程组使用详解

《Linuxkill正在执行的后台任务kill进程组使用详解》文章介绍了两个脚本的功能和区别,以及执行这些脚本时遇到的进程管理问题,通过查看进程树、使用`kill`命令和`lsof`命令,分析了子... 目录零. 用到的命令一. 待执行的脚本二. 执行含子进程的脚本，并kill2.1 进程查看2.2 遇到的
阅读更多...
从基础到高级详解Go语言中错误处理的实践指南

从基础到高级详解Go语言中错误处理的实践指南

《从基础到高级详解Go语言中错误处理的实践指南》Go语言采用了一种独特而明确的错误处理哲学,与其他主流编程语言形成鲜明对比,本文将为大家详细介绍Go语言中错误处理详细方法,希望对大家有所帮助... 目录1 Go 错误处理哲学与核心机制1.1 错误接口设计1.2 错误与异常的区别2 错误创建与检查2.1 基础
阅读更多...
Python版本信息获取方法详解与实战

Python版本信息获取方法详解与实战

《Python版本信息获取方法详解与实战》在Python开发中,获取Python版本号是调试、兼容性检查和版本控制的重要基础操作,本文详细介绍了如何使用sys和platform模块获取Python的主... 目录1. python版本号获取基础2. 使用sys模块获取版本信息2.1 sys模块概述2.1.1
阅读更多...
一文详解Python如何开发游戏

一文详解Python如何开发游戏

《一文详解Python如何开发游戏》Python是一种非常流行的编程语言,也可以用来开发游戏模组,：本文主要介绍Python如何开发游戏的相关资料,文中通过代码介绍的非常详细,需要的朋友可以参考下... 目录一、python简介二、Python 开发 2D 游戏的优劣势优势缺点三、Python 开发 3D
阅读更多...
Python函数作用域与闭包举例深度解析

Python函数作用域与闭包举例深度解析

《Python函数作用域与闭包举例深度解析》Python函数的作用域规则和闭包是编程中的关键概念,它们决定了变量的访问和生命周期,：本文主要介绍Python函数作用域与闭包的相关资料,文中通过代码... 目录1. 基础作用域访问示例1：访问全局变量示例2：访问外层函数变量2. 闭包基础示例3：简单闭包示例4
阅读更多...
Python实现字典转字符串的五种方法

Python实现字典转字符串的五种方法

《Python实现字典转字符串的五种方法》本文介绍了在Python中如何将字典数据结构转换为字符串格式的多种方法,首先可以通过内置的str()函数进行简单转换;其次利用ison.dumps()函数能够... 目录1、使用json模块的dumps方法：2、使用str方法：3、使用循环和字符串拼接：4、使用字符
阅读更多...
Python版本与package版本兼容性检查方法总结

Python版本与package版本兼容性检查方法总结

《Python版本与package版本兼容性检查方法总结》：本文主要介绍Python版本与package版本兼容性检查方法的相关资料,文中提供四种检查方法,分别是pip查询、conda管理、PyP... 目录引言为什么会出现兼容性问题方法一：用 pip 官方命令查询可用版本方法二：conda 管理包环境方法
阅读更多...
基于Python开发Windows自动更新控制工具

基于Python开发Windows自动更新控制工具

《基于Python开发Windows自动更新控制工具》在当今数字化时代,操作系统更新已成为计算机维护的重要组成部分,本文介绍一款基于Python和PyQt5的Windows自动更新控制工具,有需要的可... 目录设计原理与技术实现系统架构概述数学建模工具界面完整代码实现技术深度分析多层级控制理论服务层控制注
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2