套接字编程Socket
1，Socket介绍
1，什么是Socket
Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部。
也有人将socket说成ip+port，ip是用来标识互联网中的一台主机的位置，而port是用来标识这台机器上的一个应用程序，ip地址是配置到网卡上的，而port是应用程序开启的，ip与port的绑定就标识了互联网中独一无二的一个应用程序 而程序的pid是同一台机器上不同进程或者线程的标识
2，什么是套接字
套接字起源于 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)，如果连接成功，这时客户端与服务器端的连接就建立了。客户端发送数据请求，服务器端接收请求并处理请求，然后把回应数据发送给客户端，客户端读取数据，最后关闭连接，一次交互结束
socket()模块函数用法
1 import socket 2 socket.socket(socket_family,socket_type,protocal=0) 3 socket_family 可以是 AF_UNIX 或 AF_INET。socket_type 可以是 SOCK_STREAM 或 SOCK_DGRAM。protocol 一般不填,默认值为 0。 4 5 获取tcp/ip套接字 6 tcpSock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 7 8 获取udp/ip套接字 9 udpSock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) 10 11 由于 socket 模块中有太多的属性。我们在这里破例使用了'from module import *'语句。使用 'from socket import *',我们就把 socket 模块里的所有属性都带到我们的命名空间里了,这样能 大幅减短我们的代码。 12 例如tcpSock = socket(AF_INET, SOCK_STREAM)
服务端套接字函数
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() 创建一个与该套接字相关的文件
4，基于TCP的套接字
tcp是基于链接的，必须先启动服务端，然后再启动客户端去链接服务端
tcp服务端
1 ss = socket() #创建服务器套接字 2 ss.bind() #把地址绑定到套接字 3 ss.listen() #监听链接 4 inf_loop: #服务器无限循环 5 cs = ss.accept() #接受客户端链接 6 comm_loop: #通讯循环 7 cs.recv()/cs.send() #对话(接收与发送) 8 cs.close() #关闭客户端套接字 9 ss.close() #关闭服务器套接字(可选)
tcp客户端
1 cs = socket() # 创建客户套接字 2 cs.connect() # 尝试连接服务器 3 comm_loop: # 通讯循环 4 cs.send()/cs.recv() # 对话(发送/接收) 5 cs.close() # 关闭客户套接字
一次通话
1 import socket 2 3 phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #买手机 4 phone.bind(('127.0.0.1',8000)) #绑定手机卡 5 phone.listen(5) #开机 6 print('---->') 7 conn,addr=phone.accept() #等电话 (阻塞) 8 9 data=conn.recv(1024) #收消息(阻塞) 10 print('客户端发来的消息是: ',data) 11 conn.send(data.upper())#发消息 12 13 conn.close() 14 phone.close() 15 16 server
1 import socket 2 3 phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) 4 5 phone.connect(('127.0.0.1',8000)) #拨通电话 6 7 phone.send('hello地方'.encode('utf-8')) #发消息 8 data=phone.recv(1024) # (阻塞) 9 print('收到服务端的发来的消息：',data)
循环通话
对于windows，client程序退出后server异常，对于linux，client程序退出后server一直接收空数据进入死循环
import socket phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # 买手机 phone.bind(('127.0.0.1', 8000)) # 绑定手机卡 phone.listen(5) # 开机 print('---->') conn, addr = phone.accept() # 等电话 (阻塞) while True: # 通信循环 data = conn.recv(1024) # 收消息(阻塞) print('客户端发来的消息是: ', data) conn.send(data.upper()) # 发消息 conn.close() phone.close()
1 import socket 2 3 phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) 4 5 phone.connect(('127.0.0.1',8000)) #拨通电话 6 7 while True: # 通信循环 8 msg=input('>>: ').strip() 9 phone.send(msg.encode('utf-8')) #发消息,发送空给server，server接收空一直阻塞，不会进一步发送数据给client(客户端打通电话不说话，服务端等待客户端说话，然后大家都不说话。。。)，# 不能直接写入字符串，需要转码，因为传到物理层需要转成二进制才行 10 data=phone.recv(1024) 11 print(data) 12 13 phone.close()
加上链接循环
1 import socket 2 3 phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 4 phone.connect(('127.0.0.1', 8085)) 5 6 while True: # 通信循环 7 msg = input('>>> ').strip() 8 if not msg: continue # 解决因为输入为空而导致出现停运 9 phone.send(msg.encode('utf-8')) # 不能直接写入字符串，需要转码，因为传到物理层需要转成二进制才行 10 data = phone.recv(1024) 11 print(data.decode('utf-8')) 12 13 phone.close()
1 import socket 2 3 phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 4 phone.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # 解决ip端口冲突，可以重用ip端口 5 phone.bind(('127.0.0.1', 8085)) # 0-65535:0-1024给操作系统使用 6 phone.listen(5) # 最大挂起的链接数 7 8 print(1) 9 while True: 10 conn, client_addr = phone.accept() # 在服务端要有一个收发消息，所接受的数据都是bytes类型 11 print(client_addr) 12 13 while True: # 通信循环 14 try: # 应对windows系统:如果不捕获异常，客户端程序停止后,服务端程序异常停止,ConnectionResetError: [WinError 10054] 远程主机强迫关闭了一个现有的连接。 15 data = conn.recv(1024) # 1，单位：bytes，2，1024代表最大接受1024个bytes 16 if not data: break # 适用Linux。防止客户端断开，导致出现死循环，占用大量内存(前提是只发生在linux上面，windows系统上面若客户端单方面断开，直接报错) 17 print('客户端的数据:', data.decode('utf-8')) 18 conn.send(data.upper()) 19 except ConnectionResetError: 20 break 21 22 conn.close() 23 phone.close()
5，基于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() # 关闭客户套接字
import socket udpserver=socket.socket(socket.AF_INET,socket.SOCK_DGRAM) udpserver.bind(('127.0.0.1',8080)) while True: #通讯循环 data,client_addr=udpserver.recvfrom(1024) print('======>',data.decode('utf-8')) print(client_addr) # msg=input('>>: ') udpserver.sendto(data.upper(),client_addr)
1 import socket 2 3 udpclient=socket.socket(socket.AF_INET,socket.SOCK_DGRAM) 4 5 server_ip_port=('127.0.0.1',8080) 6 while True: 7 inp=input(">>: ") 8 udpclient.sendto(inp.encode('utf-8'),server_ip_port) 9 10 data,server_addr=udpclient.recvfrom(1024) 11 print(data.decode('utf-8'))
模拟ssh远程执行命令
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) # 解决ip端口冲突，可以重用ip端口 6 phone.bind(('127.0.0.1', 8085)) # 0-65535:0-1024给操作系统使用 7 phone.listen(5) # 最大挂起的链接数 8 9 print(1) 10 while True: # 链接循环 11 conn, client_addr = phone.accept() # 在服务端要有一个收发消息，所接受的数据都是bytes类型 12 print(client_addr) 13 14 while True: # 通信循环 15 try: # 应对windows系统:如果不捕获异常，客户端程序停止后,服务端程序异常停止,ConnectionResetError: [WinError 10054] 远程主机强迫关闭了一个现有的连接。 16 # 1，收命令 17 cmd = conn.recv(1024) # 1，单位：bytes，2，1024代表最大接受1024个bytes 18 if not cmd: break # 适用Linux。防止客户端断开，导致出现死循环，占用大量内存(前提是只发生在linux上面，windows系统上面若客户端单方面断开，直接报错) 19 print('客户端的数据:', cmd.decode('utf-8')) 20 21 # 2，执行命令，拿到结果 22 23 obj = subprocess.Popen(cmd.decode('utf-8'), shell=True, 24 stdout=subprocess.PIPE, 25 stderr=subprocess.PIPE) 26 # print(obj) 27 # print('srdout 1--->: ', obj.stdout.read().decode('utf-8')) 28 # print('stdout 2--->: ', obj.stdout.read().decode('utf-8')) 29 # print('srderr 1--->: ', obj.stderr.read().decode('utf-8')) 30 stdout = obj.stdout.read() 31 stderr = obj.stdout.read() 32 33 # 3，把命令的结果返回给客户端 34 print(len(stdout)+len(stderr)) 35 conn.send(stdout + stderr) 36 except ConnectionResetError: 37 break 38 39 conn.close() 40 phone.close() 41 42 server
1 import socket 2 3 phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 4 phone.connect(('127.0.0.1', 8085)) 5 6 while True: 7 # 1，发命令 8 cmd = input('>>> ').strip() 9 if not cmd: 10 continue # 解决因为输入为空而导致出现停运 11 phone.send(cmd.encode('utf-8')) # 不能直接写入字符串，需要转码，因为传到物理层需要转成二进制才行 12 13 # 2，那命令的结果，并打印 14 data = phone.recv(1024) 15 print(data.decode('gbk')) # 这里如果是windows就使用gbk，linux使用utf-8. 16 17 phone.close() 18 复制代码
qq聊天（由于udp无连接，所以可以同时多个客户端去跟服务器端通信）
1 #_*_coding:utf-8_*_ 2 __author__ = 'Linhaifeng' 3 import socket 4 ip_port=('127.0.0.1',8081) 5 udp_server_sock=socket.socket(socket.AF_INET,socket.SOCK_DGRAM) #买手机 6 udp_server_sock.bind(ip_port) 7 8 while True: 9 qq_msg,addr=udp_server_sock.recvfrom(1024) 10 print('来自[%s:%s]的一条消息: 33[1;44m%s 33[0m' %(addr[0],addr[1],qq_msg.decode('utf-8'))) 11 back_msg=input('回复消息: ').strip() 12 13 udp_server_sock.sendto(back_msg.encode('utf-8'),addr)
1 #_*_coding:utf-8_*_ 2 __author__ = 'Linhaifeng' 3 import socket 4 BUFSIZE=1024 5 udp_client_socket=socket.socket(socket.AF_INET,socket.SOCK_DGRAM) 6 7 qq_name_dic={ 8 '狗哥alex':('127.0.0.1',8081), 9 '瞎驴':('127.0.0.1',8081), 10 '一棵树':('127.0.0.1',8081), 11 '武大郎':('127.0.0.1',8081), 12 } 13 14 15 while True: 16 qq_name=input('请选择聊天对象: ').strip() 17 while True: 18 msg=input('请输入消息,回车发送: ').strip() 19 if msg == 'quit':break 20 if not msg or not qq_name or qq_name not in qq_name_dic:continue 21 udp_client_socket.sendto(msg.encode('utf-8'),qq_name_dic[qq_name]) 22 23 back_msg,addr=udp_client_socket.recvfrom(BUFSIZE) 24 print('来自[%s:%s]的一条消息: 33[1;44m%s 33[0m' %(addr[0],addr[1],back_msg.decode('utf-8'))) 25 26 udp_client_socket.close()
1 #_*_coding:utf-8_*_ 2 __author__ = 'Linhaifeng' 3 import socket 4 BUFSIZE=1024 5 udp_client_socket=socket.socket(socket.AF_INET,socket.SOCK_DGRAM) 6 7 qq_name_dic={ 8 '狗哥alex':('127.0.0.1',8081), 9 '瞎驴':('127.0.0.1',8081), 10 '一棵树':('127.0.0.1',8081), 11 '武大郎':('127.0.0.1',8081), 12 } 13 14 15 while True: 16 qq_name=input('请选择聊天对象: ').strip() 17 while True: 18 msg=input('请输入消息,回车发送: ').strip() 19 if msg == 'quit':break 20 if not msg or not qq_name or qq_name not in qq_name_dic:continue 21 udp_client_socket.sendto(msg.encode('utf-8'),qq_name_dic[qq_name]) 22 23 back_msg,addr=udp_client_socket.recvfrom(BUFSIZE) 24 print('来自[%s:%s]的一条消息: 33[1;44m%s 33[0m' %(addr[0],addr[1],back_msg.decode('utf-8'))) 25 26 udp_client_socket.close()
2，粘包现象
1，粘包原因
接收方不知道消息之间的界限，不知道一次性提取多少字节的数据所造成的。
在python语法里，socket.send(x)的含义是把x当作一个包发送到发送到缓存
就如上面模拟ssh远程执行命令，虽然可以执行windows下面的dir等命令，但是出现了粘包，导致结果粘在了一起，它的发生主要就是因为socket缓冲区导致的。
你的程序实际上无权直接操作网卡的，你操作网卡都是通过操作系统给用户程序暴露出来的接口，那每次你的程序要给远程发数据时，其实是先把数据从用户态copy到内核态，这样的操作是耗资源和时间的，频繁的在内核态和用户态之前交换数据势必会导致发送效率降低， 因此socket 为提高传输效率，发送方往往要收集到足够多的数据后才发送一次数据给对方。若连续几次需要send的数据都很少，通常TCP socket 会根据优化算法把这些数据合成一个TCP段后一次发送出去，这样接收方就收到了粘包数据。
2，粘包只发生与TCP
粘包问题只存在于TCP中，NOT UDP
还是看上图，发送端可以是一K一K地发送数据，而接收端的应用程序可以两K两K地提走数据，当然也有可能一次提走3K或6K数据，或者一次只提走几个字节的数据，也就是说，应用程序所看到的数据是一个整体，或说是一个流（stream），一条消息有多少字节对应用程序是不可见的，因此TCP协议是面向流的协议，这也是容易出现粘包问题的原因。而UDP是面向消息的协议，每个UDP段都是一条消息，应用程序必须以消息为单位提取数据，不能一次提取任意字节的数据，这一点和TCP是很不同的。怎样定义消息呢？可以认为对方一次性write/send的数据为一个消息，需要明白的是当对方send一条信息的时候，无论底层怎样分段分片，TCP协议层会把构成整条消息的数据段排序完成后才呈现在内核缓冲区。
例如基于tcp的套接字客户端往服务端上传文件，发送时文件内容是按照一段一段的字节流发送的，在接收方看了，根本不知道该文件的字节流从何处开始，在何处结束
所谓粘包问题主要还是因为接收方不知道消息之间的界限，不知道一次性提取多少字节的数据所造成的。
总结:
- TCP（transport control protocol，传输控制协议）是面向连接的，面向流的，提供高可靠性服务。收发两端（客户端和服务器端）都要有一一成对的socket，因此，发送端为了将多个发往接收端的包，更有效的发到对方，使用了优化方法（Nagle算法），将多次间隔较小且数据量小的数据，合并成一个大的数据块，然后进行封包。这样，接收端，就难于分辨出来了，必须提供科学的拆包机制。 即面向流的通信是无消息保护边界的。
- UDP（user datagram protocol，用户数据报协议）是无连接的，面向消息的，提供高效率服务。不会使用块的合并优化算法，, 由于UDP支持的是一对多的模式，所以接收端的skbuff(套接字缓冲区）采用了链式结构来记录每一个到达的UDP包，在每个UDP包中就有了消息头（消息来源地址，端口等信息），这样，对于接收端来说，就容易进行区分处理了。 即面向消息的通信是有消息保护边界的。
- tcp是基于数据流的，于是收发的消息不能为空，这就需要在客户端和服务端都添加空消息的处理机制，防止程序卡住，而udp是基于数据报的，即便是你输入的是空内容（直接回车），那也不是空消息，udp协议会帮你封装上消息头，实验略
3，如何会产生粘包
发送方发送数据时间间隔很短，且数据量很小，会合到一起，产生粘包
接收方不及时接收缓冲区的包，造成多个包接收（客户端发送了一段数据，服务端只收了一小部分，服务端下次再收的时候还是从缓冲区拿上次遗留的数据，产生粘包）
代码示例：
1，发送时间间隔短，数据量小，客户端产生粘包
1 import socket 2 3 server = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 4 server.bind(('127.0.0.1', 9903)) # 0-65535; 1-1024给操作系统使用 5 server.listen(5) 6 7 conn, addr = server.accept() 8 9 res1 = conn.recv(1024) 10 print('第一次', res1) 11 12 res2 = conn.recv(1024) 13 print('第二次', res2)
1 # -*- coding: utf-8 -*- 2 import socket 3 4 client = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 5 6 client.connect(('127.0.0.1', 9903)) 7 8 client.send('hello'.encode('utf-8')) 9 client.send('world'.encode('utf-8'))
1 第一次 b'helloworld' 2 第二次 b''
2，发送时间间隔长，服务端每次接收数据量够大，则不产生粘包
1 # -*- coding: utf-8 -*- 2 import socket 3 4 server = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 5 server.bind(('127.0.0.1', 9903)) # 0-65535; 1-1024给操作系统使用 6 server.listen(5) 7 8 conn, addr = server.accept() 9 10 res1 = conn.recv(1024) 11 print('第一次', res1) 12 13 res2 = conn.recv(1024) 14 print('第二次', res2)
1 # -*- coding: utf-8 -*- 2 import socket 3 import time 4 5 client = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 6 7 client.connect(('127.0.0.1', 9903)) 8 9 client.send('hello'.encode('utf-8')) 10 time.sleep(3) # 设定sleeptime为3秒钟 11 client.send('world'.encode('utf-8'))
1 第一次 b'hello' 2 第二次 b'world'
注意：当在1中的服务端和客户端都各加上timesleep，或者服务端每次接收的数据不一，这两种情况的任意一种变化，都可能产生粘包。加上timesleep解决粘包是最不可取的方法，如何without timesleep并且利用Nagle算法优势的情况下解决粘包问题呢？
4，如何解决粘包
实际上就是让服务端知道客户端发出多少数据，然后让服务端收多少数据，实际上就可以解决粘包问题了
简单版
远程执行命令
导入struct模块制作报头，提前知道数据量为多少，以达到接收不粘包，但是这种方法不能发送大一点的文件
1 # -*- coding: utf-8 -*- 2 import socket 3 import subprocess 4 import struct 5 6 phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 7 # phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) 8 phone.bind(('127.0.0.1', 9909)) # 0-65535:0-1024给操作系统使用 9 phone.listen(5) # 监听进程 10 11 print('starting...') 12 while True: # 链接循环 13 conn, client_addr = phone.accept() 14 print(client_addr) 15 16 while True: # 通信循环 17 try: 18 # 1、收命令 19 cmd = conn.recv(8096) 20 if not cmd: break # 适用于linux操作系统 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 30 # 3、把命令的结果返回给客户端 31 # 第一步：制作固定长度的报头 32 total_size = len(stdout) + len(stderr) 33 header = struct.pack('i', total_size) 34 35 # 第二步：把报头发送给客户端 36 conn.send(header) 37 38 # 第三步：再发送真实的数据 39 conn.send(stdout) 40 conn.send(stderr) 41 42 except ConnectionResetError: # 适用于windows操作系统 43 break 44 conn.close() 45 46 phone.close()
1 # -*- coding: utf-8 -*- 2 import socket 3 import struct 4 5 phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 6 7 phone.connect(('127.0.0.1', 9909)) 8 9 while True: 10 # 1、发命令 11 cmd = input('>>: ').strip() # ls /etc 12 if not cmd:continue 13 phone.send(cmd.encode('utf-8')) 14 15 # 2、拿命令的结果，并打印 16 17 # 第一步：先收报头 18 header = phone.recv(4) 19 20 # 第二步：从报头中解析出对真实数据的描述信息（数据的长度） 21 total_size = struct.unpack('i', header)[0] # struct.pack(格式，) 22 23 # 第三步：接收真实的数据 24 recv_size = 0 25 recv_data = b'' # 数据类型为bytes类型 26 while recv_size < total_size: 27 res = phone.recv(1024) # 1024是一个坑 28 recv_data += res 29 recv_size += len(res) 30 31 print(recv_data.decode('gbk')) # windows默认为gbk，linux为utf-8 32 33 phone.close()
终极版
远程执行命令
报头增加了信息量，文件可传输变大
1 import socket 2 import subprocess 3 import struct 4 import json 5 6 phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 7 # phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) 8 phone.bind(('127.0.0.1',9909)) # 0-65535:0-1024给操作系统使用 9 phone.listen(5) 10 11 print('starting...') 12 while True: # 链接循环 13 conn, client_addr=phone.accept() 14 print(client_addr) 15 16 while True: # 通信循环 17 try: 18 # 1、收命令 19 cmd = conn.recv(8096) 20 if not cmd: break # 适用于linux操作系统 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 30 # 3、把命令的结果返回给客户端 31 # 第一步：制作固定长度的报头 32 header_dic = { 33 'filename': 'a.txt', 34 'md5': 'xxdxxx', 35 'total_size': len(stdout) + len(stderr) 36 } 37 38 header_json = json.dumps(header_dic) # 将head_dic转为json字符串类型 39 40 header_bytes = header_json.encode('utf-8') # 将header_json转化为bytes类型，就可用于传输了 41 42 # 第二步：先发送报头的长度 43 conn.send(struct.pack('i', len(header_bytes))) # 将head_bytes改成固定的长度，让客户端识别 44 45 # 第三步：再发报头 46 conn.send(header_bytes) 47 48 # 第四步：再发送真实的数据 49 conn.send(stdout) 50 conn.send(stderr) 51 52 except ConnectionResetError: # 适用于windows操作系统 53 break 54 conn.close() 55 56 phone.close()
1 import socket 2 import struct 3 import json 4 5 phone=socket.socket(socket.AF_INET, socket.SOCK_STREAM) 6 7 phone.connect(('127.0.0.1', 9909)) 8 9 while True: 10 # 1、发命令 11 cmd = input('>>: ').strip() # ls /etc 12 if not cmd:continue 13 phone.send(cmd.encode('utf-8')) 14 15 # 2、拿命令的结果，并打印 16 17 # 第一步：先收报头的长度 18 obj = phone.recv(4) 19 header_size = struct.unpack('i', obj)[0] # 接收报头的长度 20 21 # 第二步：再收报头 22 header_bytes = phone.recv(header_size) 23 24 # 第三步：从报头中解析出对真实数据的描述信息 25 header_json = header_bytes.decode('utf-8') 26 header_dic = json.loads(header_json) # 反序列化 27 print(header_dic) 28 total_size = header_dic['total_size'] 29 30 # 第四步：接收真实的数据 31 recv_size = 0 32 recv_data = b'' 33 while recv_size < total_size: 34 res = phone.recv(1024) # 1024是一个坑 35 recv_data += res 36 recv_size += len(res) 37 38 print(recv_data.decode('gbk')) # windows默认编码为gbk，Linux为utf-8 39 40 phone.close()
5，通过socket收发文件软件开发
收发文件与远程执行命令的程序原理是一模一样的，比如下载文件的过程：
1、客户端提交命令
2、服务端接收命令，解析，执行下载文件的方法，即以读的方式打开文件，for循环读出文件的一行行内容，然后send给客户端
3、客户端以写的方式打开文件，将接收的内容写入文件中
单线程
简单版
实现简单的文件传输，下面代码示例是客户端从服务端下载文件，上传只需更改两者的文件读取命令即可
1 import socket 2 import subprocess 3 import struct 4 import json 5 import os 6 7 share_dir = r'这里填写服务端需要上传的文件具体目录地址' 8 9 phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM) 10 # phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) 11 phone.bind(('127.0.0.1', 8912)) # 0-65535:0-1024给操作系统使用 12 phone.listen(5) 13 14 print('starting...') 15 while True: # 链接循环 16 conn, client_addr = phone.accept() 17 print(client_addr) 18 19 while True: # 通信循环 20 try: 21 # 1、收命令 22 res = conn.recv(8096) # b'get 1.mp4' 遵循get+文件名格式提交命令 23 if not res: break # 适用于linux操作系统 24 25 # 2、解析命令，提取相应命令参数 26 cmds = res.decode('utf-8').split() # ['get','1.mp4'] 27 filename = cmds[1] 28 29 # 3、以读的方式打开文件,读取文件内容发送给客户端 30 # 第一步：制作固定长度的报头 31 header_dic = { 32 'filename': filename, # 'filename':'1.mp4' 33 'md5': 'xxdxxx', 34 'file_size': os.path.getsize(r'%s/%s' % (share_dir, filename)) # os.path.getsize(r'服务端文件上传目录') 35 } 36 37 header_json = json.dumps(header_dic) 38 39 header_bytes = header_json.encode('utf-8') 40 41 # 第二步：先发送报头的长度 42 conn.send(struct.pack('i', len(header_bytes))) 43 44 # 第三步：再发报头 45 conn.send(header_bytes) 46 47 # 第四步：再发送真实的数据 48 with open('%s/%s' % (share_dir, filename), 'rb') as f: 49 # conn.send(f.read()) 50 for line in f: 51 conn.send(line) 52 53 except ConnectionResetError: # 适用于windows操作系统 54 break 55 conn.close() 56 57 phone.close()
1 import socket 2 import struct 3 import json 4 5 download_dir = r'客户端需要题目下载地方的目录地址' 6 7 phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 8 9 phone.connect(('127.0.0.1', 8912)) 10 11 while True: 12 # 1、发命令 13 cmd = input('>>: ').strip() # get a.txt 14 if not cmd: continue 15 phone.send(cmd.encode('utf-8')) 16 17 # 2、以写的方式打开一个新文件，接收服务端发来的文件的内容写入客户的新文件 18 # 第一步：先收报头的长度 19 obj = phone.recv(4) 20 header_size = struct.unpack('i', obj)[0] 21 22 # 第二步：再收报头 23 header_bytes = phone.recv(header_size) 24 25 # 第三步：从报头中解析出对真实数据的描述信息 26 header_json = header_bytes.decode('utf-8') 27 header_dic = json.loads(header_json) 28 ''' 29 header_dic={ 30 'filename': filename, #'filename':'1.mp4' 31 'md5':'xxdxxx', 32 'file_size': os.path.getsize(filename) 33 } 34 ''' 35 print(header_dic) 36 total_size = header_dic['file_size'] 37 filename = header_dic['filename'] 38 39 # 第四步：接收真实的数据 40 with open('%s/%s' % (download_dir, filename), 'wb') as f: 41 recv_size = 0 42 while recv_size < total_size: 43 line = phone.recv(1024) # 1024是一个坑 44 f.write(line) 45 recv_size += len(line) 46 print('总大小：%s 已下载大小：%s' % (total_size, recv_size)) 47 48 49 phone.close()
函数版
简单版定义装进函数
1 import socket 2 import subprocess 3 import struct 4 import json 5 import os 6 7 share_dir = r'server 上传目录' 8 9 def get(conn,cmds): 10 filename = cmds[1] 11 12 # 3、以读的方式打开文件,读取文件内容发送给客户端 13 # 第一步：制作固定长度的报头 14 header_dic = { 15 'filename': filename, # 'filename':'1.mp4' 16 'md5': 'xxdxxx', 17 'file_size': os.path.getsize(r'%s/%s' % (share_dir, filename)) 18 # os.path.getsize(r'server 上传目录') 19 } 20 21 header_json = json.dumps(header_dic) 22 23 header_bytes = header_json.encode('utf-8') 24 25 # 第二步：先发送报头的长度 26 conn.send(struct.pack('i', len(header_bytes))) 27 28 # 第三步：再发报头 29 conn.send(header_bytes) 30 31 # 第四步：再发送真实的数据 32 with open('%s/%s' % (share_dir, filename), 'rb') as f: 33 # conn.send(f.read()) 34 for line in f: 35 conn.send(line) 36 37 def put(conn,cmds): 38 pass 39 40 def run(): 41 phone=socket.socket(socket.AF_INET, socket.SOCK_STREAM) 42 # phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) 43 phone.bind(('127.0.0.1', 8912)) # 0-65535:0-1024给操作系统使用 44 phone.listen(5) 45 46 print('starting...') 47 while True: # 链接循环 48 conn,client_addr=phone.accept() 49 print(client_addr) 50 51 while True: # 通信循环 52 try: 53 # 1、收命令 54 res = conn.recv(8096) # b'put 1.mp4' 55 if not res: break # 适用于linux操作系统 56 57 # 2、解析命令，提取相应命令参数 58 cmds = res.decode('utf-8').split() # ['put','1.mp4'] 59 if cmds[0] == 'get': 60 get(conn, cmds) 61 elif cmds[0] == 'put': 62 input(conn, cmds) 63 64 65 except ConnectionResetError: #适用于windows操作系统 66 break 67 conn.close() 68 69 phone.close() 70 71 72 if __name__ == '__main__': 73 run()
1 import socket 2 import struct 3 import json 4 5 download_dir = r'client 下载目录' 6 7 def get(phone,cmds): 8 # 2、以写的方式打开一个新文件，接收服务端发来的文件的内容写入客户的新文件 9 # 第一步：先收报头的长度 10 obj = phone.recv(4) 11 header_size = struct.unpack('i', obj)[0] 12 13 # 第二步：再收报头 14 header_bytes = phone.recv(header_size) 15 16 # 第三步：从报头中解析出对真实数据的描述信息 17 header_json = header_bytes.decode('utf-8') 18 header_dic = json.loads(header_json) 19 ''' 20 header_dic={ 21 'filename': filename, #'filename':'1.mp4' 22 'md5':'xxdxxx', 23 'file_size': os.path.getsize(filename) 24 } 25 ''' 26 print(header_dic) 27 total_size = header_dic['file_size'] 28 filename = header_dic['filename'] 29 30 # 第四步：接收真实的数据 31 with open('%s/%s' % (download_dir, filename), 'wb') as f: 32 recv_size = 0 33 while recv_size < total_size: 34 line = phone.recv(1024) # 1024是一个坑 35 f.write(line) 36 recv_size += len(line) 37 print('总大小：%s 已下载大小：%s' % (total_size, recv_size)) 38 39 def put(phone,cmds): 40 pass 41 42 def run(): 43 phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) 44 45 phone.connect(('127.0.0.1',8912)) 46 47 while True: 48 #1、发命令 49 inp=input('>>: ').strip() #get a.txt 50 if not inp:continue 51 phone.send(inp.encode('utf-8')) 52 53 cmds=inp.split() #['get','a.txt'] 54 if cmds[0] == 'get': 55 get(phone,cmds) 56 elif cmds[0] == 'put': 57 put(phone,cmds) 58 59 phone.close() 60 61 62 63 if __name__ == '__main__': 64 run()
面向对象版
1 import socket 2 import struct 3 import json 4 import subprocess 5 import os 6 7 class MYTCPServer: 8 address_family = socket.AF_INET 9 10 socket_type = socket.SOCK_STREAM 11 12 allow_reuse_address = False 13 14 max_packet_size = 8192 15 16 coding='utf-8' 17 18 request_queue_size = 5 19 20 server_dir='file_upload' 21 22 def __init__(self, server_address, bind_and_activate=True): 23 """Constructor. May be extended, do not override.""" 24 self.server_address=server_address 25 self.socket = socket.socket(self.address_family, 26 self.socket_type) 27 if bind_and_activate: 28 try: 29 self.server_bind() 30 self.server_activate() 31 except: 32 self.server_close() 33 raise 34 35 def server_bind(self): 36 """Called by constructor to bind the socket. 37 """ 38 if self.allow_reuse_address: 39 self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) 40 self.socket.bind(self.server_address) 41 self.server_address = self.socket.getsockname() 42 43 def server_activate(self): 44 """Called by constructor to activate the server. 45 """ 46 self.socket.listen(self.request_queue_size) 47 48 def server_close(self): 49 """Called to clean-up the server. 50 """ 51 self.socket.close() 52 53 def get_request(self): 54 """Get the request and client address from the socket. 55 """ 56 return self.socket.accept() 57 58 def close_request(self, request): 59 """Called to clean up an individual request.""" 60 request.close() 61 62 def run(self): 63 while True: 64 self.conn,self.client_addr=self.get_request() 65 print('from client ',self.client_addr) 66 while True: 67 try: 68 head_struct = self.conn.recv(4) 69 if not head_struct:break 70 71 head_len = struct.unpack('i', head_struct)[0] 72 head_json = self.conn.recv(head_len).decode(self.coding) 73 head_dic = json.loads(head_json) 74 75 print(head_dic) 76 #head_dic={'cmd':'put','filename':'a.txt','filesize':123123} 77 cmd=head_dic['cmd'] 78 if hasattr(self,cmd): 79 func=getattr(self,cmd) 80 func(head_dic) 81 except Exception: 82 break 83 84 def put(self,args): 85 file_path=os.path.normpath(os.path.join( 86 self.server_dir, 87 args['filename'] 88 )) 89 90 filesize=args['filesize'] 91 recv_size=0 92 print('----->',file_path) 93 with open(file_path,'wb') as f: 94 while recv_size < filesize: 95 recv_data=self.conn.recv(self.max_packet_size) 96 f.write(recv_data) 97 recv_size+=len(recv_data) 98 print('recvsize:%s filesize:%s' %(recv_size,filesize)) 99 100 101 tcpserver1=MYTCPServer(('127.0.0.1',8080)) 102 103 tcpserver1.run() 104 105 server
1 import socket 2 import struct 3 import json 4 import os 5 6 7 8 class MYTCPClient: 9 address_family = socket.AF_INET 10 11 socket_type = socket.SOCK_STREAM 12 13 allow_reuse_address = False 14 15 max_packet_size = 8192 16 17 coding='utf-8' 18 19 request_queue_size = 5 20 21 def __init__(self, server_address, connect=True): 22 self.server_address=server_address 23 self.socket = socket.socket(self.address_family, 24 self.socket_type) 25 if connect: 26 try: 27 self.client_connect() 28 except: 29 self.client_close() 30 raise 31 32 def client_connect(self): 33 self.socket.connect(self.server_address) 34 35 def client_close(self): 36 self.socket.close() 37 38 def run(self): 39 while True: 40 inp=input(">>: ").strip() 41 if not inp:continue 42 l=inp.split() 43 cmd=l[0] 44 if hasattr(self,cmd): 45 func=getattr(self,cmd) 46 func(l) 47 48 49 def put(self,args): 50 cmd=args[0] 51 filename=args[1] 52 if not os.path.isfile(filename): 53 print('file:%s is not exists' %filename) 54 return 55 else: 56 filesize=os.path.getsize(filename) 57 58 head_dic={'cmd':cmd,'filename':os.path.basename(filename),'filesize':filesize} 59 print(head_dic) 60 head_json=json.dumps(head_dic) 61 head_json_bytes=bytes(head_json,encoding=self.coding) 62 63 head_struct=struct.pack('i',len(head_json_bytes)) 64 self.socket.send(head_struct) 65 self.socket.send(head_json_bytes) 66 send_size=0 67 with open(filename,'rb') as f: 68 for line in f: 69 self.socket.send(line) 70 send_size+=len(line) 71 print(send_size) 72 else: 73 print('upload successful') 74 75 76 77 78 client=MYTCPClient(('127.0.0.1',8080)) 79 80 client.run() 81 82 client
多线程
基于多进程实现并发的套接字通信，需要不断开启新进程来服务
1 from socket import * 2 from multiprocessing import Process 3 4 def talk(conn): 5 while True: 6 try: 7 data = conn.recv(1024) 8 if not data: break 9 conn.send(data.upper()) 10 except ConnectionResetError: 11 break 12 13 conn.close() 14 15 16 def server(ip,port): 17 server = socket(AF_INET, SOCK_STREAM) 18 server.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1) 19 server.bind((ip,port)) 20 server.listen(5) 21 22 while True: 23 conn, addr = server.accept() 24 p = Process(target=talk, args=(conn,)) 25 p.start() 26 27 server.close() 28 29 30 if __name__ == '__main__': 31 server('127.0.0.1', 8080)
1 from socket import * 2 3 client=socket(AF_INET,SOCK_STREAM) 4 client.connect(('127.0.0.1',8080)) 5 6 while True: 7 msg=input('>>: ').strip() 8 if not msg:continue 9 10 client.send(msg.encode('utf-8')) 11 data=client.recv(1024) 12 print(data.decode('utf-8'))
1，基于多线程的并发套接字通信
随着客户端数目的增加，服务端主机可能瘫痪
1 # 并发多线程 2 from socket import * 3 from threading import Thread 4 5 def communicate(conn): 6 while True: 7 try: 8 data = conn.recv(1024) 9 if not data: break 10 conn.send(data.upper()) 11 except ConnectionResetError: 12 break 13 14 conn.close() 15 16 17 def server(ip, port): 18 server = socket(AF_INET, SOCK_STREAM) 19 server.bind((ip, port)) 20 server.listen(5) 21 22 while True: 23 conn, addr = server.accept() 24 t = Thread(target=communicate,args=(conn,)) 25 t.start() 26 27 server.close() 28 29 30 if __name__ == '__main__': 31 server('127.0.0.1', 8081)
1 from socket import * 2 3 client=socket(AF_INET,SOCK_STREAM) 4 client.connect(('127.0.0.1',8081)) 5 6 7 while True: 8 msg = input('>>: ').strip() 9 if not msg: continue 10 client.send(msg.encode('utf-8')) 11 data = client.recv(1024) 12 print(data.decode('utf-8')) 13 14 client.close()