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)

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。