本站文章除注明转载/出处外,均为本站原创或翻译,转载前请务必署名原文链接~~~

Python基础(30)之socket网络编程

微信搜索 zze_coding 或扫描 👉 二维码关注我的微信公众号获取更多资源推送:


参数及方法说明

初始化参数

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 端

import socket

sk = socket.socket()
sk.bind(('127.0.0.1', 8080))
sk.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)  # 设置ip和端口重用
sk.listen()
conn, addr = sk.accept()
request_msg = conn.recv(1024)
print(request_msg.decode('utf8'))
sk.close()

client 端

import socket

sk = socket.socket()
sk.connect(('127.0.0.1', 8080))
sk.send('hello'.encode('utf8'))
sk.close()

基于 UDP 协议的 socket 示例

server 端

import socket

udp_sk = socket.socket(type=socket.SOCK_DGRAM)
udp_sk.bind(('127.0.0.1', 8081))
msg, addr = udp_sk.recvfrom(1024)
print(msg.decode('utf8'))
udp_sk.sendto(b'hello', addr)
udp_sk.close()

client 端

import socket

ip_port=('127.0.0.1',9000)
udp_sk=socket.socket(type=socket.SOCK_DGRAM)
udp_sk.sendto(b'hello',ip_port)
back_msg,addr=udp_sk.recvfrom(1024)
print(back_msg.decode('utf-8'),addr)

黏包

在 tcp 协议下同时执行多条命令之后,得到的结果很可能只有一部分,在执行其他命令的时候又接收到之前执行的另外一部分结果,这种显现就是黏包。

黏包的两种情况

情况一 发送方的缓存机制

发送端需要等缓冲区满才发送出去,造成粘包(发送数据时间间隔很短,数据了很小,会合到一起,产生粘包)。

# server 端
from socket import *
ip_port=('127.0.0.1',8080)

tcp_socket_server=socket(AF_INET,SOCK_STREAM)
tcp_socket_server.bind(ip_port)
tcp_socket_server.listen(5)

conn,addr=tcp_socket_server.accept()

data1=conn.recv(10)
data2=conn.recv(10)

print('----->',data1.decode('utf-8'))
print('----->',data2.decode('utf-8'))

conn.close()
# client 端
import socket
BUFSIZE=1024
ip_port=('127.0.0.1',8080)

s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
res=s.connect_ex(ip_port)

s.send('hello'.encode('utf-8'))
s.send('egg'.encode('utf-8'))

情况二 接收方的缓存机制

接收方不及时接收缓冲区的包,造成多个包接收(客户端发送了一段数据,服务端只收了一小部分,服务端下次再收的时候还是从缓冲区拿上次遗留的数据,产生粘包)。

# server 端
from socket import *
ip_port=('127.0.0.1',8080)

tcp_socket_server=socket(AF_INET,SOCK_STREAM)
tcp_socket_server.bind(ip_port)
tcp_socket_server.listen(5)

conn,addr=tcp_socket_server.accept()

data1=conn.recv(2) #一次没有收完整
data2=conn.recv(10)#下次收的时候,会先取旧的数据,然后取新的

print('----->',data1.decode('utf-8'))
print('----->',data2.decode('utf-8'))

conn.close()
# client 端
import socket

BUFSIZE=1024
ip_port=('127.0.0.1',8080)

s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
res=s.connect_ex(ip_port)

s.send('hello egg'.encode('utf-8'))

黏包成因

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 协议中:

  • 从表面上看,黏包问题主要是因为发送方和接收方的缓存机制、tcp 协议面向流通信的特点。
  • 实际上,主要还是因为接收方不知道消息之间的界限,不知道一次性提取多少字节的数据所造成的。

黏包的解决方案

方案一

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

# server 端
from socket import *
ip_port=('127.0.0.1',8080)

tcp_socket_server=socket(AF_INET,SOCK_STREAM)
tcp_socket_server.bind(ip_port)
tcp_socket_server.listen()

conn,addr=tcp_socket_server.accept()
len = int(conn.recv(1024).decode('utf8'))
print(len)
conn.send(b'ready')
request_msg = conn.recv(len)
print(request_msg)
conn.close()

#result:
# 36
# b'abcdefghijklmnopqrstuvwxyz0123456789'
# client 端
import socket

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

方案二

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

# server 端
from socket import *
import struct
ip_port=('127.0.0.1',8080)

tcp_socket_server=socket(AF_INET,SOCK_STREAM)
tcp_socket_server.bind(ip_port)
tcp_socket_server.listen()

conn,addr=tcp_socket_server.accept()
len = struct.unpack('i',conn.recv(4))[0]
print(len)
request_msg = conn.recv(len)
print(request_msg)
conn.close()

#result:
# 36
# b'abcdefghijklmnopqrstuvwxyz0123456789'
# client 端
import socket,struct

ip_port = ('127.0.0.1', 8080)
s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
conn = s.connect(ip_port)
msg = b'abcdefghijklmnopqrstuvwxyz0123456789'  # 将要发送的数据
msg_len = len(msg)
pack_len = struct.pack('i',msg_len)
s.send(pack_len)  # 发送pack后的数据长度
s.send(msg)  # 发送数据

方案三

# server 端
from socket import *
import struct, json

ip_port = ('127.0.0.1', 8080)

tcp_socket_server = socket(AF_INET, SOCK_STREAM)
tcp_socket_server.bind(ip_port)
tcp_socket_server.listen()

conn, addr = tcp_socket_server.accept()
len = struct.unpack('i', conn.recv(4))[0]  # 接收header长度
print(len)
request_header = conn.recv(len)  # 接收json格式header转bytes后的数据
request_header = eval(request_header.decode('utf-8'))
print(request_header)
msg = conn.recv(request_header['len'])#取出header中内容长度来接收数据
print(msg.decode('utf-8'))
conn.close()
tcp_socket_server.close()

# result:
# 148
# {'type': '字符串', 'msg': '发送的是26个小写字母和0到9的10个数字', 'len': 36}
# abcdefghijklmnopqrstuvwxyz0123456789'
# client 端
import socket, struct, json

ip_port = ('127.0.0.1', 8080)
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
conn = s.connect(ip_port)
header = {
    'type': '字符串',
    'msg': '发送的是26个小写字母和0到9的10个数字',
    'len': ''
}

msg = b'abcdefghijklmnopqrstuvwxyz0123456789'  # 将要发送的数据
header['len'] = len(msg)
header_json = json.dumps(header).encode('utf-8')  # header转json并转bytes
header_json_len = len(header_json)  # json格式的header转bytes后长度
pack_header_len = struct.pack('i', header_json_len)  # pack长度
s.send(pack_header_len)  # 发送header头转json的长度
s.send(header_json)  # 发送json格式header转bytes后数据
s.send(msg)  # 发送数据
s.close()

客户端连接校验

# server 端
import socket
import hmac
import os


def check_auth(conn):
    '''
    认证客户端链接
    :param conn: 连接
    :return: 是否验证成功
    '''
    salt = 'zze'
    pwd = os.urandom(32)  # 随机生成一个bytes形式的32位十六进制数
    conn.sendall(pwd)  # 发送给接收端
    my_pwd = hmac.new(salt.encode('utf8'), pwd).digest()  # 加盐生成验证标识
    return_pwd = conn.recv(len(my_pwd))  # 返回的标识
    return hmac.compare_digest(my_pwd, return_pwd)


sk = socket.socket()
sk.bind(('127.0.0.1', 8080))
sk.listen()
conn, addr = sk.accept()
print(check_auth(conn))  # True
# client
import socket
import hmac

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

SocketServer 使用

server 端

创建一个类继承 socketserverBaseRequestHandler,实现 handle 方法。

import socketserver


class MyServer(socketserver.BaseRequestHandler):
    def handle(self):
        self.data = self.request.recv(1024).strip()
        print("{} wrote:".format(self.client_address[0]))
        print(self.data)
        self.request.sendall(self.data.upper())


if __name__ == "__main__":
    HOST, PORT = "127.0.0.1", 9999

    # 设置allow_reuse_address允许服务器重用地址
    socketserver.TCPServer.allow_reuse_address = True
    # 创建一个server, 将服务地址绑定到127.0.0.1:9999
    server = socketserver.TCPServer((HOST, PORT), MyServer)
    # 让server永远运行下去,除非强制停止程序
    server.serve_forever()

client 端

import socket

HOST, PORT = "127.0.0.1", 9999
data = "hello"

# 创建一个socket链接,SOCK_STREAM代表使用TCP协议
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
    sock.connect((HOST, PORT))          # 链接到客户端
    sock.sendall(bytes(data + "\n", "utf-8")) # 向服务端发送数据
    received = str(sock.recv(1024), "utf-8")# 从服务端接收数据

print("Sent:     {}".format(data))
print("Received: {}".format(received))

如果这篇文章对您有帮助,可点击下方链接分享给你的朋友们😋,如果遇到问题欢迎评论、留言~~~😇

评论

公众号:zze_coding

Your browser is out-of-date!

Update your browser to view this website correctly. Update my browser now

×