Python基础之（Socket编程）

时间 2020-04-28

原文原文链接

1、什么是Socketpython

Socket又称为套接字，它是应用层与TCP/IP协议族通讯的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来讲，一组简单的接口就是所有，让Socket去组织数据，以符合指定的协议。因此，咱们无需深刻理解tcp/udp协议，socket已经为咱们封装好了，咱们只须要遵循socket的规定去编程，写出的程序天然就是遵循tcp/udp标准的。程序员

UNIX BSD发明了socket这种东西，socket屏蔽了各个协议的通讯细节，使得程序员无需关注协议自己，直接使用socket提供的接口来进行互联的不一样主机间的进程的通讯。这就比如操做系统给咱们提供了使用底层硬件功能的系统调用，经过系统调用咱们能够方便的使用磁盘、内存，而无需本身去进行磁盘读写，内存管理。socket其实也是同样的东西，就是提供了tcp/ip协议的抽象，对外提供了一套接口，经过这个接口就能够统1、方便的使用tcp/ip协议的功能了。从使用上面看，socket就是一个模块。咱们经过调用模块中已经实现的方法创建两个进程之间的链接和通讯。也有人将socket说成ip+port，由于ip是用来标识互联网中的一台主机的位置，而port是用来标识这台机器上的一个应用程序。因此咱们只要确立了ip和port就能找到一个应用程序，而且使用socket模块来与之通讯。算法

2、套接字发展及分类shell

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

基于文件类型的套接字家族设计模式

套接字家族的名字：AF_UNIX浏览器

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

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

套接字家族的名字：AF_INET网络

(还有AF_INET6被用于ipv6，还有一些其余的地址家族，不过，他们要么是只用于某个平台，要么就是已经被废弃，或者是不多被使用，或者是根本没有实现，全部地址家族中，AF_INET是使用最普遍的一个，python支持不少种地址家族，可是因为咱们只关心网络编程，因此大部分时候我么只使用AF_INET)

3、套接字的工做流程（基于TCP和 UDP两个协议）

3.一、TCP与UDP

TCP（Transmission Control Protocol）可靠的、面向链接的协议。传输效率低全双工通讯（发送缓存&接收缓存）、面向字节流。使用TCP的应用：Web浏览器；文件传输程序。

UDP（User Datagram Protocol）不可靠的、无链接的服务，传输效率高（发送前时延小）。一对1、一对多、多对1、多对多、面向报文(数据包)，尽最大努力服务，无拥塞控制。使用UDP的应用：域名系统 (DNS)；视频流；IP语音(VoIP)

3.二、TCP协议下的Socket

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

socket()模块函数用法：

import socket
socket.socket(socket_family,socket_type,protocal=0)
#socket_family 能够是 AF_UNIX 或 AF_INET。socket_type 能够是 SOCK_STREAM 或 SOCK_DGRAM。protocol 通常不填,默认值为 0。

#获取tcp/ip套接字
TcpSock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

#获取udp/ip套接字
UdpSock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

#也能够'from module import *'语句，TcpSock = socket(AF_INET, SOCK_STREAM)

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

3.2.一、TCP socket示例三连

简单一次发送接收版：

#最简单版

#server端
import socket
tcpserver = socket.socket(socket.AF_INET,socket.SOCK_STREAM)  #创建
tcpserver.bind(("127.0.0.1",10000))   #绑定
tcpserver.listen(5)  #监听
conn,addr = tcpserver.accept()  #阻塞等待链接
data = conn.recv(1024)   #接收
print(data.decode("utf-8"))
conn.send(data.upper())  #发送
conn.close()   #关闭链接
tcpserver.close()  #关闭

#client端
import socket
tcpclient = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
tcpclient.connect(("127.0.0.1",10000))  #链接
data=input(">:")
tcpclient.send(data.encode("utf-8"))  #发送
ret=tcpclient.recv(1024)   #接收
print(ret.decode("utf-8"))
tcpclient.close()

执行结果：

循环接收发送信息示例：

#循环接收发送信息版

#server端
import socket
tcpserver = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
tcpserver.bind(("127.0.0.1", 10000))
tcpserver.listen(5)
while True:
    conn,addr = tcpserver.accept()
    print(conn)
    while True:
        try:
            data = conn.recv(1024)
            print(data.decode("utf-8"))
            conn.send(data.upper())
        except Exception:
            break
    conn.close()
tcpserver.close()

#客户端
import socket
tcpclient = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
tcpclient.connect(("127.0.0.1",10000))
while 1:
    while 1:
        data = input('>>>').strip()
        tcpclient.send(data.encode('utf-8'))

        ret = tcpclient.recv(1024)

        print(ret.decode('utf-8'))

执行结果：

远程执行结果返回示例：

（ret.stdout.read()读出的就是GBK编码的，在接收端须要用GBK解码，且只能从管道里读一次结果）

#server端
import socket
import subprocess
tcpserver = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
tcpserver.bind(("127.0.0.1", 10000))
tcpserver.listen(5)
while True:
    conn,addr = tcpserver.accept()
    print(conn)
    while True:
        try:
            data = conn.recv(1024)
            ret=subprocess.Popen(data.decode('utf-8'),shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
            error = ret.stderr.read()
            if error:
                cmd_ret = error
            else:
                cmd_ret=ret.stdout.read()
            conn.send(cmd_ret)
        except Exception:
            break
    conn.close()
tcpserver.close()

#客户端
import socket
tcpclient = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
tcpclient.connect(("127.0.0.1",10000))
while 1:
    while 1:
        data = input('>>>').strip()
        tcpclient.send(data.encode('utf-8'))

        ret = tcpclient.recv(1024)

        print(ret.decode('gbk'))

执行结果：

3.三、UDP协议下的 Socket

UDP下的socket通信流程：先从服务器端提及。服务器端先初始化Socket，而后与端口绑定(bind)，recvform接收消息，这个消息有两项，消息内容和对方客户端的地址，而后回复消息时也要带着你收到的这个客户端的地址，发送回去，最后关闭链接，一次交互就结束了

3.3.一、Udp socket 示例二连

循环发送接收消息版：

#server端
import socket
ip_port=('127.0.0.1',10001)
udp_server=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
udp_server.bind(ip_port)
while True:
    msg,addr=udp_server.recvfrom(1024)
    print(msg,addr)
    udp_server.sendto(msg.upper(),addr)
udp_server.close()

#客户端
import socket
ip_port=('127.0.0.1',10001)
udp_client=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
while True:
    msg=input('>>: ').strip()
    udp_client.sendto(msg.encode('utf-8'),ip_port)
    msg,addr=udp_client.recvfrom(1024)
    print(msg.decode('utf-8'),addr)
udp_client.close()

发送接收时间示例：

#server端：
import socket,time
ip_port=('127.0.0.1',10001)
udp_server=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
udp_server.bind(ip_port)
while True:
    msg,addr=udp_server.recvfrom(1024)
    if not msg:
        ret = "%Y-%m-%d %X"
    else:
        ret=msg.decode("utf-8")
    cmd_ret = time.strftime(ret)
    udp_server.sendto(cmd_ret.encode("utf-8"),addr)
udp_server.close()

#客户端:
import socket
ip_port=('127.0.0.1',10001)
udp_client=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
while True:
    msg=input('>>: ').strip()
    udp_client.sendto(msg.encode('utf-8'),ip_port)

    msg,addr=udp_client.recvfrom(1024)
    print(msg.decode('utf-8'))

执行结果：

注意点：

udp是无连接的，先启动哪一端都不会报错，而tcp须要先启动server端
因为udp无链接，因此能够同时多个客户端去跟服务端通讯，而tcp同时只能有一个客户端与服务端链接，其余客户端只能等待中，直到链接中客户端下线

4、粘包

4.一、Socket 缓冲区

　　每一个 socket 被建立后，都会分配两个缓冲区，输入缓冲区和输出缓冲区。write()/send() 并不当即向网络中传输数据，而是先将数据写入缓冲区中，再由TCP协议将数据从缓冲区发送到目标机器。一旦将数据写入到缓冲区，函数就能够成功返回，无论它们有没有到达目标机器，也无论它们什么时候被发送到网络，这些都是TCP协议负责的事情。TCP协议独立于 write()/send() 函数，数据有可能刚被写入缓冲区就发送到网络，也可能在缓冲区中不断积压，屡次写入的数据被一次性发送到网络，这取决于当时的网络状况、当前线程是否空闲等诸多因素，不禁程序员控制。read()/recv() 函数也是如此，也从输入缓冲区中读取数据，而不是直接从网络中读取

4.二、粘包的缘由

TCP（transport control protocol，传输控制协议）是面向链接的，面向流的，提供高可靠性服务。收发两端（客户端和服务器端）都要有一一成对的socket，所以，发送端为了将多个发往接收端的包，更有效的发到对方，使用了优化方法（Nagle算法），将屡次间隔较小且数据量小的数据，合并成一个大的数据块，而后进行封包。这样，接收端，就难于分辨出来了，必须提供科学的拆包机制。即面向流的通讯是无消息保护边界的。

UDP（user datagram protocol，用户数据报协议）是无链接的，面向消息的，提供高效率服务。不会使用块的合并优化算法，, 因为UDP支持的是一对多的模式，因此接收端的skbuff(套接字缓冲区）采用了链式结构来记录每个到达的UDP包，在每一个UDP包中就有了消息头（消息来源地址，端口等信息），这样，对于接收端来讲，就容易进行区分处理了。即面向消息的通讯是有消息保护边界的。

udp的recvfrom是阻塞的，一个recvfrom(x)必须对惟一一个sendinto(y),收完了x个字节的数据就算完成,如果y>x数据就丢失，这意味着udp根本不会粘包，可是会丢数据，不可靠。tcp的协议数据不会丢，没有收完包，下次接收，会继续上次继续接收，己端老是在收到ack时才会清除缓冲区内容。数据是可靠的，可是会粘包。

因此所谓粘包问题主要仍是由于接收方不知道消息之间的界限，不知道一次性提取多少字节的数据所形成的。而且只有TCP有粘包现象，UDP永远不会粘包！

粘包的两种状况：

接收方没有及时接收缓冲区的包，形成多个包接收（客户端发送了一段数据，服务端只收了一小部分，服务端下次再收的时候仍是从缓冲区拿上次遗留的数据，产生粘包）
发送端须要等缓冲区满才发送出去，形成粘包（发送数据时间间隔很短，数据也很小，会合到一块儿，产生粘包）

4.三、解决粘包的方法

粘包问题的根源在于接收端不知道发送端将要传送的字节流的长度，因此解决粘包的方法就是如何让发送端在发送数据前先把本身将要发送的数据大小让接收端知晓，而后再来一个循环接收完全部数据

#服务端
import socket,subprocess
ip_port=('127.0.0.1',10001)
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.bind(ip_port)
s.listen(5)

while True:
    conn,addr=s.accept()
    while True:
        try:
            msg=conn.recv(1024)
            res=subprocess.Popen(msg.decode('utf-8'),shell=True,stdin=subprocess.PIPE,stderr=subprocess.PIPE,stdout=subprocess.PIPE)
            error=res.stderr.read()
            if error:
                ret=error
            else:
                ret=res.stdout.read()
            data_length=len(ret)
            print(data_length)
            conn.send(str(data_length).encode('utf-8')) #发送长度
            data=conn.recv(1024).decode('utf-8')    
            if data == 'ready':    #确认
                conn.sendall(ret)   #发送所有数据
        except Exception:
            break
    conn.close()
s.close()

#客户端
import socket
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.connect(('127.0.0.1',10001))
while True:
    msg=input('>>: ').strip()
    s.send(msg.encode('utf-8'))
    length=int(s.recv(1024).decode('utf-8'))   #接收长度
    print(length)
    s.send('ready'.encode('utf-8'))
    recv_size=0
    data = b""
    while recv_size < length:   #若是长度不够就一直接收，直到完成
        r_m = s.recv(1024)
        data+= r_m
        recv_size+=len(r_m)
    print(recv_size)
    print(data.decode('gbk'))

另外一种解决粘包的方法便是：将总数据大小封装成固定大小后和数据分别发，接收方先接收封装的总数据大小，而后再接收数据（效率更高）

#server 端
import socket,subprocess,struct
ip_port=('127.0.0.1',10001)
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.bind(ip_port)
s.listen(5)

while True:
    conn,addr=s.accept()
    while True:
        try:
            msg=conn.recv(1024)
            res=subprocess.Popen(msg.decode('utf-8'),shell=True,stdin=subprocess.PIPE,stderr=subprocess.PIPE,stdout=subprocess.PIPE)
            error=res.stderr.read()
            if error:
                ret=error
            else:
                ret=res.stdout.read()
            length=len(ret)
            conn.send(struct.pack("i",length)) #发送封装好的固定长度
     
            conn.sendall(ret)   #发送所有数据
        except Exception:
            break
    conn.close()
s.close()

#client端
import socket,struct
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.connect(('127.0.0.1',10001))
while True:
    msg=input('>>: ').strip()
    s.send(msg.encode('utf-8'))
    l=s.recv(4)
    print(struct.unpack("i",l))
    length = struct.unpack("i",l)[0] #解析封装好的固定长度

    print(length)
    recv_size=0
    data = b""
    while recv_size < length:   #若是长度不够就一直接收，直到完成
        r_m = s.recv(1024)
        data+= r_m
        recv_size+=len(r_m)
    print(recv_size)
    print(data.decode('gbk'))

补充：struct模块说明：

用处：

按照指定格式将Python数据转换为字符串,该字符串为字节流,如网络传输时,不能传输int,此时先将int转化为字节流,而后再发送;
按照指定格式将字节流转换为Python指定的数据类型;
处理二进制数据,若是用struct来处理文件的话,须要用’wb’,’rb’以二进制(字节流)写,读的方式来处理文件;
处理c语言中的结构体;

struct模块中的函数

函数	return	explain
pack(fmt,v1,v2…)	string	按照给定的格式(fmt),把数据转换成字符串(字节流),并将该字符串返回.
pack_into(fmt,buffer,offset,v1,v2…)	None	按照给定的格式(fmt),将数据转换成字符串(字节流),并将字节流写入以offset开始的buffer中.(buffer为可写的缓冲区,可用array模块)
unpack(fmt,v1,v2…..)	tuple	按照给定的格式(fmt)解析字节流,并返回解析结果
pack_from(fmt,buffer,offset)	tuple	按照给定的格式(fmt)解析以offset开始的缓冲区,并返回解析结果
calcsize(fmt)	size of fmt	计算给定的格式(fmt)占用多少字节的内存，注意对齐方式

格式符

格式符	C语言类型	Python类型	Standard size
x	pad byte(填充字节)	no value
c	char	string of length 1	1
b	signed char	integer	1
B	unsigned char	integer	1
?	_Bool	bool	1
h	short	integer	2
H	unsigned short	integer	2
i	int	integer	4
I(大写的i)	unsigned int	integer	4
l(小写的L)	long	integer	4
L	unsigned long	long	4
q	long long	long	8
Q	unsigned long long	long	8
f	float	float	4
d	double	float	8
s	char[]	string
p	char[]	string
P	void *	long

5、SocketServer 实现并发

基于tcp的套接字，关键就是两个循环，一个连接循环，一个通讯循环。而socketserver模块中分两大类：server类（解决连接问题）和request类（解决通讯问题）

#server 端
import socketserver
class Myserver(socketserver.BaseRequestHandler):
    def handle(self):
        print(self.request)
        while True:
            try:
                self.data = self.request.recv(1024).strip()
                print(self.data)
                self.request.sendall(self.data.upper())
            except Exception:
                break

if __name__ == "__main__":
    HOST, PORT = "127.0.0.1", 10001
    # 建立一个server, 将服务地址绑定到127.0.0.1:10001 （TCP socket）
    # server = socketserver.TCPServer((HOST, PORT),Myserver)
    #（多线程）
    server = socketserver.ThreadingTCPServer((HOST, PORT), Myserver)
     #（多进程）
    #server=socketserver.ForkingTCPServer((host,port),myserver)
    # 让server永远运行下去，除非强制中止程序
    server.serve_forever()

#客户端
import socket
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.connect(('127.0.0.1',10001))
while True:
    msg=input('>>: ').strip()
    s.send(msg.encode('utf-8'))
    data=s.recv(1024)
    print(data.decode('utf-8'))

执行结果：

补充udp （不要这样玩，由于每新建一个链接就建立一个实例）：

#udp  socketserver
import socketserver
class Myserver(socketserver.BaseRequestHandler):
    def handle(self):
        print(self.request)
        self.data = self.request[0]
        print(self.data)
        self.request[1].sendto(self.request[0].upper(), self.client_address)
if __name__ == "__main__":
    HOST, PORT = "127.0.0.1", 10001
    # server = socketserver.TCPServer((HOST, PORT),Myserver)
    server = socketserver.ThreadingUDPServer((HOST, PORT), Myserver)
    # 让server永远运行下去，除非强制中止程序
    server.serve_forever()

#客户端
import socket
ip_port=('127.0.0.1',10001)
udp_client=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
while True:
    msg=input('>>: ').strip()
    udp_client.sendto(msg.encode('utf-8'),ip_port)
    msg,addr=udp_client.recvfrom(1024)
    print(msg.decode('utf-8'),addr)
udp_client.close()

基于tcp的socketserver咱们本身定义的类中的

self.server即套接字对象
self.request即一个连接（self.request = conn）
self.client_address即客户端地址

基于udp的socketserver咱们本身定义的类中的

self.request是一个元组（第一个元素是客户端发来的数据，第二部分是服务端的udp套接字对象），如(b'adsf', <socket.socket fd=200, family=AddressFamily.AF_INET, type=SocketKind.SOCK_DGRAM, proto=0, laddr=('127.0.0.1', 8080)>)
self.client_address即客户端地址

6、客户端链接合法示例

#server端
import socketserver
import hmac,os
secret_key=b'Crazyjump'
def conn_auth(conn):
    '''
    认证客户端连接
    '''
    print('开始验证新连接的合法性')
    msg=os.urandom(16) #随机生成16个字节的串
    print(msg)
    conn.sendall(msg)
    h=hmac.new(secret_key,msg)
    digest=h.digest()
    respone=conn.recv(len(digest))
    return hmac.compare_digest(respone,digest)

def data_handler(conn,bufsize=1024):
    if not conn_auth(conn):
        print('该连接不合法,关闭')
        conn.close()
        return
    print('连接合法,开始通讯')
    while True:
        try:
            data=conn.recv(bufsize)
            conn.sendall(data.upper())
        except Exception:
            break
class Myserver(socketserver.BaseRequestHandler):
    def handle(self):
        data_handler(self.request)
if __name__ == "__main__":
    HOST, PORT = "127.0.0.1", 10001
    server = socketserver.ThreadingTCPServer((HOST, PORT), Myserver)
    server.serve_forever()
#（单）
#def server_handler(ip_port,bufsize,backlog=5):
    '''
    只处理连接
    '''
   # tcp_socket_server=socket(AF_INET,SOCK_STREAM)
    #tcp_socket_server.bind(ip_port)
   # tcp_socket_server.listen(backlog)
    #while True:
       # conn,addr=tcp_socket_server.accept()
        #print('新链接[%s:%s]' %(addr[0],addr[1]))
        #data_handler(conn,bufsize)

#客户端
import hmac,os,socket

secret_key=b'Crazyjump'
def conn_auth(conn):
    '''
    验证客户端到服务器的连接
    '''
    msg=conn.recv(16)
    h=hmac.new(secret_key,msg)
    digest=h.digest()
    conn.sendall(digest)

def client_handler(ip_port):
    tcp_socket_client=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    tcp_socket_client.connect(ip_port)
    conn_auth(tcp_socket_client)

    while True:
        data=input('>>: ').strip()
        tcp_socket_client.sendall(data.encode('utf-8'))
        respone=tcp_socket_client.recv(1024)
        print(respone.decode('utf-8'))
    tcp_socket_client.close()

if __name__ == '__main__':
    ip_port=('127.0.0.1',10001)
    client_handler(ip_port)