郑州做网站的外包公司有哪些,宁波 电商平台网站建设,汽车网站推广策划方案,三星网上商城投诉电话一、基础知识 1. C/S架构 C/S架构即客户机/服务器模式。 它可以分为客户机和服务器两层#xff1a; 第一层: 在客户机系统上结合了界面显示与业务逻辑#xff1b; 第二层: 通过网络结合了数据库服务器。 简单的说就是第一层是用户表示层#xff0c;第二层是数据库层。 这里… 一、基础知识 1. C/S架构 C/S架构即客户机/服务器模式。 它可以分为客户机和服务器两层 第一层: 在客户机系统上结合了界面显示与业务逻辑 第二层: 通过网络结合了数据库服务器。 简单的说就是第一层是用户表示层第二层是数据库层。 这里需要补充的是客户端不仅仅是一些简单的操作它也是会处理一些运算业务逻辑的处理等。也就是说客户端也做着一些本该由服务器来做的一些事情如图所示 2. TCP/IP模型 互联网协议按照功能不同分为osi七层或tcp/ip五层或tcp/ip四层 每层运行常见物理设备 我们将应用层表示层会话层并作应用层从tcpip五层协议的角度来阐述每层的由来与功能搞清楚了每层的主要协议就理解了整个互联网通信的原理。 首先用户感知到的只是最上面一层应用层自上而下每层都依赖于下一层所以我们从最下一层开始切入比较好理解 每层都运行特定的协议越往上越靠近用户越往下越靠近硬件 物理层 物理层由来上面提到孤立的计算机之间要想一起玩就必须接入internet言外之意就是计算机之间必须完成组网 物理层功能主要是基于电器特性发送高低电压(电信号)高电压对应数字1低电压对应数字0 数据链路层 数据链路层由来单纯的电信号0和1没有任何意义必须规定电信号多少位一组每组什么意思 数据链路层的功能定义了电信号的分组方式 以太网协议 早期的时候各个公司都有自己的分组方式后来形成了统一的标准即以太网协议ethernet ethernet规定 一组电信号构成一个数据包叫做‘帧’每一数据帧分成报头head和数据data两部分 head data head包含(固定18个字节) 发送者源地址6个字节接收者目标地址6个字节数据类型6个字节data包含(最短46字节最长1500字节) 数据包的具体内容head长度data长度最短64字节最长1518字节超过最大限制就分片发送 mac地址 head中包含的源和目标地址由来ethernet规定接入internet的设备都必须具备网卡发送端和接收端的地址便是指网卡的地址即mac地址 mac地址每块网卡出厂时都被烧制上一个世界唯一的mac地址长度为48位2进制通常由12位16进制数表示前六位是厂商编号后六位是流水线号 广播 有了mac地址同一网络内的两台主机就可以通信了一台主机通过arp协议获取另外一台主机的mac地址 ethernet采用最原始的方式广播的方式进行通信即计算机通信基本靠吼 网络层 网络层由来有了ethernet、mac地址、广播的发送方式世界上的计算机就可以彼此通信了问题是世界范围的互联网是由 一个个彼此隔离的小的局域网组成的那么如果所有的通信都采用以太网的广播方式那么一台机器发送的包全世界都会收到 这就不仅仅是效率低的问题了这会是一种灾难 上图结论必须找出一种方法来区分哪些计算机属于同一广播域哪些不是如果是就采用广播的方式发送如果不是 就采用路由的方式向不同广播域子网分发数据包mac地址是无法区分的它只跟厂商有关 网络层功能引入一套新的地址用来区分不同的广播域子网这套地址即网络地址 IP协议 规定网络地址的协议叫ip协议它定义的地址称之为ip地址广泛采用的v4版本即ipv4它规定网络地址由32位2进制表示范围0.0.0.0-255.255.255.255一个ip地址通常写成四段十进制数例172.16.10.1ip地址分成两部分 网络部分标识子网主机部分标识主机注意单纯的ip地址段只是标识了ip地址的种类从网络部分或主机部分都无法辨识一个ip所处的子网 例172.16.10.1与172.16.10.2并不能确定二者处于同一子网 子网掩码 所谓”子网掩码”就是表示子网络特征的一个参数。它在形式上等同于IP地址也是一个32位二进制数字它的网络部分全部为1主机部分全部为0。比如IP地址172.16.10.1如果已知网络部分是前24位主机部分是后8位那么子网络掩码就是11111111.11111111.11111111.00000000写成十进制就是255.255.255.0。 知道”子网掩码”我们就能判断任意两个IP地址是否处在同一个子网络。方法是将两个IP地址与子网掩码分别进行AND运算两个数位都为1运算结果为1否则为0然后比较结果是否相同如果是的话就表明它们在同一个子网络中否则就不是。 比如已知IP地址172.16.10.1和172.16.10.2的子网掩码都是255.255.255.0请问它们是否在同一个子网络两者与子网掩码分别进行AND运算 172.16.10.110101100.00010000.00001010.000000001 255255.255.255.0:11111111.11111111.11111111.00000000 AND运算得网络地址结果10101100.00010000.00001010.000000001-172.16.10.0 172.16.10.210101100.00010000.00001010.000000010 255255.255.255.0:11111111.11111111.11111111.00000000 AND运算得网络地址结果10101100.00010000.00001010.000000001-172.16.10.0 结果都是172.16.10.0因此它们在同一个子网络。 总结一下IP协议的作用主要有两个一个是为每一台计算机分配IP地址另一个是确定哪些地址在同一个子网络。 ip数据包 ip数据包也分为head和data部分无须为ip包定义单独的栏位直接放入以太网包的data部分 head长度为20到60字节 data最长为65,515字节。 而以太网数据包的”数据”部分最长只有1500字节。因此如果IP数据包超过了1500字节它就需要分割成几个以太网数据包分开发送了。 以太网头 ip 头 ip数据 ARP协议 arp协议由来计算机通信基本靠吼即广播的方式所有上层的包到最后都要封装上以太网头然后通过以太网协议发送在谈及以太网协议时候我门了解到 通信是基于mac的广播方式实现计算机在发包时获取自身的mac是容易的如何获取目标主机的mac就需要通过arp协议 arp协议功能广播的方式发送数据包获取目标主机的mac地址 协议工作方式每台主机ip都是已知的 例如主机172.16.10.10/24访问172.16.10.11/24 一首先通过ip地址和子网掩码区分出自己所处的子网 场景数据包地址同一子网目标主机mac目标主机ip不同子网网关mac目标主机ip 二分析172.16.10.10/24与172.16.10.11/24处于同一网络(如果不是同一网络那么下表中目标ip为172.16.10.1,通过arp获取的是网关的mac 源mac目标mac源ip目标ip数据部分发送端主机发送端macFF:FF:FF:FF:FF:FF172.16.10.10/24172.16.10.11/24数据 三这个包会以广播的方式在发送端所处的自网内传输所有主机接收后拆开包发现目标ip为自己的就响应返回自己的mac 传输层 传输层的由来网络层的ip帮我们区分子网以太网层的mac帮我们找到主机然后大家使用的都是应用程序你的电脑上可能同时开启qq暴风影音等多个应用程序 那么我们通过ip和mac找到了一台特定的主机如何标识这台主机上的应用程序答案就是端口端口即应用程序与网卡关联的编号。 传输层功能建立端口到端口的通信 补充端口范围0-655350-1023为系统占用端口 tcp协议 可靠传输TCP数据包没有长度限制理论上可以无限长但是为了保证网络的效率通常TCP数据包的长度不会超过IP数据包的长度以确保单个TCP数据包不必再分割。 以太网头ip 头 tcp头 数据 udp协议 不可靠传输”报头”部分一共只有8个字节总长度不超过65,535字节正好放进一个IP数据包。 以太网头ip头 udp头 数据 tcp报文 tcp三次握手和四次挥手 应用层 应用层由来用户使用的都是应用程序均工作于应用层互联网是开发的大家都可以开发自己的应用程序数据多种多样必须规定好数据的组织形式 应用层功能规定应用程序的数据格式。 例TCP协议可以为各种各样的程序传递数据比如Email、WWW、FTP等等。那么必须有不同协议规定电子邮件、网页、FTP数据的格式这些应用程序协议就构成了”应用层”。 3. socket层 Socket是应用层与TCP/IP协议族通信的中间软件抽象层它是一组接口。在设计模式中Socket其实就是一个门面模式它把复杂的TCP/IP协议族隐藏在Socket接口后面对用户来说一组简单的接口就是全部让Socket去组织数据以符合指定的协议。 所以我们无需深入理解tcp/udp协议socket已经为我们封装好了我们只需要遵循socket的规定去编程写出的程序自然就是遵循tcp/udp标准的。 二、套接字 1. 套接字的分类 套接字起源于 20 世纪 70 年代加利福尼亚大学伯克利分校版本的 Unix,即人们所说的 BSD Unix。 因此,有时人们也把套接字称为“伯克利套接字”或“BSD 套接字”。一开始,套接字被设计用在同 一台主机上多个应用程序之间的通讯。这也被称进程间通讯,或 IPC。套接字有两种或者称为有两个种族,分别是基于文件型的和基于网络型的。 基于文件类型的套接字家族 套接字家族的名字AF_UNIX unix一切皆文件基于文件的套接字调用的就是底层的文件系统来取数据两个套接字进程运行在同一机器可以通过访问同一个文件系统间接完成通信 基于网络类型的套接字家族 套接字家族的名字AF_INET (还有AF_INET6被用于ipv6还有一些其他的地址家族不过他们要么是只用于某个平台要么就是已经被废弃或者是很少被使用或者是根本没有实现所有地址家族中AF_INET是使用最广泛的一个python支持很多种地址家族但是由于我们只关心网络编程所以大部分时候我么只使用AF_INET) 服务端套接字函数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() 创建一个与该套接字相关的文件 2.基于TCP的套接字 服务端 from socket import *ip_port (192.168.50.85, 8000)
sever socket(AF_INET, SOCK_STREAM) # AF_INET 基于网络 SOCK_STREAM 基于TCP
sever.bind(ip_port) # 绑定到套接字
sever.listen(5) # 开始监听
while True:conn, addr sever.accept() # 等待连接while True:try:msg conn.recv(1024) # 收消息print(客户端%s发来的消息%s % (addr, msg.decode(utf-8)))conn.send(msg.upper()) # 发消息except Exception:breakconn.close()
sever.close()客户端 from socket import *
client socket(AF_INET, SOCK_STREAM)
client.connect((192.168.50.85, 8000)) # 连接到服务器
while True:msg input(:).strip()client.send(msg.encode(utf-8)) # 不能发送str必须是二进制格式data client.recv(1024)print(收到服务端的消息, data.decode(utf-8))
client.close()基于TCP远程执行命令 1 from socket import *2 import subprocess3 4 ip_port (192.168.50.85, 8080)5 sever socket(AF_INET, SOCK_STREAM)6 sever.bind(ip_port)7 sever.listen(5)8 while True:9 conn, addr sever.accept()
10 while True:
11 try:
12 cmd conn.recv(1024)
13 if not cmd:
14 break
15 print(收到客户端的命令, cmd)
16 # 执行命令得到cmd_res
17 res subprocess.Popen(cmd.decode(utf-8), shellTrue, stdoutsubprocess.PIPE, stdinsubprocess.PIPE,
18 stderrsubprocess.PIPE)
19 err res.stderr.read()
20 if err:
21 cmd_res err
22 else:
23 cmd_res res.stdout.read()
24 conn.send(cmd_res)
25 except Exception as e:
26 print(e)
27 break
28 conn.close() 服务端 1 from socket import *2 ip_port (192.168.50.85, 8080)3 client socket(AF_INET, SOCK_STREAM)4 client.connect(ip_port)5 while True:6 cmd input(请输入命令).strip()7 if not cmd:8 continue9 if cmd quit:
10 break
11 client.send(cmd.encode(utf-8))
12 data client.recv(1024)
13 print(得到的结果是, data.decode(gbk))
14 client.close() 客户端 1 请输入命令dir2 得到的结果是 驱动器 D 中的卷是 DATA3 卷的序列号是 A473-AA804 5 D:\python\Project\python基础\网络编程 的目录6 7 2019/07/19 15:16 DIR .8 2019/07/19 15:16 DIR ..9 2019/07/19 15:13 864 TCP客户端.py
10 2019/07/19 15:16 1,456 TCP服务端.py
11 2019/07/19 14:00 675 UDP客户端1.py
12 2019/07/19 14:00 354 UDP客户端2.py
13 2019/07/19 14:21 278 UDP服务端.py
14 5 个文件 3,627 字节
15 2 个目录 200,399,257,600 可用字节 运行结果 在重启服务端时可能会遇到 这个是由于服务端仍然存在四次挥手的time_wait状态在占用地址如果不懂请深入研究1.tcp三次握手四次挥手 2.syn洪水攻击 3.服务器高并发情况下会有大量的time_wait状态的优化方法 解决方法 #加入一条socket配置重用ip和端口phonesocket(AF_INET,SOCK_STREAM)
phone.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #就是它在bind前加
phone.bind((127.0.0.1,8080))1 发现系统存在大量TIME_WAIT状态的连接通过调整linux内核参数解决2 vi /etc/sysctl.conf3 4 编辑文件加入以下内容5 net.ipv4.tcp_syncookies 16 net.ipv4.tcp_tw_reuse 17 net.ipv4.tcp_tw_recycle 18 net.ipv4.tcp_fin_timeout 309
10 然后执行 /sbin/sysctl -p 让参数生效。
11
12 net.ipv4.tcp_syncookies 1 表示开启SYN Cookies。当出现SYN等待队列溢出时启用cookies来处理可防范少量SYN攻击默认为0表示关闭
13
14 net.ipv4.tcp_tw_reuse 1 表示开启重用。允许将TIME-WAIT sockets重新用于新的TCP连接默认为0表示关闭
15
16 net.ipv4.tcp_tw_recycle 1 表示开启TCP连接中TIME-WAIT sockets的快速回收默认为0表示关闭。
17
18 net.ipv4.tcp_fin_timeout 修改系統默认的 TIMEOUT 时间 方法二 3. 基于UDP的套接字 服务端 from socket import *ip_port (192.168.50.85, 8080)
sever socket(AF_INET, SOCK_DGRAM)
sever.bind(ip_port)
while True:msg, addr sever.recvfrom(1024)print(msg, addr)sever.sendto(msg.upper(), addr)客户端 from socket import *
ip_port (192.168.50.85, 8080)
client socket(AF_INET, SOCK_DGRAM)
while True:msg input(:).strip()if not msg:continueclient.sendto(msg.encode(utf-8), ip_port)msg, addr client.recvfrom(1024)print(msg.decode(utf-8), addr)基于UDP远程执行命令 1 from socket import *2 import subprocess3 4 ip_port (192.168.50.85, 8080)5 server socket(AF_INET, SOCK_DGRAM)6 server.bind(ip_port)7 while True:8 cmd, addr server.recvfrom(1024)9 res subprocess.Popen(cmd.decode(utf-8), shellTrue, stdoutsubprocess.PIPE, stderrsubprocess.PIPE, stdinsubprocess.PIPE)
10 err res.stderr.read()
11 if err:
12 cmd_res err
13 else:
14 cmd_res res.stdout.read()
15 server.sendto(cmd_res, addr) 服务端 1 from socket import *2 3 ip_port (192.168.50.85, 8080)4 client socket(AF_INET, SOCK_DGRAM)5 while True:6 msg input(:).strip()7 if not msg:8 continue9 client.sendto(msg.encode(utf-8), ip_port)
10 data, addr client.recvfrom(1024)
11 print(得到结果, data.decode(gbk))
12 client.close() 客户端 1 :dir2 得到结果 驱动器 D 中的卷是 DATA3 卷的序列号是 A473-AA804 5 D:\python\Project\python基础\网络编程 的目录6 7 2019/07/19 16:40 DIR .8 2019/07/19 16:40 DIR ..9 2019/07/19 15:24 862 TCP客户端.py
10 2019/07/19 15:29 1,523 TCP服务端.py
11 2019/07/19 16:40 709 UDP客户端1.py
12 2019/07/19 14:00 354 UDP客户端2.py
13 2019/07/19 16:35 767 UDP服务端.py
14 5 个文件 4,215 字节
15 2 个目录 200,399,253,504 可用字节 运行结果 三、粘包 1. 什么是粘包 须知只有TCP有粘包现象UDP永远不会粘包为何且听我娓娓道来 首先需要掌握一个socket收发消息的原理 发送端可以是一K一K地发送数据而接收端的应用程序可以两K两K地提走数据当然也有可能一次提走3K或6K数据或者一次只提走几个字节的数据也就是说应用程序所看到的数据是一个整体或说是一个流stream一条消息有多少字节对应用程序是不可见的因此TCP协议是面向流的协议这也是容易出现粘包问题的原因。而UDP是面向消息的协议每个UDP段都是一条消息应用程序必须以消息为单位提取数据不能一次提取任意字节的数据这一点和TCP是很不同的。怎样定义消息呢可以认为对方一次性write/send的数据为一个消息需要明白的是当对方send一条信息的时候无论底层怎样分段分片TCP协议层会把构成整条消息的数据段排序完成后才呈现在内核缓冲区。 例如基于tcp的套接字客户端往服务端上传文件发送时文件内容是按照一段一段的字节流发送的在接收方看了根本不知道该文件的字节流从何处开始在何处结束 所谓粘包问题主要还是因为接收方不知道消息之间的界限不知道一次性提取多少字节的数据所造成的。 此外发送方引起的粘包是由TCP协议本身造成的TCP为提高传输效率发送方往往要收集到足够多的数据后才发送一个TCP段。若连续几次需要send的数据都很少通常TCP会根据优化算法把这些数据合成一个TCP段后一次发送出去这样接收方就收到了粘包数据。 TCPtransport control protocol传输控制协议是面向连接的面向流的提供高可靠性服务。收发两端客户端和服务器端都要有一一成对的socket因此发送端为了将多个发往接收端的包更有效的发到对方使用了优化方法Nagle算法将多次间隔较小且数据量小的数据合并成一个大的数据块然后进行封包。这样接收端就难于分辨出来了必须提供科学的拆包机制。 即面向流的通信是无消息保护边界的。UDPuser datagram protocol用户数据报协议是无连接的面向消息的提供高效率服务。不会使用块的合并优化算法, 由于UDP支持的是一对多的模式所以接收端的skbuff(套接字缓冲区采用了链式结构来记录每一个到达的UDP包在每个UDP包中就有了消息头消息来源地址端口等信息这样对于接收端来说就容易进行区分处理了。 即面向消息的通信是有消息保护边界的。tcp是基于数据流的于是收发的消息不能为空这就需要在客户端和服务端都添加空消息的处理机制防止程序卡住而udp是基于数据报的即便是你输入的是空内容直接回车那也不是空消息udp协议会帮你封装上消息头实验略udp的recvfrom是阻塞的一个recvfrom(x)必须对唯一一个sendinto(y),收完了x个字节的数据就算完成,若是yx数据就丢失这意味着udp根本不会粘包但是会丢数据不可靠 tcp的协议数据不会丢没有收完包下次接收会继续上次继续接收己端总是在收到ack时才会清除缓冲区内容。数据是可靠的但是会粘包。 两种情况下会发生粘包 发送端需要等缓冲区满才发送出去造成粘包发送数据时间间隔很短数据量很小会合到一起产生粘包 # 服务端
from socket import *
ip_port (192.168.50.85, 8000)
sever socket(AF_INET, SOCK_STREAM) # AF_INET 基于网络 SOCK_STREAM 基于TCP
sever.bind(ip_port) # 绑定到套接字
sever.listen(5) # 开始监听
while True:conn, addr sever.accept() # 等待连接msg1 conn.recv(1024)print(第一次收到的数据, msg1)msg2 conn.recv(1024)print(第二次收到的数据, msg2)msg3 conn.recv(1024)print(第三次收到的数据, msg3)conn.close()# 客户端
from socket import *
client socket(AF_INET, SOCK_STREAM)
client.connect((192.168.50.85, 8000)) # 连接到服务器
client.send(bhello)
client.send(bworld)
client.send(b123)# 结果
第一次收到的数据 bhelloworld123
第二次收到的数据 b
第三次收到的数据 b接收方不及时接收缓冲区的包造成多个包接收客户端发送了一段数据服务端只收了一小部分服务端下次再收的时候还是从缓冲区拿上次遗留的数据产生粘包 # 服务端
from socket import *
ip_port (192.168.50.85, 8000)
sever socket(AF_INET, SOCK_STREAM) # AF_INET 基于网络 SOCK_STREAM 基于TCP
sever.bind(ip_port) # 绑定到套接字
sever.listen(5) # 开始监听
while True:conn, addr sever.accept() # 等待连接msg1 conn.recv(1)print(第一次收到的数据, msg1)msg2 conn.recv(3)print(第二次收到的数据, msg2)msg3 conn.recv(5)print(第三次收到的数据, msg3)conn.close()# 客户端
from socket import *
client socket(AF_INET, SOCK_STREAM)
client.connect((192.168.50.85, 8000)) # 连接到服务器
client.send(bhelloworld)# 结果
第一次收到的数据 bh
第二次收到的数据 bell
第三次收到的数据 boworl2. 解决粘包的方法 1. 接收端不知道发送端将要传送的字节流的长度所以解决粘包的方法就是围绕如何让发送端在发送数据前把自己将要发送的字节流总大小让接收端知晓然后接收端来一个死循环接收完所有数据 from socket import *
import subprocess
buffer_size 1024
ip_port (192.168.50.85, 8000)
sever socket(AF_INET, SOCK_STREAM)
sever.bind(ip_port)
sever.listen(5)
while True:conn, addr sever.accept()while True:try:cmd conn.recv(buffer_size)if not cmd:breakprint(收到客户端的命令, cmd)# 执行命令得到cmd_resres subprocess.Popen(cmd.decode(utf-8), shellTrue, stdoutsubprocess.PIPE, stdinsubprocess.PIPE,stderrsubprocess.PIPE)err res.stderr.read()if err:cmd_res errelse:cmd_res res.stdout.read()# 解决粘包问题length len(cmd_res)conn.send(str(length).encode(utf-8))client_ready conn.recv(buffer_size)if client_ready bready:conn.send(cmd_res)except Exception as e:print(e)breakconn.close() 服务端 1 from socket import *2 3 buffer_size 10244 ip_port (192.168.50.85, 8000)5 client socket(AF_INET, SOCK_STREAM)6 client.connect(ip_port)7 while True:8 cmd input(请输入命令).strip()9 if not cmd:
10 continue
11 if cmd quit:
12 break
13 client.send(cmd.encode(utf-8))
14
15 # 解决粘包
16 length client.recv(buffer_size)
17 client.send(bready)
18 length int(length.decode(utf-8))
19 recv_size 0
20 recv_msg b
21 while recv_size length:
22 recv_msg client.recv(buffer_size)
23 recv_size len(recv_msg)
24
25 print(得到的结果是, recv_msg.decode(gbk))
26 client.close() 客户端 程序的运行速度远快于网络传输速度所以在发送一段字节前先用send去发送该字节流长度这种方式会放大网络延迟带来的性能损耗 2. 为字节流加上自定义固定长度报头报头中包含字节流长度然后一次send到对端对端在接收时先从缓存中取出定长的报头然后再取真实数据 1 from socket import *2 import struct3 import subprocess4 buffer_size 10245 ip_port (192.168.50.85, 8000)6 sever socket(AF_INET, SOCK_STREAM)7 sever.bind(ip_port)8 sever.listen(5)9 while True:
10 conn, addr sever.accept()
11 while True:
12 try:
13 cmd conn.recv(buffer_size)
14 if not cmd:
15 break
16 print(收到客户端的命令, cmd)
17 # 执行命令得到cmd_res
18 res subprocess.Popen(cmd.decode(utf-8), shellTrue, stdoutsubprocess.PIPE, stdinsubprocess.PIPE,
19 stderrsubprocess.PIPE)
20 err res.stderr.read()
21 if err:
22 cmd_res err
23 else:
24 cmd_res res.stdout.read()
25
26 # 解决粘包问题
27 length len(cmd_res)
28
29 data_length struct.pack(i, length)
30 conn.send(data_length)
31 conn.send(cmd_res)
32
33 except Exception as e:
34 print(e)
35 break
36 conn.close() 服务端 1 from socket import *2 import struct3 4 buffer_size 10245 ip_port (192.168.50.85, 8000)6 client socket(AF_INET, SOCK_STREAM)7 client.connect(ip_port)8 while True:9 cmd input(请输入命令).strip()
10 if not cmd:
11 continue
12 if cmd quit:
13 break
14 client.send(cmd.encode(utf-8))
15
16 # 解决粘包
17 data_length client.recv(4)
18 length struct.unpack(i, data_length)[0]
19 recv_size 0
20 recv_msg b
21 while recv_size length:
22 recv_msg client.recv(buffer_size)
23 recv_size len(recv_msg)
24 # recv_msg client.recv(length) 一次接收所有数据
25 print(得到的结果是, recv_msg.decode(gbk))
26 client.close() 客户端 struct模块 该模块可以把一个类型如数字转成固定长度的bytes l struct.pack(i,1111111111111) 反解 struct.unpack(i, l) 四、socketserver模块实现并发 import socketserverclass MyServer(socketserver.BaseRequestHandler):def handle(self):print(conn is:, self.request) # connprint(addr is:, self.client_address) # addrwhile True:try:# 收消息data self.request.recv(1024)if not data:breakprint(收到的消息是, data)# 发消息self.request.sendall(data.upper())except Exception:breakif __name__ __main__:s socketserver.ThreadingTCPServer((192.168.50.85, 8000), MyServer)s.serve_forever()转载于:https://www.cnblogs.com/lsf123456/p/11212605.html
