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是同一台机器上不同进程或者线程的标识
socket发展历史和分类
套接字起源于 20 世纪 70 年代加利福尼亚大学伯克利分校版本的 Unix,即人们所说的 BSD Unix。 因此,有时人们也把套接字称为“伯克利套接字”或“BSD 套接字”。一开始,套接字被设计用在同 一台主机上多个应用程序之间的通讯。这也被称进程间通讯,或 IPC。
进程之间不能互相通信，文件可以被所以软件使用
套接字有两种（或者称为有两个种族）,分别是基于文件型的和基于网络型的。
基于文件类型的套接字家族
套接字家族的名字：AF_UNIX
unix一切皆文件，基于文件的套接字调用的就是底层的文件系统来取数据，两个套接字进程运行在同一机器，可以通过访问同一个文件系统间接完成通信
基于网络类型的套接字家族
套接字家族的名字：AF_INET
(还有AF_INET6被用于ipv6，还有一些其他的地址家族，不过，他们要么是只用于某个平台，要么就是已经被废弃，或者是很少被使用，或者是根本没有实现，所有地址家族中，AF_INET是使用最广泛的一个，python支持很多种地址家族，但是由于我们只关心网络编程，所以大部分时候我么只使用AF_INET)
套接字工作流程
示意图
简单示例
客户端
import socket client = socket.socket(socket.AF_INET,socket.SOCK_STREAM) conn = client.connect(('127.0.0.1',8080)) # 链接服务端 # print('----',conn) # None client.send('hello'.encode('utf8')) # 发送二进制数据 data = client.recv(1024) print('服务端发来的数据：',data) client.close()
服务端
import socket # socket.AF_INET : 基于网络通信 # socket.SOCK_STREAM : 基于TCP通信，基于流通性 #收发消息是二进制数据 phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM) phone.bind(('127.0.0.1',8080)) phone.listen(5) # 阻塞接收消息 conn,addr = phone.accept() # 返回去元组数据类型 data = conn.recv(1024) # 利用获取的客户端链接接收1024字节数据 print('客户端的数据：',data) conn.send(data.decode('utf8').upper().encode('utf8')) conn.close() phone.close()
由于 socket 模块中有太多的属性。我们在这里破例使用了'from module import *'语句。 使用 'from socket import *',我们就把 socket 模块里的所有属性 都带到我们的命名空间里了,这样能 大幅减短我们的代码。 例如tcpSock = socket(AF_INET, SOCK_STREAM)
socket的方法
服务端
服务端套接字函数
s.bind() 绑定(主机,端口号)到套接字
s.listen() 开始TCP监听
s.accept() 被动接受TCP客户的连接,(阻塞式)等待连接的到来
客户端
客户端套接字函数
s.connect() 主动初始化TCP服务器连接 （使用）
s.connect_ex() connect()函数的扩展版本,出错时返回出错码,而不是抛出异常
公共用途的套接字方法
----- TCP 接收发送数据 ------------- s.recv() 接收TCP数据 s.send() 发送TCP数据(send在待发送数据量大于己端缓存区剩余空间时,数据丢失,不会发完) s.sendall() 发送完整的TCP数据(本质就是循环调用send,sendall在待发送数据量大于己端缓存区剩余空间时,数据不丢失,循环调用send直到发完) ----- UDP接收发送数据 ------------- 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() 创建一个与该套接字相关的文件
四次挥手断开连接
假设Client端发起中断连接请求，也就是发送FIN报文。Server端接到FIN报文，FIN报文的意思是说"我Client端没有数据要发给你了"，但是如果Server端还有数据没有发送完成，则不必急着关闭Server端Socket，可以继续发送数据。
所以Server服务端先发送ACK，"告诉Client端的请求我收到了，但是我还没准备好，请继续你等我的消息"。这个时候Client端就进入FIN_WAIT状态，继续等待Server端的FIN报文
当Server端确定数据已发送完成，则向Client端发送FIN报文，"告诉Client端，好了，我这边数据发完了，准备好关闭连接了"。
Client端收到FIN报文后，"就知道可以关闭连接了，但是他还是不相信网络，怕Server端不知道要关闭，所以发送ACK后进入TIME_WAIT状态，如果Server端没有收到ACK则可以重传。“
Server端收到ACK后，"就知道可以断开连接了"。
Client端等待了2MSL后依然没有收到回复，则证明Server端已正常关闭，
Client端也可以关闭连接了。Ok，TCP连接就这样关闭了！
FIN_WAIT_1：主动断开的请求
FIN_WAIT_2：被动断开的请求
TIME_WAIT : 马上就要断开连接了，会发一个ACK，等待了2MSL后没有收到信息，就可以断开连接
整个过程Client端所经历的状态如下：
Server端所经历的过程如下：
【注意】 在TIME_WAIT状态中，如果TCP client端最后一次发送的ACK丢失了，它将重新发送。TIME_WAIT状态中所需要的时间是依赖于实现方法的。典型的值为30秒、1分钟和2分钟。等待之后连接正式关闭，并且所有的资源(包括端口号)都被释放。
【问题1】为什么连接的时候是三次握手，关闭的时候却是四次握手？
答：因为当Server端收到Client端的SYN连接请求报文后，可以直接发送SYN+ACK报文。其中ACK报文是用来应答的，SYN报文是用来同步的。但是关闭连接时，当Server端收到FIN报文时，很可能并不会立即关闭SOCKET，所以只能先回复一个ACK报文，告诉Client端，"你发的FIN报文我收到了"。只有等到我Server端所有的报文都发送完了，我才能发送FIN报文，因此不能一起发送。故需要四步握手。
【问题2】为什么TIME_WAIT状态需要经过2MSL(最大报文段生存时间)才能返回到CLOSE状态？
答：虽然按道理，四个报文都发送完毕，我们可以直接进入CLOSE状态了，但是我们必须假象网络是不可靠的，最后一个ACK可能丢失。所以TIME_WAIT状态就是用来重发可能丢失的ACK报文。
socket循环收发消息&原理
简单示例
服务端
from socket import * ip_port = ('127.0.0.1', 8080) back_log = 5 buffer_size = 1024 server = socket(AF_INET, SOCK_STREAM) server.bind(ip_port) server.listen(back_log) conn, addr = server.accept() print('双向连接：', conn) print('客户端地址：', addr) while True: data = conn.recv(buffer_size) print('接收到的客户端数据：', data.decode('utf8')) conn.send(data.upper()) print('已经将数据发送给客户端') conn.close() server.close()
from socket import * ip_port = ('127.0.0.1',8080) buffer_size = 1024 client = socket(AF_INET,SOCK_STREAM) client.connect(ip_port) while True: user_data = input(">>:") client.send(user_data.encode('utf8')) print('已经向客户端发送数据') data = client.recv(buffer_size) print('服务端发来的数据：',data.decode('utf8')) client.close()
socket收发消息的原理
socket客户端程序send（数据）到客户端的缓存，操作系统根据协议发送到socket服务端的缓存
socket服务端程序从socket服务端的缓存接收数据
如果socket客户端程序send（空的数据）到客户端的缓存，操作系统不会发送消息，
socket服务端程序的缓存没有东西，socket.rev(1024)，将一直阻塞
问题：
有的同学在重启服务端时可能会遇到
这个是由于你的服务端仍然存在四次挥手的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的套接字
服务端
from socket import * ip_port = ('127.0.0.1',8080) buffer_size = 1024 udp_server = socket(AF_INET,SOCK_DGRAM) #创建一个socket对象 udp_server.bind(ip_port) # 绑定一个IP和端口 while True: data,addr = udp_server.recvfrom(buffer_size) # socket对象接收数据 print('客户端发来的消息：',data) # data为二进制byte udp_server.sendto(data.upper(),addr) # socket对象向指定的IP和端口号发送数据
客户端
from socket import * ip_port = ('127.0.0.1', 8080) buffer_size = 1024 udp_client = socket(AF_INET, SOCK_DGRAM) # 创建一个socket对象 while True : user_data = input('>>:') udp_client.sendto(user_data.encode('utf8'), ip_port) # socket对象向指定的IP和端口发送消息 data = udp_client.recvfrom(buffer_size) # socket接收数据 print('服务端发来的消息：', data) # data是元组类型：(b'SDF', ('127.0.0.1', 8080))
时间服务器
客户端
from socket import * ip_port = ('127.0.0.1',8080) buffer_size = 1024 ntp_client = socket(AF_INET,SOCK_DGRAM) while True: user_data = input('>>:') ntp_client.sendto(user_data.encode('utf8'), ip_port) data,addr = ntp_client.recvfrom(buffer_size) print('ntp服务端的时间是',data.decode('utf8'))
服务端
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: data,addr = ntp_server.recvfrom(buffer_size) if not data: fm = '%Y-%m-%d %X' else: fm = data.decode('utf8') retime = time.strftime(fm) ntp_server.sendto(retime.encode('utf8'),addr)
基于tcp实现远程执行命令
简单示例：没解决粘包现象
服务端
from socket import * import subprocess ip_port = ('127.0.0.1',8080) buffer_size = 1024 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() # 循环收发消息 while True: try: # window系统：客户端断开会抛出异常 cmd = conn.recv(buffer_size) # 由于某些操作系统，在客户端断开时，在此循环一直收 空 # 疑问：如果客户端断开，socket.rev() 收不到消息不应该是处于阻塞状态吗？？？？？ # 不同点： socket发送空消息 & socket使用close()断开连接 if not cmd : break # 若收空，即客户端断开连接（客户端编程限制不能发空消息）,需要重新连接 res = subprocess.Popen(cmd.decode('utf-8'),shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin= subprocess.PIPE ) # 获取到的byte二进制，是根据操作系统使用的编码进行编码的（window为GBK） if res.stderr.read(): cmd_res = res.stderr.read() else: cmd_res = res.stdout.read() if not cmd_res: cmd_res = '命令执行成功！'.encode('utf-8') conn.send(cmd_res) except Exception: break conn.close() tcp_server.close()
问题：
# 由于某些操作系统，在客户端断开时，在此循环一直收 空 # 疑问：如果客户端断开，socket.rev() 收不到消息不应该是处于阻塞状态吗？？？？？ # 不同点： socket发送空消息 & socket使用close()断开连接
解释：应为客户端conn断开，没有意义了，所以收空消息，如果客户端没有结束，socket.rev() 就会处于阻塞状态
客户端
from socket import * import struct from functools import partial 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: cmd=input('>>: ').strip() if not cmd:continue if cmd == 'quit':break tcp_client.send(cmd.encode('utf-8')) recv_data = tcp_client.recv(buffer_size) print('命令的执行结果是 ',recv_data.decode('gbk')) tcp_client.close()
粘包现象
tcp收发消息产生粘包的原因
1.发送端为了将多个发往接收端的包，更有效的发到对方，使用了优化方法（Nagle算法），将多次间隔较小且数据量小的数据，合并成一个大的数据块，然后进行封包。
这样，接收端，就难于分辨出来了，必须提供科学的拆包机制。 即面向流的通信是无消息保护边界的。
2. 接收方不及时接收缓冲区的包（缓冲区有大量的数据），造成多个包接收（客户端发送了一段数据，服务端只收了一小部分，服务端下次再收的时候还是从缓冲区拿上次遗留的数据，产生粘包）
udp收发消息的原理
UDP（user datagram protocol，用户数据报协议）是无连接的，面向消息的，提供高效率服务。
不会使用块的合并优化算法，, 由于UDP支持的是一对多的模式，所以接收端的skbuff(套接字缓冲区）采用了链式结构来记录每一个到达的UDP包，
在每个UDP包中就有了消息头（消息来源地址，端口等信息），这样，对于接收端来说，就容易进行区分处理了。 即面向消息的通信是有消息保护边界的。
udp的recvfrom是阻塞的，一个recvfrom(x)必须对唯一一个sendinto(y),收完了x个字节的数据就算完成,若是y>x数据就丢失，这意味着udp根本不会粘包，但是会丢数据，不可靠
如果一个recvfrom()方法在执行，而没有一个对应的sendinto()方法执行发送消息来，则会处于阻塞状态
解决粘包
方法一：
客户端
#解决粘包问题 from socket import * ip_port = ('127.0.0.1',8080) buffer_size = 1024 tcp_client = socket(AF_INET,SOCK_STREAM) tcp_client.connect(ip_port) while True: cmd = input('>>>:').strip() if not cmd : continue if cmd == 'quit': break tcp_client.send(cmd.encode('utf-8')) # 解决粘包 length = tcp_client.recv(buffer_size) # 客户端即将发接收服务端的数据字节长度 length = int(length.decode('utf-8')) if length: tcp_client.send(b'ready') res_size = 0 res_data = b'' while res_size < length: res_data += tcp_client.recv(buffer_size) res_size = len(res_data) # 目前接收到的数据字节长度 # cmd_res = tcp_client.recv(buffer_size) cmd_res = res_data.decode('gbk') print('接收到服务端发来的消息：',cmd_res) tcp_client.close()
服务端
# 解决粘包问题 from socket import * import subprocess ip_port = ('127.0.0.1',8080) buffer_size = 1024 # 字节 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() # 循环收发消息 while True: try: # window系统：客户端断开会抛出异常 cmd = conn.recv(buffer_size) # 由于某些操作系统，在客户端断开时，在此循环一直收 空 # 疑问：如果客户端断开，socket.rev() 收不到消息不应该是处于阻塞状态吗？？？？？ # 不同点： socket发送空消息 & socket使用close()断开连接 if not cmd : break # 若收空，即客户端断开连接（客户端编程限制不能发空消息）,需要重新连接 res = subprocess.Popen(cmd.decode('utf-8'),shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin= subprocess.PIPE ) # 获取到的byte二进制，是根据操作系统使用的编码进行编码的（window为GBK） if res.stderr.read(): cmd_res = res.stderr.read() else: cmd_res = res.stdout.read() if not cmd_res: cmd_res = '命令执行成功！'.encode('utf-8') # 解决粘包现象 length = len(cmd_res) # 即将发送的数据字节长度 conn.send(str(length).encode('utf-8')) client_ready = conn.recv(buffer_size) if client_ready == b'ready': conn.send(cmd_res) except Exception: break conn.close() tcp_server.close()
方法二：简单使用struct模块
客户端
#解决粘包问题二 from socket import * import struct ip_port = ('127.0.0.1',8080) buffer_size = 1024 tcp_client = socket(AF_INET,SOCK_STREAM) tcp_client.connect(ip_port) while True: cmd = input('>>>:').strip() if not cmd : continue if cmd == 'quit': break tcp_client.send(cmd.encode('utf-8')) # 解决粘包 # length = tcp_client.recv(buffer_size) # 客户端即将发接收服务端的数据字节长度 # length = int(length.decode('utf-8')) data_length = tcp_client.recv(4) # 获取指定大小的数据：关于数据的大小信息 length = struct.unpack('i',data_length)[0] # 将信息数据解包，客户端即将发接收服务端的数据字节长度 res_size = 0 res_data = b'' while res_size < length: res_data += tcp_client.recv(buffer_size) res_size = len(res_data) # 目前接收到的数据字节长度 # cmd_res = tcp_client.recv(buffer_size) cmd_res = res_data.decode('gbk') print('接收到服务端发来的消息：',cmd_res) tcp_client.close()
服务端
# 解决粘包问题二 from socket import * import subprocess import struct ip_port = ('127.0.0.1',8080) buffer_size = 1024 # 字节 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() # 循环收发消息 while True: try: # window系统：客户端断开会抛出异常 cmd = conn.recv(buffer_size) # 由于某些操作系统，在客户端断开时，在此循环一直收 空 # 疑问：如果客户端断开，socket.rev() 收不到消息不应该是处于阻塞状态吗？？？？？ # 不同点： socket发送空消息 & socket使用close()断开连接 if not cmd : break # 若收空，即客户端断开连接（客户端编程限制不能发空消息）,需要重新连接 res = subprocess.Popen(cmd.decode('utf-8'),shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin= subprocess.PIPE ) # 获取到的byte二进制，是根据操作系统使用的编码进行编码的（window为GBK） if res.stderr.read(): cmd_res = res.stderr.read() else: cmd_res = res.stdout.read() if not cmd_res: cmd_res = '命令执行成功！'.encode('utf-8') # 解决粘包现象 length = len(cmd_res) # 即将发送的数据字节长度 # 将数据字节长度，转换为字节类型，并以4个字节(int 类型占四个字节)的空间存放 data_length = struct.pack('i',length) conn.send(data_length) conn.send(cmd_res) except Exception: break conn.close() tcp_server.close()
补充：
l = ['a','b','c','d'] iter(l,'b') #表示迭代到‘b’时停止
根据补充的两个知识点，推出第三种解决粘包的方法
socketserver
简单示例
客户端
from socket import * ip_port = ('127.0.0.1',8080) socket_client = socket(AF_INET,SOCK_STREAM) socket_client.connect(ip_port) while True: msg = input('>>>:').strip() if not msg : continue socket_client.send(msg.encode('utf-8')) data = socket_client.recv(1024) print('服务端发来的消息是：',data.decode('utf-8')) socket_client.close()
服务端
import socketserver class MySocketServer(socketserver.BaseRequestHandler): def handle(self): print('conn is: ',self.request) # conn print('addr is: ',self.client_address) # addr while True: try: data = self.request.recv(1024) if not data:break print('收到客户端的消息是：',data,self.client_address) self.request.sendall(data.upper()) except Exception: print(e) break if __name__ == '__main__': s = socketserver.ThreadingTCPServer(('127.0.0.1',8080),MySocketServer) s.serve_forever()
认证客户端的链接合法性
参考：http://www.cnblogs.com/linhaifeng/articles/6129246.html
阿萨德
浙公网安备 33010602011771号