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))