python--(socket與粘包解決方案)
阿新 • • 發佈:2018-11-10
python--(socket與粘包解決方案)
一.socket:
Socket 是任何一種計算機網路通訊中最基礎的內容。例如當你在瀏覽器位址列中輸入 http://www.cnblogs.com/ 時,你會開啟一個套接字,然後連線到 http://www.cnblogs.com/ 並讀取響應的頁面然後然後顯示出來。而其他一些聊天客戶端如 gtalk 和 skype 也是類似。任何網路通訊都是通過 Socket 來完成的
開啟 => 讀寫 => 關閉
socket ftp傳輸:
import socket server = socket.socket() #socket ftp傳輸,服務端建立一個手機#建立了一個socket物件 ip_port = ('192.168.15.113',8001) #建立了一張電話卡 server.bind(ip_port) #插上電話卡#繫結IP地址和埠 server.listen() #開機#監聽IP地址和埠 conn, addr = server.accept() #等著別人給我打電話,阻塞住#等待客連結 from_client_msg = conn.recv(1024) #接收訊息#1024為訊息大小,單位B,MB = 1024KB,1KB = 1024B from_client_msg = from_client_msg.decode('utf-8')#接收的訊息是bytes型別,需要轉換為字串 print(from_client_msg) conn.send('死鬼,十點'.encode('utf-8')) #傳送訊息 conn.close()#關閉連結 server.close()
import socket client = socket.socket() server_ip_port = ('192.168.15.113',8001) client.connect(server_ip_port)#連結服務端 client.send(socket ftp傳輸,客戶端'約嗎'.encode('utf-8')) #發訊息#send裡面的訊息必須是位元組型別的 from_server_msg = client.recv(1024) #阻塞住,等待接收訊息 from_server_msg = from_server_msg.decode('utf-8') print(from_server_msg) client.close()
socket udp傳輸:
import socket udp_server = socket.socket(type=socket.SOCK_DGRAM) #建立一個udp協議下的socket,需要使用引數type#DGRAM : datagram 資料報 ip_port = ('192.168.15.113',8001)#拿到一個地址,啟動程式的時候,告訴電腦,你給我這個程式分配8001埠. udp_server.bind(ip_port) #繫結IP地址和埠 from_client_msg,client_addr = udp_server.recvfrom(1024)#阻塞住了,接收客戶端訊息#from_client_msg來自客戶端的訊息,client_addr客戶端的地址('192.168.15.113', 8001) udp_server.sendto(b'gunduzi',client_addr)#傳送訊息 udp_server.close()#關閉udp的socket物件socket udp傳輸,服務端
import socket udp_client = socket.socket(type=socket.SOCK_DGRAM) server_ip_port = ('192.168.15.113',8001) udp_client.sendto(b'hello',server_ip_port) from_server_msg,server_addr = udp_client.recvfrom(1024) print(from_server_msg) print(server_addr) udp_client.close()socket udp傳輸,客戶端
socketserver:
它是在socket的基礎上進行了一層封裝,也就是說底層還是呼叫的socket,在py2.7裡面叫做SocketServer也就是大寫了兩個S,在py3裡面就小寫了。需要用它來實現併發,也就是同時可以和多個客戶端進行通訊,多個人可以同時進行上傳下載等。
import socketserver class MyServer(socketserver.BaseRequestHandler) #1.定義一個類,2.類裡面繼承socketserve.BaseRequestHandler def handle(self): #類裡面定義一個handle方法,handle名稱不能變 while 1: from_client_data = self.request.recv(1024).decode("utf-8") # self.request #conn連結通道 print(from_client_data) server_input = ("輝哥說>>>>") self.request.send(server_input.encode("utf-8")) # self.request.send(server_input.encode("utf-8") # self.request.close() if __name__ == "__main__": ip_port = ('127.0.0.1',8001)#服務端的ip地址和埠 socketserver.TCPServer.allow_reuse_address = True server = socketserver.ThreadingTCPServer(ip_port, MyServer)# 繫結IP地址和埠,並且啟動我定義的上面這個類 server.serve_forever()#永久的給我執行下去服務端程式碼解析
import socket tcp_client = socket.socket() server_ip_port = ('127.0.0.1',8001) tcp_client.connect(server_ip_port) while 1: client_msg = input('大陽哥>>>') tcp_client.send(client_msg.encode('utf-8')) from_server_msg = tcp_client.recv(1024).decode('utf-8') print(from_server_msg) tcp_client.close()客戶端程式碼解析
socket相關常用操作:
sk.bind(address)
s.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,失敗則丟擲異常。
內部通過遞迴呼叫send,將所有內容傳送出去。
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()
套接字的檔案描述符
二.粘包
緩衝區 : 暫時存放傳輸資料的,防止你的程式在傳送資料的時候卡住,提高程式碼執行效率
輸入緩衝區:recv
輸出緩衝區:send
緩衝區有長度限制
MTU:最大傳輸單元,網路層限制是1500B,每次傳送資料的時候最好不要超過這個數
粘包現象:
1 連續傳送小的資料,間隔時間很短,有可能一次就接收到了這幾個連續的拼接在一起的小資料. #原因:為了提高tcp傳輸效率,內部提供了一個叫做Nagel演算法,他的意思就是為了避免你連續傳送小的資料.
2 當你一次接收的資料長度小於你一次傳送的資料長度,那麼一次接受完剩下的資料會在下一次接收資料的時候被一起接收.#原因面向流的傳輸
粘包的根本原因:
兩端互相不知道對方傳送資料的長度
解決方案一:
傳送訊息之前,先計算要傳送訊息的長度,然後先將訊息長度傳送過去,對方給你回一個確認收到長度的資訊,然後根據接收到的訊息長度來修改自己一次接收訊息的大小
這個過程多了一次互動.
解決方案二:
struct:
import struct num = 156 #將int型別的資料打包成4個位元組的資料 num_stru = struct.pack('i',num) print(len(num_stru)) print(num_stru) print('11111111111111111111111111111111') #在通過int型別解包,將前面打包的資料解包成打包之前的int資料 num2 = struct.unpack('i',num_stru) #解包出來是個元組 print(num2)#(156,) print(num2[0])神奇的打包工具struck
ftp傳輸 案例:
服務端: import socketserver # 服務端 class Myserver(socketserver.BaseRequestHandler): def handle(self): conn = self.request conn.sendall(bytes("你好,我是孔二楞",encoding="utf-8")) while True: ret_bytes = conn.recv(1024) ret_str = str(ret_bytes,encoding="utf-8") if ret_str == "q": break conn.sendall(bytes(ret_str+"你真無聊~",encoding="utf-8")) if __name__ == "__main__": server = socketserver.ThreadingTCPServer(("192.168.15.70",8080),Myserver) server.serve_forever() 客戶端: import socket obj = socket.socket() obj.connect(("192.168.15.70",8080)) ret_bytes = obj.recv(1024) ret_str = str(ret_bytes,encoding="utf-8") print(ret_str) while True: inp = input("你好請問您有什麼問題? \n >>>") if inp == "q": obj.sendall(bytes(inp,encoding="utf-8")) break else: obj.sendall(bytes(inp, encoding="utf-8")) ret_bytes = obj.recv(1024) ret_str = str(ret_bytes,encoding="utf-8") print(ret_str)案例一 自動回覆聊天
import socket import struct import json import os tcp_server = socket.socket() ip_port = ('127.0.0.1',8001)#本機迴環地址,供內部程式之間測試用 tcp_server.bind(ip_port) tcp_server.listen() client_file_path = r'F:\pp' conn,adddr = tcp_server.accept() file_info_stru = conn.recv(4)#首先接收到檔案資訊長度轉換出來的4個位元組的資料 file_info_len = struct.unpack('i',file_info_stru)[0]#解包檔案資訊的長度 client_file_info = conn.recv(file_info_len).decode('utf-8') abc_file_info = json.loads(client_file_info)#將接收到的json字串反序列化 print('abc_file_info>>>',abc_file_info) client_file_size = abc_file_info['file_size'] recv_all_size = 0 client_full_path = client_file_path + '\\' + abc_file_info['file_name'] # client_full_path = os.path.join(client_file_path,abc_file_info['file_name']) with open(client_full_path,'wb') as f: while recv_all_size < client_file_size: every_recv_data = conn.recv(1024) f.write(every_recv_data) recv_all_size += len(every_recv_data) conn.send('小夥牛逼啊,上傳成功!'.encode('utf-8')) conn.close() tcp_server.close()案例二 大於10M檔案上傳服務端
import socket import struct import json import os tcp_client = socket.socket() server_client = socket.socket() server_ip_port = ("127.0.0.1",8001) tcp_client.connect(server_ip_port) read_size = 1024 file_info = { 'file_path':r'F:\untitled\10.18\jj\aaa.mp4', 'file_name':'aaa.mp4', 'file_size':None, } file_size = os.path.getsize(file_info["file_path"])#獲取檔案大小 file_info["file_size"] = file_size#將檔案大小新增到檔案資訊的字典中 file_info_json = json.dumps(file_info)#因為我們要傳送的資料是位元組型別,那麼必須將字典轉換為bytes型別,但字典不能直接轉換為byte,所以用過先轉換成字串 file_info_len = len(file_info_json) #獲取字串的長度 file_info_stru = struct.pack("i",file_info_len)#將長度打包為四個位元組 tcp_client.send(file_info_stru)#將打包好的4個自己的資料和我的檔案資訊資料一起傳送給了服務端 tcp_client.send(file_info_json.encode("utf-8")) all_file_data = b'' #統計檔案資料 all_size_len = 0 #統計檔案資料長度 with open(file_info['file_path'],'rb') as f: while all_size_len < file_size: every_read_data = f.read(read_size) all_file_data += every_read_data all_size_len += len(every_read_data) tcp_client.send(every_read_data)#傳送每次讀取的資料 print(tcp_client.recv(1024).decode('utf-8')) tcp_client.close()案例二 大於10M檔案上傳客戶端
import socket import subprocess import struct server = socket.socket() ip_port = ("192.168.15.33",8001) server.bind(ip_port) server.listen() conn,addr = server.accept() while 1: print("等待接收訊息...") from_client_cmd = conn.recv(1024).decode("utf-8")#接收客戶端訊息 print(from_client_cmd) sub_obj = subprocess.Popen( #通過subprocess模組執行服務端指令,並拿到指令結果 from_client_cmd, #客戶端指令 shell = True, stdout = subprocess.PIPE, #標準輸出:正確指令的執行結果 stderr = subprocess.PIPE, #標準錯誤輸出:錯誤指令的執行結果 ) server_cmd_msg = sub_obj.stdout.read() #server_cmd_msg = sub_obj.stderr.read() #接收到的返回資訊是bytes型別,並且windoes系統的預設編碼為gbk cmd_msg_len = len(server_cmd_msg) #計算你要傳送的資料長度 msg_len_stru = struct.pack("i",cmd_msg_len)#先對資料長度進行打包,打包成4個位元組的資料,目的是為了和你將要傳送的資料拼接在一起,就像我們自制一個訊息頭. conn.send(msg_len_stru) #首先發送打包成功後的那4個位元組的資料 conn.sendall(server_cmd_msg) #迴圈send資料,直到資料全部發送成功 conn.close() server.close()案例三 解決粘包問題服務端
import socket import struct client = socket.socket() server_ip_port = ("192.168.15.33",8001) client.connect(server_ip_port) while 1: msg = input("請輸入要執行的命令>>>>>") client.send(msg.encode("utf-8")) from_server_msglen = client.recv(4)#先接受服務端要傳送給我的資料長度,前四個位元組,固定的 unpack_len_msg = struct.unpack("i",from_server_msglen)[0] recv_msg_len = 0 all_msg = b"" while recv_msg_len < unpack_len_msg: every_recv_date = client.recv(1024) all_msg += every_recv_date #將每次接收到的資料進行拼接和統計 recv_msg_len += len(every_recv_date) #對每次接受到的資料進行累加 print(all_msg.decode("gbk")) client.close()案例三 解決粘包問題客戶端