網絡通信中TCP出現的黏包以及解決方法 socket 模擬黏包

粘包問題概述

 

1.1  描述背景

采用TCP協議進行網絡數據傳送的軟件設計中，普遍存在粘包問題。這主要是由於現代操作系統的網絡傳輸機制所產生的。我們知道，網絡通信采用的套接字(socket)技術，其實現實際是由系統內核提供一片連續緩存(流緩沖)來實現應用層程序與網卡接口之間的中轉功能。多個數據包被連續存儲於連續的緩存中，在對數據包進行讀取時由於無法確定發生方的發送邊界，而采用某一估測值大小來進行數據讀出，若雙方的size不一致時就會使數據包的邊界發生錯位，導致讀出錯誤的數據分包，進而曲解原始數據含義。

 

1.2  粘包的概念

粘包問題的本質就是數據讀取邊界錯誤所致，通過下圖可以形象地理解其現象。

如圖1所示，當前的socket緩存中已經有6個數據分組到達，其大小如圖中數字。而應用程序在對數據進行收取時(如圖2)，采用了300字節的要求去讀取，則會誤將pkg1和pkg2一起收走當做一個包來處理。而實際上，很可能pkg1是一個文本文件的內容，而pkg2則可能是一個音頻內容，這風馬牛不相及的兩個數據包卻被揉進一個包進行處理，顯然有失妥當。嚴重時可能因為丟了pkg2而導致軟件陷入異常分支產生烏龍事件。

因此，粘包問題必須引起所有軟件設計者（項目經理）的高度重視！

那么，或許會有讀者發問，為何不讓接收程序按照100字節來讀取呢？我想如果您了解一些TCP編程的話就不會有這樣的問題。網絡通信程序中，數據包通常是不能確定大小的，尤其在軟件設計階段無法真的做到確定為一個固定值。比如聊天軟件客戶端若采用TCP傳輸一個用戶名和密碼到服務端進行驗證登陸，我想這個數據包不過是幾十字節，至多幾百字節即可發送完畢，而有時候要傳輸一個很大的視頻文件，即使分包發送也應該一個包在幾千字節吧。（據說，某國電信平台的MW中見到過一次發送1.5萬字節的電話數據）這種情況下，發送數據的分包大小無法固定，接收端也就無法固定。所以一般采用一個較為合理的預估值進行輪詢接收。（網卡的MTU都是1500字節，因此這個預估值一般為MTU的1~3倍）。

 

粘包現象

　　

　　說粘包之前，我們先說兩個內容，1.緩沖區、2.windows下cmd窗口調用系統指令

　　9.1 緩沖區（下面粘包現象的圖里面還有關於緩沖區的解釋）

　　　　

 

每個 socket 被創建后，都會分配兩個緩沖區，輸入緩沖區和輸出緩沖區。 write()/send() 並不立即向網絡中傳輸數據，而是先將數據寫入緩沖區中，再由TCP協議將數據從緩沖區發送到目標機器。一旦將數據寫入到緩沖區，函數就可以成功返回，不管它們有沒有到達目標機器，也不管它們何時被發送到網絡，這些都是TCP協議負責的事情。 TCP協議獨立於 write()/send() 函數，數據有可能剛被寫入緩沖區就發送到網絡，也可能在緩沖區中不斷積壓，多次寫入的數據被一次性發送到網絡，這取決於當時的網絡情況、當前線程是否空閑等諸多因素，不由程序員控制。 read()/recv() 函數也是如此，也從輸入緩沖區中讀取數據，而不是直接從網絡中讀取。 這些I/O緩沖區特性可整理如下： 1.I/O緩沖區在每個TCP套接字中單獨存在； 2.I/O緩沖區在創建套接字時自動生成； 3.即使關閉套接字也會繼續傳送輸出緩沖區中遺留的數據； 4.關閉套接字將丟失輸入緩沖區中的數據。 輸入輸出緩沖區的默認大小一般都是 8K，可以通過 getsockopt() 函數獲取： 1.unsigned optVal; 2.int optLen = sizeof(int); 3.getsockopt(servSock, SOL_SOCKET, SO_SNDBUF,(char*)&optVal, &optLen); 4.printf("Buffer length: %d\n", optVal); socket緩沖區解釋

9.2 windows下cmd窗口調用系統指令(linux下沒有寫出來，大家仿照windows的去摸索一下吧)

　　　　a.首先ctrl+r，彈出左下角的下圖，輸入cmd指令，確定

　　　　　　

　　　　b.在打開的cmd窗口中輸入dir（dir：查看當前文件夾下的所有文件和文件夾），你會看到下面的輸出結果。

　　　　　　

　　　　　　另外還有ipconfig（查看當前電腦的網絡信息），在windows沒有ls這個指令(ls在linux下是查看當前文件夾下所有文件和文件夾的指令，和windows下的dir是類似的)，那么沒有這個指令就會報下面這個錯誤

　　　　　　

 

linux shell中一個運行多個命令，命令間用;隔開即可 windows的命令提示符中運行多條命令用的是：&&、||、& aa && bb 就是執行aa，成功后再執行bb aa || bb 先執行aa，若執行成功則不再執行bb，若失敗則執行bb a & b 表示執行a再執行b，無論a是否成功 “執行成功”的意思是返回的errorlevel=0 windows下執行多條指令

 為什么要說這個系統指令呢，是希望借助系統指令和指令輸出的結果來模擬一下粘包現象，那什么是粘包呢？

9.3 粘包現象（兩種）

　　　　先上圖：（本圖是我做出來為了讓小白同學有個大致的了解用的，其中很多地方更加的復雜，那就需要將來大家有多余的精力的時候去做一些深入的研究了，這里我就不帶大家搞啦）

　　　　

 

　　　　關於MTU大家可以看看這篇文章 https://yq.aliyun.com/articles/222535  還有百度百科 MTU百科

　　　　MTU簡單解釋：

MTU是Maximum Transmission Unit的縮寫。意思是網絡上傳送的最大數據包。MTU的單位是字節。 大部分網絡設備的MTU都是1500個字節，也就是1500B。如果本機一次需要發送的數據比網關的MTU大，大的數據包就會被拆開來傳送，這樣會產生很多數據包碎片，增加丟包率，降低網絡速度

 

　　　　關於上圖中提到的Nagle算法等建議大家去看一看Nagle算法、延遲ACK、linux下的TCP_NODELAY和TCP_CORK，這些內容等你們把python學好以后再去研究吧，網絡的內容實在太多啦，也就是說大家需要努力的過程還很長，加油！

　　

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

 

 　　

　　9.4 模擬一個粘包現象

　　　　在模擬粘包之前，我們先學習一個模塊subprocess。

import subprocess cmd = input('請輸入指令>>>') res = subprocess.Popen( cmd, #字符串指令：'dir','ipconfig',等等
    shell=True,              #使用shell，就相當於使用cmd窗口
    stderr=subprocess.PIPE,  #標准錯誤輸出，凡是輸入錯誤指令，錯誤指令輸出的報錯信息就會被它拿到
    stdout=subprocess.PIPE,  #標准輸出，正確指令的輸出結果被它拿到
) print(res.stdout.read().decode('gbk')) print(res.stderr.read().decode('gbk')) subprocess的簡單使用

注意：

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

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

 

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

　　　　

　　　　

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

　　　　tcp粘包演示(一)：

　　　　　　先從上面粘包現象中的第一種開始：接收方沒有及時接收緩沖區的包，造成多個包接收（客戶端發送了一段數據，服務端只收了一小部分，服務端下次再收的時候還是從緩沖區拿上次遺留的數據，產生粘包） 

　　　　　　server端代碼示例：

 

cket import *
import subprocess ip_port=('127.0.0.1',8080) BUFSIZE=1024 tcp_socket_server=socket(AF_INET,SOCK_STREAM) tcp_socket_server.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) tcp_socket_server.bind(ip_port) tcp_socket_server.listen(5) while True: conn,addr=tcp_socket_server.accept() print('客戶端>>>',addr) while True: cmd=conn.recv(BUFSIZE) if len(cmd) == 0:break res=subprocess.Popen(cmd.decode('gbk'),shell=True, stdout=subprocess.PIPE, stdin=subprocess.PIPE, stderr=subprocess.PIPE) stderr=res.stderr.read() stdout=res.stdout.read() conn.send(stderr) conn.send(stdout) tcp_server.py

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:continue
    if msg == 'quit':break tcp_sk.send(msg.encode('utf-8')) act_res=tcp_sk.recv(size) print('接收的返回結果長度為>',len(act_res)) print('std>>>',act_res.decode('gbk')) #windows返回的內容需要用gbk來解碼，因為windows系統的默認編碼為gbk
 tcp_client.py

 

 

tcp粘包演示(二)：發送數據時間間隔很短，數據也很小，會合到一起，產生粘包

　　　　　　server端代碼示例：（如果兩次發送有一定的時間間隔，那么就不會出現這種粘包情況，試着在兩次發送的中間加一個time.sleep(1)）

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.py

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_server.py

 

示例二的結果：全部被第一個recv接收了

　　　　

 

　　　　udp粘包演示：注意：udp是面向包的，所以udp是不存在粘包的

　　　　　　server端代碼示例：

import socket from socket import SOL_SOCKET,SO_REUSEADDR,SO_SNDBUF,SO_RCVBUF sk = socket.socket(type=socket.SOCK_DGRAM) # sk.setsockopt(SOL_SOCKET,SO_RCVBUF,80*1024)
sk.bind(('127.0.0.1',8090)) msg,addr = sk.recvfrom(1024) while True: cmd = input('>>>>') if cmd == 'q': break sk.sendto(cmd.encode('utf-8'),addr) msg,addr = sk.recvfrom(1032) # print('>>>>', sk.getsockopt(SOL_SOCKET, SO_SNDBUF))
    # print('>>>>', sk.getsockopt(SOL_SOCKET, SO_RCVBUF))
    print(len(msg)) print(msg.decode('utf-8')) sk.close() udp_server.py

 client端代碼示例：

import socket from socket import SOL_SOCKET,SO_REUSEADDR,SO_SNDBUF,SO_RCVBUF sk = socket.socket(type=socket.SOCK_DGRAM) # sk.setsockopt(SOL_SOCKET,SO_RCVBUF,80*1024)
sk.bind(('127.0.0.1',8090)) msg,addr = sk.recvfrom(1024) while True: cmd = input('>>>>') if cmd == 'q': break sk.sendto(cmd.encode('utf-8'),addr) msg,addr = sk.recvfrom(1024) # msg,addr = sk.recvfrom(1218)
    # print('>>>>', sk.getsockopt(SOL_SOCKET, SO_SNDBUF))
    # print('>>>>', sk.getsockopt(SOL_SOCKET, SO_RCVBUF))
    print(len(msg)) print(msg.decode('utf-8')) sk.close() udp_server.py

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

　　

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

 

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

 

補充兩個問題：

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

 

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

 

 

 粘包的解決方案

　　解決方案（一）：

 　　　　問題的根源在於，接收端不知道發送端將要傳送的字節流的長度，所以解決粘包的方法就是圍繞，如何讓發送端在發送數據前，把自己將要發送的字節流總大小讓接收端知曉，然后接收端發一個確認消息給發送端，然后發送端再發送過來后面的真實內容，接收端再來一個死循環接收完所有數據。

 　　　　

　　　　看代碼示例：

　　　　　　server端代碼　

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:break res=subprocess.Popen(msg.decode('utf-8'),shell=True,\ stdin=subprocess.PIPE,\ stderr=subprocess.PIPE,\ stdout=subprocess.PIPE) err=res.stderr.read() if err: ret=err else: 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.py

　　　　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:continue
    if msg == 'quit':break s.send(msg.encode('utf-8')) length=int(s.recv(1024).decode('utf-8')) s.send('recv_ready'.encode('utf-8')) send_size=0 recv_size=0 data=b''
    while recv_size < length: data+=s.recv(1024) recv_size+=len(data) print(data.decode('utf-8')) tcp_server.py

解決方案（二）：

　　　　通過struck模塊將需要發送的內容的長度進行打包，打包成一個4字節長度的數據發送到對端，對端只要取出前4個字節，然后對這四個字節的數據進行解包，拿到你要發送的內容的長度，然后通過這個長度來繼續接收我們實際要發送的內容。不是很好理解是吧？哈哈，沒關系，看下面的解釋~~

 　　　   為什么要說一下這個模塊呢，因為解決方案（一）里面你發現，我每次要先發送一個我的內容的長度，需要接收端接收，並切需要接收端返回一個確認消息，我發送端才能發后面真實的內容，這樣是為了保證數據可靠性，也就是接收雙方能順利溝通，但是多了一次發送接收的過程，為了減少這個過程，我們就要使struck來發送你需要發送的數據的長度，來解決上面我們所說的通過發送內容長度來解決粘包的問題。

　　　　關於struck的介紹：

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

　　　　

　　　　struck模塊的使用：struct模塊中最重要的兩個函數是pack()打包, unpack()解包。

 

　　　　

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

import struct a=12
# 將a變為二進制
bytes=struct.pack('i',a) ------------------------------------------------------------------------------- struct.pack('i',1111111111111) 如果int類型數據太大會報錯struck.error struct.error: 'i' format requires -2147483648 <= number <= 2147483647 #這個是范圍

 

pack方法圖解：

　　　　　　

 

　　　　unpack()：

# 注意，unpack返回的是tuple !!
 a,=struct.unpack('i',bytes) #將bytes類型的數據解包后，拿到int類型數據

 

好，到這里我們將struck這個模塊將int類型的數據打包成四個字節的方法了，那么我們就來使用它解決粘包吧。

　　先看一段偽代碼示例：

import json,struct #假設通過客戶端上傳1T:1073741824000的文件a.txt

#為避免粘包,必須自定制報頭
header={'file_size':1073741824000,'file_name':'/a/b/c/d/e/a.txt','md5':'8f6fbf8347faa4924a76856701edb0f3'} #1T數據,文件路徑和md5值

#為了該報頭能傳送,需要序列化並且轉為bytes，因為bytes只能將字符串類型的數據轉換為bytes類型的，所有需要先序列化一下這個字典，字典不能直接轉化為bytes
head_bytes=bytes(json.dumps(header),encoding='utf-8') #序列化並轉成bytes,用於傳輸

#為了讓客戶端知道報頭的長度,用struck將報頭長度這個數字轉成固定長度:4個字節
head_len_bytes=struct.pack('i',len(head_bytes)) #這4個字節里只包含了一個數字,該數字是報頭的長度

#客戶端開始發送
conn.send(head_len_bytes) #先發報頭的長度,4個bytes
conn.send(head_bytes) #再發報頭的字節格式
conn.sendall(文件內容) #然后發真實內容的字節格式

#服務端開始接收
head_len_bytes=s.recv(4) #先收報頭4個bytes,得到報頭長度的字節格式
x=struct.unpack('i',head_len_bytes)[0] #提取報頭的長度
 head_bytes=s.recv(x) #按照報頭長度x,收取報頭的bytes格式
header=json.loads(json.dumps(header)) #提取報頭

#最后根據報頭的內容提取真實的數據,比如
real_data_len=s.recv(header['file_size']) s.recv(real_data_len) 偽代碼（含解釋）

下面看正式的代碼：

　　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:break
        print('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=err else: back_msg=res.stdout.read() conn.send(struct.pack('i',len(back_msg))) #先發back_msg的長度
        conn.sendall(back_msg) #在發真實的內容
        #其實就是連續的將長度和內容一起發出去，那么整個內容的前4個字節就是我們打包的后面內容的長度，對吧
 conn.close( tcp_server.py（自定制報頭）

　　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:continue
    if msg == 'quit':break s.send(msg.encode('utf-8'))  #發送給一個指令
    l=s.recv(4)     #先接收4個字節的數據，因為我們將要發送過來的內容打包成了4個字節，所以先取出4個字節
    x=struct.unpack('i',l)[0]  #解包，是一個元祖，第一個元素就是我們的內容的長度
    print(type(x),x) # print(struct.unpack('I',l))
    r_s=0 data=b''
    while r_s < x:    #根據內容的長度來繼續接收4個字節后面的內容。
        r_d=s.recv(1024) data+=r_d r_s+=len(r_d) # print(data.decode('utf-8'))
    print(data.decode('gbk')) #windows默認gbk編碼
 tcp_client.py（自定制報頭）

 

 

復雜一些的代碼示例

　　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:break
        print('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=err else: 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))) #先發報頭的長度
        conn.send(head_json_bytes) #再發報頭
        conn.sendall(back_msg) #在發真實的內容
 conn.close() tcp_server.py

　　client端：

from socket import *
import struct,json ip_port=('127.0.0.1',8080) client=socket(AF_INET,SOCK_STREAM) client.connect(ip_port) while True: cmd=input('>>: ') if not cmd:continue client.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=0 recv_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默認gbk編碼
 tcp_client.py

 

其實上面復雜的代碼做了個什么事情呢，就是自定制了報頭：

　　

　你為啥多次send啊，其實多次send和將數據拼接起來send一次是一樣的，因為我們約定好了，你接收的時候先接收4個字節，然后再接收后面的內容。

整個流程的大致解釋：
我們可以把報頭做成字典，字典里包含將要發送的真實數據的描述信息(大小啊之類的)，然后json序列化，然后用struck將序列化后的數據長度打包成4個字節。
我們在網絡上傳輸的所有數據 都叫做數據包，數據包里的所有數據都叫做報文，報文里面不止有你的數據，還有ip地址、mac地址、端口號等等，其實所有的報文都有報頭，這個報頭是協議規定的，看一下

發送時：
先發報頭長度
再編碼報頭內容然后發送
最后發真實內容

接收時：
先手報頭長度，用struct取出來
根據取出的長度收取報頭內容，然后解碼，反序列化
從反序列化的結果中取出待取數據的描述信息，然后去取真實的數據內容

 

FTP上傳下載文件的代碼（簡易版）

import socket import struct import json sk = socket.socket() # buffer = 4096 # 當雙方的這個接收發送的大小比較大的時候，就像這個4096，就會丟數據，這個等我查一下再告訴大家，改小了就ok的，在linux上也是ok的。
buffer = 1024 #每次接收數據的大小
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: #>=是因為如果剛好等於的情況出現也是可以的。
            content = conn.recv(buffer) f.write(content) filesize -= buffer else: content = conn.recv(buffer) f.write(content) break conn.close() sk.close() tcp_server.py

 

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) #字典轉換成字符串
json_head = json.dumps(head)  #字典轉換成字符串
bytes_head = json_head.encode('utf-8') #字符串轉換成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) #先發送報頭長度
sk.send(bytes_head) #再發送bytes類型的報頭

#即便是視頻文件，也是可以按行來讀取的，也可以readline，也可以for循環，但是讀取出來的數據大小就不固定了，影響效率，有可能讀的比較小，也可能很大，像視頻文件一般都是一行的二進制字節流。 #所有我們可以用read，設定一個一次讀取內容的大小，一邊讀一邊發，一邊收一邊寫
with open(file_path,'rb') as f: while filesize: if filesize >= buffer: #>=是因為如果剛好等於的情況出現也是可以的。
            content = f.read(buffer) #每次讀取出來的內容
 sk.send(content) filesize -= buffer #每次減去讀取的大小
        else: #那么說明剩余的不夠一次讀取的大小了，那么只要把剩下的讀取出來發送過去就行了
            content = f.read(filesize) sk.send(content) break sk.close() tcp_client.py

 

 

FTP上傳下載文件的代碼（升級版）(注：咱們學完網絡編程就留FTP作業，這個代碼可以參考，當你用函數的方式寫完之后，再用面向對象進行改版卻沒有思路的時候再來看，別騙自己昂~~)

 

import socket import struct import json import subprocess import os class MYTCPServer: address_family = socket.AF_INET socket_type = socket.SOCK_STREAM allow_reuse_address = False max_packet_size = 8192 coding='utf-8' request_queue_size = 5 server_dir='file_upload'

    def __init__(self, server_address, bind_and_activate=True): """Constructor. May be extended, do not override.""" self.server_address=server_address self.socket = socket.socket(self.address_family, self.socket_type) if bind_and_activate: try: self.server_bind() self.server_activate() except: self.server_close() raise

    def server_bind(self): """Called by constructor to bind the socket. """
        if self.allow_reuse_address: self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self.socket.bind(self.server_address) self.server_address = self.socket.getsockname() def server_activate(self): """Called by constructor to activate the server. """ self.socket.listen(self.request_queue_size) def server_close(self): """Called to clean-up the server. """ self.socket.close() def get_request(self): """Get the request and client address from the socket. """
        return self.socket.accept() def close_request(self, request): """Called to clean up an individual request.""" request.close() def run(self): while True: self.conn,self.client_addr=self.get_request() print('from client ',self.client_addr) while True: try: head_struct = self.conn.recv(4) if not head_struct:break head_len = struct.unpack('i', head_struct)[0] head_json = self.conn.recv(head_len).decode(self.coding) head_dic = json.loads(head_json) print(head_dic) #head_dic={'cmd':'put','filename':'a.txt','filesize':123123}
                    cmd=head_dic['cmd'] if hasattr(self,cmd): func=getattr(self,cmd) func(head_dic) except Exception: break

    def put(self,args): file_path=os.path.normpath(os.path.join( self.server_dir, args['filename'] )) filesize=args['filesize'] recv_size=0 print('----->',file_path) with open(file_path,'wb') as f: while recv_size < filesize: recv_data=self.conn.recv(self.max_packet_size) f.write(recv_data) recv_size+=len(recv_data) print('recvsize:%s filesize:%s' %(recv_size,filesize)) tcpserver1=MYTCPServer(('127.0.0.1',8080)) tcpserver1.run() server.py

 

import socket import struct import json import os class MYTCPClient: address_family = socket.AF_INET socket_type = socket.SOCK_STREAM allow_reuse_address = False max_packet_size = 8192 coding='utf-8' request_queue_size = 5

    def __init__(self, server_address, connect=True): self.server_address=server_address self.socket = socket.socket(self.address_family, self.socket_type) if connect: try: self.client_connect() except: self.client_close() raise

    def client_connect(self): self.socket.connect(self.server_address) def client_close(self): self.socket.close() def run(self): while True: inp=input(">>: ").strip() if not inp:continue l=inp.split() cmd=l[0] if hasattr(self,cmd): func=getattr(self,cmd) func(l) def put(self,args): cmd=args[0] filename=args[1] if not os.path.isfile(filename): print('file:%s is not exists' %filename) return
        else: filesize=os.path.getsize(filename) head_dic={'cmd':cmd,'filename':os.path.basename(filename),'filesize':filesize} print(head_dic) head_json=json.dumps(head_dic) head_json_bytes=bytes(head_json,encoding=self.coding) head_struct=struct.pack('i',len(head_json_bytes)) self.socket.send(head_struct) self.socket.send(head_json_bytes) send_size=0 with open(filename,'rb') as f: for line in f: self.socket.send(line) send_size+=len(line) print(send_size) else: print('upload successful') client=MYTCPClient(('127.0.0.1',8080)) client.run() client.py