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()
執行結果:
------------->
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()
執行結果:
收到服務端的發來的消息: b'HELLO'
二、tcp三次握手和四次揮手
主動斷開鏈接 :FIN_WAIT_1
被動斷開鏈接: FIN_WAIT_2
立刻斷開鏈接: TIME_WAIT
socket中TCP的三次握手創建鏈接詳解
流程以下:
只有就完了三次握手,可是這個三次握手發生在socket的那幾個函數中呢?請看下圖:
圖一、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中的四次握手釋放鏈接的過程,請看下圖:
圖二、socket中發送的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)
服務端套接字函數
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() #關閉服務器套接字(可選)
tcp客戶端
cs = socket() #建立客戶套接字 cs.connect() #嘗試鏈接服務器 comm_loop: #通信循環 cs.send()/cs.recv() #對話(發送/接收) cs.close() #關閉客戶套接字
一、基於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()
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()
執行結果:
實驗過程當中遇到的問題:
在重啓服務端時可能會遇到以下報錯:
這個是因爲你的服務端仍然存在四次揮手的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 時間
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() 小寫變大寫
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'))
執行結果:
先運行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)
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'))
執行結果:
運行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()
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()
執行結果:
在客戶端執行命令:
>>: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'
四、基於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)
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()
執行結果:
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段後一次發送出去,這樣接收方就收到了粘包數據。
三、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)
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)
執行結果:
第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)
粘包客戶端
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)
執行結果:
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)
粘包客戶端
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)
執行結果:
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)
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)
執行結果:
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)
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()
執行結果:
先啓動服務端,再啓動客戶端向服務端發送消息:
#客戶端發送消息 請選擇聊天對象: 努力哥 請輸入消息,回車發送: 吃飯沒有 來自[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
low_socket_client客戶端
執行結果:
總結:
(爲什麼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
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()
執行結果:
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
示例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類型
示例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"
二、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
示例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類型
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() #鏈接循環
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()
執行結果:
開啓一個服務端程序,再開多個客戶端,向服務器發送命令:
#客戶端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'
二、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()
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)
執行結果:
先啓動服務端,再開多個客戶端,向服務端發送消息。
#客戶端 >>: 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'
十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)
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)