socket学习
一、socket抽象层
Socket是应用层与TCP/IP协议族通信的中间软件抽象层,它是一组接口。在设计模式中,Socket其实就是一个门面模式,它把复杂的TCP/IP协议族隐藏在Socket接口后面,对用户来说,一组简单的接口就是全部,让Socket去组织数据,以符合指定的协议。
所以遵循socket的规定去编程,写出的程序自然就是遵循tcp/udp标准的。
基于文件类型的套接字家族
套接字家族的名字: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() 创建一个与该套接字相关的文件
二、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
phone=socket(AF_INET,SOCK_STREAM)
phone.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #就是它,在bind前加
phone.bind(('127.0.0.1',8080))
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-2-9979bf596780> in <module>()
1 #1
----> 2 phone=socket(AF_INET,SOCK_STREAM)
3 phone.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #就是它,在bind前加
4 phone.bind(('127.0.0.1',8080))
NameError: name 'socket' is not defined
发现系统存在大量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 时间
File "<ipython-input-1-51a109a1ed88>", line 1
发现系统存在大量TIME_WAIT状态的连接,通过调整linux内核参数解决,
^
SyntaxError: invalid character in identifier
#服务端
from socket import *
ip_port = ('192.168.50.182',8080)
buffer_size = 1024
back_log = 5
tcp_sever = socket(AF_INET,SOCK_STREAM)
tcp_sever.bind(ip_port)
tcp_sever.listen(back_log)
print('服务端运行中')
while True:
print('等待客户端连接中')
conn,addr = tcp_sever.accept() #服务端阻塞:等待连接
print('双向连接是',conn)
print('客户端地址',addr)
while True:
try:
msg = conn.recv(buffer_size)
print('客户端发来的信息是:',msg)
if not msg : break
conn.send(msg.upper())
except Exception:
break
conn.close()
tcp_sever.close()
客户端和服务端运行在应用层,数据在用户态内存中。收发信息在内核态内存中。客户端和服务端需要到内核态内存中recv,send。内核态发出到网络是通过tcp、udp协议。
客户端send一个空的自己的内核态缓存。自己的内核态缓存并没有将空内容发出。故服务端和客户端都会卡住。
#客户端
from socket import *
ip_port = ('192.168.50.182',8080)
buffer_size = 1024
tcp_client = socket(AF_INET,SOCK_STREAM)
tcp_client.connect(ip_port)
print('客户端运行中')
while True:
msg = input('>>>').strip()
tcp_client.send(msg.encode('utf8'))
print('信息已发送')
data = tcp_client.recv(buffer_size)
print('客户端发来的信息是:',data.decode('utf8'))
tcp_client.close()
二、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() # 关闭客户套接字
#服务端
from socket import *
ip_port = ('192.168.50.182',8080)
buffer_size = 1024
udp_server = socket(AF_INET,SOCK_DGRAM)
udp_server.bind(ip_port)
while True:
data,addr = udp_server.recvfrom(buffer_size)
print('从客户端%s发来信息:' % str(addr))
print(addr)
print(data)
udp_server.sendto(data.upper(),addr)
#客户端
from socket import *
ip_port = ('192.168.50.182', 8080)
buffer_size = 1024
udp_client = socket (AF_INET, SOCK_DGRAM)
while True:
msg = input('>>>').strip()
udp_client.sendto(msg.encode('utf8'),ip_port)
data, addr = udp_client.recvfrom (buffer_size)
print(addr)
print (data.decode('utf8'))
三、粘包
udp传输收发一一对应,没收到的话会丢弃。而tcp传输收发本质上都是操作缓存,当一次收信息没收全时,下次收取的就是剩余部分,所以会发生粘包。
TCP(transport control protocol,传输控制协议)是面向连接的,面向流的,提供高可靠性服务。收发两端(客户端和服务器端)都要有一一成对的socket,因此,发送端为了将多个发往接收端的包,更有效的发到对方,使用了优化方法(Nagle算法),将多次间隔较小且数据量小的数据,合并成一个大的数据块,然后进行封包。这样,接收端,就难于分辨出来了,必须提供科学的拆包机制。 即面向流的通信是无消息保护边界的。
UDP(user datagram protocol,用户数据报协议)是无连接的,面向消息的,提供高效率服务。不会使用块的合并优化算法,, 由于UDP支持的是一对多的模式,所以接收端的skbuff(套接字缓冲区)采用了链式结构来记录每一个到达的UDP包,在每个UDP包中就有了消息头(消息来源地址,端口等信息),这样,对于接收端来说,就容易进行区分处理了。 即面向消息的通信是有消息保护边界的。
tcp是基于数据流的,于是收发的消息不能为空,这就需要在客户端和服务端都添加空消息的处理机制,防止程序卡住,而udp是基于数据报的,即便是你输入的是空内容(直接回车),那也不是空消息,udp协议会帮你封装上消息头,实验略
#粘包解决1
#sever端
from socket import *
import subprocess
ip_port = ('192.168.50.182',8080)
buffer_size = 1024
back_log = 5
tcp_sever = socket(AF_INET,SOCK_STREAM)
tcp_sever.bind(ip_port)
tcp_sever.listen(back_log)
print('服务端运行中')
while True:
print('等待客户端连接中')
conn,addr = tcp_sever.accept() #服务端阻塞:等待连接
print('双向连接是',conn)
print('客户端地址',addr)
while True:
try:
cmd = conn.recv(buffer_size)
print('客户端发来的信息是:',cmd)
if not cmd : break
res=subprocess.Popen(cmd.decode('utf8'),shell=True,
stderr=subprocess.PIPE,
stdout=subprocess.PIPE,
stdin=subprocess.PIPE)
if res.stderr.read():
cmd_res=res.stderr.read()
else:
cmd_res=res.stdout.read()
if not cmd_res:
cmd_res='执行成功'.encode('gbk')
conn.send(str(len(cmd_res)).encode('utf8'))
ret = conn.recv(buffer_size)
if ret == b'ready':
conn.send(cmd_res.decode('gbk').encode('utf8'))
except Exception as e:
print(e)
break
#client端
from socket import *
ip_port = ('192.168.50.182',8080)
buffer_size = 1024
tcp_client = socket(AF_INET,SOCK_STREAM)
tcp_client.connect(ip_port)
print('客户端运行中')
while True:
cmd = input('>>>').strip() #去掉空格
if not cmd : continue #直接回车或只有空格
if cmd == 'quit':break
tcp_client.send(cmd.encode('utf8'))
print('信息已发送')
length = tcp_client.recv(buffer_size)
tcp_client.send('ready'.encode('utf8'))
length = int(length.decode('utf8'))
recv_size = 0
recv_msg = b''
while recv_size < length:
recv_msg += tcp_client.recv(buffer_size)
recv_size = len(recv_msg)
print('服务端发来的信息是:',recv_msg.decode('utf8'))
使用struct模块打包报文长度为4字节
from socket import *
import struct
import subprocess
ip_port = ('192.168.50.182',8080)
buffer_size = 1024
back_log = 5
tcp_sever = socket(AF_INET,SOCK_STREAM)
tcp_sever.bind(ip_port)
tcp_sever.listen(back_log)
print('服务端运行中')
while True:
print('等待客户端连接中')
conn,addr = tcp_sever.accept() #服务端阻塞:等待连接
print('双向连接是',conn)
print('客户端地址',addr)
while True:
try:
cmd = conn.recv(buffer_size)
print('客户端发来的信息是:',cmd)
if not cmd : break
res=subprocess.Popen(cmd.decode('utf8'),shell=True,
stderr=subprocess.PIPE,
stdout=subprocess.PIPE,
stdin=subprocess.PIPE)
if res.stderr.read():
cmd_res=res.stderr.read()
else:
cmd_res=res.stdout.read()
if not cmd_res:
cmd_res='执行成功'.encode('gbk')
length = len(cmd_res)
data_length = struct.pack('i',length)
conn.send(data_length)
conn.send(cmd_res)
except Exception as e:
print(e)
break
from socket import *
import struct
ip_port = (‘192.168.50.182’,8080)
buffer_size = 1024
tcp_client = socket(AF_INET,SOCK_STREAM)
tcp_client.connect(ip_port)
print(‘客户端运行中’)
while True:
cmd = input(‘>>>’).strip()
if not cmd : continue
if cmd == ‘quit’:break
tcp_client.send(cmd.encode(‘utf8’))
print(‘信息已发送’)
length_data = tcp_client.recv(4)
length = struct.unpack('i',length_data)[0]
recv_size = 0
recv_msg = b''
while recv_size < length:
recv_msg += tcp_client.recv(buffer_size)
recv_size = len(recv_msg)
print('服务端发来的信息是:',recv_msg.decode('gbk'))
socketserver
实现tcp并发
import socketserver
class Myserver(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 as e:
print(e)
break
if __name__ == '__main__':
s = socketserver.ThreadingTCPServer(('127.0.0.1',8080),Myserver)
s.serve_forever()
subprocess模块
subprocess模块用于调用系统命令,允许一个进程创建一个新的子进程,通过管道连接到子进程的stdin/stdout/stderr,获取子进程的返回值等操作。
Popen所有参数: subprocess.Popen(args, bufsize=0, executable=None, stdin=None, stdout=None,stderr=None, preexec_fn=None, close_fds=False, shell=False,cwd=None, env=None, universal_newlines=False, startupinfo=None, creationflags=0)
import subprocess
res = subprocess.Popen('dir',shell=True,stdout=subprocess.PIPE) #标准输出存放到管道
p1=res.stdout.read() #读取标准输出
print(p1)