python網絡編程-socket編程

1、服務端和客戶端html

BS架構 (騰訊通軟件:server+client)python

CS架構 (web網站)linux

 

C/S架構與socket的關係:web

咱們學習socket就是爲了完成C/S架構的開發算法

 

2、OSI七層模型shell

互聯網協議按照功能不一樣分爲osi七層或tcp/ip五層或tcp/ip四層編程

 

每層運行常見物理設備windows

 

詳細參考:設計模式

http://www.cnblogs.com/linhaifeng/articles/5937962.html#_label4緩存

 

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

1.首先:本節課程的目標就是教會你如何基於socket編程,來開發一款本身的C/S架構軟件

2.其次:C/S架構的軟件(軟件屬於應用層)是基於網絡進行通訊的

3.而後:網絡的核心即一堆協議,協議即標準,你想開發一款基於網絡通訊的軟件,就必須遵循這些標準。

4.最後:就讓咱們從這些標準開始研究,開啓咱們的socket編程之旅

TCP/IP協議族包括運輸層、網絡層、鏈路層。

 

3、socket層,不懂看圖就明白了。

Socket是介於應用層和傳輸層之間。

4、socket是什麼

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

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

 掃盲篇:

1 將socket說成ip+port,ip是用來標識互聯網中的一臺主機的位置,而port是用來標識這臺機器上的一個應用程序,ip地址是配置到網卡上的,而port是應用程序開啓的,ip與port的綁定就標識了互聯網中獨一無二的一個應用程序
2 
3 而程序的pid是同一臺機器上不一樣進程或者線程的標識(Google Chrome會有多個PID)

 

5、套接字發展史及分類

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

 

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

套接字家族的名字:AF_UNIX

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

 

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

套接字家族的名字:AF_INET

(還有AF_INET6被用於ipv6,還有一些其餘的地址家族,不過,他們要麼是隻用於某個平臺,要麼就是已經被廢棄,或者是不多被使用,或者是根本沒有實現,全部地址家族中,AF_INET是使用最普遍的一個,python支持不少種地址家族,可是因爲咱們只關心網絡編程,因此大部分時候我麼只使用AF_INET)

 

6、套接字工做流程

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

生活中的場景就解釋了這工做原理,也許TCP/IP協議族就是誕生於生活中,這也不必定。

 

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

 

一、socket模塊發送和接收消息

示例:模擬發送消息和接收消息的過程

tcp服務端(server)

#!/usr/bin/env python
# -*- coding:utf-8 -*-      
#Author: nulige
 
import socket
                             
phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)  #買手機
phone.bind(('127.0.0.1',8000))  #綁定手機卡   #改爲服務端網卡IP地址和端口
phone.listen(5)  #開機  5的做用是最大掛起鏈接數   #backlog鏈接池(也叫半連接)
print('------------->')
conn,addr=phone.accept()  #等電話

msg=conn.recv(1024)  #收消息
print('客戶端發來的消息是:',msg)
conn.send(msg.upper())  #發消息

conn.close()
phone.close()
View Code

 

執行結果:

------------->

tcp客戶端(client)

#!/usr/bin/env python
# -*- coding:utf-8 -*-      
#Author: nulige

import socket

phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

phone.connect(('127.0.0.1',8000)) #拔通電話   #改爲服務端網卡IP地址和端口

phone.send('hello'.encode('utf-8'))  #發消息
data=phone.recv(1024)
print('收到服務端的發來的消息: ',data)

phone.close()
View Code

 

 

執行結果:

收到服務端的發來的消息:  b'HELLO'


二、tcp三次握手和四次揮手

主動斷開鏈接 :FIN_WAIT_1
被動斷開鏈接: FIN_WAIT_2
立刻斷開鏈接: TIME_WAIT

 

socket中TCP的三次握手創建鏈接詳解

流程以下:

  • 客戶端向服務器發送一個SYN J
  • 服務器向客戶端響應一個SYN K,並對SYN J進行確認ACK J+1
  • 客戶端再向服務器發一個確認ACK K+1

只有就完了三次握手,可是這個三次握手發生在socket的那幾個函數中呢?請看下圖:

image

                    圖一、socket中發送的TCP三次握手

從圖中能夠看出,當客戶端調用connect時,觸發了鏈接請求,向服務器發送了SYN J包,這時connect進入阻塞狀態;服務器監聽到鏈接請求,即收到SYN J包,調用accept函數接收請求向客戶端發送SYN K ,ACK J+1,這時accept進入阻塞狀態;客戶端收到服務器的SYN K ,ACK J+1以後,這時connect返回,並對SYN K進行確認;服務器收到ACK K+1時,accept返回,至此三次握手完畢,鏈接創建。

總結:客戶端的connect在三次握手的第二個次返回,而服務器端的accept在三次握手的第三次返回。

 

socket中TCP的四次握手釋放鏈接詳解

上面介紹了socket中TCP的三次握手創建過程,及其涉及的socket函數。如今咱們介紹socket中的四次握手釋放鏈接的過程,請看下圖:

image

                 圖二、socket中發送的TCP四次握手

圖示過程以下:

  • 某個應用進程首先調用close主動關閉鏈接,這時TCP發送一個FIN M;
  • 另外一端接收到FIN M以後,執行被動關閉,對這個FIN進行確認。它的接收也做爲文件結束符傳遞給應用進程,由於FIN的接收意味着應用進程在相應的鏈接上再也接收不到額外數據;
  • 一段時間以後,接收到文件結束符的應用進程調用close關閉它的socket。這致使它的TCP也發送一個FIN N;
  • 接收到這個FIN的源發送端TCP對它進行確認。

這樣每一個方向上都有一個FIN和ACK。

 

總結:

四次揮手斷開鏈接原則:

記住一條原則:誰先發起客戶端請求,誰先斷開鏈接
可是在大併發狀況下,大部分都是服務端先斷開鏈接,不會保留鏈接。由於每一分鐘都有不少人在訪問網站。

 

三、socket()模塊函數用法

import socket
socket.socket(socket_family,socket_type,protocal=0)
socket_family 能夠是 AF_UNIX 或 AF_INET。socket_type 能夠是 SOCK_STREAM 或 SOCK_DGRAM。protocol 通常不填,默認值爲 0。

獲取tcp/ip套接字
tcpSock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

獲取udp/ip套接字
udpSock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

因爲 socket 模塊中有太多的屬性。咱們在這裏破例使用了'from module import *'語句。使用 'from socket import *',咱們就把 socket 模塊裏的全部屬性都帶到咱們的命名空間裏了,這樣能 大幅減短咱們的代碼。
例如tcpSock = socket(AF_INET, SOCK_STREAM)
View Code

 

服務端套接字函數

s.bind()     綁定(主機,端口號)到套接字
s.listen()    開始TCP監聽
s.accept() 被動接受TCP客戶的鏈接,(阻塞式)等待鏈接的到來

客戶端套接字函數
s.connect()                       主動初始化TCP服務器鏈接
s.connect_ex() connect()  函數的擴展版本,出錯時返回出錯碼,而不是拋出異常

公共用途的套接字函數
s.recv()         接收TCP數據
s.send()        發送TCP數據(send在待發送數據量大於己端緩存區剩餘空間時,數據丟失,不會發完)
s.sendall()     發送完整的TCP數據(本質就是循環調用send,sendall在待發送數據量大於己端緩存區剩餘空間時,數據不丟失,循環調用send直到發完)
s.recvfrom()  接收UDP數據
s.sendto()     發送UDP數據
s.getpeername()   鏈接到當前套接字的遠端的地址
s.getsockname()   當前套接字的地址
s.getsockopt()      返回指定套接字的參數
s.setsockopt()       設置指定套接字的參數
s.close()               關閉套接字

面向鎖的套接字方法
s.setblocking()   設置套接字的阻塞與非阻塞模式
s.settimeout()    設置阻塞套接字操做的超時時間
s.gettimeout()    獲得阻塞套接字操做的超時時間

面向文件的套接字的函數
s.fileno()        套接字的文件描述符
s.makefile()   建立一個與該套接字相關的文件

 

7、基於TCP的套接字

tcp語法格式:

tcp服務端

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

 

tcp客戶端

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

 

 

一、基於tcp實現:客戶端發送空格,服務端也會接收

示例:

tcp_server端

#!/usr/bin/env python
# -*- coding:utf-8 -*-      
#Author: nulige
 
from socket import *
 
ip_port = ('127.0.0.1', 8080)
back_log = 5
buffer_size = 1024
 
tcp_server = socket(AF_INET, SOCK_STREAM)
tcp_server.bind(ip_port)
tcp_server.listen(back_log)
 
print('服務端開始運行了')
conn, addr = tcp_server.accept()  #服務器阻塞
print('雙向連接是', conn)
print('客戶端地址', addr)
 
while True:
    data = conn.recv(buffer_size)    #收緩存爲空,則阻塞
    print('客戶端發來的消息是', data.decode('utf-8'))
    conn.send(data.upper())
conn.close()
 
tcp_server.close()
View Code

 

tcp_client端

#!/usr/bin/env python
# -*- coding:utf-8 -*-      
#Author: nulige

from socket import *

ip_port = ('127.0.0.1', 8080)
back_log = 5
buffer_size = 1024
 
tcp_client = socket(AF_INET, SOCK_STREAM)
tcp_client.connect(ip_port)
 
while True:
    msg = input('>>:')          #發送空格到本身的發送緩存中
    # msg=input('>>:').strip()  #去掉空格
    tcp_client.send(msg.encode('utf-8'))
    print('客戶端已經發送消息')
    data = tcp_client.recv(buffer_size)  #收緩存爲空則阻塞
    print('收到服務端發來的消息是', data.decode('utf-8'))
 
tcp_client.close()
View Code

 

執行結果:

  View Code

 

實驗過程當中遇到的問題:

在重啓服務端時可能會遇到以下報錯:

  這個是因爲你的服務端仍然存在四次揮手的time_wait狀態在佔用地址(若是不懂,請深刻研究1.tcp三次握手,四次揮手 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))

 

法二:在linux系統中,經過調整系統內核參數的方式來解決

發現系統存在大量TIME_WAIT狀態的鏈接,經過調整linux內核參數解決,系統優化的一個優化點)
 
vi /etc/sysctl.conf

編輯文件,加入如下內容:
net.ipv4.tcp_syncookies = 1
net.ipv4.tcp_tw_reuse = 1
net.ipv4.tcp_tw_recycle = 1
net.ipv4.tcp_fin_timeout = 30
  
而後執行 /sbin/sysctl -p 讓參數生效。
  
net.ipv4.tcp_syncookies = 1   表示開啓SYN Cookies。當出現SYN等待隊列溢出時,啓用cookies來處理,可防範少許SYN攻擊,默認爲0,表示關閉;
 
net.ipv4.tcp_tw_reuse = 1     表示開啓重用。容許將TIME-WAIT sockets從新用於新的TCP鏈接,默認爲0,表示關閉;
 
net.ipv4.tcp_tw_recycle = 1   表示開啓TCP鏈接中TIME-WAIT sockets的快速回收,默認爲0,表示關閉。
 
net.ipv4.tcp_fin_timeout = 30 修改系統默認的 TIMEOUT 時間
View Code

 

8、基於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()                      # 關閉客戶套接字

 

一、基於upd實現方法

示例:

udp_server端

#!/usr/bin/env python
# -*- coding:utf-8 -*-      
#Author: nulige
 
from socket import *
ip_port=('127.0.0.1',8080)
buffer_size = 1024
 
udp_server = socket(AF_INET,SOCK_DGRAM)  #數據報套接字
udp_server.bind(ip_port)
 
while True:
    data,addr=udp_server.recvfrom(buffer_size)
    print(data)

    udp_server.sendto(data.upper(),addr)  #upper() 小寫變大寫
View Code

 

udp_client端:

from socket import *
ip_port=('127.0.0.1',8080)  #服務端IP+端口
buffer_size = 1024

udp_client=socket(AF_INET,SOCK_DGRAM) #udp數據報套接字
 
while True:
    msg=input('>>:').strip()
    udp_client.sendto(msg.encode('utf-8'),ip_port)
    #數據,ip地址+端口
    data,addr=udp_client.recvfrom(buffer_size)
    print(data.decode('utf-8'))
View Code

 

執行結果:

先運行udp_server,再運行udp_client。

服務端返回結果:

1 b'sfdsfds'  #bytes類型
2 b'fdsfds'
3 b'fsdfds'
4 b'sdfdsf'

在客戶端輸入:

複製代碼
1 >>:sfdsfds  #在客戶端輸入
2 SFDSFDS     #服務端返回的結果,把客戶端輸入的字符變大寫
3 
4 >>:fdsfds
5 FDSFDS
6 
7 >>:fsdfds
8 FSDFDS
複製代碼

 

2、實現ntp時間服務器

示例:

tup_server端

#!/usr/bin/env python
# -*- coding:utf-8 -*-      
#Author: nulige
 
#實現ntp時間服務器
import time
from socket import *
ip_port=('127.0.0.1',8080)
buffer_size = 1024

udp_server = socket(AF_INET,SOCK_DGRAM)  #數據報套接字
udp_server.bind(ip_port)
 
while True:
    data,addr=udp_server.recvfrom(buffer_size)
    print(data)

    if not data:
        fmt='%Y-%m-%d %X'   #若是用戶沒有輸入時間,就返回默認格式
    else:
        fmt=data.decode('utf-8')
        back_time=time.strftime(fmt)

    udp_server.sendto(back_time.encode('utf-8'),addr)  
View Code

 

udp_client端

#!/usr/bin/env python
# -*- coding:utf-8 -*-      
#Author: nulige
 
from socket import *
ip_port=('127.0.0.1',8080)  #服務端IP+端口
buffer_size = 1024

udp_client=socket(AF_INET,SOCK_DGRAM) #數據報套接字

while True:
    msg=input('>>:').strip()
    udp_client.sendto(msg.encode('utf-8'),ip_port)

    data,addr=udp_client.recvfrom(buffer_size)
    print('ntp服務器的標準時間是',data.decode('utf-8'))
View Code

 

執行結果:

運行udp_server,再運行udp_client,而後在udp_client裏輸入:

1 >>:%Y   #在客戶端輸入%Y
2 ntp服務器的標準時間是 2017  #就會返回服務端的時間
3 >>:%m-%d-%Y
4 ntp服務器的標準時間是 01-03-2017
5 >>:

 

三、基於tcp實現遠程執行命令

備註:因系統差別,請儘可能把程序放在linux服務器上面運行,windows上面可能會報錯。

socket_server_tcp服務端 (在linux上面運行)

#!/usr/bin/env python
# -*- coding:utf-8 -*-      
#Author: nulige
 
from socket import *
import subprocess

ip_port = ('192.168.1.135', 8000)
back_log = 5
buffer_size = 1024

tcp_server = socket(AF_INET, SOCK_STREAM)
tcp_server.bind(ip_port)
tcp_server.listen(back_log)

while True:
    conn,addr=tcp_server.accept()
    print('新的客戶端連接',addr)
    while True:
        #
        try:
            cmd=conn.recv(buffer_size)
            #if not cmd:break  MAC筆記本處理方法
            print('收到客戶端的命令',cmd)

            #執行命令,獲得命令的運行結果cmd_res
            res=subprocess.Popen(cmd.decode('utf-8'),shell=True,
                                 stderr=subprocess.PIPE,
                                 stdout=subprocess.PIPE,
                                 stdin=subprocess.PIPE)
            err=res.stderr.read()
            if err:
                cmd_res=err
            else:
                cmd_res=res.stdout.read()
            #
            conn.send(cmd_res)
        except Exception as e:
            print(e)
            break
conn.close()
View Code

 

socket_client_tcp客戶端(windows系統上面運行)

#!/usr/bin/env python
# -*- coding:utf-8 -*-      
#Author: nulige
 
from socket import *

# ip_port = ('127.0.0.1', 8082)
ip_port = ('192.168.1.135', 8000)
back_log = 5
buffer_size = 1024

tcp_client = socket(AF_INET, SOCK_STREAM)
tcp_client.connect(ip_port)

while True:
    cmd=input('>>:').strip()
    if not cmd:continue
    if cmd == 'quit':break

    tcp_client.send(cmd.encode('utf-8'))
    cmd_res=tcp_client.recv(buffer_size)
    # print('命令的執行結果是 ',cmd_res.decode('gbk'))
    print('命令的執行結果是 ',cmd_res.decode('utf-8'))
tcp_client.close()
View Code

 

執行結果:

在客戶端執行命令:

 >>:df -h
 命令的執行結果是  Filesystem      Size  Used Avail Use% Mounted on
 /dev/sda3       9.6G  1.8G  7.3G  20% /
 tmpfs           931M     0  931M   0% /dev/shm
 /dev/sda1       190M   32M  149M  18% /boot
 /dev/sr0        4.4G  4.4G     0 100% /opt
 
 >>:dir
 命令的執行結果是  s3.py       server_ssh.py     socket_server.py
server.py  socket_clinet_udp.py  socket_server_udp.py
 
服務端返回結果:
[root@python3 scripts]# python socket_server.py
新的客戶端連接 ('192.168.1.115', 53569)
收到客戶端的命令 b'df -h'
收到客戶端的命令 b'dir'
View Code

 

四、基於udp實現遠程執行命令

socket_server_udp服務端:

#!/usr/bin/env python
# -*- coding:utf-8 -*-      
#Author: nulige
 
from socket import *
import subprocess

ip_port = ('192.168.1.135', 8000)
back_log = 5
buffer_size = 1024

udp_server = socket(AF_INET, SOCK_DGRAM)
udp_server.bind(ip_port)
 
while True:
    cmd,addr=udp_server.recvfrom(buffer_size)
    print(cmd)

    #執行命令,獲得命令的運行結果cmd_res
    res = subprocess.Popen(cmd.decode('utf-8'), shell=True,
                           stderr=subprocess.PIPE,
                           stdout=subprocess.PIPE,
                           stdin=subprocess.PIPE)
    err = res.stderr.read()
    if err:
        cmd_res = err
    else:
        cmd_res = res.stdout.read()

    if not cmd_res:  # 判斷爲空的狀況
        cmd_res = '執行成功'.encode('gbk')  #linux改爲utf-8
    print(cmd_res)
    #
    udp_server.sendto(cmd_res,addr)
View Code

 

socket_clinet_udp客戶端:

#!/usr/bin/env python
# -*- coding:utf-8 -*-      
#Author: nulige
  
from socket import *

ip_port = ('192.168.1.135', 8000)
# ip_port = ('192.168.12.63', 8000)
back_log = 5
buffer_size = 10240

udp_client = socket(AF_INET, SOCK_DGRAM)

while True:
    cmd=input('>>:').strip()
    if not cmd:continue
    if cmd == 'quit':break
 
    udp_client.sendto(cmd.encode('utf-8'),ip_port)
    cmd_res,addr=udp_client.recvfrom(buffer_size)
    print('命令的執行結果是 ',cmd_res.decode('gbk'))  #若是在linux上面運行,把gbk改爲utf-8
udp_client.close()
View Code

 

執行結果:

  View Code

 

9、recv與recvfrom的區別

一、收發原理詳解:

發消息:都是將數據發送到己端的發送緩衝中

收消息:都是從己端的緩衝區中收

 

二、發消息兩者相似,收消息確實有區別的?

tcp協議:send發消息,recv收消息

(1)若是收消息緩衝區裏的數據爲空,那麼recv就會阻塞

(2)tcp基於連接通訊,若是一端斷開了連接,那另一端的連接也跟着完蛋recv將不會阻塞,收到的是空

 

udp協議:sendto發消息,recvfrom收消息

(1)若是若是收消息緩衝區裏的數據爲「空」,recvfrom不會阻塞

(2)recvfrom收的數據小於sendinto發送的數據時,數據丟失

(3)只有sendinto發送數據沒有recvfrom收數據,數據丟失

 

注意:

1.你單獨運行上面的udp的客戶端,你發現並不會報錯,相反tcp卻會報錯,由於udp協議只負責把包發出去,對方收不收,我根本無論,而tcp是基於連接的,必須有一個服務端先運行着,客戶端去跟服務端創建連接而後依託於連接才能傳遞消息,任何一方試圖把連接摧毀都會致使對方程序的崩潰。

2.上面的udp程序,你註釋任何一條客戶端的sendinto,服務端都會卡住,爲何?由於服務端有幾個recvfrom就要對應幾個sendinto,哪怕是sendinto(b'')那也要有。

 

3.總結:

1.udp的sendinto不用管是否有一個正在運行的服務端,能夠己端一個勁的發消息

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

3.tcp的協議數據不會丟,己端老是在收到ack時纔會清除緩衝區內容。數據是可靠的,可是會粘包。

 

10、粘包

須知:只有TCP有粘包現象,UDP永遠不會粘包。(緣由詳見第3點)

一、socket收發消息的原理

                                                       socket發送原理圖

 

二、爲何會出現所謂的粘包

緣由:接收方不知道消息之間的界限,不知道一次性提取多少字節的數據所形成的。

  此外,發送方引發的粘包是由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協議會幫你封裝上消息頭。

 

三、tcp會發生粘包的兩種狀況以下:

一、發送端屢次send間隔較短,而且數據量較小,tcp會經過Nagls算法,封裝成一個包,發送到接收端,接收端不知道這個包由幾部分組成,因此就會產生粘包。

二、數據量發送的大,接收端接收的小,再接一次,還會出現上次沒有接收完成的數據。就會出現粘包。

 

示例1: 發送端屢次send間隔較短,而且數據量較小,tcp會經過Nagls算法,封裝成一個包,發送到接收端,接收端不知道這個包由幾部分組成,因此就會產生粘包。

server服務端:

#!/usr/bin/env python
# -*- coding:utf-8 -*-      
#Author: nulige
 
from socket import *
ip_port=('127.0.0.1',8082)
back_log=5
buffer_size=1024

tcp_server=socket(AF_INET,SOCK_STREAM)
tcp_server.bind(ip_port)
tcp_server.listen(back_log)

conn,addr=tcp_server.accept()

data1=conn.recv(buffer_size)  #指定buffer_size ,獲得的結果就是經過Nagle算法,隨機接收次數。
print('第1次數據',data1)

data2=conn.recv(buffer_size)
print('第2次數據',data2)

data3=conn.recv(buffer_size)
print('第3次數據',data3)
View Code

 

client客戶端

#!/usr/bin/env python
# -*- coding:utf-8 -*-      
#Author: nulige

from socket import *
import time

ip_port=('127.0.0.1',8082)
back_log=5
buffer_size=1024

tcp_client=socket(AF_INET,SOCK_STREAM)
tcp_client.connect(ip_port)

tcp_client.send('hello'.encode('utf-8'))
tcp_client.send('world'.encode('utf-8'))
tcp_client.send('egon'.encode('utf-8'))

time.sleep(1000)
View Code

 

執行結果:

第1次數據 b'helloworldegon'  #不肯定接收次數。

 

示例2:指定接收字節數,至關於服務端知道接收長度,就不會出現粘包現象

粘包服務端

from socket import *
ip_port=('127.0.0.1',8080)
back_log=5
buffer_size=1024

tcp_server=socket(AF_INET,SOCK_STREAM)
tcp_server.bind(ip_port)
tcp_server.listen(back_log)

conn,addr=tcp_server.accept()

data1=conn.recv(5)  #指定每次接收字節數,就不會出現粘包現象
print('第一次數據',data1)

data2=conn.recv(5)
print('第2次數據',data2)

data3=conn.recv(5)
print('第3次數據',data3)
View Code

 

粘包客戶端

from socket import *
import time
ip_port=('127.0.0.1',8080)
back_log=5
buffer_size=1024

tcp_client=socket(AF_INET,SOCK_STREAM)
tcp_client.connect(ip_port)

tcp_client.send('hello'.encode('utf-8'))
tcp_client.send('world'.encode('utf-8'))
tcp_client.send('egon'.encode('utf-8'))


time.sleep(1000)
View Code

 

執行結果:

1 第1次數據 b'hello'   #不會出現粘包現象,發送三次,就接收三次
2 第2次數據 b'world'
3 第3次數據 b'egon'

 

示例3:數據量發送的大,接收端接收的小,再接一次,還會出現上次沒有接收完成的數據。就會出現粘包。

粘包服務端

from socket import *
ip_port=('127.0.0.1',8080)
back_log=5
buffer_size=1024

tcp_server=socket(AF_INET,SOCK_STREAM)
tcp_server.bind(ip_port)
tcp_server.listen(back_log)

conn,addr=tcp_server.accept()

data1=conn.recv(1)
print('第1次數據',data1)

# data2=conn.recv(5)
# print('第2次數據',data2)
#
# data3=conn.recv(1)
# print('第3次數據',data3)
View Code

 

粘包客戶端

from socket import *
import time
ip_port=('127.0.0.1',8080)
back_log=5
buffer_size=1024  #接收的數據只有1024

tcp_client=socket(AF_INET,SOCK_STREAM)
tcp_client.connect(ip_port)

tcp_client.send('helloworldegon'.encode('utf-8'))

time.sleep(1000)
View Code

 

執行結果: 

1 第1次數據 b'h'
2 第2次數據 b'ellow'  #發送的數據過大,接收的數據設置的較小,就會出現致使粘包 
3 第3次數據 b'o'

 

四、udp永遠不會粘包

示例:

udp不粘包服務端

from socket import *
ip_port=('127.0.0.1',8080)
buffer_size=1024

udp_server=socket(AF_INET,SOCK_DGRAM) #數據報
udp_server.bind(ip_port)

data1=udp_server.recvfrom(10)
print('第1次',data1)

data2=udp_server.recvfrom(10)
print('第2次',data2)

data3=udp_server.recvfrom(10)
print('第3次',data3)

data4=udp_server.recvfrom(2)
print('第4次',data4)
View Code

 

udp不粘包客戶端

from socket import *
ip_port=('127.0.0.1',8080)
buffer_size=1024

udp_client=socket(AF_INET,SOCK_DGRAM) #udp叫數據報

udp_client.sendto(b'hello',ip_port)
udp_client.sendto(b'world',ip_port)
udp_client.sendto(b'egon',ip_port)
View Code

 

 執行結果:

1 第1次 (b'hello', ('127.0.0.1', 57813))  #udp沒有Nagle優化算法
2 第2次 (b'world', ('127.0.0.1', 57813))  #每次都是一次獨立的包,因此不會出現粘包現象
3 第3次 (b'egon', ('127.0.0.1', 57813))

 

五、qq聊天(因爲udp無鏈接,因此能夠同時多個客戶端去跟服務端通訊)

udp_socket_server服務端代碼:

#實現相似於QQ聊天功能

#!/usr/bin/env python
# -*- coding:utf-8 -*-      
#Author: nulige

import socket
ip_port=('127.0.0.1',8081)
udp_server_sock=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
udp_server_sock.bind(ip_port)

while True:
    qq_msg,addr=udp_server_sock.recvfrom(1024)
    print('來自[%s:%s]的一條消息:\033[1;44m%s\033[0m' %(addr[0],addr[1],qq_msg.decode('utf-8')))
    back_msg=input('回覆消息: ').strip()

    udp_server_sock.sendto(back_msg.encode('utf-8'),addr)
View Code

 

udp_socket_client客戶端:

#!/usr/bin/env python
# -*- coding:utf-8 -*-      
#Author: nulige

import socket
BUFSIZE=1024
udp_client_socket=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)

qq_name_dic={
    '努力哥':('127.0.0.1',8081),
    '劉哥':('127.0.0.1',8081),
    '李哥':('127.0.0.1',8081),
    '王哥':('127.0.0.1',8081),
}

while True:
    qq_name=input('請選擇聊天對象: ').strip()   #選擇字典中的聊天對象,再發送消息
    while True:
        msg=input('請輸入消息,回車發送: ').strip()
        if msg == 'quit':break
        if not msg or not qq_name or qq_name not in qq_name_dic:continue
        udp_client_socket.sendto(msg.encode('utf-8'),qq_name_dic[qq_name])

        back_msg,addr=udp_client_socket.recvfrom(BUFSIZE)
        print('來自[%s:%s]的一條消息:\033[1;44m%s\033[0m' %(addr[0],addr[1],back_msg.decode('utf-8')))

udp_client_socket.close()
View Code

 

執行結果:

先啓動服務端,再啓動客戶端向服務端發送消息:

#客戶端發送消息

請選擇聊天對象: 努力哥
請輸入消息,回車發送: 吃飯沒有
來自[127.0.0.1:8081]的一條消息:還沒吃呢
請輸入消息,回車發送: 

#服務端接收消息

來自[127.0.0.1:62642]的一條消息:吃飯沒有
回覆消息: 還沒吃呢

 

補充知識:

一、tcp是可靠傳輸

  tcp在數據傳輸時,發送端先把數據發送到本身的緩存中,而後協議控制將緩存中的數據發往對端,對端返回一個ack=1,發送端則清理緩存中的數據,對端返回ack=0,則從新發送數據,因此tcp是可靠的。

 

二、udp是不可靠傳輸

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

 

11、解決粘包的辦法

法一:比較(LOW)版本

 示例:

low_socket_server服務端

#!/usr/bin/env python
# -*- coding:utf-8 -*-      
#Author: nulige

#low版解決粘包版本服務端
from socket import *
import subprocess
ip_port=('127.0.0.1',8080)
back_log=5
buffer_size=1024

tcp_server=socket(AF_INET,SOCK_STREAM)
tcp_server.bind(ip_port)
tcp_server.listen(back_log)

while True:
    conn,addr=tcp_server.accept()
    print('新的客戶端連接',addr)
    while True:
        #收消息
        try:
            cmd=conn.recv(buffer_size)
            if not cmd:break
            print('收到客戶端的命令',cmd)

            #執行命令,獲得命令的運行結果cmd_res
            res=subprocess.Popen(cmd.decode('utf-8'),shell=True,
                                 stderr=subprocess.PIPE,
                                 stdout=subprocess.PIPE,
                                 stdin=subprocess.PIPE)
            err=res.stderr.read()
            if err:
                cmd_res=err
            else:
                cmd_res=res.stdout.read()

            #發送消息
            if not cmd_res:
                cmd_res='執行成功'.encode('gbk')

            length=len(cmd_res)  #計算長度
            conn.send(str(length).encode('utf-8')) #把長度發給客戶端
            client_ready=conn.recv(buffer_size)    #卡着一個recv
            if client_ready == b'ready':  #若是收到客戶端的ready消息,就說明準備好了。
                conn.send(cmd_res)        #就能夠send給客戶端發送消息啦!
        except Exception as e:
            print(e)
            break
View Code

 

low_socket_client客戶端

執行結果:

  View Code

總結:

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

 

法二:節省網絡傳輸版本(牛逼版本)

  爲字節流加上自定義固定長度報頭,報頭中包含字節流長度,而後一次send到對端,對端在接收時,先從緩存中取出定長的報頭,而後再取真實數據。

示例:(沒實現多客戶端併發)

 tcp_socket_server服務端:

#!/usr/bin/env python
# -*- coding:utf-8 -*-      
#Author: nulige
 
from socket import *
import subprocess
import struct
ip_port=('127.0.0.1',8080)
back_log=5
buffer_size=1024

tcp_server=socket(AF_INET,SOCK_STREAM)
tcp_server.bind(ip_port)
tcp_server.listen(back_log)

while True:
    conn,addr=tcp_server.accept()
    print('新的客戶端連接',addr)
    while True:
        #
        try:
            cmd=conn.recv(buffer_size)
            if not cmd:break
            print('收到客戶端的命令',cmd)

            #執行命令,獲得命令的運行結果cmd_res
            res=subprocess.Popen(cmd.decode('utf-8'),shell=True,
                                 stderr=subprocess.PIPE,
                                 stdout=subprocess.PIPE,
                                 stdin=subprocess.PIPE)
            err=res.stderr.read()
            if err:
                cmd_res=err
            else:
                cmd_res=res.stdout.read()
            #
            if not cmd_res:
                cmd_res='執行成功'.encode('gbk')

            length=len(cmd_res)

            data_length=struct.pack('i',length)
            conn.send(data_length)
            conn.send(cmd_res)
        except Exception as e:
            print(e)
            break
View Code

 

 tcp_socket_client客戶端

#!/usr/bin/env python
# -*- coding:utf-8 -*-      
#Author: nulige

from socket import *
import struct
from functools import partial
ip_port=('127.0.0.1',8080)
back_log=5
buffer_size=1024

tcp_client=socket(AF_INET,SOCK_STREAM)
tcp_client.connect(ip_port)

while True:
    cmd=input('>>: ').strip()
    if not cmd:continue
    if cmd == 'quit':break

    tcp_client.send(cmd.encode('utf-8'))
 
 
    #解決粘包
    length_data=tcp_client.recv(4)
    length=struct.unpack('i',length_data)[0]

    recv_size=0
    recv_data=b''
    while recv_size < length:
        recv_data+=tcp_client.recv(buffer_size)
        recv_size=len(recv_data)
    print('命令的執行結果是 ',recv_data.decode('gbk'))
tcp_client.close()
View Code

 

執行結果:

  View Code

 

12、用到的相關模塊知識講解

 一、subprocess模塊

subprocess 做用:啓動一個新的進程並與之通訊

 語法:

subprocess.Popen(args, bufsize=0, executable=None, stdin=None, stdout=None, stderr=None, preexec_fn=None, close_fds=False, shell=False, cwd=None, env=None, universal_newlines=False, startupinfo=None, creationflags=0)

 參數:

Popen類:    用Popen來建立進程,並與進程進行復雜的交互
shell=True:  指定的命令行會經過shell來執行
stdin :   標準輸入
stdout : 標準輸出
stderr :  標準錯誤的文件句柄
PIPE :    管道 ,默認值 爲: None, 表示不作重定向,管道能夠用來接收數據。

 

 示例1:執行dir命令,就會交給shell解釋器執行

import subprocess  #導入模塊

命令:
>>> subprocess.Popen("dir", shell=True)    #執行dir命令,交給shell解釋器執行

執行結果:
<subprocess.Popen object at 0x00A7B950>
 Directory of C:\Python3.5
2016/11/21  14:14    <DIR>          .
2016/11/21  14:14    <DIR>          ..
2016/11/21  14:14    <DIR>          DLLs
2016/11/21  14:14    <DIR>          Doc
2016/11/21  14:14    <DIR>          include
2016/11/21  14:14    <DIR>          Lib
2016/11/21  14:14    <DIR>          libs
2016/06/25  22:08            30,345 LICENSE.txt
2016/06/25  21:48           340,667 NEWS.txt
2016/06/25  22:02            39,576 python.exe
2016/06/25  22:02            51,864 python3.dll
2016/06/25  22:02         3,127,960 python35.dll
2016/06/25  22:02            39,576 pythonw.exe
2016/06/25  21:48             8,282 README.txt
2016/11/21  14:14    <DIR>          Scripts
2016/11/21  14:14    <DIR>          tcl
2016/11/21  14:14    <DIR>          Tools
2016/03/17  22:48            85,840 vcruntime140.dll
               8 File(s)      3,724,110 bytes
              10 Dir(s)  211,565,547,520 bytes free
View Code

 

示例2:subprocess 把標準輸出放入管道中,屏幕上就不會輸出內容

示例2:把標準輸出放入管道中,屏幕上就不會輸出內容。
res=subprocess.Popen("dir", shell=True,stdout=subprocess.PIPE,stdin=subprocess.PIPE,stderr=subprocess.PIPE)   #執行dir命令,交給shell解釋器執行,經過標準類型和subprocess.PIPE放入管道中。

>>> res.stdout.read()  #讀取管道里面的數據,在程序中,讀取也不會輸出到屏幕上。

執行結果:
b' Volume in drive C has no label.\r\n Volume Serial Number is 4C49-9FA8\r\n\r\n Directory of C:\\Python3.5\r\n\r\n2016/11/21  14:14    <DIR>          .\r\n2016/11/21  14:14    <DIR>          ..\r\n2016/11/21  14:14    <DIR>          DLLs\r\n2016/11/21  14:14    <DIR>          Doc\r\n2016/11/21  14:14    <DIR>          include\r\n2016/11/21  14:14    <DIR>          Lib\r\n2016/11/21  14:14    <DIR>          libs\r\n2016/06/25  22:08            30,345 LICENSE.txt\r\n2016/06/25  21:48           340,667 NEWS.txt\r\n2016/06/25  22:02            39,576 python.exe\r\n2016/06/25  22:02            51,864 python3.dll\r\n2016/06/25  22:02         3,127,960 python35.dll\r\n2016/06/25  22:02            39,576 pythonw.exe\r\n2016/06/25  21:48             8,282 README.txt\r\n2016/11/21  14:14    <DIR>          Scripts\r\n2016/11/21  14:14    <DIR>          tcl\r\n2016/11/21  14:14    <DIR>          Tools\r\n2016/03/17  22:48            85,840 vcruntime140.dll\r\n               8 File(s)      3,724,110 bytes\r\n              10 Dir(s)  211,560,914,944 bytes free\r\n'

>>> res.stdout.read()   #再read一次,內容就爲空,說明讀取完成啦!
b''  #顯示爲:bytes類型
View Code

 

 示例3:subprocess 執行一個系統沒有的命令,就會產生正常的輸出

#執行一個系統沒有的命令,就會產生正常的輸出

>>> res=subprocess.Popen("sfsfdsfdsfs", shell=True,stdout=subprocess.PIPE,stdin=subprocess.PIPE,stderr=subprocess.PIPE)

>>> res.stdout.read()  #讀取沒有內容
b''

>>> res.stderr.read()  #有正常的輸出
b"'sfsfdsfdsfs' is not recognized as an internal or external command,\r\noperable program or batch file.\r\n"
View Code

 

 

二、struct模塊

struct模塊做用:解決bytes和其餘二進制數據類型的轉換

示例用法:
struct.pack('i',12)

參數說明:

pack函數做用:把任意數據類型變成bytes

i 表示4字節無符號整數。

示例1:

>>> import struct
>>> struct.pack('i',12) #把後面的整形數據,封裝成一個bytes類型
b'\x0c\x00\x00\x00' #長度就是4

>>> l=struct.pack('i',12313123)
>>> len(l)
4 #長度就是4
View Code

 

 示例2:

>>> struct.pack('i',1)
b'\x01\x00\x00\x00'

#反解
>>> struct.unpack('i',l)
(12313123,)

#查看類型
>>> l=struct.pack('i',1)
>>> type(l)
<class 'bytes'>  #bytes類型
View Code

 

 

Format Characters(格式化字符):

Format C Type Python type Standard size Notes
x pad byte no value    
c char bytes of length 1 1  
b signed char integer 1 (1),(3)
B unsigned char integer 1 (3)
? _Bool bool 1 (1)
h short integer 2 (3)
H unsigned short integer 2 (3)
i int integer 4 (3)
I unsigned int integer 4 (3)
l long integer 4 (3)
L unsigned long integer 4 (3)
q long long integer 8 (2), (3)
Q unsigned long long integer 8 (2), (3)
n ssize_t integer   (4)
N size_t integer   (4)
e (7) float 2 (5)
f float float 4 (5)
d double float 8 (5)
s char[] bytes    
p char[] bytes    
P void * integer   (6)

 

詳細用法參考:

http://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/001431955007656a66f831e208e4c189b8a9e9f3f25ba53000

官方文檔參考:(英文文檔)
https://docs.python.org/3/library/struct.html#format-characters

 

三、urandom模塊

做用:產生隨機數

>>> import os
>>> os.urandom(32)  #產生32位字節隨機數
b'=\xbcC\xa3\xe0\xd5\x12\xe4CZ?\xd9Q{\x97\x89g7lvD\xd4\xed\xd8\xeau\xc1\x9c\xb6\xd8fR'

 

示例:使用md5 + os.urandom(n) 產生隨機字符串

import os
from hashlib import md5

for i in range(5):  #循環幾回就產生幾回隨機數
   print(md5(os.urandom(32)).hexdigest())

執行結果:

1fc70d335903283e1ac8165a28fbdddb
7a1305507f485e4d3c03f4e0c200ab6d
824db1b1076302f46166bbd93c41f0dd
a350c246781d5a6139d18df267e50485
f38fb315a24e33d1703df81fe6b7a4e2

 

十3、socket 實現併發

SocketServer是基於socket寫成的一個更強大的模塊。

SocketServer簡化了網絡服務器的編寫。它有4個類:TCPServer,UDPServer,UnixStreamServer,UnixDatagramServer。這4個類是同步進行處理的,另外經過ForkingMixIn和ThreadingMixIn類來支持異步。

 

在python3中該模塊是socketserver

在python2中該模塊是Socketserver

分狀況導入導入模塊
try:
   import socketserver      #Python 3
except ImportError:
   import SocketServer      #Python 2

服務器

  服務器要使用處理程序,必須將其出入到服務器對象,定義了5個基本的服務器類型(就是「類」)。BaseServer,TCPServer,UnixStreamServer,UDPServer,UnixDatagramServer。注意:BaseServer不直接對外服務。

 

關係以下:

 服務器:

  要使用處理程序,必須將其傳入到服務器的對象,定義了四個基本的服務器類。

(1)TCPServer(address,handler)   支持使用IPv4的TCP協議的服務器,address是一個(host,port)元組。Handler是BaseRequestHandler或StreamRequestHandler類的子類的實例。

(2)UDPServer(address,handler)   支持使用IPv4的UDP協議的服務器,address和handler與TCPServer中相似。

(3)UnixStreamServer(address,handler)   使用UNIX域套接字實現面向數據流協議的服務器,繼承自TCPServer。

(4)UnixDatagramServer(address,handler)  使用UNIX域套接字實現數據報協議的服務器,繼承自UDPServer。

 

這四個類的實例都有如下方法。

一、s.socket   用於傳入請求的套接字對象。

二、s.sever_address  監聽服務器的地址。如元組("127.0.0.1",80)

三、s.RequestHandlerClass   傳遞給服務器構造函數並由用戶提供的請求處理程序類。

四、s.serve_forever()  處理無限的請求  #無限處理client鏈接請求

五、s.shutdown()   中止serve_forever()循環

 

SocketServer模塊中主要的有如下幾個類:

一、BaseServer    包含服務器的核心功能與混合類(mix-in)的鉤子功能。這個類主要用於派生,不要直接生成這個類的類對象,能夠考慮使用TCPServer和UDPServer類。

二、TCPServer     基本的網絡同步TCP服務器

三、UDPServer     基本的網絡同步UDP服務器

四、ForkingTCPServer      是ForkingMixIn與TCPServer的組合

五、ForkingUDPServer    是ForkingMixIn與UDPServer的組合

六、ThreadingUDPServer  是ThreadingMixIn和UDPserver的組合

七、ThreadingTCPServer   是ThreadingMixIn和TCPserver的組合

八、BaseRequestHandler   必須建立一個請求處理類,它是BaseRequestHandler的子類並重載其handle()方法。

九、StreamRequestHandler        實現TCP請求處理類的

十、DatagramRequestHandler  實現UDP請求處理類的

十一、ThreadingMixIn  實現了核心的線程化功能,用於與服務器類進行混合(mix-in),以提供一些異步特性。不要直接生成這個類的對象。

十二、ForkingMixIn     實現了核心的進程化功能,用於與服務器類進行混合(mix-in),以提供一些異步特性。不要直接生成這個類的對象。

 

關係圖以下:

建立服務器的步驟:

1:首先必須建立一個請求處理類

2:它是BaseRequestHandler的子類

3:該請求處理類是BaseRequestHandler的子類並從新寫其handle()方法

 

實例化  請求處理類傳入服務器地址和請求處理程序類

最後實例化調用serve_forever()  #無限處理client請求

 

記住一個原則:對tcp來講:self.request=conn

示例:

一、tcp_socket_server服務端

#!/usr/bin/env python
# -*- coding:utf-8 -*-      
#Author: nulige

#服務端已經實現併發,處理客戶端請求

import socketserver

class MyServer(socketserver.BaseRequestHandler):   #基本的通訊循環
    def handle(self):
        print('conn is: ',self.request)  #與client的連接請求信息
        print('addr is: ',self.client_address)  #獲取client的地址和端口號
        #通訊循環
        while True:
            #收消息
            data=self.request.recv(1024)
            print('收到客戶端的消息是',data)

            #發消息
            self.request.sendall(data.upper())

if __name__ == '__main__':
    s=socketserver.ThreadingTCPServer(('127.0.0.1',8000),MyServer) #開啓多線程,綁定地址,和處理通訊的類
    s.serve_forever() #鏈接循環
View Code

 

tcp_socket_client客戶端

#!/usr/bin/env python
# -*- coding:utf-8 -*-      
#Author: nulige
 
from socket import *
ip_port=('127.0.0.1',8000)
back_log=5
buffer_size=1024

tcp_client=socket(AF_INET,SOCK_STREAM)
tcp_client.connect(ip_port)

while True:
    msg=input('>>: ').strip()
    if not msg:continue
    if msg == 'quit':break

    tcp_client.send(msg.encode('utf-8'))

    data=tcp_client.recv(buffer_size)
    print('收到服務端發來的消息: ',data.decode('utf-8'))
 
tcp_client.close()
View Code

 

執行結果:

開啓一個服務端程序,再開多個客戶端,向服務器發送命令:

#客戶端1
>>: hello   #輸入要發送的消息
收到服務端發來的消息:  HELLO

#客戶端2
>>: word
收到服務端發來的消息:  WORD

#服務端
conn is:  <socket.socket fd=412, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 8000), raddr=('127.0.0.1', 62813)>
addr is:  ('127.0.0.1', 62813)
收到客戶端的消息是 b'hello'  #客戶端收到的消息

conn is:  <socket.socket fd=256, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 8000), raddr=('127.0.0.1', 62816)>
addr is:  ('127.0.0.1', 62816)
收到客戶端的消息是 b'word'
View Code

 

 

二、udp實現併發

記住一個原則:對udp來講:self.request=(client_data_bytes,udp的套接字對象)

實例:

 udp_socket_server服務端:

#!/usr/bin/env python
# -*- coding:utf-8 -*-      
#Author: nulige
 
import socketserver

class MyServer(socketserver.BaseRequestHandler):
    def handle(self):
        print(self.request)
        print('收到客戶端的消息是',self.request[0])
        self.request[1].sendto(self.request[0].upper(),self.client_address) #發送的是第1個消息,第2個地址


if __name__ == '__main__':
    s=socketserver.ThreadingUDPServer(('127.0.0.1',8080),MyServer) #多線程
    s.serve_forever()
View Code

 

udp_socket_client客戶端:

#!/usr/bin/env python
# -*- coding:utf-8 -*-      
#Author: nulige
 
from socket import *
ip_port=('127.0.0.1',8080)
buffer_size=1024

udp_client=socket(AF_INET,SOCK_DGRAM) #數據報

while True:
    msg=input('>>: ').strip()
    udp_client.sendto(msg.encode('utf-8'),ip_port)

    data,addr=udp_client.recvfrom(buffer_size)
    # print(data.decode('utf-8'))
    print(data)
View Code

 

執行結果:

先啓動服務端,再開多個客戶端,向服務端發送消息。

#客戶端
>>: welcome  #輸入要發送的消息
b'WELCOME'

>>: hello
b'HELLO'
>>: 

#服務端
(b'welcome', <socket.socket fd=388, family=AddressFamily.AF_INET, type=SocketKind.SOCK_DGRAM, proto=0, laddr=('127.0.0.1', 8080)>)
收到客戶端的消息是 b'welcome'   #服務端接收到的消息

(b'hello', <socket.socket fd=388, family=AddressFamily.AF_INET, type=SocketKind.SOCK_DGRAM, proto=0, laddr=('127.0.0.1', 8080)>)
收到客戶端的消息是 b'hello'
View Code

 

 

十4、認證客戶端的連接合法性

若是你想在分佈式系統中實現一個簡單的客戶端連接認證功能,又不像SSL那麼複雜,那麼利用hmac+加鹽的方式來實現

tcp_socket_server服務端:

#!/usr/bin/env python
# -*- coding:utf-8 -*-      
#Author: nulige


from socket import *
import hmac,os

secret_key=b'linhaifeng bang bang bang'  #加段代碼(加鹽)
def conn_auth(conn):
    '''
    認證客戶端連接
    :param conn:
    :return:
    '''
    print('開始驗證新連接的合法性')
    msg=os.urandom(32)
    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('該連接不合法,關閉')
        conn.close()
        return
    print('連接合法,開始通訊')
    while True:
        data=conn.recv(bufsize)
        if not data:break
        conn.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=1024
    server_handler(ip_port,bufsize)
View Code

 

tcp_socket_client客戶端:

#!/usr/bin/env python
# -*- coding:utf-8 -*-      
#Author: nulige

from socket import *
import hmac,os

secret_key=b'linhaifeng bang bang bang'  #加鹽
def conn_auth(conn):
    '''
    驗證客戶端到服務器的連接
    :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:continue
        if data == 'quit':break

        tcp_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=1024
    client_handler(ip_port,bufsize)
View Code
相關文章
相關標籤/搜索