socket网络编程
socket编程
一 客户端/服务器架构
1.硬件C/S架构(打印机)
2.软件C/S架构
互联网中处处是C/S架构
如黄色网站是服务端，你的浏览器是客户端（B/S架构也是C/S架构的一种）
腾讯作为服务端为你提供视频，你得下个腾讯视频客户端才能看它的视频）
C/S架构与socket的关系：
socket就是为了完成C/S架构的开发。
二 osi七层
须知一个完整的计算机系统是由硬件、操作系统、应用软件三者组成,具备了这三个条件，一台计算机系统就可以自己跟自己玩了（打个单机游戏，玩个扫雷啥的）
如果你要跟别人一起玩，那你就需要上网了，什么是互联网？
互联网的核心就是由一堆协议组成，协议就是标准，比如全世界人通信的标准是英语
如果把计算机比作人，互联网协议就是计算机界的英语。所有的计算机都学会了互联网协议，那所有的计算机都就可以按照统一的标准去收发信息从而完成通信了。
人们按照分工不同把互联网协议从逻辑上划分了层级。
为何学习socket一定要先学习互联网协议：
1.首先：如何基于socket编程，来开发一款自己的C/S架构软件
2.其次：C/S架构的软件（软件属于应用层）是基于网络进行通信的
3.然后：网络的核心即一堆协议，协议即标准，你想开发一款基于网络通信的软件，就必须遵循这些标准。
三 socket层
四 socket是什么
Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。
所以，我们无需深入理解tcp/udp协议，socket已经为我们封装好了，我们只需要遵循socket的规定去编程，写出的程序自然就是遵循tcp/udp标准的。
注意：
也有人将socket说成ip+port，ip是用来标识互联网中的一台主机的位置，而port是用来标识这台机器上的一个应用程序，ip地址是配置到网卡上的，而port是应用程序开启的，ip与port的绑定就标识了互联网中独一无二的一个应用程序 而程序的pid是同一台机器上不同进程或者线程的标识
五 套接字发展史及分类
套接字起源于 20 世纪 70 年代加利福尼亚大学伯克利分校版本的 Unix,即人们所说的 BSD Unix。 因此,有时人们也把套接字称为“伯克利套接字”或“BSD 套接字”。一开始,套接字被设计用在同 一台主机上多个应用程序之间的通讯。这也被称进程间通讯,或 IPC。套接字有两种（或者称为有两个种族）,分别是基于文件型的和基于网络型的。
基于文件类型的套接字家族
套接字家族的名字：AF_UNIX
unix一切皆文件，基于文件的套接字调用的就是底层的文件系统来取数据，两个套接字进程运行在同一机器，可以通过访问同一个文件系统间接完成通信
基于网络类型的套接字家族套接字家族的名字：AF_INET
(还有AF_INET6被用于ipv6，还有一些其他的地址家族，不过，他们要么是只用于某个平台，要么就是已经被废弃，或者是很少被使用，或者是根本没有实现，所有地址家族中，AF_INET是使用最广泛的一个，python支持很多种地址家族，但是由于我们只关心网络编程，所以大部分时候我么只使用AF_INET)
六 套接字工作流程
一个生活中的场景。你要打电话给一个朋友，先拨号，朋友听到电话铃声后提起电话，这时你和你的朋友就建立起了连接，就可以讲话了。等交流结束，挂断电话结束此次交谈。 生活中的场景就解释了这工作原理。
图3
先从服务器端说起。服务器端先初始化Socket，然后与端口绑定(bind)，对端口进行监听(listen)，调用accept阻塞，等待客户端连接。在这时如果有个客户端初始化一个Socket，然后连接服务器(connect)，如果连接成功，这时客户端与服务器端的连接就建立了。客户端发送数据请求，服务器端接收请求并处理请求，然后把回应数据发送给客户端，客户端读取数据，最后关闭连接，一次交互结束
服务端套接字函数
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() 创建一个与该套接字相关的文件
## 服务端 import socket phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM) ## 买手机；参数指基于网络类型，和基于TCP协议 phone.bind(('127.0.0.1',8080))# 绑定手机号；以元祖的形式传入服务端IP地址，和端口 phone.listen(5) # 开机；5代表最多可有5条线路链接 print('--------->') conn,addr = phone.accept() #等着接电话。conn指电话链接，addr对方的手机号 ## 底层触发的是建立TCP的三次握手 ## 程序会在这等待 msg = conn.recv(1024) # 收消息，1024指可接收的消息字节最多1024个 print('客户端发来的消息是 ：',msg) conn.send(msg.upper()) ## 发消息，转换为大写 conn.close() # 断开链接 ## 底层触发的是建立TCP的四次挥手 phone.close() # 关机 ## 客户端 import socket phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM) ## 客户端买手机 phone.connect(('127.0.0.1',8080)) ## 客户端拨电话 phone.send('hello'.encode('utf-8')) ## 给服务端发消息 date = phone.recv(1024) ## 接收来自服务端的消息 print('收到来自服务端的消息：',date)
七 基于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客户端
1 cs = socket() # 创建客户套接字 2 cs.connect() # 尝试连接服务器 3 comm_loop: # 通讯循环 4 cs.send()/cs.recv() # 对话(发送/接收) 5 cs.close() # 关闭客户套接字
加上链接循环与通信循环
#---------服务端循环收发消息------- from socket import * ip_port = ('127.0.0.1',8080) 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('双向链接是',conn) print('客户端地址是',addr) while True: try: ### 异常检测下，此时保证了第一个连入的客户端关闭时，不要报错，直接去连接下一个挂起的链接 date = conn.recv(buffer_size) print('客户端发来的消息是：',date.decode('utf-8')) conn.send(date.upper()) except Exception: break conn.close() tcp_server.close()
#---------客户端循环收发消息------- from socket import * ip_port = ('127.0.0.1',8080) back_log = 5 buffer_size = 1024 tcp_client = socket(AF_INET,SOCK_STREAM) tcp_client.connect(ip_port) while True: msg = input('>>') if not msg:continue tcp_client.send(msg.encode('utf-8')) print('客户端已经发送消息') date = tcp_client.recv(buffer_size) print('客户端发来的消息是：',date.decode('utf-8')) tcp_client.close()
注意：
这个是由于你的服务端仍然存在四次挥手的time_wait状态在占用地址（1.tcp三次握手，四次挥手 2.syn洪水攻击 3.服务器高并发情况下会有大量的time_wait状态的优化方法）
#加入一条socket配置，重用ip和端口 phone=socket(AF_INET,SOCK_STREAM) phone.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #就是它，在bind前加 phone.bind(('127.0.0.1',8080))
发现系统存在大量TIME_WAIT状态的连接，通过调整linux内核参数解决， vi /etc/sysctl.conf 编辑文件，加入以下内容： net.ipv4.tcp_syncookies = 1 net.ipv4.tcp_tw_reuse = 1 net.ipv4.tcp_tw_recycle = 1 net.ipv4.tcp_fin_timeout = 30 然后执行 /sbin/sysctl -p 让参数生效。 net.ipv4.tcp_syncookies = 1 表示开启SYN Cookies。当出现SYN等待队列溢出时，启用cookies来处理，可防范少量SYN攻击，默认为0，表示关闭； net.ipv4.tcp_tw_reuse = 1 表示开启重用。允许将TIME-WAIT sockets重新用于新的TCP连接，默认为0，表示关闭； net.ipv4.tcp_tw_recycle = 1 表示开启TCP连接中TIME-WAIT sockets的快速回收，默认为0，表示关闭。 net.ipv4.tcp_fin_timeout 修改系統默认的 TIMEOUT 时间 方法二
八 基于UDP的套接字
udp是无链接的，先启动哪一端都不会报错
udp服务端
1 ss = socket() #创建一个服务器的套接字 2 ss.bind() #绑定服务器套接字 3 inf_loop: #服务器无限循环 4 cs = ss.recvfrom()/ss.sendto() # 对话(接收与发送) 5 ss.close() # 关闭服务器套接字
udp客户端
cs = socket() # 创建客户套接字
comm_loop: # 通讯循环
cs.sendto()/cs.recvfrom() # 对话(发送/接收)
cs.close() # 关闭客户套接字
udp套接字简单示例
from socket import * ip_port = ('127.0.0.1',8080) buffer_size = 1024 udp_server = socket(AF_INET,SOCK_DGRAM) udp_server.bind(ip_port) while True: date,addr = udp_server.recvfrom(buffer_size) print('客户端发来的消息是：',date.decode('utf-8')) print('客户端地址是：',addr) udp_server.sendto(date.upper(),addr)
from socket import * ip_port = ('127.0.0.1',8080) buffer_size = 1024 udp_client = socket(AF_INET,SOCK_DGRAM) while True: msg = input('>>').strip() udp_client.sendto(msg.encode('utf-8'),ip_port) print('客户端已发送消息') date,addr = udp_client.recvfrom(buffer_size) print('服务端发来的消息是：',date.decode('utf-8')) print('服务端地址是：',addr)
实例：时间服务器
from socket import * import time ip_port = ('127.0.0.1',8080) buffer_size = 1024 ntp_server = socket(AF_INET,SOCK_DGRAM) ntp_server.bind(ip_port) while True: date,addr = ntp_server.recvfrom(buffer_size) if not date: fmt = '%Y-%m-%d %X' else: fmt = date.decode('utf-8') back_time = time.strftime(fmt) ntp_server.sendto(back_time.encode('utf-8'),addr)
from socket import * ip_port = ('127.0.0.1',8080) buffer_size = 1024 ntp_client = socket(AF_INET,SOCK_DGRAM) while True: msg = input('>>').strip() ntp_client.sendto(msg.encode('utf-8'),ip_port) date, addr = ntp_client.recvfrom(buffer_size) print(date.decode('utf-8'))
实例：实现远程执行命令
基于TCP协议
#------ 服务端-------利用tcp实行远程执行命令及测试结果------------- from socket import * import subprocess ip_port = ('127.0.0.1',8090) 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 ## uinux上处理异常，在客户端主动断开后，不会报错，而会一直接收空 print('客户端传来的命令是：',cmd) res = subprocess.Popen(cmd.decode('utf-8'),shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin = subprocess.PIPE) err = res.stderr.read() ##如果传过来的cmd 命令运行出错，则err会得到报错的内容，即不为空 if err: ##cmd命令出错的情况下,err不为空 cmd_res = err else: cmd_res = res.stdout.read() #subprocess得到的结果为字节型（编码默认为系统的编码），直接发 if not cmd_res: cmd_res = '执行成功'.encode('gbk') ## 该情况为命令执行成功后没有返回值的，则自己定义一个返回值 conn.send(cmd_res) except Exception as e: print('-----',e) break conn.close() tcp_server.close()
#------- 客户端------利用tcp实行远程执行命令及测试结果------------- from socket import * ip_port = ('127.0.0.1',8090) back_log = 5 buffer_size = 1024 tcp_client = socket(AF_INET,SOCK_STREAM) tcp_client.connect(ip_port) while True: msg = input('请输入要执行的命令：').strip() if not msg: continue if msg == 'quit': break tcp_client.send(msg.encode('utf-8')) date = tcp_client.recv(buffer_size) print('命令的执行结果是：',date.decode('gbk'))## 因为subprocess得到的结果为字节型,服务端直接发过来的，（windows编码默认为gbk,）,故解码用GBK tcp_client.close()
基于UDP协议
from socket import * import subprocess ip_port = ('127.0.0.1',8010) 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, stderr=subprocess.PIPE, stdin=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) udp_server.close()
from socket import * ip_port = ('127.0.0.1',8010) buffer_size = 1024 udp_client = socket(AF_INET,SOCK_DGRAM) while True: msg = input('>>').strip() if not msg:continue if msg == 'quit':break udp_client.sendto(msg.encode('utf-8'),ip_port) date,addr = udp_client.recvfrom(buffer_size) print('命令运行的结果是:',date.decode('gbk'),addr) udp_client.close(
九 粘包现象
利用上述的远程执行命令分别执行下列命令，出现粘包现象。
1：执行错误命令 2：执行dir 3：执行ipconfig
什么是粘包：
此图显示了socket底层收发消息的机制。
发送端可以是一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时才会清除缓冲区内容。数据是可靠的，但是会粘包。
两种情况下会发生粘包。
1、发送端需要等缓冲区满才发送出去，造成粘包（发送数据时间间隔很短，数据了很小，会合到一起，产生粘包）
2、接收方不及时接收缓冲区的包，造成多个包接收（客户端发送了一段数据，服务端只收了一小部分，服务端下次再收的时候还是从缓冲区拿上次遗留的数据，产生粘包）
十、解决粘包的low比处理方法
问题的根源在于，接收端不知道发送端将要传送的字节流的长度，所以解决粘包的方法就是围绕，如何让发送端在发送数据前，把自己将要发送的字节流总大小让接收端知晓，然后接收端来一个死循环接收完所有数据
low版本的解决方法。
# #------ 服务端-------利用tcp实行远程执行命令及测试结果------------- # from socket import * # import subprocess # # ip_port = ('127.0.0.1',8090) # 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 ## uinux上处理异常，在客户端主动断开后，不会报错，而会一直接收空 # print('客户端传来的命令是：',cmd) # res = subprocess.Popen(cmd.decode('utf-8'),shell=True, # stdout=subprocess.PIPE, # stderr=subprocess.PIPE, # stdin = subprocess.PIPE) # err = res.stderr.read() ##如果传过来的cmd 命令运行出错，则err会得到报错的内容，即不为空 # if err: ##cmd命令出错的情况下,err不为空 # cmd_res = err # else: # cmd_res = res.stdout.read() #subprocess得到的结果为字节型（编码默认为系统的编码），直接发 # if not cmd_res: # cmd_res = '执行成功'.encode('gbk') ## 该情况为命令执行成功后没有返回值的，则自己定义一个返回值 # # 解决粘包 # length = len(cmd_res) # conn.send(str(length).encode('utf-8')) ### 将要发送的消息长度发给客户端 # cilent_ready = conn.recv(buffer_size) ## 为了防止seng消息长度，和后面seng命令运行结果时，seng间隔太短，发生粘包 # if cilent_ready == b'ready': ##让客户端返回的已经准备好（已经知道要收的消息长度）， # conn.send(cmd_res) # except Exception as e: # print('-----',e) # break # conn.close() # tcp_server.close() ### ------优化版--- #------ 服务端-------利用tcp实行远程执行命令及测试结果------------- from socket import * import subprocess,struct ip_port = ('127.0.0.1',8090) 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 ## uinux上处理异常，在客户端主动断开后，不会报错，而会一直接收空 print('客户端传来的命令是：',cmd) res = subprocess.Popen(cmd.decode('utf-8'),shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin = subprocess.PIPE) err = res.stderr.read() ##如果传过来的cmd 命令运行出错，则err会得到报错的内容，即不为空 if err: ##cmd命令出错的情况下,err不为空 cmd_res = err else: cmd_res = res.stdout.read() #subprocess得到的结果为字节型（编码默认为系统的编码），直接发 if not cmd_res: cmd_res = '执行成功'.encode('gbk') ## 该情况为命令执行成功后没有返回值的，则自己定义一个返回值 # 解决粘包 length = len(cmd_res) # conn.send(str(length).encode('utf-8')) ### 将要发送的消息长度发给客户端 # cilent_ready = conn.recv(buffer_size) ## 为了防止seng消息长度，和后面seng命令运行结果时，seng间隔太短，发生粘包 # if cilent_ready == b'ready': ##让客户端返回的已经准备好（已经知道要收的消息长度）， # conn.send(cmd_res) length = struct.pack('i',length) ##代替上面4行代码 conn.send(length) conn.send(cmd_res) except Exception as e: print('-----',e) break conn.close() tcp_server.close()
# #------- 客户端------利用tcp实行远程执行命令及测试结果------------- # from socket import * # # ip_port = ('127.0.0.1',8090) # back_log = 5 # buffer_size = 1024 # # tcp_client = socket(AF_INET,SOCK_STREAM) # tcp_client.connect(ip_port) # while True: # msg = input('请输入要执行的命令：').strip() # if not msg: continue # if msg == 'quit': break # tcp_client.send(msg.encode('utf-8')) # ## 解决粘包 # length = tcp_client.recv(buffer_size) ## 接收要收的消息的长度，有服务端告诉客户端 # length = int(length.decode('utf-8')) # tcp_client.send(b'ready') ##给服务端回应客户端，我知道了消息长度，准备好了接收消息了 # recv_msg = b'' ## 定义初始接受的消息为空 # recv_size = 0 ## 定义初始消息长度为0 # while recv_size < length: #因为服务端可能发来的消息很大，由于自己的缓存区很小，所以需要循环接收消息 # recv_msg += tcp_client.recv(buffer_size)## 每次接受的消息 加在一起，拼接在一起 # recv_size = len(recv_msg) ## 获取循环一次后已收到消息的长度 # print('命令的执行结果是：',recv_msg.decode('gbk'))## 因为subprocess得到的结果为字节型,服务端直接发过来的，（windows编码默认为gbk,）,故解码用GBK # tcp_client.close() #------优化版----- #------- 客户端------利用tcp实行远程执行命令及测试结果------------- from socket import * import struct ip_port = ('127.0.0.1',8090) back_log = 5 buffer_size = 1024 tcp_client = socket(AF_INET,SOCK_STREAM) tcp_client.connect(ip_port) while True: msg = input('请输入要执行的命令：').strip() if not msg: continue if msg == 'quit': break tcp_client.send(msg.encode('utf-8')) ## 解决粘包 # length = tcp_client.recv(buffer_size) ## 接收要收的消息的长度，有服务端告诉客户端 # length = int(length.decode('utf-8')) # tcp_client.send(b'ready') ##给服务端回应客户端，我知道了消息长度，准备好了接收消息了 length = tcp_client.recv(4) # 直接取4个字节 length = struct.unpack('i',length)[0] ## 取元祖的第一个数 recv_msg = b'' ## 定义初始接受的消息为空 recv_size = 0 ## 定义初始消息长度为0 while recv_size < length: #因为服务端可能发来的消息很大，由于自己的缓存区很小，所以需要循环接收消息 recv_msg += tcp_client.recv(buffer_size)## 每次接受的消息 加在一起，拼接在一起 recv_size = len(recv_msg) ## 获取循环一次后已收到消息的长度 print('命令的执行结果是：',recv_msg.decode('gbk'))## 因为subprocess得到的结果为字节型,服务端直接发过来的，（windows编码默认为gbk,）,故解码用GBK tcp_client.close()
为何low：
程序的运行速度远快于网络传输速度，所以在发送一段字节前，先用send去发送该字节流长度，这种方式会放大网络延迟带来的性能损耗
为字节流加上自定义固定长度报头，报头中包含字节流长度，然后一次send到对端，对端在接收时，先从缓存中取出定长的报头，然后再取真实数据
struct模块
该模块可以把一个类型，如数字，转成固定长度的bytes
>>> struct.pack('i',1111111111111)
。。。。。。。。。
struct.error: 'i' format requires -2147483648 <= number <= 2147483647 #这个是范围
# 优化版 from socket import * import subprocess import struct ip_port = ('127.0.0.1', 8080) back_log = 5 buffer_size = 1024 sk = socket(AF_INET, SOCK_STREAM) sk.bind(ip_port) sk.listen(back_log) while True: conn, addr = sk.accept() while 1: try: cmd = conn.recv(buffer_size).decode('utf-8') res = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE) error = res.stderr.read() if error: conn.send(error) else: cmd_res = res.stdout.read() if not cmd_res: # 处理那些命令执行的返回值是None的命令 r = struct.pack('i', 000) conn.send(r) else: r = struct.pack('i', len(cmd_res)) # 拿到固定长度的4个字节的字符串 conn.send(r+cmd_res) # 做一个字符串拼接，把数据长度和数据的内容一起发过去， except Exception: break conn.close() sk.close()
# 优化版解决粘包 from socket import * import struct ip_port = ('127.0.0.1', 8080) buffer_size = 800 sk = socket(AF_INET, SOCK_STREAM) sk.connect(ip_port) while True: cmd = input('>>>') sk.send(cmd.encode('utf-8')) res = sk.recv(4) # 先拿4个字节，拿到数据长度 cmd_res_len = struct.unpack('i', res)[0] if cmd_res_len == 000: print('执行成功') else: cmd_res = sk.recv(cmd_res_len).decode('gbk') print(cmd_res)
十一 认证客户端的链接合法性
如果你想在分布式系统中实现一个简单的客户端链接认证功能，又不像SSL那么复杂，那么利用hmac+加盐的方式来实现：
__author__ = 'goulonghui' import hmac,os from socket import * secret_key = b'goulonghui' def conn_auth(conn): print('开始验证客户端链接') msg = os.urandom(32) ## 获得一个32个字节的随机数据 conn.sendall(msg) h = hmac.new(secret_key,msg) digest = h.digest() ### 12,13 行实现了利用secret_key，msg得到一个字节型数据 respon = conn.recv(len(digest)) return hmac.compare_digest(digest,respon) ## 比较digest和respon是否一样 def conn_hangdle(conn,buffer_size=1024): '处理链接' if not conn_auth(conn): print('客户端不合法') conn.close() return print('链接合法,开始通信') while True: try: date = conn.recv(buffer_size) if not date:break conn.sendall(date.upper()) except Exception as e: print(e) break def server_handle(ip_port,buffer_size,back_log=5): 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) conn_hangdle(conn,buffer_size) if __name__ == '__main__': ip_port = ('127.0.0.1', 8080) buffer_size = 1024 server_handle(ip_port,buffer_size)
__author__ = 'goulonghui' from socket import * import hmac,os secret_key = b'goulonghui' def conn_auth(tcp_client): date = tcp_client.recv(32) h = hmac.new(secret_key, date) digest = h.digest() tcp_client.sendall(digest) def client_handler(ip_port,buffer_size=1024): tcp_client = socket(AF_INET, SOCK_STREAM) tcp_client.connect(ip_port) conn_auth(tcp_client) while True: msg = input('>>') if not msg:continue tcp_client.send(msg.encode('utf-8')) print('客户端已经发送消息') date = tcp_client.recv(buffer_size) print('客户端发来的消息是：',date.decode('utf-8')) tcp_client.close() if __name__ == '__main__': ip_port = ('127.0.0.1', 8080) client_handler(ip_port)
十二 socketserver实现并发
socketserver源码分析：
基于tcp的套接字，关键就是两个循环，一个链接循环，一个通信循环
socketserver模块中分两大类：server类（解决链接问题）和request类（解决通信问题）
server类：
request类：
继承关系:
以下述代码为例，分析socketserver源码：
ftpserver=socketserver.ThreadingTCPServer(('127.0.0.1',8080),FtpServer)
ftpserver.serve_forever()
查找属性的顺序：ThreadingTCPServer->ThreadingMixIn->TCPServer->BaseServer
- 实例化得到ftpserver，先找类ThreadingTCPServer的__init__,在TCPServer中找到，进而执行server_bind,server_active
- 找ftpserver下的serve_forever,在BaseServer中找到，进而执行self._handle_request_noblock()，该方法同样是在BaseServer中
- 执行self._handle_request_noblock()进而执行request, client_address = self.get_request()（就是TCPServer中的self.socket.accept()），然后执行self.process_request(request, client_address)
- 在ThreadingMixIn中找到process_request，开启多线程应对并发，进而执行process_request_thread，执行self.finish_request(request, client_address)
- 上述四部分完成了链接循环，本部分开始进入处理通讯部分，在BaseServer中找到finish_request,触发我们自己定义的类的实例化，去找__init__方法，而我们自己定义的类没有该方法，则去它的父类也就是BaseRequestHandler中找....
源码分析总结：
基于tcp的socketserver我们自己定义的类中的
- self.server即套接字对象
- self.request即一个链接
- self.client_address即客户端地址
基于udp的socketserver我们自己定义的类中的
- self.request是一个元组（第一个元素是客户端发来的数据，第二部分是服务端的udp套接字对象），如(b'adsf', <socket.socket fd=200, family=AddressFamily.AF_INET, type=SocketKind.SOCK_DGRAM, proto=0, laddr=('127.0.0.1', 8080)>)
- self.client_address即客户端地址
#####################代码实现########################
基于TCP：
''' 通过分析socketserver模块底层，得出在tcp中，self.request 就是链接conn ''' import socketserver class MyServer(socketserver.BaseRequestHandler): def handle(self): print('conn is:',self.request) print('addr is:',self.client_address) while True: try: date = self.request.recv(1024) if not date:break print('客户端发来的消息是：',date.decode('utf-8'),self.client_address) self.request.sendall(date.upper()) except Exception as e: print(e) break if __name__ == '__main__': s = socketserver.ThreadingTCPServer(('127.0.0.1',8080),MyServer) s.serve_forever()
from socket import * ip_port = ('127.0.0.1',8080) back_log = 5 buffer_size = 1024 tcp_client = socket(AF_INET,SOCK_STREAM) tcp_client.connect(ip_port) while True: msg = input('>>') if not msg:continue tcp_client.send(msg.encode('utf-8')) print('客户端已经发送消息') date = tcp_client.recv(buffer_size) print('客户端发来的消息是：',date.decode('utf-8')) tcp_client.close()
基于UDP：
## 通过分析socketserver模块底层，得出，对于udp， ## self.request 是一个元祖，元祖的第一个元素是客户端发来的消息，元祖的第二个消息就是self.socket，即一个 ## udp的套接字对象，可通过该套接字对象，向服务端发消息 import socketserver class Myserver(socketserver.BaseRequestHandler): def handle(self): print(self.request) print('客户端发来的消息是：',self.request[0]) self.request[1].sendto(self.request[0].upper(),self.client_address) if __name__ == '__main__': s = socketserver.ThreadingUDPServer(('127.0.0.1',8080),Myserver) s.serve_forever()
from socket import * ip_port = ('127.0.0.1',8080) buffer_size = 1024 udp_client = socket(AF_INET,SOCK_DGRAM) while True: msg = input('>>').strip() udp_client.sendto(msg.encode('utf-8'),ip_port) print('客户端已发送消息') date,addr = udp_client.recvfrom(buffer_size) print('服务端发来的消息是：',date.decode('utf-8')) print('服务端地址是：',addr)
学无止境！
浙公网安备 33010602011771号