一、兩種粘包：

MTU簡單解釋：

MTU是Maximum Transmission Unit的縮寫。意思是網(wǎng)絡(luò)上傳送的最大數(shù)據(jù)包。MTU的單位是字節(jié)。 大部分網(wǎng)絡(luò)設(shè)備的MTU都是1500個字節(jié)，也就是1500B。
如果本機一次需要發(fā)送的數(shù)據(jù)比網(wǎng)關(guān)的MTU大，大的數(shù)據(jù)包就會被拆開來傳送，這樣會產(chǎn)生很多數(shù)據(jù)包碎片，增加丟包率，降低網(wǎng)絡(luò)速度

超出緩沖區(qū)大小會報下面的錯誤，或者udp協(xié)議的時候，你的一個數(shù)據(jù)包的大小超過了你一次recv能接受的大小，也會報下面的錯誤，tcp不會，但是超出緩存區(qū)大小的時候，肯定會報這個錯誤。

subprocess import subprocess cmd = input('請輸入指令>>>') res = subprocess.Popen(cmd, #字符串指令：'dir','ipconfig',等等shell=True, #使用shell，就相當(dāng)于使用cmd窗口stderr=subprocess.PIPE, #標(biāo)準(zhǔn)錯誤輸出，凡是輸入錯誤指令，錯誤指令輸出的報錯信息就會被它拿到stdout=subprocess.PIPE, #標(biāo)準(zhǔn)輸出，正確指令的輸出結(jié)果被它拿到 ) print(res.stdout.read().decode('gbk')) print(res.stderr.read().decode('gbk')) subprocess

注意：

如果是windows，那么res.stdout.read()讀出的就是GBK編碼的，在接收端需要用GBK解碼

且只能從管道里讀一次結(jié)果，PIPE稱為管道。

下面是subprocess和windows上cmd下的指令的對應(yīng)示意圖：subprocess的stdout.read()和stderr.read()，拿到的結(jié)果是bytes類型，所以需要轉(zhuǎn)換為字符串打印出來看。

　　　　

　　　　好，既然我們會使用subprocess了，那么我們就通過它來模擬一個粘包

tcp粘包演示(一)：

先從上面粘包現(xiàn)象中的第一種開始：接收方?jīng)]有及時接收緩沖區(qū)的包，造成多個包接收（客戶端發(fā)送了一段數(shù)據(jù)，服務(wù)端只收了一小部分，
服務(wù)端下次再收的時候還是從緩沖區(qū)拿上次遺留的數(shù)據(jù)，產(chǎn)生粘包）
server端代碼示例? Server端

client端代碼示例

import socket ip_port = ('127.0.0.1',8080) size = 1024 tcp_sk = socket.socket(socket.AF_INET,socket.SOCK_STREAM) res = tcp_sk.connect(ip_port) while True:msg=input('>>: ').strip()if len(msg) == 0:continueif msg == 'quit':breaktcp_sk.send(msg.encode('utf-8'))act_res=tcp_sk.recv(size)print('接收的返回結(jié)果長度為>',len(act_res))print('std>>>',act_res.decode('gbk')) #windows返回的內(nèi)容需要用gbk來解碼，因為windows系統(tǒng)的默認(rèn)編碼為gbk tcp_client端

tcp粘包演示(二)：發(fā)送端需要等緩沖區(qū)滿才發(fā)送出去，造成粘包（發(fā)送數(shù)據(jù)時間間隔很短，數(shù)據(jù)也很小，會合到一起，產(chǎn)生粘包）

server端

from socket import * ip_port=('127.0.0.1',8080)tcp_socket_server=socket(AF_INET,SOCK_STREAM) tcp_socket_server.bind(ip_port) tcp_socket_server.listen(5) conn,addr=tcp_socket_server.accept() data1=conn.recv(10) data2=conn.recv(10)print('----->',data1.decode('utf-8')) print('----->',data2.decode('utf-8'))conn.close() tcp_server

client端

import socket BUFSIZE=1024 ip_port=('127.0.0.1',8080) s=socket.socket(socket.AF_INET,socket.SOCK_STREAM) # res=s.connect_ex(ip_port) res=s.connect(ip_port) s.send('hi'.encode('utf-8')) s.send('meinv'.encode('utf-8')) tcp_client

udp：是面向包的,且包和包之間存在包邊界保護(hù)所以不會產(chǎn)生粘包。

在udp的代碼中，我們在server端接收返回消息的時候，我們設(shè)置的recvfrom(1024)，那么當(dāng)我輸入的執(zhí)行指令為‘dir’的時候，dir在我當(dāng)前文件夾下輸出的內(nèi)容大于1024，
然后就報錯了，報的錯誤也是下面這個：

解釋原因：是因為udp是面向報文的，意思就是每個消息是一個包，你接收端設(shè)置接收大小的時候，必須要比你發(fā)的這個包要大，不然一次接收不了就會報這個錯誤，
而tcp不會報錯，這也是為什么ucp會丟包的原因之一，這個和我們上面緩沖區(qū)那個錯誤的報錯原因是不一樣的。

粘包原因 發(fā)送端可以是一K一K地發(fā)送數(shù)據(jù)，而接收端的應(yīng)用程序可以兩K兩K地提走數(shù)據(jù)，當(dāng)然也有可能一次提走3K或6K數(shù)據(jù)，或者一次只提走幾個字節(jié)的數(shù)據(jù)，也就是說，應(yīng)用程序所看到的數(shù)據(jù)是一個整體，或說是一個流（stream），一條消息有多少字節(jié)對應(yīng)用程序是不可見的，因此TCP協(xié)議是面向流的協(xié)議，這也是容易出現(xiàn)粘包問題的原因。而UDP是面向消息的協(xié)議，每個UDP段都是一條消息，應(yīng)用程序必須以消息為單位提取數(shù)據(jù)，不能一次提取任意字節(jié)的數(shù)據(jù)，這一點和TCP是很不同的。怎樣定義消息呢？可以認(rèn)為對方一次性write/send的數(shù)據(jù)為一個消息，需要明白的是當(dāng)對方send一條信息的時候，無論底層怎樣分段分片，TCP協(xié)議層會把構(gòu)成整條消息的數(shù)據(jù)段排序完成后才呈現(xiàn)在內(nèi)核緩沖區(qū)。例如基于tcp的套接字客戶端往服務(wù)端上傳文件，發(fā)送時文件內(nèi)容是按照一段一段的字節(jié)流發(fā)送的，在接收方看了，根本不知道該文件的字節(jié)流從何處開始，在何處結(jié)束所謂粘包問題主要還是因為接收方不知道消息之間的界限，不知道一次性提取多少字節(jié)的數(shù)據(jù)所造成的。此外，發(fā)送方引起的粘包是由TCP協(xié)議本身造成的，TCP為提高傳輸效率，發(fā)送方往往要收集到足夠多的數(shù)據(jù)后才發(fā)送一個TCP段。若連續(xù)幾次需要send的數(shù)據(jù)都很少，通常TCP會根據(jù)優(yōu)化算法把這些數(shù)據(jù)合成一個TCP段后一次發(fā)送出去，這樣接收方就收到了粘包數(shù)據(jù)。1.TCP（transport control protocol，傳輸控制協(xié)議）是面向連接的，面向流的，提供高可靠性服務(wù)。收發(fā)兩端（客戶端和服務(wù)器端）都要有一一成對的socket，因此，發(fā)送端為了將多個發(fā)往接收端的包，更有效的發(fā)到對方，使用了優(yōu)化方法（Nagle算法），將多次間隔較小且數(shù)據(jù)量小的數(shù)據(jù)，合并成一個大的數(shù)據(jù)塊，然后進(jìn)行封包。這樣，接收端，就難于分辨出來了，必須提供科學(xué)的拆包機制。 即面向流的通信是無消息保護(hù)邊界的。2.UDP（user datagram protocol，用戶數(shù)據(jù)報協(xié)議）是無連接的，面向消息的，提供高效率服務(wù)。不會使用塊的合并優(yōu)化算法，, 由于UDP支持的是一對多的模式，所以接收端的skbuff(套接字緩沖區(qū)）采用了鏈?zhǔn)浇Y(jié)構(gòu)來記錄每一個到達(dá)的UDP包，在每個UDP包中就有了消息頭（消息來源地址，端口等信息），這樣，對于接收端來說，就容易進(jìn)行區(qū)分處理了。 即面向消息的通信是有消息保護(hù)邊界的。3.tcp是基于數(shù)據(jù)流的，于是收發(fā)的消息不能為空，這就需要在客戶端和服務(wù)端都添加空消息的處理機制，防止程序卡住，而udp是基于數(shù)據(jù)報的，即便是你輸入的是空內(nèi)容（直接回車），那也不是空消息，udp協(xié)議會幫你封裝上消息頭，實驗略 udp的recvfrom是阻塞的，一個recvfrom(x)必須對唯一一個sendinto(y),收完了x個字節(jié)的數(shù)據(jù)就算完成,若是y>x數(shù)據(jù)就丟失，這意味著udp根本不會粘包，但是會丟數(shù)據(jù)，不可靠tcp的協(xié)議數(shù)據(jù)不會丟，沒有收完包，下次接收，會繼續(xù)上次繼續(xù)接收，己端總是在收到ack時才會清除緩沖區(qū)內(nèi)容。數(shù)據(jù)是可靠的，但是會粘包。 粘包機制

tcp和udpb比較

補充問題一：為何tcp是可靠傳輸，udp是不可靠傳輸tcp在數(shù)據(jù)傳輸時，發(fā)送端先把數(shù)據(jù)發(fā)送到自己的緩存中，然后協(xié)議控制將緩存中的數(shù)據(jù)發(fā)往對端，對端返回一個ack=1，發(fā)送端則清理緩存中的數(shù)據(jù)，對端返回ack=0，則重新發(fā)送數(shù)據(jù)，所以tcp是可靠的。而udp發(fā)送數(shù)據(jù)，對端是不會返回確認(rèn)信息的，因此不可靠補充問題二：send(字節(jié)流)和sendallsend的字節(jié)流是先放入己端緩存，然后由協(xié)議控制將緩存內(nèi)容發(fā)往對端，如果待發(fā)送的字節(jié)流大小大于緩存剩余空間，那么數(shù)據(jù)丟失，用sendall就會循環(huán)調(diào)用send，數(shù)據(jù)不會丟失，一般的小數(shù)據(jù)就用send，因為小數(shù)據(jù)也用sendall的話有些影響代碼性能，簡單來講就是還多while循環(huán)這個代碼呢。用UDP協(xié)議發(fā)送時，用sendto函數(shù)最大能發(fā)送數(shù)據(jù)的長度為：65535- IP頭(20) – UDP頭(8)＝65507字節(jié)。用sendto函數(shù)發(fā)送數(shù)據(jù)時，如果發(fā)送數(shù)據(jù)長度大于該值，則函數(shù)會返回錯誤。（丟棄這個包，不進(jìn)行發(fā)送） 用TCP協(xié)議發(fā)送時，由于TCP是數(shù)據(jù)流協(xié)議，因此不存在包大小的限制（暫不考慮緩沖區(qū)的大小），這是指在用send函數(shù)時，數(shù)據(jù)長度參數(shù)不受限制。而實際上，所指定的這段數(shù)據(jù)并不一定會一次性發(fā)送出去，如果這段數(shù)據(jù)比較長，會被分段發(fā)送，如果比較短，可能會等待和下一次數(shù)據(jù)一起發(fā)送。 tcp_udp比較

粘包的原因：主要還是因為接收方不知道消息之間的界限，不知道一次性提取多少字節(jié)的數(shù)據(jù)所造成的

二、粘包現(xiàn)象的解決
解決方案（一）： 問題的根源在于，接收端不知道發(fā)送端將要傳送的字節(jié)流的長度，所以解決粘包的方法就是圍繞，如何讓發(fā)送端在發(fā)送數(shù)據(jù)前，把自己將要發(fā)送的字節(jié)流總大小讓接收端知曉，然后接收端發(fā)一個確認(rèn)消息給發(fā)送端，然后發(fā)送端再發(fā)送過來后面的真實內(nèi)容，接收端再來一個死循環(huán)接收完所有數(shù)據(jù)。

　　　　看代碼示例：

server端代碼 復(fù)制代碼 import socket,subprocess ip_port=('127.0.0.1',8080) 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()print('客戶端',addr)while True:msg=conn.recv(1024)if not msg:breakres=subprocess.Popen(msg.decode('utf-8'),shell=True,\stdin=subprocess.PIPE,\stderr=subprocess.PIPE,\stdout=subprocess.PIPE)err=res.stderr.read()if err:ret=errelse:ret=res.stdout.read()data_length=len(ret)conn.send(str(data_length).encode('utf-8'))data=conn.recv(1024).decode('utf-8')if data == 'recv_ready':conn.sendall(ret)conn.close() tcp_server端

　　　　　　client端代碼示例

import socket,time s=socket.socket(socket.AF_INET,socket.SOCK_STREAM) res=s.connect_ex(('127.0.0.1',8080))while True:msg=input('>>: ').strip()if len(msg) == 0:continueif msg == 'quit':breaks.send(msg.encode('utf-8'))length=int(s.recv(1024).decode('utf-8'))s.send('recv_ready'.encode('utf-8'))send_size=0recv_size=0data=b''while recv_size < length:data+=s.recv(1024)recv_size+=len(data)print(data.decode('utf-8')) tcp_client

解決方案（二）：

通過struck模塊將需要發(fā)送的內(nèi)容的長度進(jìn)行打包，打包成一個4字節(jié)長度的數(shù)據(jù)發(fā)送到對端，對端只要取出前4個字節(jié)，然后對這四個字節(jié)的數(shù)據(jù)進(jìn)行解包，拿到你要發(fā)送的內(nèi)容的長度，然后通過這個長度來繼續(xù)接收我們實際要發(fā)送的內(nèi)容。

關(guān)于struck的介紹： 了解c語言的人，一定會知道struct結(jié)構(gòu)體在c語言中的作用，不了解C語言的同學(xué)也沒關(guān)系，不影響，其實它就是定義了一種結(jié)構(gòu)，里面包含不同類型的數(shù)據(jù)(int,char,bool等等)，方便對某一結(jié)構(gòu)對象進(jìn)行處理。而在網(wǎng)絡(luò)通信當(dāng)中，大多傳遞的數(shù)據(jù)是以二進(jìn)制流（binary data）存在的。當(dāng)傳遞字符串時，不必?fù)?dān)心太多的問題，而當(dāng)傳遞諸如int、char之類的基本數(shù)據(jù)的時候，就需要有一種機制將某些特定的結(jié)構(gòu)體類型打包成二進(jìn)制流的字符串然后再網(wǎng)絡(luò)傳輸，而接收端也應(yīng)該可以通過某種機制進(jìn)行解包還原出原始的結(jié)構(gòu)體數(shù)據(jù)。python中的struct模塊就提供了這樣的機制，該模塊的主要作用就是對python基本類型值與用python字符串格式表示的C struct類型間的轉(zhuǎn)化（This module performs conversions between Python values and C structs represented as Python strings.）。 struck模塊的使用：struct模塊中最重要的兩個函數(shù)是pack()打包, unpack()解包。

　　　　pack()：#我在這里只介紹一下'i'這個int類型，上面的圖中列舉除了可以打包的所有的數(shù)據(jù)類型，并且struck除了pack和uppack兩個方法之外還有好多別的方法和用法，大家以后找時間可以去研究一下，這里我就不做介紹啦，網(wǎng)上的教程很多

import struct a=12 # 將a變?yōu)槎M(jìn)制 bytes=struct.pack('i',a)

pack方法圖解：

　　　　unpack()：

# 注意，unpack返回的是tuple !!a,=struct.unpack('i',bytes)
struck解決粘包問題
先看一段偽代碼： import json,struct #假設(shè)通過客戶端上傳1T:1073741824000的文件a.txt#為避免粘包,必須自定制報頭 header={'file_size':1073741824000,'file_name':'/a/b/c/d/e/a.txt','md5':'8f6fbf8347faa4924a76856701edb0f3'} #1T數(shù)據(jù),文件路徑和md5值#為了該報頭能傳送,需要序列化并且轉(zhuǎn)為bytes，因為bytes只能將字符串類型的數(shù)據(jù)轉(zhuǎn)換為bytes類型的，所有需要先序列化一下這個字典，字典不能直接轉(zhuǎn)化為bytes head_bytes=bytes(json.dumps(header),encoding='utf-8') #序列化并轉(zhuǎn)成bytes,用于傳輸#為了讓客戶端知道報頭的長度,用struck將報頭長度這個數(shù)字轉(zhuǎn)成固定長度:4個字節(jié) head_len_bytes=struct.pack('i',len(head_bytes)) #這4個字節(jié)里只包含了一個數(shù)字,該數(shù)字是報頭的長度#客戶端開始發(fā)送 conn.send(head_len_bytes) #先發(fā)報頭的長度,4個bytes conn.send(head_bytes) #再發(fā)報頭的字節(jié)格式 conn.sendall(文件內(nèi)容) #然后發(fā)真實內(nèi)容的字節(jié)格式#服務(wù)端開始接收 head_len_bytes=s.recv(4) #先收報頭4個bytes,得到報頭長度的字節(jié)格式 x=struct.unpack('i',head_len_bytes)[0] #提取報頭的長度 head_bytes=s.recv(x) #按照報頭長度x,收取報頭的bytes格式 header=json.loads(json.dumps(header)) #提取報頭#最后根據(jù)報頭的內(nèi)容提取真實的數(shù)據(jù),比如 real_data_len=s.recv(header['file_size']) s.recv(real_data_len) 偽代碼

正式代碼

server端代碼示例：報頭：就是消息的頭部信息，我們要發(fā)送的真實內(nèi)容為報頭后面的內(nèi)容。

import socket,struct,json import subprocess phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) #忘了這是干什么的了吧，地址重用？想起來了嗎~ phone.bind(('127.0.0.1',8080)) phone.listen(5) while True:conn,addr=phone.accept()while True:cmd=conn.recv(1024)if not cmd:breakprint('cmd: %s' %cmd)res=subprocess.Popen(cmd.decode('utf-8'),shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)err=res.stderr.read()if err:back_msg=errelse:back_msg=res.stdout.read()conn.send(struct.pack('i',len(back_msg))) #先發(fā)back_msg的長度conn.sendall(back_msg) #在發(fā)真實的內(nèi)容#其實就是連續(xù)的將長度和內(nèi)容一起發(fā)出去，那么整個內(nèi)容的前4個字節(jié)就是我們打包的后面內(nèi)容的長度，對吧 conn.close() server端

client端

import socket,time,struct s=socket.socket(socket.AF_INET,socket.SOCK_STREAM) res=s.connect_ex(('127.0.0.1',8080)) while True:msg=input('>>: ').strip()if len(msg) == 0:continueif msg == 'quit':breaks.send(msg.encode('utf-8')) #發(fā)送給一個指令l=s.recv(4) #先接收4個字節(jié)的數(shù)據(jù)，因為我們將要發(fā)送過來的內(nèi)容打包成了4個字節(jié)，所以先取出4個字節(jié)x=struct.unpack('i',l)[0] #解包，是一個元祖，第一個元素就是我們的內(nèi)容的長度print(type(x),x)# print(struct.unpack('I',l))r_s=0data=b''while r_s < x: #根據(jù)內(nèi)容的長度來繼續(xù)接收4個字節(jié)后面的內(nèi)容。r_d=s.recv(1024)data+=r_dr_s+=len(r_d)# print(data.decode('utf-8'))print(data.decode('gbk')) #windows默認(rèn)gbk編碼 自定制報頭

精進(jìn)代碼示例：

server端

import socket,struct,json import subprocess phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)phone.bind(('127.0.0.1',8080)) phone.listen(5)while True:conn,addr=phone.accept()while True:cmd=conn.recv(1024)if not cmd:breakprint('cmd: %s' %cmd)res=subprocess.Popen(cmd.decode('utf-8'),shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)err=res.stderr.read()print(err)if err:back_msg=errelse:back_msg=res.stdout.read()headers={'data_size':len(back_msg)}head_json=json.dumps(headers)head_json_bytes=bytes(head_json,encoding='utf-8')conn.send(struct.pack('i',len(head_json_bytes))) #先發(fā)報頭的長度conn.send(head_json_bytes) #再發(fā)報頭conn.sendall(back_msg) #在發(fā)真實的內(nèi)容 conn.close() server端

client端:

from socket import * import struct,jsonip_port=('127.0.0.1',8080) client=socket(AF_INET,SOCK_STREAM) client.connect(ip_port)while True:cmd=input('>>: ')if not cmd:continueclient.send(bytes(cmd,encoding='utf-8'))head=client.recv(4)head_json_len=struct.unpack('i',head)[0]head_json=json.loads(client.recv(head_json_len).decode('utf-8'))data_len=head_json['data_size']recv_size=0recv_data=b''while recv_size < data_len:recv_data+=client.recv(1024)recv_size+=len(recv_data)#print(recv_data.decode('utf-8'))print(recv_data.decode('gbk')) #windows默認(rèn)gbk編碼 client端 整個流程的大致解釋：
我們可以把報頭做成字典，字典里包含將要發(fā)送的真實數(shù)據(jù)的描述信息(大小啊之類的)，然后json序列化，然后用struck將序列化后的數(shù)據(jù)長度打包成4個字節(jié)。 我們在網(wǎng)絡(luò)上傳輸?shù)乃袛?shù)據(jù) 都叫做數(shù)據(jù)包，數(shù)據(jù)包里的所有數(shù)據(jù)都叫做報文，報文里面不止有你的數(shù)據(jù)，還有ip地址、mac地址、端口號等等，其實所有的報文都有報頭，這個報頭是協(xié)議規(guī)定的，看一下
發(fā)送時： 先發(fā)報頭長度 再編碼報頭內(nèi)容然后發(fā)送 最后發(fā)真實內(nèi)容接收時： 先手報頭長度，用struct取出來 根據(jù)取出的長度收取報頭內(nèi)容，然后解碼，反序列化 從反序列化的結(jié)果中取出待取數(shù)據(jù)的描述信息，然后去取真實的數(shù)據(jù)內(nèi)容? FTB上傳下載文件的代碼（簡易版） import socket import struct import json sk = socket.socket() # buffer = 4096 # 當(dāng)雙方的這個接收發(fā)送的大小比較大的時候，就像這個4096，就會丟數(shù)據(jù)，這個等我查一下再告訴大家，改小了就ok的，在linux上也是ok的。 buffer = 1024 #每次接收數(shù)據(jù)的大小 sk.bind(('127.0.0.1',8090)) sk.listen()conn,addr = sk.accept() #接收 head_len = conn.recv(4) head_len = struct.unpack('i',head_len)[0] #解包 json_head = conn.recv(head_len).decode('utf-8') #反序列化 head = json.loads(json_head) filesize = head['filesize'] with open(head['filename'],'wb') as f:while filesize:if filesize >= buffer: #>=是因為如果剛好等于的情況出現(xiàn)也是可以的。content = conn.recv(buffer)f.write(content)filesize -= bufferelse:content = conn.recv(buffer)f.write(content)breakconn.close() sk.close() tpc_server_ftb import os import json import socket import struct sk = socket.socket() sk.connect(('127.0.0.1',8090)) buffer = 1024 #讀取文件的時候，每次讀取的大小 head = {'filepath':r'D:\打包程序', #需要下載的文件路徑，也就是文件所在的文件夾'filename':'xxx.mp4', #改成上面filepath下的一個文件'filesize':None,}file_path = os.path.join(head['filepath'],head['filename']) filesize = os.path.getsize(file_path) head['filesize'] = filesize # json_head = json.dumps(head,ensure_ascii=False) #字典轉(zhuǎn)換成字符串 json_head = json.dumps(head) #字典轉(zhuǎn)換成字符串 bytes_head = json_head.encode('utf-8') #字符串轉(zhuǎn)換成bytes類型 print(json_head) print(bytes_head)#計算head的長度，因為接收端先接收我們自己定制的報頭，對吧 head_len = len(bytes_head) #報頭長度 pack_len = struct.pack('i',head_len) print(head_len) print(pack_len) sk.send(pack_len) #先發(fā)送報頭長度 sk.send(bytes_head) #再發(fā)送bytes類型的報頭#即便是視頻文件，也是可以按行來讀取的，也可以readline，也可以for循環(huán)，但是讀取出來的數(shù)據(jù)大小就不固定了，影響效率，有可能讀的比較小，也可能很大，像視頻文件一般都是一行的二進(jìn)制字節(jié)流。 #所有我們可以用read，設(shè)定一個一次讀取內(nèi)容的大小，一邊讀一邊發(fā)，一邊收一邊寫 with open(file_path,'rb') as f:while filesize:if filesize >= buffer: #>=是因為如果剛好等于的情況出現(xiàn)也是可以的。content = f.read(buffer) #每次讀取出來的內(nèi)容 sk.send(content)filesize -= buffer #每次減去讀取的大小else: #那么說明剩余的不夠一次讀取的大小了，那么只要把剩下的讀取出來發(fā)送過去就行了content = f.read(filesize)sk.send(content)breaksk.close() tpc_client_ftb

三、驗證客戶端的鏈接合法性

首先，我們來探討一下，什么叫驗證合法性，?舉個例子：有一天，我開了一個socket服務(wù)端，只想讓咱們這個班的同學(xué)使用，但是有一天，隔壁班的同學(xué)過來問了一下我開的這個服務(wù)端的ip和端口，然后他是不是就可以去連接我了啊，那怎么辦，我是不是不想讓他連接我啊，我需要驗證一下你的身份，這就是驗證連接的合法性，再舉個例子，就像我們上面說的你的windows系統(tǒng)是不是連接微軟的時間服務(wù)器來獲取時間的啊，你的mac能到人家微軟去獲取時間嗎，你愿意，人家微軟還不愿意呢，對吧，那這時候，你每次連接我來獲取時間的時候，我是不是就要驗證你的身份啊，也就是你要帶著你的系統(tǒng)信息，我要判斷你是不是我微軟的windows，對吧，如果是mac，我是不是不讓你連啊，這就是連接合法性。如果驗證你的連接是合法的，那么如果我還要對你的身份進(jìn)行驗證的需求，也就是要驗證用戶名和密碼，那么我們還需要進(jìn)行身份認(rèn)證。連接認(rèn)證>>身份認(rèn)證>>ok你可以玩了。

如果你想在分布式系統(tǒng)中實現(xiàn)一個簡單的客戶端鏈接認(rèn)證功能，又不像SSL那么復(fù)雜，那么利用hmac+加鹽的方式來實現(xiàn)，直接看代碼！（SSL，我們都）

from socket import * import hmac,ossecret_key=b'Jedan has a big key!' def conn_auth(conn):'''認(rèn)證客戶端鏈接:param conn::return:'''print('開始驗證新鏈接的合法性')msg=os.urandom(32)#生成一個32字節(jié)的隨機字符串 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('該鏈接不合法,關(guān)閉')conn.close()returnprint('鏈接合法,開始通信')while True:data=conn.recv(bufsize)if not data:breakconn.sendall(data.upper())def server_handler(ip_port,bufsize,backlog=5):'''只處理鏈接:param ip_port::return:'''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)if __name__ == '__main__':ip_port=('127.0.0.1',9999)bufsize=1024server_handler(ip_port,bufsize) 服務(wù)端 from socket import * import hmac,ossecret_key=b'Jedan has a big key！' def conn_auth(conn):'''驗證客戶端到服務(wù)器的鏈接:param conn::return:'''msg=conn.recv(32)h=hmac.new(secret_key,msg)digest=h.digest()conn.sendall(digest)def client_handler(ip_port,bufsize=1024):tcp_socket_client=socket(AF_INET,SOCK_STREAM)tcp_socket_client.connect(ip_port)conn_auth(tcp_socket_client)while True:data=input('>>: ').strip()if not data:continueif data == 'quit':breaktcp_socket_client.sendall(data.encode('utf-8'))respone=tcp_socket_client.recv(bufsize)print(respone.decode('utf-8'))tcp_socket_client.close()if __name__ == '__main__':ip_port=('127.0.0.1',9999)bufsize=1024client_handler(ip_port,bufsize) 客戶端

介紹代碼中使用的兩個方法：

1、os.urandom(n) 其中os.urandom(n) 是一種bytes類型的隨機生成n個字節(jié)字符串的方法，而且每次生成的值都不相同。再加上md5等加密的處理，就能夠成內(nèi)容不同長度相同的字符串了。 os.urandom(n)函數(shù)在python官方文檔中做出了這樣的解釋函數(shù)定位： Return a string of n random bytes suitable for cryptographic use. 意思就是，返回一個有n個byte那么長的一個string，然后很適合用于加密。然后這個函數(shù)，在文檔中，被歸結(jié)于os這個庫的Miscellaneous Functions，意思是不同種類的函數(shù)（也可以說是混種函數(shù)） 原因是： This function returns random bytes from an OS-specific randomness source. （函數(shù)返回的隨機字節(jié)是根據(jù)不同的操作系統(tǒng)特定的隨機函數(shù)資源。即，這個函數(shù)是調(diào)用OS內(nèi)部自帶的隨機函數(shù)的。有特異性）

?　　　　使用方法：

import os from hashlib import md5for i in range(10):print md5(os.urandom(24)).hexdigest() 2、hmac： 我們完全可以用hashlib來實現(xiàn)，但是學(xué)個新的嗎，沒什么不好的，這個操作更方便一些。 Python自帶的hmac模塊實現(xiàn)了標(biāo)準(zhǔn)的Hmac算法，我們首先需要準(zhǔn)備待計算的原始消息message，隨機key，哈希算法，這里采用MD5，使用hmac的代碼如下： import hmac message = b'Hello world' key = b'secret' h = hmac.new(key,message,digestmod='MD5') print(h.hexdigest())
比較兩個密文是否相同，可以用hmac.compare_digest(密文、密文)，然會True或者False。

?　　　　可見使用hmac和普通hash算法非常類似。hmac輸出的長度和原始哈希算法的長度一致。需要注意傳入的key和message都是bytes類型，str類型需要首先編碼為bytes。

def hmac_md5(key, s):return hmac.new(key.encode('utf-8'), s.encode('utf-8'), 'MD5').hexdigest()class User(object):def __init__(self, username, password):self.username = usernameself.key = ''.join([chr(random.randint(48, 122)) for i in range(20)])self.password = hmac_md5(self.key, password) OVER

轉(zhuǎn)載于:https://www.cnblogs.com/z520h123/p/10008200.html

總結(jié)

以上是生活随笔為你收集整理的python D28 粘包的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。