socket

Posted 2022-03-24 zhangdajin

socket是什么

Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。

所以，我们无需深入理解tcp/udp协议，socket已经为我们封装好了，我们只需要遵循socket的规定去编程，写出的程序自然就是遵循tcp/udp标准的。

套接字发展史及分类

套接字起源于 20 世纪 70 年代加利福尼亚大学伯克利分校版本的 Unix,即人们所说的 BSD Unix。 因此,有时人们也把套接字称为“伯克利套接字”或“BSD 套接字”。一开始,套接字被设计用在同 一台主机上多个应用程序之间的通讯。这也被称进程间通讯,或 IPC。套接字有两种（或者称为有两个种族）,分别是基于文件型的和基于网络型的。 

基于文件类型的套接字家族

套接字家族的名字：AF_UNIX

unix一切皆文件，基于文件的套接字调用的就是底层的文件系统来取数据，两个套接字进程运行在同一机器，可以通过访问同一个文件系统间接完成通信

基于网络类型的套接字家族

套接字家族的名字：AF_INET

套接字工作流程

一个生活中的场景。你要打电话给一个朋友，先拨号，朋友听到电话铃声后提起电话，这时你和你的朋友就建立起了连接，就可以讲话了。等交流结束，挂断电话结束此次交谈。 生活中的场景就解释了这工作原理。

 

先从服务器端说起。服务器端先初始化Socket，然后与端口绑定(bind)，对端口进行监听(listen)，调用accept阻塞，等待客户端连接。在这时如果有个客户端初始化一个Socket，然后连接服务器(connect)，如果连接成功，这时客户端与服务器端的连接就建立了。客户端发送数据请求，服务器端接收请求并处理请求，然后把回应数据发送给客户端，客户端读取数据，最后关闭连接，一次交互结束

服务端套接字函数
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()           关闭套接字

socket通信流程案例

tcp服务端

import socket
ip_port=(‘127.0.0.1‘,9000)  #电话卡
BUFSIZE=1024                #收发消息的尺寸
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #买手机
s.bind(ip_port) #手机插卡
s.listen(5)     #手机待机
conn,addr=s.accept()            #手机接电话
# print(conn)
# print(addr)
print(‘接到来自%s的电话‘ %addr[0])
msg=conn.recv(BUFSIZE)             #听消息,听话
print(msg,type(msg))
conn.send(msg.upper())          #发消息,说话
conn.close()                    #挂电话
s.close()                       #手机关机

tcp客户端

import socket
ip_port=(‘127.0.0.1‘,9000)
BUFSIZE=1024
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.connect_ex(ip_port)           #拨电话
s.send(‘linhaifeng nb‘.encode(‘utf-8‘))         #发消息,说话(只能发送字节类型)
feedback=s.recv(BUFSIZE)                           #收消息,听话
print(feedback.decode(‘utf-8‘))
s.close()                                       #挂电话

加上链接循环与通信循环
服务端改进版

import socket
ip_port=(‘127.0.0.1‘,8081)#电话卡
BUFSIZE=1024
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #买手机
s.bind(ip_port) #手机插卡
s.listen(5)     #手机待机


while True:                         #新增接收链接循环,可以不停的接电话
    conn,addr=s.accept()            #手机接电话
    # print(conn)
    # print(addr)
    print(‘接到来自%s的电话‘ %addr[0])
    while True:                         #新增通信循环,可以不断的通信,收发消息
        msg=conn.recv(BUFSIZE)             #听消息,听话

        # if len(msg) == 0:break        #如果不加,那么正在链接的客户端突然断开,recv便不再阻塞,死循环发生

        print(msg,type(msg))

        conn.send(msg.upper())          #发消息,说话

    conn.close()                    #挂电话

s.close()                       #手机关机

客户端改进版

import socket
ip_port=(‘127.0.0.1‘,8081)
BUFSIZE=1024
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

s.connect_ex(ip_port)           #拨电话

while True:                             #新增通信循环,客户端可以不断发收消息
    msg=input(‘>>: ‘).strip()
    if len(msg) == 0:continue
    s.send(msg.encode(‘utf-8‘))         #发消息,说话(只能发送字节类型)

    feedback=s.recv(BUFSIZE)                           #收消息,听话
    print(feedback.decode(‘utf-8‘))

s.close()                                       #挂电话

粘包现象

什么是粘包？

粘包指的是数据与数据之间没有明确的分界线，导致不能正确读取数据！

要理解粘包问题，需要先了解TCP协议传输数据时的具体流程，TCP协议也称之为流式协议(UDP称为数据报协议)

应用程序无法直接操作硬件，应用程序想要发送数据则必须将数据交给操作系统，而操作系统需要需要同时为所有应用程序提供数据传输服务，也就意味着，操作系统不可能立马就能将应用程序的数据发送出去，就需要为应用程序提供一个缓冲区，用于临时存放数据，具体流程如下：

发送方：

当应用程序调用send函数时，应用程序会将数据从应用程序拷贝到操作系统缓存，再由操作系统从缓冲区读取数据并发送出去

接收方：

对方计算机收到数据也是操作系统先收到，至于应用程序何时处理这些数据，操作系统并不清楚，所以同样需要将数据先存储到操作系统的缓冲区中，当应用程序调用recv时，实际上是从操作系统缓冲区中将数据拷贝到应用程序的过程

上述过程对于TCP与UDP都是相同的不同之处在于：

UDP：

UDP在收发数据时是基于数据包的，即一个包一个包的发送，包与包之间有着明确的分界，到达对方操作系统缓冲区后也是一个一个独立的数据包，接收方从操作系统缓冲区中将数据包拷贝到应用程序

这种方式存在的问题：

1.发送方发送的数据长度每个操作系统会有不同的限制，数据超过限制则无法发送

2.接收方接收数据时如果应用程序的提供的缓存容量小于数据包的长度将造成数据丢失，而缓冲区大小不可能无限大

TCP：

当我们需要传输较大的数据，或需要保证数据完整性时，最简单的方式就是使用TCP协议了

与UDP不同的是，TCP增加了一套校验规则来保证数据的完整性，会将超过TCP包最大长度的数据拆分为多个TCP包 并在传输数据时为每一个TCP数据包指定一个顺序号，接收方在收到TCP数据包后按照顺序将数据包进行重组，重组后的数据全都是二进制数据，且每次收到的二进制数据之间没有明显的分界

基于这种工作机制TCP在三种情况下会发送粘包问题

1.当单个数据包较小时接收方可能一次性读取了多个包的数据

2.当整体数据较大时接收方可能一次仅读取了一个包的一部分内容

3.另外TCP协议为了提高效率，增加了一种优化机制，会将数据较小且发送间隔较短的数据合并发送，该机制也会导致发送方将两个数据包粘在一起发送

粘包的解决方案

1.使用struct模块

import json,struct
#假设通过客户端上传1T:1073741824000的文件a.txt

#为避免粘包,必须自定制报头
header=‘file_size‘:1073741824000,‘file_name‘:‘/a/b/c/d/e/a.txt‘,‘md5‘:‘8f6fbf8347faa4924a76856701edb0f3‘ #1T数据,文件路径和md5值

#为了该报头能传送,需要序列化并且转为bytes
head_bytes=bytes(json.dumps(header),encoding=‘utf-8‘) #序列化并转成bytes,用于传输

#为了让客户端知道报头的长度,用struck将报头长度这个数字转成固定长度:4个字节
head_len_bytes=struct.pack(‘i‘,len(head_bytes)) #这4个字节里只包含了一个数字,该数字是报头的长度

#客户端开始发送
conn.send(head_len_bytes) #先发报头的长度,4个bytes
conn.send(head_bytes) #再发报头的字节格式
conn.sendall(文件内容) #然后发真实内容的字节格式

#服务端开始接收
head_len_bytes=s.recv(4) #先收报头4个bytes,得到报头长度的字节格式
x=struct.unpack(‘i‘,head_len_bytes)[0] #提取报头的长度

head_bytes=s.recv(x) #按照报头长度x,收取报头的bytes格式
header=json.loads(json.dumps(header)) #提取报头

#最后根据报头的内容提取真实的数据,比如
real_data_len=s.recv(header[‘file_size‘])
s.recv(real_data_len)

2.自定义报头

上述方案已经完美解决了粘包问题，但是扩展性不高，例如我们要实现文件上传下载，不光要传输文件数据，还需要传输文件名字，md5值等等，如何能实现呢？

具体思路：

发送端：

1.先将所有的额外信息打包到一个头中

2.然后先发送头部数据

3.最后发送真实数据

接收端：

1.接收固定长度的头部长度数据

2.根据长度数据获取头部数据

3.根据头部数据获取真实数据
服务端

import socket
import subprocess
import struct
import json
"""
服务端:
要有固定的ip和port
24小时不间断提供服务
"""
server = socket.socket()
server.bind((‘127.0.0.1‘,8083))
server.listen(5)  # 半连接池
?
while True:
    conn,addr = server.accept()  # 阻塞
    while True:
        try:
            data = conn.recv(1024).decode(‘utf-8‘)  # 阻塞
            if len(data) == 0:break  # 针对linux和mac系统 客户端异常断开反复收空的情况
            obj = subprocess.Popen(data,shell=True,
                    stdout=subprocess.PIPE,stderr=subprocess.PIPE)
            stdout = obj.stdout.read()
            stderr = obj.stderr.read()
            print(len(stdout+stderr))
?
            header_dic = 
                ‘filename‘:‘cls.av‘,
                ‘len‘:len(stdout+stderr)
            
            header_bytes = json.dumps(header_dic).encode(‘utf-8‘)
            # 制作报头
            header = struct.pack(‘i‘, len(header_bytes))  # 将需要发送给客户端的数据打包成固定4个字节
            conn.send(header)
?
            conn.send(header_bytes)
?
            conn.send(stdout+stderr)
?
        except ConnectionResetError:
            break
    conn.close()
?
server.close()

客户端 

import socket
import struct
import json
?
?
client = socket.socket()
client.connect((‘127.0.0.1‘,8083))
?
?
while True:
    msg = input(‘>>>:‘).encode(‘utf-8‘)
    if len(msg) == 0:continue
    client.send(msg)
    header = client.recv(4)
    # 对这个头进行解包，获取真实数据的长度
?
    head_len = struct.unpack(‘i‘,header)[0]
    print(head_len)
    head_dic = json.loads(client.recv(head_len).decode(‘utf-8‘))
    print(head_dic)
    # 对需要接受的数据 进行循环接收
    total_size = head_dic[‘len‘]
    recv_size = 0
    res = b‘‘
    while recv_size < total_size:
        data = client.recv(1024)
        res += data
        recv_size += len(data)
    print(res.decode(‘gbk‘))
?
?

?
?
?
?
?
?
?
?
?

 

?
?
?
?
?