第 9 章 網絡編程

1、客戶端/服務器架構

一、硬件C/S架構（打印機）

二、軟件C/S架構

        互聯網中到處是C/S架構

        如網站是服務端，瀏覽器是客戶端（B/S架構也是C/S架構的一種）

        騰訊做爲服務端提供視頻，得下載個騰訊視頻客戶端才能看它的視頻。

        C/S 架構與socket 的關係：

        socket就是爲了完成C/S架構的開發

2、OSI 七層

須知一個完整的計算機系統是由硬件，操做系統，應用軟件三者組成，具有了這個三個條件，一臺計算機系統就能夠本身跟本身玩了（打個單機遊戲，玩個掃雷）

若是要跟別人一塊兒玩，那就須要鏈接互聯網。

互聯網的核心就是由一堆協議組成，協議就是標準，好比全世界人通訊的標準是英語

若是把計算機比做人，互聯網協議就是計算機界的英語，全部的計算機都學會了互聯網協議，那全部的計算機均可以按照統一的標準去收發信息從而完成通訊了。

人們按照分工不一樣把互聯網協議從邏輯上劃分了層級

詳見網絡通訊原理：http://www.cnblogs.com/linhaifeng/articles/5937962.html

 學習socket必定要先學習互聯網協議：

一、首先：基於socket編程，就是基於socket來開發一款本身的C/S架構軟件

二、其次：C/S架構的軟件（軟件屬於應用層）是基於網絡進行通訊的

三、而後：網絡的核心即一堆協議，協議即標準，想開發一款基於網絡通訊的軟件，就必須遵循這些標準。

四、最後：就讓咱們從這些標準開始研究，開啓socket編程之旅。

3、socket層

在上圖中，沒有看到socket的影子，那麼它到底在哪裏呢？仍是用圖來講話，一目瞭然。

4、socket是什麼

socket是應用層與TCP/IP協議族通訊的中間軟件抽象層，它是一組接口，在設計模式中，socket其實就是一個門面模式，它把複雜的TCP/IP協議族隱藏在socket接口後面，對用戶來講，一組簡單的接口就是所有，讓socket去組織數據，以符合指定的協議。

因此，咱們無需深刻理解tcp/udp協議，socket已經爲咱們封裝好了，咱們只須要遵循socket的規定去編程，寫出的程序天然就是遵循tcp/udp標準的。

也有人將socket說成ip+port，ip是用來標識互聯網中的一臺主機的位置，而port是用來標識這臺機器上的一個應用程序，ip地址是配置到網卡上的，而port是應用程序開啓的，ip與port的綁定就標識了互聯網中獨一無二的一個應用程序

而程序的pid是同一臺機器上不一樣進程或者線程的標識

socket通俗解釋

5、套接字發展史及分類

套接字起源於20世紀70年代加利福尼亞大學伯克利分校版本的unix。即人們所說的BSD unix，所以，有時人們也把套接字稱爲「伯克利套接字」或「BSD套接字」。一開始，套接字被設計用在同一臺主機上多個應用程序之間的通信，這也被稱爲進程間通信或IPC，套接字有兩種（或者稱爲有兩個種族），分別是基於文件型的和基於網絡型的。

基於文件類型的套接字家族

套接字家族的名字：AF_UNIX

unlx一切皆文件，基於文件的套接字調用的就是底層的文件系統來取數據，兩個套接字進程運行在同一機器，能夠經過訪問同一個文件系統間接完成通訊。

基於網絡類型的套接字家族

套接字家族的名字：AF_INET

(還有AF_INET6被用於ipv6，還有一些其餘的地址家族，不過，他們要麼是隻用與某個平臺，要麼就是已經被廢棄，或者是不多被使用，或者因爲咱們只關心網絡編程，因此大部分時候咱們只使用AF_INET)

6、套接字工做流程

一個生活中的場景。你要打電話給你一個朋友，先撥號，朋友聽到電話鈴聲後提起電話，這時你和你的朋友就創建起了鏈接，就能夠講話了，等交流結束，掛斷電話結束這次交談，生活中場景就解釋了這個工做原理。

 

先從服務器端提及，服務器端先初始化socket，而後與端口綁定（bind）,對端口進行監聽（listen），調用accept阻塞，等待客戶端鏈接，在這時若是有個客戶端初始化一個socket，而後鏈接服務器（connect），若是鏈接成功，這時客戶端與服務器端的鏈接就創建了，客戶端發生數據請求，服務器端接收請求並處理請求，而後把迴應數據發送給客戶端，客戶端讀取數據，最後關閉鏈接，一次交互結束socket（）模塊函數用法

 1 import socket
 2 socket.socket(socket_family,socket_type,protocal=0)
 3 socket_family 能夠是 AF_UNIX 或 AF_INET。socket_type 能夠是 SOCK_STREAM 或 SOCK_DGRAM。protocol 通常不填,默認值爲 0。
 4 
 5 獲取tcp/ip套接字
 6 tcpSock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 7 
 8 獲取udp/ip套接字
 9 udpSock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
10 
11 因爲 socket 模塊中有太多的屬性。咱們在這裏破例使用了'from module import *'語句。使用 'from socket import *',咱們就把 socket 模塊裏的全部屬性都帶到咱們的命名空間裏了,這樣能 大幅減短咱們的代碼。
12 例如tcpSock = socket(AF_INET, SOCK_STREAM)

服務端套接字函數

s.bind()  綁定（主機，端口號）到套接字

s.listen() 開始TCP監聽

s.accept() 被動接受tcp客戶的鏈接，（阻塞式）等待鏈接的到來

 

客戶端套接字函數

s.connect()  主動初始化tcp服務器鏈接

s.connet_ex()  connect（）函數的擴展版本，出錯是返回錯誤碼。而不是拋出異常

 

公共用途的套接字函數

s.recv()       接收tcp數據

s.send()  發送tcp數據（send 在待發送數據量大於己端緩存區剩餘空間時，數據丟失，不會發完）

s.sendall()  發送完整的tcp數據（本質就是循環調用send，sendall在待發送數據量大於己端緩存區剩餘空間時，數據不丟失，循環調用send直到發完）

s.recvfrom()  接收udp數據

s.sendto()     發送udp數據

s.getpeername()  鏈接當前套接字的遠端的地址

s.getsockename() 當前套接字的地址

s.getsockopt()     返回指定套接字的參數

s.setsockopt()     設置指定套接字的參數

s.close()              關閉套接字

 

面向鎖的套接字方法

s.setblocking()    設置套接字的阻塞與非阻塞模式

s.settimeout()     設置套接字操做的超時時間

s.gettimeout()     獲得阻塞套接字操做的超時時間

 

面向文件的套接字的函數

s.fileno()        套接字的文件描述

s.makefile()   建立一個與該套接字相關的文件

 

 1 1：用打電話的流程快速描述socket通訊
 2 2：服務端和客戶端加上基於一次連接的循環通訊
 3 3：客戶端發送空，卡主，證實是從哪一個位置卡的
 4 服務端：
 5 from socket import *
 6 phone=socket(AF_INET,SOCK_STREAM)
 7 phone.bind(('127.0.0.1',8081))
 8 phone.listen(5)
 9 
10 conn,addr=phone.accept()
11 while True:
12     data=conn.recv(1024)
13     print('server===>')
14     print(data)
15     conn.send(data.upper())
16 conn.close()
17 phone.close()
18 客戶端：
19 from socket import *
20 
21 phone=socket(AF_INET,SOCK_STREAM)
22 phone.connect(('127.0.0.1',8081))
23 
24 while True:
25     msg=input('>>: ').strip()
26     phone.send(msg.encode('utf-8'))
27     print('client====>')
28     data=phone.recv(1024)
29     print(data)
30 
31 說明卡的緣由：緩衝區爲空recv就卡住，引出原理圖
32 
33 
34 
35 4.演示客戶端斷開連接，服務端的狀況，提供解決方法
36 
37 5.演示服務端不能重複接受連接，而服務器都是正常運行不斷來接受客戶連接的
38 
39 6:簡單演示udp
40 服務端
41 from socket import *
42 phone=socket(AF_INET,SOCK_DGRAM)
43 phone.bind(('127.0.0.1',8082))
44 while True:
45     msg,addr=phone.recvfrom(1024)
46     phone.sendto(msg.upper(),addr)
47 客戶端
48 from socket import *
49 phone=socket(AF_INET,SOCK_DGRAM)
50 while True:
51     msg=input('>>: ')
52     phone.sendto(msg.encode('utf-8'),('127.0.0.1',8082))
53     msg,addr=phone.recvfrom(1024)
54     print(msg)
55 
56 udp客戶端能夠併發演示
57 udp客戶端能夠輸入爲空演示，說出recvfrom與recv的區別，暫且不提tcp流和udp報的概念

socket實驗推演流程

7、基於tcp的套接字

tcp是基於連接的，必須先啓動服務端，而後再啓動客戶端去連接服務端

tcp服務端

1 ss = socket() #建立服務器套接字
2 ss.bind()      #把地址綁定到套接字
3 ss.listen()      #監聽連接
4 inf_loop:      #服務器無限循環
5     cs = ss.accept() #接受客戶端連接
6     comm_loop:         #通信循環
7         cs.recv()/cs.send() #對話(接收與發送)
8     cs.close()    #關閉客戶端套接字
9 ss.close()        #關閉服務器套接字(可選)

tcp客戶端

1 cs = socket()    # 建立客戶套接字
2 cs.connect()    # 嘗試鏈接服務器
3 comm_loop:        # 通信循環
4      cs.send()/cs.recv()    # 對話(發送/接收)
5 cs.close()            # 關閉客戶套接字

socket通訊流程與打電話流程相似，就以打電話爲例來實現一個low版的套接字通訊

 1 import socket
 2 #買手機
 3 phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
 4 #插卡
 5 phone.bind(('127.0.0.1',8080))
 6 #開機
 7 phone.listen(5)
 8 #等電話連接
 9 print('server start...')
10 conn,client_addr=phone.accept() #(tcp連接,client_addr)
11 print('連接',conn)
12 print(client_addr)
13 
14 #基於創建的連接，收發消息
15 client_data=conn.recv(1024)
16 print('客戶端的消息',client_data)
17 conn.send(client_data.upper())
18 
19 #掛電話連接
20 conn.close()
21 
22 #關機
23 phone.close()

服務端

 1 import socket
 2 phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
 3 phone.connect(('127.0.0.1',8080))
 4 
 5 
 6 phone.send('hello'.encode('utf-8'))
 7 server_data=phone.recv(1024)
 8 print('服務端迴應的消息',server_data)
 9 
10 phone.close()

客戶端

加上連接循環與通訊循環

 1 #買手機
 2 import socket
 3 phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
 4 
 5 #插卡
 6 phone.bind(('127.0.0.1',8080))
 7 
 8 
 9 #開機
10 phone.listen(5)
11 
12 
13 #等待電話
14 while True:  #連接循環
15     print('sever start....')
16     conn,client_addr=phone.accept()
17     print('連接',conn)
18     print(client_addr)
19 
20     #基於創建連接，進行收發信息
21     while True: #通信循環
22         try:  #針對windows 系統
23             client_data=conn.recv(1024)
24             if not client_data:break  #針對linux系統
25             print(client_data)
26             conn.send(client_data.upper())
27         except Exception:
28               break
29 
30     #掛斷電話連接
31     conn.close()
32 
33 #關機
34 phone.close()

服務端

 1 #買電話
 2 import socket
 3 phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
 4 
 5 phone.connect(('127.0.0.1',8080))
 6 
 7 
 8 while True:
 9     msg=input('>>：').strip()
10     if msg == '':continue
11     phone.send(msg.encode('utf-8'))
12     server_data=phone.recv(1024)
13     print(server_data.decode('utf-8'))
14 
15 phone.close()

客戶端

問題：

在重啓服務端時可能會遇到

這個是因爲服務端仍然存在四次會瘦的time_wait狀態在佔用地址（若是不懂，請深刻研究1.tcp上次握手，四次揮手，以及tcp/ip的12種有機狀態 2.syn洪水攻擊 3.服務器高併發狀況下會有大量的time_wait狀態的優化方法）

解決方法：

1 #加入一條socket配置，重用ip和端口
2 
3 phone=socket(AF_INET,SOCK_STREAM)
4 phone.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #就是它，在bind前加
5 phone.bind(('127.0.0.1',8080))

方法一

 1 發現系統存在大量TIME_WAIT狀態的鏈接，經過調整linux內核參數解決，
 2 vi /etc/sysctl.conf
 3 
 4 編輯文件，加入如下內容：
 5 net.ipv4.tcp_syncookies = 1
 6 net.ipv4.tcp_tw_reuse = 1
 7 net.ipv4.tcp_tw_recycle = 1
 8 net.ipv4.tcp_fin_timeout = 30
 9  
10 而後執行 /sbin/sysctl -p 讓參數生效。
11  
12 net.ipv4.tcp_syncookies = 1 表示開啓SYN Cookies。當出現SYN等待隊列溢出時，啓用cookies來處理，可防範少許SYN攻擊，默認爲0，表示關閉；
13 
14 net.ipv4.tcp_tw_reuse = 1 表示開啓重用。容許將TIME-WAIT sockets從新用於新的TCP鏈接，默認爲0，表示關閉；
15 
16 net.ipv4.tcp_tw_recycle = 1 表示開啓TCP鏈接中TIME-WAIT sockets的快速回收，默認爲0，表示關閉。
17 
18 net.ipv4.tcp_fin_timeout 修改系統默認的 TIMEOUT 時間
19 
20 方法二

方法二

基於udp的套接字

udp是無連接的，先啓動哪一端都不會報錯

udp服務端

1 ss = socket()   #建立一個服務器的套接字
2 ss.bind()       #綁定服務器套接字
3 inf_loop:       #服務器無限循環
4     cs = ss.recvfrom()/ss.sendto() # 對話(接收與發送)
5 ss.close()                         # 關閉服務器套接字

udp客戶端

1 cs = socket()   # 建立客戶套接字
2 comm_loop:      # 通信循環
3     cs.sendto()/cs.recvfrom()   # 對話(發送/接收)
4 cs.close()                      # 關閉客戶套接字

udp套接字簡單示例

 1 #_*_coding:utf-8_*_
 2 __author__ = 'Linhaifeng'
 3 import socket
 4 ip_port=('127.0.0.1',9000)
 5 BUFSIZE=1024
 6 udp_server_client=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
 7 
 8 udp_server_client.bind(ip_port)
 9 
10 while True:
11     msg,addr=udp_server_client.recvfrom(BUFSIZE)
12     print(msg,addr)
13 
14     udp_server_client.sendto(msg.upper(),addr)
15 
16 udp服務端

udp服務端

 1 #_*_coding:utf-8_*_
 2 __author__ = 'Linhaifeng'
 3 import socket
 4 ip_port=('127.0.0.1',9000)
 5 BUFSIZE=1024
 6 udp_server_client=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
 7 
 8 while True:
 9     msg=input('>>: ').strip()
10     if not msg:continue
11 
12     udp_server_client.sendto(msg.encode('utf-8'),ip_port)
13 
14     back_msg,addr=udp_server_client.recvfrom(BUFSIZE)
15     print(back_msg.decode('utf-8'),addr)
16 
17 udp客戶端

udp客戶端

QQ聊天（因爲udp無鏈接，因此能夠同時多個客戶端跟服務端通訊）

 1 #_*_coding:utf-8_*_
 2 __author__ = 'Linhaifeng'
 3 import socket
 4 ip_port=('127.0.0.1',8081)
 5 udp_server_sock=socket.socket(socket.AF_INET,socket.SOCK_DGRAM) #買手機
 6 udp_server_sock.bind(ip_port)
 7 
 8 while True:
 9     qq_msg,addr=udp_server_sock.recvfrom(1024)
10     print('來自[%s:%s]的一條消息:\033[1;44m%s\033[0m' %(addr[0],addr[1],qq_msg.decode('utf-8')))
11     back_msg=input('回覆消息: ').strip()
12 
13     udp_server_sock.sendto(back_msg.encode('utf-8'),addr)
14 
15 udp服務端

udp服務端

 1 #_*_coding:utf-8_*_
 2 __author__ = 'Linhaifeng'
 3 import socket
 4 BUFSIZE=1024
 5 udp_client_socket=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
 6 
 7 qq_name_dic={
 8     '狗哥alex':('127.0.0.1',8081),
 9     '瞎驢':('127.0.0.1',8081),
10     '一棵樹':('127.0.0.1',8081),
11     '武大郎':('127.0.0.1',8081),
12 }
13 
14 
15 while True:
16     qq_name=input('請選擇聊天對象: ').strip()
17     while True:
18         msg=input('請輸入消息,回車發送: ').strip()
19         if msg == 'quit':break
20         if not msg or not qq_name or qq_name not in qq_name_dic:continue
21         udp_client_socket.sendto(msg.encode('utf-8'),qq_name_dic[qq_name])
22 
23         back_msg,addr=udp_client_socket.recvfrom(BUFSIZE)
24         print('來自[%s:%s]的一條消息:\033[1;44m%s\033[0m' %(addr[0],addr[1],back_msg.decode('utf-8')))
25 
26 udp_client_socket.close()
27 
28 udp客戶端1

udp客戶端1

 1 #_*_coding:utf-8_*_
 2 __author__ = 'Linhaifeng'
 3 import socket
 4 BUFSIZE=1024
 5 udp_client_socket=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
 6 
 7 qq_name_dic={
 8     '狗哥alex':('127.0.0.1',8081),
 9     '瞎驢':('127.0.0.1',8081),
10     '一棵樹':('127.0.0.1',8081),
11     '武大郎':('127.0.0.1',8081),
12 }
13 
14 
15 while True:
16     qq_name=input('請選擇聊天對象: ').strip()
17     while True:
18         msg=input('請輸入消息,回車發送: ').strip()
19         if msg == 'quit':break
20         if not msg or not qq_name or qq_name not in qq_name_dic:continue
21         udp_client_socket.sendto(msg.encode('utf-8'),qq_name_dic[qq_name])
22 
23         back_msg,addr=udp_client_socket.recvfrom(BUFSIZE)
24         print('來自[%s:%s]的一條消息:\033[1;44m%s\033[0m' %(addr[0],addr[1],back_msg.decode('utf-8')))
25 
26 udp_client_socket.close()
27 
28 udp客戶端2

udp客戶端2

服務端運行結果

客戶端1運行結果

客戶端2運行結果

時間服務器

 1 #_*_coding:utf-8_*_
 2 __author__ = 'Linhaifeng'
 3 from socket import *
 4 from time import strftime
 5 
 6 ip_port=('127.0.0.1',9000)
 7 bufsize=1024
 8 
 9 tcp_server=socket(AF_INET,SOCK_DGRAM)
10 tcp_server.bind(ip_port)
11 
12 while True:
13     msg,addr=tcp_server.recvfrom(bufsize)
14     print('===>',msg)
15     
16     if not msg:
17         time_fmt='%Y-%m-%d %X'
18     else:
19         time_fmt=msg.decode('utf-8')
20     back_msg=strftime(time_fmt)
21 
22     tcp_server.sendto(back_msg.encode('utf-8'),addr)
23 
24 tcp_server.close()
25 
26 ntp服務端

ntp服務端

 1 #_*_coding:utf-8_*_
 2 __author__ = 'Linhaifeng'
 3 from socket import *
 4 ip_port=('127.0.0.1',9000)
 5 bufsize=1024
 6 
 7 tcp_client=socket(AF_INET,SOCK_DGRAM)
 8 
 9 
10 
11 while True:
12     msg=input('請輸入時間格式(例%Y %m %d)>>: ').strip()
13     tcp_client.sendto(msg.encode('utf-8'),ip_port)
14 
15     data=tcp_client.recv(bufsize)
16 
17     print(data.decode('utf-8'))
18 
19 tcp_client.close()
20 
21 ntp客戶端

ntp客戶端

8、粘包現象

讓我基於tcp先製做一個遠程執行命令的程序（1：執行錯誤命令，2：執行ls 3:執行ifconfig）

注意：

res=subprocess.Poen(cmd.decode('urf-8),

shell=True,

stderr=subprocess.PIPE,

stdout=subprocess.PIPE)

的結果的編碼是以當前所在的系統爲準的，若是是windows，那麼res.stdout.read()讀出的就是GBK編碼的，在接收端須要用GBK解碼

且只能從管道里讀出一次結果

注意：命令ls -l;lllll；pwd的結果是既有正確的stdout結果，又有錯誤stderr結果

 1 #_*_coding:utf-8_*_
 2 from socket import *
 3 import subprocess
 4 
 5 ip_port=('127.0.0.1',8080)
 6 BUFSIZE=1024
 7 
 8 tcp_socket_server=socket(AF_INET,SOCK_STREAM)
 9 tcp_socket_server.bind(ip_port)
10 tcp_socket_server.listen(5)
11 
12 while True:
13     conn,addr=tcp_socket_server.accept()
14     print('客戶端',addr)
15 
16     while True:
17         cmd=conn.recv(BUFSIZE)
18         if len(cmd) == 0:break
19 
20         res=subprocess.Popen(cmd.decode('utf-8'),shell=True,
21                          stdout=subprocess.PIPE,
22                          stdin=subprocess.PIPE,
23                          stderr=subprocess.PIPE)
24 
25         stderr=act_res.stderr.read()
26         stdout=act_res.stdout.read()
27         conn.send(stderr)
28         conn.send(stdout)
29 
30 服務端

服務端

 1 #_*_coding:utf-8_*_
 2 __author__ = 'Linhaifeng'
 3 import socket
 4 BUFSIZE=1024
 5 ip_port=('127.0.0.1',8080)
 6 
 7 s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
 8 res=s.connect_ex(ip_port)
 9 
10 while True:
11     msg=input('>>: ').strip()
12     if len(msg) == 0:continue
13     if msg == 'quit':break
14 
15     s.send(msg.encode('utf-8'))
16     act_res=s.recv(BUFSIZE)
17 
18     print(act_res.decode('utf-8'),end='')

客戶端

上述程序是基於tcp的socket，在運行時會發生粘包

讓咱們再基於udp製做一個遠程執行命令的程序

 1 #_*_coding:utf-8_*_
 2 __author__ = 'Linhaifeng'
 3 
 4 #_*_coding:utf-8_*_
 5 __author__ = 'Linhaifeng'
 6 from socket import *
 7 import subprocess
 8 
 9 ip_port=('127.0.0.1',9003)
10 bufsize=1024
11 
12 udp_server=socket(AF_INET,SOCK_DGRAM)
13 udp_server.bind(ip_port)
14 
15 while True:
16     #收消息
17     cmd,addr=udp_server.recvfrom(bufsize)
18     print('用戶命令----->',cmd)
19 
20     #邏輯處理
21     res=subprocess.Popen(cmd.decode('utf-8'),shell=True,stderr=subprocess.PIPE,stdin=subprocess.PIPE,stdout=subprocess.PIPE)
22     stderr=res.stderr.read()
23     stdout=res.stdout.read()
24 
25     #發消息
26     udp_server.sendto(stderr,addr)
27     udp_server.sendto(stdout,addr)
28 udp_server.close()
29 
30 服務端

服務端

 1 from socket import *
 2 ip_port=('127.0.0.1',9003)
 3 bufsize=1024
 4 
 5 udp_client=socket(AF_INET,SOCK_DGRAM)
 6 
 7 
 8 while True:
 9     msg=input('>>: ').strip()
10     udp_client.sendto(msg.encode('utf-8'),ip_port)
11 
12     data,addr=udp_client.recvfrom(bufsize)
13     print(data.decode('utf-8'),end='')
14 
15 客戶端

客戶端

上述程序是基於udp的socket，在運行時永遠不會發生粘包

 

9、什麼是粘包

須知：只有tcp有粘包現象，udp永遠不會粘包，爲什麼，首先須要掌握一個socket收發消息的原理。

 發送端能夠是1K-1k的發送數據，而接收端的應用程序能夠倆k倆k地提走數據，固然也有可能一次提走3K或者6k數據，或者一次只提走幾個字節的數據，也就是說，應用程序所看到的數據是一個總體，或說是一個流（stream），一條消息有多少字節對程序是不可見的，所以tcp協議是面向流的協議，這也是容易出現粘包問題的緣由，而UDP是面向消息的協議，每一個udp段都是一條消息，應用程序必須以消息爲單位提取數據，不能一次提取任意字節的數據，這一點和tcp是很不一樣的。怎樣定義消息呢？能夠認爲對方一次性write/send的數據爲一個消息，須要明白的是當對方send一條信息的時候，不管底層怎樣分段分片，tcp協議層會把構成整條消息的數據段排序完成後才呈如今內核緩衝區。

例如基於tcp的套接字客戶端往服務端上傳文件，發送時文件內容是按照一段一段的字節流送的，在接收方看了，根本不知道該文件的字節流從何處開始，在何處結束。

所謂粘包問題主要仍是由於接收方不知道消息之間的界限，不知道一次性提取多少字節的數據所形成的。

此外，發送方引發的粘包是由TCP協議自己形成的，TCP爲提升傳輸效率，發送方每每要收集到足夠多的數據後才發送一個TCP段。若連續幾回須要send的數據都不多，一般TCP會根據優化算法把這些數據合成一個TCP段後一次發送出去，這樣接收方就收到了粘包數據。

    TCP（transport control protocol，傳輸控制協議）是面向鏈接的，面向流的，提供高可靠性服務。收發兩端（客戶端和服務器端）都要有一一成對的socket，所以，發送端爲了將多個發往接收端的包，更有效的發到對方，使用了優化方法（Nagle算法），將屢次間隔較小且數據量小的數據，合併成一個大的數據塊，而後進行封包。這樣，接收端，就難於分辨出來了，必須提供科學的拆包機制。 即面向流的通訊是無消息保護邊界的。
    UDP（user datagram protocol，用戶數據報協議）是無鏈接的，面向消息的，提供高效率服務。不會使用塊的合併優化算法，, 因爲UDP支持的是一對多的模式，因此接收端的skbuff(套接字緩衝區）採用了鏈式結構來記錄每個到達的UDP包，在每一個UDP包中就有了消息頭（消息來源地址，端口等信息），這樣，對於接收端來講，就容易進行區分處理了。 即面向消息的通訊是有消息保護邊界的。
    tcp是基於數據流的，因而收發的消息不能爲空，這就須要在客戶端和服務端都添加空消息的處理機制，防止程序卡住，而udp是基於數據報的，即使是你輸入的是空內容（直接回車），那也不是空消息，udp協議會幫你封裝上消息頭，實驗略

udp的recvfrom是阻塞的，一個recvfrom(x)必須對惟一一個sendinto(y),收完了x個字節的數據就算完成,如果y>x數據就丟失，這意味着udp根本不會粘包，可是會丟數據，不可靠

tcp的協議數據不會丟，沒有收完包，下次接收，會繼續上次繼續接收，己端老是在收到ack時纔會清除緩衝區內容。數據是可靠的，可是會粘包。

拆包的發生狀況

當發送端緩存區的長度大於網卡的MTU時，tcp會將此次發送的數據拆成幾個數據包發送出去。

補充問題一：爲什麼tcp是可靠傳輸，udp是不可靠傳輸

基於tcp的數據傳輸請參考http://www.cnblogs.com/linhaifeng/articles/5937962.html，tcp在數據傳輸時，發送端先把數據發送到本身的緩存中，而後協議控制將緩存中的數據發送對端，對端返回一個ack+1，發送端則清理緩存中的數據，對端返回ack=0，則從新發送數據，因此tcp是可靠的

而udp發送數據，對端是不會返回確認信息的，所以不可靠

補充問題二：send（字節流）和recv(1024)及sendall

recv裏指定的1024意思是從緩存一次拿出1024個字節的數據

send的字節流是先放入己端緩存，而後由協議控制緩存內容發送對端，若是待發送的字節流大小大於緩存剩餘空間，那麼數據丟失，用sendall就會循環調用send，數據不會丟失

10、解決粘包的low比處理方法

問題的根源在於，接收端不知道發送端將要傳送的字節流的長度，因此解決粘包的方法就是圍繞，如何讓發送端在發送數據前，把本身將要發送的字節流大小總大小讓接收端知曉，而後接收端來一個死循環接收完全部數據。

low版本的解決方法

 1 #_*_coding:utf-8_*_
 2 __author__ = 'Linhaifeng'
 3 import socket,subprocess
 4 ip_port=('127.0.0.1',8080)
 5 s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
 6 s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
 7 
 8 s.bind(ip_port)
 9 s.listen(5)
10 
11 while True:
12     conn,addr=s.accept()
13     print('客戶端',addr)
14     while True:
15         msg=conn.recv(1024)
16         if not msg:break
17         res=subprocess.Popen(msg.decode('utf-8'),shell=True,\
18                             stdin=subprocess.PIPE,\
19                          stderr=subprocess.PIPE,\
20                          stdout=subprocess.PIPE)
21         err=res.stderr.read()
22         if err:
23             ret=err
24         else:
25             ret=res.stdout.read()
26         data_length=len(ret)
27         conn.send(str(data_length).encode('utf-8'))
28         data=conn.recv(1024).decode('utf-8')
29         if data == 'recv_ready':
30             conn.sendall(ret)
31     conn.close()
32 
33 服務端

服務端

 1 #_*_coding:utf-8_*_
 2 __author__ = 'Linhaifeng'
 3 import socket,time
 4 s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
 5 res=s.connect_ex(('127.0.0.1',8080))
 6 
 7 while True:
 8     msg=input('>>: ').strip()
 9     if len(msg) == 0:continue
10     if msg == 'quit':break
11 
12     s.send(msg.encode('utf-8'))
13     length=int(s.recv(1024).decode('utf-8'))
14     s.send('recv_ready'.encode('utf-8'))
15     send_size=0
16     recv_size=0
17     data=b''
18     while recv_size < length:
19         data+=s.recv(1024)
20         recv_size+=len(data)
21 
22 
23     print(data.decode('utf-8'))
24 
25 客戶端

客戶端

爲什麼low：

程序的運行速度快於網絡傳輸速度，因此在發送一段字節前，先用send去發送該字節流長度，這種方式會放大網絡延遲帶來的性能損耗。

11、解決粘包的方法

爲字節流加上自定義固定長度報頭，而後再取真實數據。

struct 模塊

該模塊能夠把一個類型，如數字，轉成固定長度的bytes

 

 1 import json,struct
 2 #假設經過客戶端上傳1T:1073741824000的文件a.txt
 3 
 4 #爲避免粘包,必須自定製報頭
 5 header={'file_size':1073741824000,'file_name':'/a/b/c/d/e/a.txt','md5':'8f6fbf8347faa4924a76856701edb0f3'} #1T數據,文件路徑和md5值
 6 
 7 #爲了該報頭能傳送,須要序列化而且轉爲bytes
 8 head_bytes=bytes(json.dumps(header),encoding='utf-8') #序列化並轉成bytes,用於傳輸
 9 
10 #爲了讓客戶端知道報頭的長度,用struck將報頭長度這個數字轉成固定長度:4個字節
11 head_len_bytes=struct.pack('i',len(head_bytes)) #這4個字節裏只包含了一個數字,該數字是報頭的長度
12 
13 #客戶端開始發送
14 conn.send(head_len_bytes) #先發報頭的長度,4個bytes
15 conn.send(head_bytes) #再發報頭的字節格式
16 conn.sendall(文件內容) #而後發真實內容的字節格式
17 
18 #服務端開始接收
19 head_len_bytes=s.recv(4) #先收報頭4個bytes,獲得報頭長度的字節格式
20 x=struct.unpack('i',head_len_bytes)[0] #提取報頭的長度
21 
22 head_bytes=s.recv(x) #按照報頭長度x,收取報頭的bytes格式
23 header=json.loads(json.dumps(header)) #提取報頭
24 
25 #最後根據報頭的內容提取真實的數據,好比
26 real_data_len=s.recv(header['file_size'])
27 s.recv(real_data_len)

 1 #_*_coding:utf-8_*_
 2 #http://www.cnblogs.com/coser/archive/2011/12/17/2291160.html
 3 __author__ = 'Linhaifeng'
 4 import struct
 5 import binascii
 6 import ctypes
 7 
 8 values1 = (1, 'abc'.encode('utf-8'), 2.7)
 9 values2 = ('defg'.encode('utf-8'),101)
10 s1 = struct.Struct('I3sf')
11 s2 = struct.Struct('4sI')
12 
13 print(s1.size,s2.size)
14 prebuffer=ctypes.create_string_buffer(s1.size+s2.size)
15 print('Before : ',binascii.hexlify(prebuffer))
16 # t=binascii.hexlify('asdfaf'.encode('utf-8'))
17 # print(t)
18 
19 
20 s1.pack_into(prebuffer,0,*values1)
21 s2.pack_into(prebuffer,s1.size,*values2)
22 
23 print('After pack',binascii.hexlify(prebuffer))
24 print(s1.unpack_from(prebuffer,0))
25 print(s2.unpack_from(prebuffer,s1.size))
26 
27 s3=struct.Struct('ii')
28 s3.pack_into(prebuffer,0,123,123)
29 print('After pack',binascii.hexlify(prebuffer))
30 print(s3.unpack_from(prebuffer,0))

關於struct的詳細用法

 1 phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) #就是它，在bind前加
 2 
 3 phone.bind(('127.0.0.1',8080))
 4 
 5 phone.listen(5)
 6 
 7 while True:
 8     conn,addr=phone.accept()
 9     while True:
10         cmd=conn.recv(1024)
11         if not cmd:break
12         print('cmd: %s' %cmd)
13 
14         res=subprocess.Popen(cmd.decode('utf-8'),
15                              shell=True,
16                              stdout=subprocess.PIPE,
17                              stderr=subprocess.PIPE)
18         err=res.stderr.read()
19         print(err)
20         if err:
21             back_msg=err
22         else:
23             back_msg=res.stdout.read()
24 
25 
26         conn.send(struct.pack('i',len(back_msg))) #先發back_msg的長度
27         conn.sendall(back_msg) #在發真實的內容
28 
29     conn.close()

服務端（自定製報頭）

 1 #_*_coding:utf-8_*_
 2 __author__ = 'Linhaifeng'
 3 import socket,time,struct
 4 
 5 s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
 6 res=s.connect_ex(('127.0.0.1',8080))
 7 
 8 while True:
 9     msg=input('>>: ').strip()
10     if len(msg) == 0:continue
11     if msg == 'quit':break
12 
13     s.send(msg.encode('utf-8'))
14 
15 
16 
17     l=s.recv(4)
18     x=struct.unpack('i',l)[0]
19     print(type(x),x)
20     # print(struct.unpack('I',l))
21     r_s=0
22     data=b''
23     while r_s < x:
24         r_d=s.recv(1024)
25         data+=r_d
26         r_s+=len(r_d)
27 
28     # print(data.decode('utf-8'))
29     print(data.decode('gbk')) #windows默認gbk編碼

客戶端（自定製報頭）

 能夠把報頭作成字典，字典裏包含將要發送的真實數據的詳細信息，而後json序列化後的數據長度打包成4個字節（4個足夠用了）

發送時：

先發報頭長度

再編碼報頭內容而後發送

最後發真實內容

 

接收時：

先收報頭長度，用struct取出來

根據取出報頭長度內容，而後解碼，反序列化

從反序列化的結果中取出待取數據的詳細信息，而後去取真實的數據內容

 1 import socket,struct,json
 2 import subprocess
 3 phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
 4 phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) #就是它，在bind前加
 5 
 6 phone.bind(('127.0.0.1',8080))
 7 
 8 phone.listen(5)
 9 
10 while True:
11     conn,addr=phone.accept()
12     while True:
13         cmd=conn.recv(1024)
14         if not cmd:break
15         print('cmd: %s' %cmd)
16 
17         res=subprocess.Popen(cmd.decode('utf-8'),
18                              shell=True,
19                              stdout=subprocess.PIPE,
20                              stderr=subprocess.PIPE)
21         err=res.stderr.read()
22         print(err)
23         if err:
24             back_msg=err
25         else:
26             back_msg=res.stdout.read()
27 
28         headers={'data_size':len(back_msg)}
29         head_json=json.dumps(headers)
30         head_json_bytes=bytes(head_json,encoding='utf-8')
31 
32         conn.send(struct.pack('i',len(head_json_bytes))) #先發報頭的長度
33         conn.send(head_json_bytes) #再發報頭
34         conn.sendall(back_msg) #在發真實的內容
35 
36     conn.close()

服務端：定製稍微複雜一點的報頭

 1 from socket import *
 2 import struct,json
 3 
 4 ip_port=('127.0.0.1',8080)
 5 client=socket(AF_INET,SOCK_STREAM)
 6 client.connect(ip_port)
 7 
 8 while True:
 9     cmd=input('>>: ')
10     if not cmd:continue
11     client.send(bytes(cmd,encoding='utf-8'))
12 
13     head=client.recv(4)
14     head_json_len=struct.unpack('i',head)[0]
15     head_json=json.loads(client.recv(head_json_len).decode('utf-8'))
16     data_len=head_json['data_size']
17 
18     recv_size=0
19     recv_data=b''
20     while recv_size < data_len:
21         recv_data+=client.recv(1024)
22         recv_size+=len(recv_data)
23 
24     print(recv_data.decode('utf-8'))
25     #print(recv_data.decode('gbk')) #windows默認gbk編碼

客戶端

12、socketserver實現併發

基於tcp的套接字，關鍵就是兩個循環，一個連接循環，一個通訊循環

socketserver模塊中分兩大類：server類（解決連接問題）和request類（解決通訊問題）

server類：

request類：

繼承關係：

如下述代碼爲例，分析socketserver源碼：

ftpserver=socketserver.ThreadingTCPServer(('127.0.0.1',8080),FtpServer)
ftpserver.serve_forever()

查找屬性的順序：ThreadingTCPServer->ThreadingMixIn->TCPServer->BaseServer

    1、實例化獲得ftpserver，先找類ThreadingTCPServer的__init__,在TCPServer中找到，進而執行server_bind,server_active
    2、找ftpserver下的serve_forever,在BaseServer中找到，進而執行self._handle_request_noblock()，該方法一樣是在BaseServer中
    三、執行self._handle_request_noblock()進而執行request, client_address = self.get_request()（就是TCPServer中的self.socket.accept()），而後執行self.process_request(request, client_address)
   /4、在ThreadingMixIn中找到process_request，開啓多線程應對併發，進而執行process_request_thread，執行self.finish_request(request, client_address)
    上述四部分完成了連接循環，本部分開始進入處理通信部分，在BaseServer中找到finish_request,觸發咱們本身定義的類的實例化，去找__init__方法，而咱們本身定義的類沒有該方法，則去它的父類也就是BaseRequestHandler中找....

源碼分析總結：

基於tcp的socketserver咱們本身定義的類中的

    　 1、self.server即套接字對象
    　 2、self.request即一個連接
    　 3、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即客戶端地址

 1 import socketserver
 2 import struct
 3 import json
 4 import os
 5 class FtpServer(socketserver.BaseRequestHandler):
 6     coding='utf-8'
 7     server_dir='file_upload'
 8     max_packet_size=1024
 9     BASE_DIR=os.path.dirname(os.path.abspath(__file__))
10     def handle(self):
11         print(self.request)
12         while True:
13             data=self.request.recv(4)
14             data_len=struct.unpack('i',data)[0]
15             head_json=self.request.recv(data_len).decode(self.coding)
16             head_dic=json.loads(head_json)
17             # print(head_dic)
18             cmd=head_dic['cmd']
19             if hasattr(self,cmd):
20                 func=getattr(self,cmd)
21                 func(head_dic)
22     def put(self,args):
23         file_path = os.path.normpath(os.path.join(
24             self.BASE_DIR,
25             self.server_dir,
26             args['filename']
27         ))
28 
29         filesize = args['filesize']
30         recv_size = 0
31         print('----->', file_path)
32         with open(file_path, 'wb') as f:
33             while recv_size < filesize:
34                 recv_data = self.request.recv(self.max_packet_size)
35                 f.write(recv_data)
36                 recv_size += len(recv_data)
37                 print('recvsize:%s filesize:%s' % (recv_size, filesize))
38 
39 
40 ftpserver=socketserver.ThreadingTCPServer(('127.0.0.1',8080),FtpServer)
41 ftpserver.serve_forever()

FtpServer

 1 import socket
 2 import struct
 3 import json
 4 import os
 5 
 6 
 7 
 8 class MYTCPClient:
 9     address_family = socket.AF_INET
10 
11     socket_type = socket.SOCK_STREAM
12 
13     allow_reuse_address = False
14 
15     max_packet_size = 8192
16 
17     coding='utf-8'
18 
19     request_queue_size = 5
20 
21     def __init__(self, server_address, connect=True):
22         self.server_address=server_address
23         self.socket = socket.socket(self.address_family,
24                                     self.socket_type)
25         if connect:
26             try:
27                 self.client_connect()
28             except:
29                 self.client_close()
30                 raise
31 
32     def client_connect(self):
33         self.socket.connect(self.server_address)
34 
35     def client_close(self):
36         self.socket.close()
37 
38     def run(self):
39         while True:
40             inp=input(">>: ").strip()
41             if not inp:continue
42             l=inp.split()
43             cmd=l[0]
44             if hasattr(self,cmd):
45                 func=getattr(self,cmd)
46                 func(l)
47 
48 
49     def put(self,args):
50         cmd=args[0]
51         filename=args[1]
52         if not os.path.isfile(filename):
53             print('file:%s is not exists' %filename)
54             return
55         else:
56             filesize=os.path.getsize(filename)
57 
58         head_dic={'cmd':cmd,'filename':os.path.basename(filename),'filesize':filesize}
59         print(head_dic)
60         head_json=json.dumps(head_dic)
61         head_json_bytes=bytes(head_json,encoding=self.coding)
62 
63         head_struct=struct.pack('i',len(head_json_bytes))
64         self.socket.send(head_struct)
65         self.socket.send(head_json_bytes)
66         send_size=0
67         with open(filename,'rb') as f:
68             for line in f:
69                 self.socket.send(line)
70                 send_size+=len(line)
71                 print(send_size)
72             else:
73                 print('upload successful')
74 
75 
76 
77 
78 client=MYTCPClient(('127.0.0.1',8080))
79 
80 client.run()
81 
82 FtpClient

FtpClient

ssh遠程執行命令+定製報頭

 1 import socket
 2 import struct
 3 import subprocess
 4 phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
 5 phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) #就是它，在bind前加
 6 phone.bind(('127.0.0.1',8080))
 7 phone.listen(5)
 8 print('server start...')
 9 while True: #連接循環
10     conn,client_addr=phone.accept()
11     print(conn,client_addr)
12 
13     while True: #通信循環
14         try:
15             cmd=conn.recv(1024)
16             if not cmd:break
17 
18             #執行命令，拿到結果
19             res=subprocess.Popen(cmd.decode('utf-8'),
20                              shell=True,
21                              stdout=subprocess.PIPE,
22                              stderr=subprocess.PIPE)
23 
24             stdout=res.stdout.read()
25             stderr=res.stderr.read()
26 
27             #製做報頭
28             header=struct.pack('i',len(stdout)+len(stderr))
29 
30 
31             #先發報頭(固定長度)
32             conn.send(header)
33             #再發真實的數據
34             conn.send(stdout)
35             conn.send(stderr)
36 
37         except Exception: #針對windwos
38             break
39     conn.close()
40 
41 phone.close()

服務端

 1 import socket
 2 import struct
 3 phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
 4 phone.connect(('127.0.0.1',8080))
 5 
 6 while True:
 7     cmd=input('>>: ').strip()
 8     if not cmd:continue
 9     #發命令
10     phone.send(cmd.encode('utf-8'))
11 
12 
13     #先收報頭
14     header=phone.recv(4)
15     total_size=struct.unpack('i',header)[0]
16 
17     #再收命令的執行結果
18     recv_size=0
19     data=b''
20     while recv_size < total_size:
21         recv_data=phone.recv(1024)
22         recv_size+=len(recv_data)
23         data+=recv_data
24 
25     #打印結果
26     print(data.decode('gbk'))
27 
28 phone.close()

客戶端

定製報頭的正確方式

 1 import socket
 2 import struct
 3 import subprocess
 4 import json
 5 phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
 6 phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) #就是它，在bind前加
 7 phone.bind(('127.0.0.1',8080))
 8 phone.listen(5)
 9 print('server start...')
10 while True: #連接循環
11     conn,client_addr=phone.accept()
12     print(conn,client_addr)
13 
14     while True: #通信循環
15         try:
16             cmd=conn.recv(1024)
17             if not cmd:break
18 
19             #執行命令，拿到結果
20             res=subprocess.Popen(cmd.decode('utf-8'),
21                              shell=True,
22                              stdout=subprocess.PIPE,
23                              stderr=subprocess.PIPE)
24 
25             stdout=res.stdout.read()
26             stderr=res.stderr.read()
27 
28 
29             #製做報頭
30             header_dic={'total_size':len(stdout)+len(stderr),'md5':None}
31             header_json=json.dumps(header_dic)
32             header_bytes=header_json.encode('utf-8')
33 
34 
35             #1 先發報頭的長度（固定4個bytes）
36             conn.send(struct.pack('i',len(header_bytes)))
37 
38 
39             #2 先發報頭
40             conn.send(header_bytes)
41 
42 
43             #3 再發真實的數據
44             conn.send(stdout)
45             conn.send(stderr)
46 
47         except Exception: #針對windwos
48             break
49     conn.close()
50 
51 phone.close()

服務端

 1 import socket
 2 import struct
 3 import json
 4 phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
 5 phone.connect(('127.0.0.1',8080))
 6 
 7 while True:
 8     cmd=input('>>: ').strip()
 9     if not cmd:continue
10     #發命令
11     phone.send(cmd.encode('utf-8'))
12 
13 
14     #先收報頭的長度
15     struct_res=phone.recv(4)
16     header_size=struct.unpack('i',struct_res)[0]
17 
18     #再收報頭
19     header_bytes=phone.recv(header_size)
20     head_json=header_bytes.decode('utf-8')
21     head_dic=json.loads(head_json)
22 
23     total_size=head_dic['total_size']
24     #再收命令的執行結果
25     recv_size=0
26     data=b''
27     while recv_size < total_size:
28         recv_data=phone.recv(1024)
29         recv_size+=len(recv_data)
30         data+=recv_data
31 
32     #打印結果
33     print(data.decode('gbk'))
34 
35 phone.close()

客戶端

併發遠程ssh

 1 import socketserver
 2 class MyTcphandler(socketserver.BaseRequestHandler):
 3     def handle(self):
 4         while True: #通訊循環
 5             data=self.request.recv(1024)
 6             self.request.send(data.upper())
 7 if __name__ == '__main__':
 8     #取代連接循環
 9     server=socketserver.ThreadingTCPServer(('127.0.0.1',8080),MyTcphandler)
10     server.serve_forever()

服務端

 1 import socket
 2 phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
 3 phone.connect(('127.0.0.1',8080))
 4 
 5 while True:
 6     msg=input('>>: ').strip()
 7     if not msg:continue
 8     phone.send(msg.encode('utf-8'))
 9     server_data=phone.recv(1024)
10     print(server_data.decode('utf-8'))
11 
12 phone.close()

客戶端