python基础(15)-socket网络编程&socketserver

时间 2019-12-04

标签 python 基础 socket 网络编程 socketserver 栏目 Python 繁體版

原文原文链接

socket

参数及方法说明

初始化参数

sk = socket.socket(参数1,参数2,参数3)
参数1：地址簇
　　socket.AF_INET IPv4（默认）
　　socket.AF_INET6 IPv6
　　socket.AF_UNIX 只可以用于单一的Unix系统进程间通讯

参数2：类型
　　socket.SOCK_STREAM　　流式socket , for TCP （默认）
　　socket.SOCK_DGRAM　　 数据报式socket , for UDP
　　socket.SOCK_RAW 原始套接字，普通的套接字没法处理ICMP、IGMP等网络报文，而SOCK_RAW能够；其次，SOCK_RAW也能够处理特殊的IPv4报文；此外，利用原始套接字，能够经过IP_HDRINCL套接字选项由用户构造IP头。
　　socket.SOCK_RDM 是一种可靠的UDP形式，即保证交付数据报但不保证顺序。SOCK_RAM用来提供对原始协议的低级访问，在须要执行某些特殊操做时使用，如发送ICMP报文。SOCK_RAM一般仅限于高级用户或管理员运行的程序使用。
　　socket.SOCK_SEQPACKET 可靠的连续数据包服务

参数3：协议
　（默认）与特定的地址家族相关的协议,若是是 0 ，则系统就会根据地址格式和套接类别,自动选择一个合适的协议

方法

sk.bind(address):将套接字绑定到地址。address地址的格式取决于地址族。在AF_INET下，以元组（host,port）的形式表示地址。
sk.listen(backlog):开始监听传入链接。backlog指定在拒绝链接以前，能够挂起的最大链接数量。backlog等于5，表示内核已经接到了链接请求，但服务器尚未调用accept进行处理的链接个数最大为5这个值不能无限大，由于要在内核中维护链接队列
sk.setblocking(bool):是否阻塞（默认True），若是设置False，那么accept和recv时一旦无数据，则报错。
sk.accept():接受链接并返回（conn,address）,其中conn是新的套接字对象，能够用来接收和发送数据。address是链接客户端的地址。接收TCP 客户的链接（阻塞式）等待链接的到来
sk.connect(address):链接到address处的套接字。通常，address的格式为元组（hostname,port）,若是链接出错，返回socket.error错误。
sk.connect_ex(address):同上，只不过会有返回值，链接成功时返回 0 ，链接失败时候返回编码，例如：10061 sk.close():关闭套接字
sk.recv(bufsize[,flag]):接受套接字的数据。数据以字符串形式返回，bufsize指定最多能够接收的数量。flag提供有关消息的其余信息，一般能够忽略。
sk.recvfrom(bufsize[.flag]):与recv()相似，但返回值是（data,address）。其中data是包含接收数据的字符串，address是发送数据的套接字地址。
sk.send(string[,flag]):将string中的数据发送到链接的套接字。返回值是要发送的字节数量，该数量可能小于string的字节大小。
sk.sendall(string[,flag]):将string中的数据发送到链接的套接字，但在返回以前会尝试发送全部数据。成功返回None，失败则抛出异常。
sk.sendto(string[,flag],address):将数据发送到套接字，address是形式为（ipaddr，port）的元组，指定远程地址。返回值是发送的字节数。该函数主要用于UDP协议。
sk.settimeout(timeout):设置套接字操做的超时期，timeout是一个浮点数，单位是秒。值为None表示没有超时期。通常，超时期应该在刚建立套接字时设置，由于它们可能用于链接的操做（如 client 链接最多等待5s ）
sk.getpeername():返回链接套接字的远程地址。返回值一般是元组（ipaddr,port）。
sk.getsockname():返回套接字本身的地址。一般是一个元组(ipaddr,port)
sk.fileno():套接字的文件描述符

使用

基于TCP协议的socket

server

 1 import socket
 2 
 3 sk = socket.socket()
 4 sk.bind(('127.0.0.1', 8080))
 5 sk.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)  # 设置ip和端口重用
 6 sk.listen()
 7 conn, addr = sk.accept()
 8 request_msg = conn.recv(1024)
 9 print(request_msg.decode('utf8'))
10 sk.close()

View Code

client

1 import socket
2 
3 sk = socket.socket()
4 sk.connect(('127.0.0.1', 8080))
5 sk.send('hello'.encode('utf8'))
6 sk.close()

View Code

基于UDP协议的socket

server

1 import socket
2 
3 udp_sk = socket.socket(type=socket.SOCK_DGRAM)
4 udp_sk.bind(('127.0.0.1', 8081))
5 msg, addr = udp_sk.recvfrom(1024)
6 print(msg.decode('utf8'))
7 udp_sk.sendto(b'hello', addr)
8 udp_sk.close()

View Code

client

1 import socket
2 ip_port=('127.0.0.1',9000)
3 udp_sk=socket.socket(type=socket.SOCK_DGRAM)
4 udp_sk.sendto(b'hello',ip_port)
5 back_msg,addr=udp_sk.recvfrom(1024)
6 print(back_msg.decode('utf-8'),addr)

View Code

黏包

在tcp协议下同时执行多条命令以后,获得的结果极可能只有一部分,在执行其余命令的时候又接收到以前执行的另一部分结果,这种显现就是黏包算法

黏包的两种状况

状况一发送方的缓存机制

发送端须要等缓冲区满才发送出去，形成粘包（发送数据时间间隔很短，数据了很小，会合到一块儿，产生粘包）json

 1 from socket import *
 2 ip_port=('127.0.0.1',8080)
 3 
 4 tcp_socket_server=socket(AF_INET,SOCK_STREAM)
 5 tcp_socket_server.bind(ip_port)
 6 tcp_socket_server.listen(5)
 7 
 8 conn,addr=tcp_socket_server.accept()
 9 
10 data1=conn.recv(10)
11 data2=conn.recv(10)
12 
13 print('----->',data1.decode('utf-8'))
14 print('----->',data2.decode('utf-8'))
15 
16 conn.close()

server

1 import socket
2 BUFSIZE=1024
3 ip_port=('127.0.0.1',8080)
4 
5 s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
6 res=s.connect_ex(ip_port)
7 
8 s.send('hello'.encode('utf-8'))
9 s.send('egg'.encode('utf-8'))

client

状况二接收方的缓存机制

接收方不及时接收缓冲区的包，形成多个包接收（客户端发送了一段数据，服务端只收了一小部分，服务端下次再收的时候仍是从缓冲区拿上次遗留的数据，产生粘包）缓存

 1 from socket import *
 2 ip_port=('127.0.0.1',8080)
 3 
 4 tcp_socket_server=socket(AF_INET,SOCK_STREAM)
 5 tcp_socket_server.bind(ip_port)
 6 tcp_socket_server.listen(5)
 7 
 8 conn,addr=tcp_socket_server.accept()
 9 
10 data1=conn.recv(2) #一次没有收完整
11 data2=conn.recv(10)#下次收的时候,会先取旧的数据,而后取新的
12 
13 print('----->',data1.decode('utf-8'))
14 print('----->',data2.decode('utf-8'))
15 
16 conn.close()

server

1 import socket
2 BUFSIZE=1024
3 ip_port=('127.0.0.1',8080)
4 
5 s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
6 res=s.connect_ex(ip_port)
7 
8 s.send('hello egg'.encode('utf-8'))

client

黏包成因

tcp协议的拆包机制
当发送端缓冲区的长度大于网卡的MTU时，tcp会将此次发送的数据拆成几个数据包发送出去。 MTU是Maximum Transmission Unit的缩写。意思是网络上传送的最大数据包。MTU的单位是字节。大部分网络设备的MTU都是1500。若是本机的MTU比网关的MTU大，大的数据包就会被拆开来传送，这样会产生不少数据包碎片，增长丢包率，下降网络速度。
面向流和优化算法
TCP（transport control protocol，传输控制协议）是面向链接的，面向流的，提供高可靠性服务。收发两端（客户端和服务器端）都要有一一成对的socket，所以，发送端为了将多个发往接收端的包，更有效的发到对方，使用了优化方法（Nagle算法），将屡次间隔较小且数据量小的数据，合并成一个大的数据块，而后进行封包。这样，接收端，就难于分辨出来了，必须提供科学的拆包机制。即面向流的通讯是无消息保护边界的。对于空消息：tcp是基于数据流的，因而收发的消息不能为空，这就须要在客户端和服务端都添加空消息的处理机制，防止程序卡住，而udp是基于数据报的，即使是你输入的是空内容（直接回车），也能够被发送，udp协议会帮你封装上消息头发送过去。可靠黏包的tcp协议：tcp的协议数据不会丢，没有收完包，下次接收，会继续上次继续接收，己端老是在收到ack时才会清除缓冲区内容。数据是可靠的，可是会粘包。

- udp不会发生黏包
  UDP（user datagram protocol，用户数据报协议）是无链接的，面向消息的，提供高效率服务。不会使用块的合并优化算法，, 因为UDP支持的是一对多的模式，因此接收端的skbuff(套接字缓冲区）采用了链式结构来记录每个到达的UDP包，在每一个UDP包中就有了消息头（消息来源地址，端口等信息），这样，对于接收端来讲，就容易进行区分处理了。即面向消息的通讯是有消息保护边界的。对于空消息：tcp是基于数据流的，因而收发的消息不能为空，这就须要在客户端和服务端都添加空消息的处理机制，防止程序卡住，而udp是基于数据报的，即使是你输入的是空内容（直接回车），也能够被发送，udp协议会帮你封装上消息头发送过去。不可靠不黏包的udp协议：udp的recvfrom是阻塞的，一个recvfrom(x)必须对惟一一个sendinto(y),收完了x个字节的数据就算完成,如果y;x数据就丢失，这意味着udp根本不会粘包，可是会丢数据，不可靠。
- 补充
  用UDP协议发送时，用sendto函数最大能发送数据的长度为：65535- IP头(20) – UDP头(8)＝65507字节。用sendto函数发送数据时，若是发送数据长度大于该值，则函数会返回错误。（丢弃这个包，不进行发送）用TCP协议发送时，因为TCP是数据流协议，所以不存在包大小的限制（暂不考虑缓冲区的大小），这是指在用send函数时，数据长度参数不受限制。而实际上，所指定的这段数据并不必定会一次性发送出去，若是这段数据比较长，会被分段发送，若是比较短，可能会等待和下一次数据一块儿发送。
- 总结
  
  黏包现象只发生在tcp协议中：服务器
  
  1.从表面上看，黏包问题主要是由于发送方和接收方的缓存机制、tcp协议面向流通讯的特色。网络
  
  2.实际上，主要仍是由于接收方不知道消息之间的界限，不知道一次性提取多少字节的数据所形成的dom

黏包的解决方案

解决方案一

让接收端在接收数据以前明确要接收数据的长度,并返回确认信息给发送端,发送端收到确认信息后开始发送socket

 1 from socket import *
 2 ip_port=('127.0.0.1',8080)
 3 
 4 tcp_socket_server=socket(AF_INET,SOCK_STREAM)
 5 tcp_socket_server.bind(ip_port)
 6 tcp_socket_server.listen()
 7 
 8 conn,addr=tcp_socket_server.accept()
 9 len = int(conn.recv(1024).decode('utf8'))
10 print(len)
11 conn.send(b'ready')
12 request_msg = conn.recv(len)
13 print(request_msg)
14 conn.close()
15 
16 #result:
17 # 36
18 # b'abcdefghijklmnopqrstuvwxyz0123456789'

server

 1 import socket
 2 
 3 ip_port = ('127.0.0.1', 8080)
 4 s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 5 conn = s.connect(ip_port)
 6 msg = b'abcdefghijklmnopqrstuvwxyz0123456789'  # 将要发送的数据
 7 msg_len = len(msg)
 8 s.send(str(msg_len).encode('utf-8'))  # 发送数据长度
 9 resp_msg = s.recv(5).decode('utf-8')
10 if resp_msg == 'ready':
11     s.send(msg)  # 发送数据

client

解决方案二(进阶)

能够借助struct模块,这个模块能够将各类类型数据(例如int)转换成固定长度的字节.也就是说接收端能够利用这个模块接收固定长度字节来获取到要接收内容的长度,这样就能够省去方案一中确认的一步tcp

struct模块的使用

1 import struct
2 
3 pack_len = struct.pack('i', 1234)
4 print(pack_len)  # b'\xd2\x04\x00\x00'
5 print(struct.unpack('i', pack_len))  # (1234,)

View Code

 1 from socket import *
 2 import struct
 3 ip_port=('127.0.0.1',8080)
 4 
 5 tcp_socket_server=socket(AF_INET,SOCK_STREAM)
 6 tcp_socket_server.bind(ip_port)
 7 tcp_socket_server.listen()
 8 
 9 conn,addr=tcp_socket_server.accept()
10 len = struct.unpack('i',conn.recv(4))[0]
11 print(len)
12 request_msg = conn.recv(len)
13 print(request_msg)
14 conn.close()
15 
16 #result:
17 # 36
18 # b'abcdefghijklmnopqrstuvwxyz0123456789'

server

 1 import socket,struct
 2 
 3 ip_port = ('127.0.0.1', 8080)
 4 s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 5 conn = s.connect(ip_port)
 6 msg = b'abcdefghijklmnopqrstuvwxyz0123456789'  # 将要发送的数据
 7 msg_len = len(msg)
 8 pack_len = struct.pack('i',msg_len)
 9 s.send(pack_len)  # 发送pack后的数据长度
10 s.send(msg)  # 发送数据

client

解决方案三(自定义报头)

 1 from socket import *
 2 import struct, json
 3 
 4 ip_port = ('127.0.0.1', 8080)
 5 
 6 tcp_socket_server = socket(AF_INET, SOCK_STREAM)
 7 tcp_socket_server.bind(ip_port)
 8 tcp_socket_server.listen()
 9 
10 conn, addr = tcp_socket_server.accept()
11 len = struct.unpack('i', conn.recv(4))[0]  # 接收header长度
12 print(len)
13 request_header = conn.recv(len)  # 接收json格式header转bytes后的数据
14 request_header = eval(request_header.decode('utf-8'))
15 print(request_header)
16 msg = conn.recv(request_header['len'])#取出header中内容长度来接收数据
17 print(msg.decode('utf-8'))
18 conn.close()
19 tcp_socket_server.close()
20 
21 # result:
22 # 148
23 # {'type': '字符串', 'msg': '发送的是26个小写字母和0到9的10个数字', 'len': 36}
24 # abcdefghijklmnopqrstuvwxyz0123456789'

server

 1 import socket, struct, json
 2 
 3 ip_port = ('127.0.0.1', 8080)
 4 s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 5 conn = s.connect(ip_port)
 6 header = {
 7     'type': '字符串',
 8     'msg': '发送的是26个小写字母和0到9的10个数字',
 9     'len': ''
10 }
11 
12 msg = b'abcdefghijklmnopqrstuvwxyz0123456789'  # 将要发送的数据
13 header['len'] = len(msg)
14 header_json = json.dumps(header).encode('utf-8')  # header转json并转bytes
15 header_json_len = len(header_json)  # json格式的header转bytes后长度
16 pack_header_len = struct.pack('i', header_json_len)  # pack长度
17 s.send(pack_header_len)  # 发送header头转json的长度
18 s.send(header_json)  # 发送json格式header转bytes后数据
19 s.send(msg)  # 发送数据
20 s.close()

client

验证客户端连接的合法性

 1 import socket
 2 import hmac
 3 import os
 4 
 5 
 6 def check_auth(conn):
 7     '''
 8     认证客户端连接
 9     :param conn: 链接
10     :return: 是否验证成功
11     '''
12     salt = 'zze'
13     pwd = os.urandom(32)  # 随机生成一个bytes形式的32位十六进制数
14     conn.sendall(pwd)  # 发送给接收端
15     my_pwd = hmac.new(salt.encode('utf8'), pwd).digest()  # 加盐生成验证标识
16     return_pwd = conn.recv(len(my_pwd))  # 返回的标识
17     return hmac.compare_digest(my_pwd, return_pwd)
18 
19 
20 sk = socket.socket()
21 sk.bind(('127.0.0.1', 8080))
22 sk.listen()
23 conn, addr = sk.accept()
24 print(check_auth(conn))  # True

server

1 import socket
2 import hmac
3 
4 sk = socket.socket()
5 sk.connect(('127.0.0.1', 8080))
6 salt = 'zze'  # 和server相同的盐
7 request_pwd = sk.recv(32)  # 收到bytes形式32位16进制数
8 my_pwd = hmac.new(salt.encode('utf8'), request_pwd).digest()  # 加盐生成验证标识
9 sk.send(my_pwd)

client

socketserver

使用

server

建立一个类继承socketserver.BaseRequestHandler,实现handle方法ide

 1 import socketserver
 2 
 3 
 4 class MyServer(socketserver.BaseRequestHandler):
 5     def handle(self):
 6         self.data = self.request.recv(1024).strip()
 7         print("{} wrote:".format(self.client_address[0]))
 8         print(self.data)
 9         self.request.sendall(self.data.upper())
10 
11 
12 if __name__ == "__main__":
13     HOST, PORT = "127.0.0.1", 9999
14 
15     # 设置allow_reuse_address容许服务器重用地址
16     socketserver.TCPServer.allow_reuse_address = True
17     # 建立一个server, 将服务地址绑定到127.0.0.1:9999
18     server = socketserver.TCPServer((HOST, PORT), MyServer)
19     # 让server永远运行下去，除非强制中止程序
20     server.serve_forever()

View Code

client

 1 import socket
 2 
 3 HOST, PORT = "127.0.0.1", 9999
 4 data = "hello"
 5 
 6 # 建立一个socket连接，SOCK_STREAM表明使用TCP协议
 7 with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
 8     sock.connect((HOST, PORT))          # 连接到客户端
 9     sock.sendall(bytes(data + "\n", "utf-8")) # 向服务端发送数据
10     received = str(sock.recv(1024), "utf-8")# 从服务端接收数据
11 
12 print("Sent:     {}".format(data))
13 print("Received: {}".format(received))

View Code

python基础(15)-socket网络编程&socketserver

socket

参数及方法说明

初始化参数

方法

使用

基于TCP协议的socket

server

client

基于UDP协议的socket

server

client

黏包

黏包的两种状况

状况一 发送方的缓存机制

状况二 接收方的缓存机制

黏包成因

tcp协议的拆包机制

面向流和优化算法

udp不会发生黏包

补充

总结

黏包的解决方案

解决方案一

解决方案二(进阶)

struct模块的使用

解决方案三(自定义报头)

验证客户端连接的合法性

socketserver

使用

server

client

状况一发送方的缓存机制

状况二接收方的缓存机制