Python--网络编程-----粘包现象

一、为了防止出现端口占用的情况,

linux中可以使用pkill -9 python

windows系统中使用taskkill python

二、什么是粘包现象

1、多个包(也就是多个命令的执行结果)粘在一起的现象,叫做粘包现象

2、代码示例如下:

服务端代码:

 1 import socket
 2 import subprocess
 3
 4 phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 5 # phone.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
 6 phone.bind((‘127.0.0.1‘, 9081))  # 0-65535:0-1024给操作系统使用
 7 phone.listen(5)
 8
 9 print(‘starting......‘)
10 while True:  # 链接循环
11     conn, client_addr = phone.accept()
12     print(client_addr)
13
14     while True:  # 通信循环
15         try:
16             # 1、收命令
17             cmd = conn.recv(1024)
18             if not cmd:  # 适用于linux操作系统
19                 break
20             print(‘客户端的数据‘, cmd)
21
22             # 2、执行命令,拿到结果
23             obj = subprocess.Popen(cmd.decode(‘utf-8‘), shell=True,
24                                    stdout=subprocess.PIPE,
25                                    stderr=subprocess.PIPE)
26
27             stdout = obj.stdout.read()
28             stderr = obj.stderr.read()
29             # 3、把命令的结果返回给客户端
30             print(len(stdout) + len(stderr))
31             conn.send(stdout+stderr)
32
33         except ConnectionResetError:  # 适用于Windows操作系统
34             break
35
36     conn.close()
37
38 phone.close()

客户端代码:

 1 import socket
 2
 3
 4 phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 5
 6 phone.connect((‘127.0.0.1‘, 9081))
 7
 8 while True:
 9     # 1、发命令
10     cmd = input(‘>>:‘).strip()
11     if not cmd:
12         continue
13     phone.send(cmd.encode(‘utf-8‘))
14
15     # 2、拿命令的结果,打印
16     data = phone.recv(1024)
17     print(data.decode(‘gbk‘))
18
19 phone.close()

在客户端依次输入dir,ipconfig,dir,

客户端运行结果为:

 1 C:\Users\xu516\PycharmProjects\Python全栈开发\venv\Scripts\python.exe "C:/Users/xu516/PycharmProjects/Python全栈开发/第三模块/网络编程/04 粘包现象/客户端.py"
 2 >>:dir
 3  驱动器 C 中的卷是 OS
 4  卷的序列号是 7849-BAF9
 5
 6  C:\Users\xu516\PycharmProjects\Python全栈开发\第三模块\网络编程\04 粘包现象 的目录
 7
 8 2018/04/07  22:17    <DIR>          .
 9 2018/04/07  22:17    <DIR>          ..
10 2018/04/05  21:18                 0 __init__.py
11 2018/04/07  22:17               376 客户端.py
12 2018/04/07  22:17             1,194 服务端.py
13                3 个文件          1,570 字节
14                2 个目录 36,304,265,216 可用字节
15
16 >>:ipconfig
17
18 Windows IP 配置
19
20
21 无线局域网适配器 本地连接* 3:
22
23    媒体状态  . . . . . . . . . . . . : 媒体已断开连接
24    连接特定的 DNS 后缀 . . . . . . . :
25
26 以太网适配器 VMware Network Adapter VMnet1:
27
28    连接特定的 DNS 后缀 . . . . . . . :
29    本地链接 IPv6 地址. . . . . . . . : fe80::5d54:4c1:d7d6:c647%6
30    IPv4 地址 . . . . . . . . . . . . : 192.168.189.1
31    子网掩码  . . . . . . . . . . . . : 255.255.255.0
32    默认网关. . . . . . . . . . . . . :
33
34 以太网适配器 VMware Network Adapter VMnet8:
35
36    连接特定的 DNS 后缀 . . . . . . . :
37    本地链接 IPv6 地址. . . . . . . . : fe80::680e:7f79:aed1:fe62%10
38    IPv4 地址 . . . . . . . . . . . . : 192.168.254.1
39    子网掩码  . . . . . . . . . . . . : 255.255.255.0
40    默认网关. . . . . . . . . . . . . :
41
42 无线局域网适配器 WLAN:
43
44    连接特定的 DNS 后缀 . . . . . . . : DHCP HOST
45    本地链接 IPv6 地址. . . . . . . . : fe80::9c84:419c:e3af:89dd%11
46    IPv4 地址 . . . . . . . . . . . . : 192.168.0.106
47    子网掩码  . . . . . . . . . . . . : 255.255.255.0
48
49 >>:dir
50 默认网关. . . . . . . . . . . . . : 192.168.0.1
51
52 以太网适配器 蓝牙网络连接:
53
54    媒体状态  . . . . . . . . . . . . : 媒体已断开连接
55    连接特定的 DNS 后缀 . . . . . . . :
56
57 隧道适配器 Teredo Tunneling Pseudo-Interface:
58
59    连接特定的 DNS 后缀 . . . . . . . :
60    IPv6 地址 . . . . . . . . . . . . : 2001:0:9d38:953c:20d3:83ef:d86a:f024
61    本地链接 IPv6 地址. . . . . . . . : fe80::20d3:83ef:d86a:f024%2
62    默认网关. . . . . . . . . . . . . : ::
63
64 >>:

第一次输入dir显示结果正常,第二次输入dir输出结果却为ip地址信息,也就是上一个ifconfig命令的遗留信息,这种现象就叫做粘包现象,

代码中服务端和客户端recv指定的最大接收字节数都为1024个字节,我们可以在服务端上看看命令执行结果的长度,如下:

1 starting......
2 (‘127.0.0.1‘, 60296)
3 客户端的数据 b‘dir‘
4 453
5 客户端的数据 b‘ipconfig‘
6 1481
7 客户端的数据 b‘dir‘
8 453

可以看出,ipconfig命令结果的长度超出了recv最大接收字节数,没有接收完,还遗留在管道里,就出现了粘包现象

原文地址:https://www.cnblogs.com/xudachen/p/8735270.html

时间: 2024-10-05 22:33:47

Python--网络编程-----粘包现象的相关文章

20 网络编程 粘包现象与解决方案

1.https://www.cnblogs.com/guobaoyuan/p/6809447.html 发送数据包前 对包的长度进行计算 1. 比较low的方法是 len( package) 然后直接发送给接收端.这样会出现一个问题,就是接收端不知道你的这个 len(package)是几个字节,就也有可能会出现粘包问题. 2. 利用struct对包的长度打包为固定4个字节或8个字节. 3. struct.pack format参数为"i" 时只能打包长度为10的数字,那么还可以先将 长

python之网络编程粘包

一.粘包 粘包现象 # 服务端 import socket import subprocess phone = socket.socket() phone.bind(('127.0.0.1',8888)) phone.listen(5) while 1: conn,addr = phone.accept() while 1: cmd = conn.recv(1024) ret = subprocess.Popen(cmd.decode('utf-8'), shell=True, stdout=s

第六章 - 网络编程 - 粘包

1.粘包: 多个包 多个命令的结果 粘到一起了 因为recv 1024限制了 导致的结果 参考:http://www.cnblogs.com/linhaifeng/articles/6129246.html 粘包底层原理分析: 1.运行一个软件 和 哪几个硬件 有关 硬盘 内存 cpu 2.启动程序: 硬盘程序 加载到 内存 启一个软件就占一个内存空间 os 就有一个内存空间 os的内存空间 和 软件的内存空间 彼此互相隔离 须知:只有TCP有粘包现象,UDP永远不会粘包. 所谓粘包问题主要还是

网络编程粘包问题

首先说为什么会粘包,在py2上运行时,服务器把两次发送的操作强制的合成一次发送给客户端,所以 粘在一起了,因为python3的版本是可以的,但是有的时候python3也会出现粘包现象. 解决粘包的问题有两种方法: 1  可以先sleep一下,这个样子就可以使缓冲区超时,就不在等下一次的了,这样就可以和下一条命令隔离开了 2  我在服务端来一个等待客户端确认,就ok了,这个确认不需要我们用户输入,而是客户端自动的给你来这个响应,就是说,客户端自动的写好代码,自动的给服务器一个响应,只要收到服务端的

Python网络编程03/ low版解决粘包问题

目录 Python网络编程03/ low版解决粘包问题 1.操作系统的缓存区 2.基于TCP协议的socket循环通信 2.1 服务端(server) 2.2客户端(client) 3.基于TCP协议的socket链接+循环 通信 3.1服务端(server) 3.2 客户端(client) 4.基于TCP协议的socket应用实例:执行远程命令 4.1服务端(server) 4.2客户端(client) 5.粘包现象 5.1服务端(server) 5.2客户端(client) 5.3展示收发问

Python网络编程04/recv原理/高大上版解决粘包方式

目录 Python网络编程04/recv原理/高大上版解决粘包方式 1.昨日内容回顾 2.recv工作原理 3.高大上版解决粘包方式(自定制报头) 3.1 解决思路: 3.2 服务端 3.3客户端 4.基于UDP协议的socket通信 4.1服务端 4.2客户端 Python网络编程04/recv原理/高大上版解决粘包方式 1.昨日内容回顾 1. 通信循环 2. 链接通信循环 3. 远程执行命令: subprocess.Popen() # bytes: 网络传输, 文件存储时. 4. 粘包现象

网络编程基础粘包现象

粘包 tcp是流式传输,字节流,数据与数据之间是没有边界的 流式传输优点: 不限定长度 可靠传输 缺点: 慢 和一个人的通信连接conn会一直占用我们的通信资源 udp协议,面向数据包的传输 数据包优点 快 由于不需要建立连接,所以谁发的消息我都能接受到 缺点 不能传输过长的数据 不可靠 粘包现象 由于流式传输的特点,产生了数据连续发送的粘包现象. 在一个conn建立起来的连接上传输的多条数据是没有边界的 数据的发送和接收实际上不是在执行send/recv的时候就立刻被发送和接收,而是需要经过操

10.python网络编程(解决粘包问题 part 2)

一.什么时候会产生粘包现象. 只有在使用tcp协议的情况下才会产生粘包现象!udp协议永远不会! 发送端可以1k1k的把数据发送出去,接收端,可以2k2k的的去接收数据,一次可能会接收3k,也有可能1次接收6k. TCP协议是面向流的协议,这也是容易出现粘包问题的原因.而UDP是面向消息的协议,每个UDP段都是一条消息,应用程序必须以消息为单位提取数据,不能一次提取任意字节的数据,这一点和TCP是很不同的.怎样定义消息呢?可以认为对方一次性write/send的数据为一个消息,需要明白的是当对方

网络编程-之------粘包现象

一.什么是粘包 须知:只有TCP有粘包现象,UDP永远不会粘包 粘包不一定会发生 如果发生了:1.可能是在客户端已经粘了 2.客户端没有粘,可能是在服务端粘了 首先需要掌握一个socket收发消息的原理 应用程序所看到的数据是一个整体,或说是一个流(stream),一条消息有多少字节对应用程序是不可见的,因此TCP协议是面向流的协议,这也是容易出现粘包问题的原因.(因为TCP是流式协议,不知道啥时候开始,啥时候结束).而UDP是面向消息的协议,每个UDP段都是一条消息,应用程序必须以消息为单位提