BS架構 （騰訊通軟件：server+client）html
CS架構 （web網站）python
C/S架構與socket的關係：linux
咱們學習socket就是爲了完成C/S架構的開發web
2、OSI七層模型
互聯網協議按照功能不一樣分爲osi七層或tcp/ip五層或tcp/ip四層算法
每層運行常見物理設備shell
詳細參考：編程
http://www.cnblogs.com/linhaifeng/articles/5937962.html#_label4windows
學習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、套接字工做流程
生活中的場景，你要打電話給一個朋友，先撥號，朋友聽到電話鈴聲後提起電話，這時你和你的朋友就創建起了鏈接，就能夠講話了。等交流結束，掛斷電話結束這次交談。
生活中的場景就解釋了這工做原理，也許TCP/IP協議族就是誕生於生活中，這也不必定。
先從服務器端提及。服務器端先初始化Socket，而後與端口綁定(bind)，對端口進行監聽(listen)，調用accept阻塞，等待客戶端鏈接。在這時若是有個客戶端初始化一個Socket，而後鏈接服務器(connect)，若是鏈接成功，這時客戶端與服務器端的鏈接就創建了。客戶端發送數據請求，服務器端接收請求並處理請求，而後把迴應數據發送給客戶端，客戶端讀取數據，最後關閉鏈接，一次交互結束。
一、socket模塊發送和接收消息
示例：模擬發送消息和接收消息的過程
tcp服務端（server）
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 #Author: nulige 4 5 import socket 6 7 phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #買手機 8 phone.bind(('127.0.0.1',8000)) #綁定手機卡 #改爲服務端網卡IP地址和端口 9 phone.listen(5) #開機 5的做用是最大掛起鏈接數 #backlog鏈接池（也叫半連接） 10 print('------------->') 11 conn,addr=phone.accept() #等電話 12 13 msg=conn.recv(1024) #收消息 14 print('客戶端發來的消息是：',msg) 15 conn.send(msg.upper()) #發消息 16 17 conn.close() 18 phone.close()
執行結果：
1 ------------->
tcp客戶端(client)
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 #Author: nulige 4 5 import socket 6 7 phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) 8 9 phone.connect(('127.0.0.1',8000)) #拔通電話 #改爲服務端網卡IP地址和端口 10 11 phone.send('hello'.encode('utf-8')) #發消息 12 data=phone.recv(1024) 13 print('收到服務端的發來的消息: ',data) 14 15 phone.close()
執行結果：
1 收到服務端的發來的消息: 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的那幾個函數中呢？請看下圖：
圖一、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四次握手
圖示過程以下：
- 某個應用進程首先調用close主動關閉鏈接，這時TCP發送一個FIN M；
- 另外一端接收到FIN M以後，執行被動關閉，對這個FIN進行確認。它的接收也做爲文件結束符傳遞給應用進程，由於FIN的接收意味着應用進程在相應的鏈接上再也接收不到額外數據；
- 一段時間以後，接收到文件結束符的應用進程調用close關閉它的socket。這致使它的TCP也發送一個FIN N；
- 接收到這個FIN的源發送端TCP對它進行確認。
這樣每一個方向上都有一個FIN和ACK。
總結：
四次揮手斷開鏈接原則：
記住一條原則：誰先發起客戶端請求，誰先斷開鏈接
可是在大併發狀況下，大部分都是服務端先斷開鏈接，不會保留鏈接。由於每一分鐘都有不少人在訪問網站。
三、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.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() 建立一個與該套接字相關的文件
6、基於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() #關閉客戶套接字
一、基於tcp實現：客戶端發送空格，服務端也會接收
示例：
tcp_server端
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 #Author: nulige 4 5 from socket import * 6 7 ip_port = ('127.0.0.1', 8080) 8 back_log = 5 9 buffer_size = 1024 10 11 tcp_server = socket(AF_INET, SOCK_STREAM) 12 tcp_server.bind(ip_port) 13 tcp_server.listen(back_log) 14 15 print('服務端開始運行了') 16 conn, addr = tcp_server.accept() #服務器阻塞 17 print('雙向連接是', conn) 18 print('客戶端地址', addr) 19 20 while True: 21 data = conn.recv(buffer_size) #收緩存爲空，則阻塞 22 print('客戶端發來的消息是', data.decode('utf-8')) 23 conn.send(data.upper()) 24 conn.close() 25 26 tcp_server.close()
tcp_client端
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 #Author: nulige 4 5 from socket import * 6 7 ip_port = ('127.0.0.1', 8080) 8 back_log = 5 9 buffer_size = 1024 10 11 tcp_client = socket(AF_INET, SOCK_STREAM) 12 tcp_client.connect(ip_port) 13 14 while True: 15 msg = input('>>:') #發送空格到本身的發送緩存中 16 # msg=input('>>:').strip() #去掉空格 17 tcp_client.send(msg.encode('utf-8')) 18 print('客戶端已經發送消息') 19 data = tcp_client.recv(buffer_size) #收緩存爲空則阻塞 20 print('收到服務端發來的消息是', data.decode('utf-8')) 21 22 tcp_client.close()
執行結果：
1 server: 2 服務端開始運行了 3 雙向連接是 <socket.socket fd=304, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 8080), raddr=('127.0.0.1', 53365)> 4 客戶端地址 ('127.0.0.1', 53365) 5 客戶端發來的消息是 6 7 client: 8 >>: 9 客戶端已經發送消息 10 收到服務端發來的消息是
實驗過程當中遇到的問題：
在重啓服務端時可能會遇到以下報錯：
這個是因爲你的服務端仍然存在四次揮手的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系統中，經過調整系統內核參數的方式來解決
1 發現系統存在大量TIME_WAIT狀態的鏈接，經過調整linux內核參數解決，（系統優化的一個優化點） 2 3 vi /etc/sysctl.conf 4 5 編輯文件，加入如下內容： 6 net.ipv4.tcp_syncookies = 1 7 net.ipv4.tcp_tw_reuse = 1 8 net.ipv4.tcp_tw_recycle = 1 9 net.ipv4.tcp_fin_timeout = 30 10 11 而後執行 /sbin/sysctl -p 讓參數生效。 12 13 net.ipv4.tcp_syncookies = 1 表示開啓SYN Cookies。當出現SYN等待隊列溢出時，啓用cookies來處理，可防範少許SYN攻擊，默認爲0，表示關閉； 14 15 net.ipv4.tcp_tw_reuse = 1 表示開啓重用。容許將TIME-WAIT sockets從新用於新的TCP鏈接，默認爲0，表示關閉； 16 17 net.ipv4.tcp_tw_recycle = 1 表示開啓TCP鏈接中TIME-WAIT sockets的快速回收，默認爲0，表示關閉。 18 19 net.ipv4.tcp_fin_timeout = 30 修改系統默認的 TIMEOUT 時間
7、基於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端
1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 #Author: nulige
4
5 from socket import *
6 ip_port=('127.0.0.1',8080)
7 buffer_size = 1024
8
9 udp_server = socket(AF_INET,SOCK_DGRAM) #數據報套接字
10 udp_server.bind(ip_port) 11 12 while True: 13 data,addr=udp_server.recvfrom(buffer_size) 14 print(data) 15 16 udp_server.sendto(data.upper(),addr) #upper() 小寫變大寫
udp_client端：
1 from socket import *
2 ip_port=('127.0.0.1',8080) #服務端IP+端口
3 buffer_size = 1024
4
5 udp_client=socket(AF_INET,SOCK_DGRAM) #udp數據報套接字
6
7 while True:
8 msg=input('>>:').strip() 9 udp_client.sendto(msg.encode('utf-8'),ip_port) 10 #數據，ip地址+端口 11 data,addr=udp_client.recvfrom(buffer_size) 12 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端
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 #Author: nulige 4 5 #實現ntp時間服務器 6 import time 7 from socket import * 8 ip_port=('127.0.0.1',8080) 9 buffer_size = 1024 10 11 udp_server = socket(AF_INET,SOCK_DGRAM) #數據報套接字 12 udp_server.bind(ip_port) 13 14 while True: 15 data,addr=udp_server.recvfrom(buffer_size) 16 print(data) 17 18 if not data: 19 fmt='%Y-%m-%d %X' #若是用戶沒有輸入時間，就返回默認格式 20 else: 21 fmt=data.decode('utf-8') 22 back_time=time.strftime(fmt) 23 24 udp_server.sendto(back_time.encode('utf-8'),addr)
udp_client端
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 #Author: nulige 4 5 from socket import * 6 ip_port=('127.0.0.1',8080) #服務端IP+端口 7 buffer_size = 1024 8 9 udp_client=socket(AF_INET,SOCK_DGRAM) #數據報套接字 10 11 while True: 12 msg=input('>>:').strip() 13 udp_client.sendto(msg.encode('utf-8'),ip_port) 14 15 data,addr=udp_client.recvfrom(buffer_size) 16 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上面運行）
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 #Author: nulige 4 5 from socket import * 6 import subprocess 7 8 ip_port = ('192.168.1.135', 8000) 9 back_log = 5 10 buffer_size = 1024 11 12 tcp_server = socket(AF_INET, SOCK_STREAM) 13 tcp_server.bind(ip_port) 14 tcp_server.listen(back_log) 15 16 while True: 17 conn,addr=tcp_server.accept() 18 print('新的客戶端連接',addr) 19 while True: 20 #收 21 try: 22 cmd=conn.recv(buffer_size) 23 #if not cmd:break MAC筆記本處理方法 24 print('收到客戶端的命令',cmd) 25 26 #執行命令，獲得命令的運行結果cmd_res 27 res=subprocess.Popen(cmd.decode('utf-8'),shell=True, 28 stderr=subprocess.PIPE, 29 stdout=subprocess.PIPE, 30 stdin=subprocess.PIPE) 31 err=res.stderr.read() 32 if err: 33 cmd_res=err 34 else: 35 cmd_res=res.stdout.read() 36 #發 37 conn.send(cmd_res) 38 except Exception as e: 39 print(e) 40 break 41 conn.close()
socket_client_tcp客戶端（windows系統上面運行）
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 #Author: nulige 4 5 from socket import * 6 7 # ip_port = ('127.0.0.1', 8082) 8 ip_port = ('192.168.1.135', 8000) 9 back_log = 5 10 buffer_size = 1024 11 12 tcp_client = socket(AF_INET, SOCK_STREAM) 13 tcp_client.connect(ip_port) 14 15 while True: 16 cmd=input('>>:').strip() 17 if not cmd:continue 18 if cmd == 'quit':break 19 20 tcp_client.send(cmd.encode('utf-8')) 21 cmd_res=tcp_client.recv(buffer_size) 22 # print('命令的執行結果是 ',cmd_res.decode('gbk')) 23 print('命令的執行結果是 ',cmd_res.decode('utf-8')) 24 tcp_client.close()
執行結果：
在客戶端執行命令：
1 >>:df -h 2 命令的執行結果是 Filesystem Size Used Avail Use% Mounted on 3 /dev/sda3 9.6G 1.8G 7.3G 20% / 4 tmpfs 931M 0 931M 0% /dev/shm 5 /dev/sda1 190M 32M 149M 18% /boot 6 /dev/sr0 4.4G 4.4G 0 100% /opt 7 8 >>:dir 9 命令的執行結果是 s3.py server_ssh.py socket_server.py 10 server.py socket_clinet_udp.py socket_server_udp.py 11 12 服務端返回結果： 13 [root@python3 scripts]# python socket_server.py 14 新的客戶端連接 ('192.168.1.115', 53569) 15 收到客戶端的命令 b'df -h' 16 收到客戶端的命令 b'dir'
四、基於udp實現遠程執行命令
socket_server_udp服務端：
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 #Author: nulige 4 5 from socket import * 6 import subprocess 7 8 ip_port = ('192.168.1.135', 8000) 9 back_log = 5 10 buffer_size = 1024 11 12 udp_server = socket(AF_INET, SOCK_DGRAM) 13 udp_server.bind(ip_port) 14 15 while True: 16 cmd,addr=udp_server.recvfrom(buffer_size) 17 print(cmd) 18 19 #執行命令，獲得命令的運行結果cmd_res 20 res = subprocess.Popen(cmd.decode('utf-8'), shell=True, 21 stderr=subprocess.PIPE, 22 stdout=subprocess.PIPE, 23 stdin=subprocess.PIPE) 24 err = res.stderr.read() 25 if err: 26 cmd_res = err 27 else: 28 cmd_res = res.stdout.read() 29 30 if not cmd_res: # 判斷爲空的狀況 31 cmd_res = '執行成功'.encode('gbk') #linux改爲utf-8 32 print(cmd_res) 33 #發 34 udp_server.sendto(cmd_res,addr)
socket_clinet_udp客戶端：
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 #Author: nulige 4 5 from socket import * 6 7 ip_port = ('192.168.1.135', 8000) 8 # ip_port = ('192.168.12.63', 8000) 9 back_log = 5 10 buffer_size = 10240 11 12 udp_client = socket(AF_INET, SOCK_DGRAM) 13 14 while True: 15 cmd=input('>>:').strip() 16 if not cmd:continue 17 if cmd == 'quit':break 18 19 udp_client.sendto(cmd.encode('utf-8'),ip_port) 20 cmd_res,addr=udp_client.recvfrom(buffer_size) 21 print('命令的執行結果是 ',cmd_res.decode('gbk')) #若是在linux上面運行，把gbk改爲utf-8 22 udp_client.close()
執行結果：
1 #在客戶端執行命令：（在windows服務器上面運行） 2 3 >>:cat /etc/passwd 4 命令的執行結果是 root:x:0:0:root:/root:/bin/bash 5 bin:x:1:1:bin:/bin:/sbin/nologin 6 daemon:x:2:2:daemon:/sbin:/sbin/nologin 7 adm:x:3:4:adm:/var/adm:/sbin/nologin 8 lp:x:4:7:lp:/var/spool/lpd:/sbin/nologin 9 sync:x:5:0:sync:/sbin:/bin/sync 10 shutdown:x:6:0:shutdown:/sbin:/sbin/shutdown 11 halt:x:7:0:halt:/sbin:/sbin/halt 12 mail:x:8:12:mail:/var/spool/mail:/sbin/nologin 13 uucp:x:10:14:uucp:/var/spool/uucp:/sbin/nologin 14 operator:x:11:0:operator:/root:/sbin/nologin 15 games:x:12:100:games:/usr/games:/sbin/nologin 16 gopher:x:13:30:gopher:/var/gopher:/sbin/nologin 17 ftp:x:14:50:FTP User:/var/ftp:/sbin/nologin 18 nobody:x:99:99:Nobody:/:/sbin/nologin 19 dbus:x:81:81:System message bus:/:/sbin/nologin 20 vcsa:x:69:69:virtual console memory owner:/dev:/sbin/nologin 21 abrt:x:173:173::/etc/abrt:/sbin/nologin 22 haldaemon:x:68:68:HAL daemon:/:/sbin/nologin 23 ntp:x:38:38::/etc/ntp:/sbin/nologin 24 saslauth:x:499:76:Saslauthd user:/var/empty/saslauth:/sbin/nologin 25 postfix:x:89:89::/var/spool/postfix:/sbin/nologin 26 sshd:x:74:74:Privilege-separated SSH:/var/empty/sshd:/sbin/nologin 27 tcpdump:x:72:72::/:/sbin/nologin 28 29 30 #服務端會返回相同結果：（在linux服務器上面運行） 31 32 [root@python3 scripts]# python socket_server_udp.py 33 b'cat /etc/passwd' 34 b'root:x:0:0:root:/root:/bin/bash\nbin:x:1:1:bin:/bin:/sbin/nologin\ndaemon:x:2:2:daemon:/sbin:/sbin/nologin\nadm:x:3:4:adm:/var/adm:/sbin/nologin\nlp:x:4:7:lp:/var/spool/lpd:/sbin/nologin\nsync:x:5:0:sync:/sbin:/bin/sync\nshutdown:x:6:0:shutdown:/sbin:/sbin/shutdown\nhalt:x:7:0:halt:/sbin:/sbin/halt\nmail:x:8:12:mail:/var/spool/mail:/sbin/nologin\nuucp:x:10:14:uucp:/var/spool/uucp:/sbin/nologin\noperator:x:11:0:operator:/root:/sbin/nologin\ngames:x:12:100:games:/usr/games:/sbin/nologin\ngopher:x:13:30:gopher:/var/gopher:/sbin/nologin\nftp:x:14:50:FTP User:/var/ftp:/sbin/nologin\nnobody:x:99:99:Nobody:/:/sbin/nologin\ndbus:x:81:81:System message bus:/:/sbin/nologin\nvcsa:x:69:69:virtual console memory owner:/dev:/sbin/nologin\nabrt:x:173:173::/etc/abrt:/sbin/nologin\nhaldaemon:x:68:68:HAL daemon:/:/sbin/nologin\nntp:x:38:38::/etc/ntp:/sbin/nologin\nsaslauth:x:499:76:Saslauthd user:/var/empty/saslauth:/sbin/nologin\npostfix:x:89:89::/var/spool/postfix:/sbin/nologin\nsshd:x:74:74:Privilege-separated SSH:/var/empty/sshd:/sbin/nologin\ntcpdump:x:72:72::/:/sbin/nologin\n'
8、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時纔會清除緩衝區內容。數據是可靠的，可是會粘包。
9、粘包
須知：只有TCP有粘包現象，UDP永遠不會粘包。（緣由詳見第3點）
一、socket收發消息的原理
socket發送原理圖
二、爲何會出現所謂的粘包
緣由：接收方不知道消息之間的界限，不知道一次性提取多少字節的數據所形成的。
此外，發送方引發的粘包是由TCP協議自己形成的，TCP爲提升傳輸效率，發送方每每要收集到足夠多的數據後才發送一個TCP段。若連續幾回須要send的數據都不多，一般TCP會根據優化算法把這些數據合成一個TCP段後一次發送出去，這樣接收方就收到了粘包數據。
- TCP（transport control protocol，傳輸控制協議）是面向鏈接的，面向流的，提供高可靠性服務。收發兩端（客戶端和服務器端）都要有一一成對的socket，所以，發送端爲了將多個發往接收端的包，更有效的發到對方，使用了優化方法（Nagle算法），將屢次間隔較小且數據量小的數據，合併成一個大的數據塊，而後進行封包。這樣，接收端，就難於分辨出來了，必須提供科學的拆包機制。 即面向流的通訊是無消息保護邊界的。
- UDP（user datagram protocol，用戶數據報協議）是無鏈接的，面向消息的，提供高效率服務。不會使用塊的合併優化算法，, 因爲UDP支持的是一對多的模式，因此接收端的skbuff(套接字緩衝區）採用了鏈式結構來記錄每個到達的UDP包，在每一個UDP包中就有了消息頭（消息來源地址，端口等信息），這樣，對於接收端來講，就容易進行區分處理了。 即面向消息的通訊是有消息保護邊界的。
- tcp是基於數據流的，因而收發的消息不能爲空，這就須要在客戶端和服務端都添加空消息的處理機制，防止程序卡住，而udp是基於數據報的，即使是你輸入的是空內容（直接回車），那也不是空消息，udp協議會幫你封裝上消息頭。
三、tcp會發生粘包的兩種狀況以下：
一、發送端屢次send間隔較短，而且數據量較小，tcp會經過Nagls算法，封裝成一個包，發送到接收端，接收端不知道這個包由幾部分組成，因此就會產生粘包。
二、數據量發送的大，接收端接收的小，再接一次，還會出現上次沒有接收完成的數據。就會出現粘包
示例1： 發送端屢次send間隔較短，而且數據量較小，tcp會經過Nagls算法，封裝成一個包，發送到接收端，接收端不知道這個包由幾部分組成，因此就會產生粘包。
server服務端：
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 #Author: nulige 4 5 from socket import * 6 ip_port=('127.0.0.1',8082) 7 back_log=5 8 buffer_size=1024 9 10 tcp_server=socket(AF_INET,SOCK_STREAM) 11 tcp_server.bind(ip_port) 12 tcp_server.listen(back_log) 13 14 conn,addr=tcp_server.accept() 15 16 data1=conn.recv(buffer_size) #指定buffer_size ,獲得的結果就是經過Nagle算法，隨機接收次數。 17 print('第1次數據',data1) 18 19 data2=conn.recv(buffer_size) 20 print('第2次數據',data2) 21 22 data3=conn.recv(buffer_size) 23 print('第3次數據',data3)
client客戶端
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 #Author: nulige 4 5 from socket import * 6 import time 7 8 ip_port=('127.0.0.1',8082) 9 back_log=5 10 buffer_size=1024 11 12 tcp_client=socket(AF_INET,SOCK_STREAM) 13 tcp_client.connect(ip_port) 14 15 tcp_client.send('hello'.encode('utf-8')) 16 tcp_client.send('world'.encode('utf-8')) 17 tcp_client.send('egon'.encode('utf-8')) 18 19 20 time.sleep(1000)
執行結果：
1 第1次數據 b'helloworldegon' #不肯定接收次數。
示例2：指定接收字節數，至關於服務端知道接收長度，就不會出現粘包現象
粘包服務端
1 from socket import * 2 ip_port=('127.0.0.1',8080) 3 back_log=5 4 buffer_size=1024 5 6 tcp_server=socket(AF_INET,SOCK_STREAM) 7 tcp_server.bind(ip_port) 8 tcp_server.listen(back_log) 9 10 conn,addr=tcp_server.accept() 11 12 data1=conn.recv(5) #指定每次接收字節數，就不會出現粘包現象 13 print('第一次數據',data1) 14 15 data2=conn.recv(5) 16 print('第2次數據',data2) 17 18 data3=conn.recv(5) 19 print('第3次數據',data3)
粘包客戶端
1 from socket import * 2 import time 3 ip_port=('127.0.0.1',8080) 4 back_log=5 5 buffer_size=1024 6 7 tcp_client=socket(AF_INET,SOCK_STREAM) 8 tcp_client.connect(ip_port) 9 10 tcp_client.send('hello'.encode('utf-8')) 11 tcp_client.send('world'.encode('utf-8')) 12 tcp_client.send('egon'.encode('utf-8')) 13 14 15 time.sleep(1000)
執行結果：
1 第1次數據 b'hello' #不會出現粘包現象，發送三次，就接收三次 2 第2次數據 b'world' 3 第3次數據 b'egon'
示例3：數據量發送的大，接收端接收的小，再接一次，還會出現上次沒有接收完成的數據。就會出現粘包。
粘包服務端
1 from socket import * 2 ip_port=('127.0.0.1',8080) 3 back_log=5 4 buffer_size=1024 5 6 tcp_server=socket(AF_INET,SOCK_STREAM) 7 tcp_server.bind(ip_port) 8 tcp_server.listen(back_log) 9 10 conn,addr=tcp_server.accept() 11 12 data1=conn.recv(1) 13 print('第1次數據',data1) 14 15 # data2=conn.recv(5) 16 # print('第2次數據',data2) 17 # 18 # data3=conn.recv(1) 19 # print('第3次數據',data3)
粘包客戶端
1 from socket import * 2 import time 3 ip_port=('127.0.0.1',8080) 4 back_log=5 5 buffer_size=1024 #接收的數據只有1024 6 7 tcp_client=socket(AF_INET,SOCK_STREAM) 8 tcp_client.connect(ip_port) 9 10 tcp_client.send('helloworldegon'.encode('utf-8')) 11 12 time.sleep(1000)
執行結果：
1 第1次數據 b'h' 2 第2次數據 b'ellow' #發送的數據過大，接收的數據設置的較小，就會出現致使粘包 3 第3次數據 b'o'
四、udp永遠不會粘包
示例：
udp不粘包服務端
1 from socket import * 2 ip_port=('127.0.0.1',8080) 3 buffer_size=1024 4 5 udp_server=socket(AF_INET,SOCK_DGRAM) #數據報 6 udp_server.bind(ip_port) 7 8 data1=udp_server.recvfrom(10) 9 print('第1次',data1) 10 11 data2=udp_server.recvfrom(10) 12 print('第2次',data2) 13 14 15 data3=udp_server.recvfrom(10) 16 print('第3次',data3) 17 18 data4=udp_server.recvfrom(2) 19 print('第4次',data4)
udp不粘包客戶端
1 from socket import * 2 ip_port=('127.0.0.1',8080) 3 buffer_size=1024 4 5 udp_client=socket(AF_INET,SOCK_DGRAM) #udp叫數據報 6 7 udp_client.sendto(b'hello',ip_port) 8 udp_client.sendto(b'world',ip_port) 9 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服務端代碼：
1 #實現相似於QQ聊天功能 2 3 #!/usr/bin/env python 4 # -*- coding:utf-8 -*- 5 #Author: nulige 6 7 import socket 8 ip_port=('127.0.0.1',8081) 9 udp_server_sock=socket.socket(socket.AF_INET,socket.SOCK_DGRAM) 10 udp_server_sock.bind(ip_port) 11 12 while True: 13 qq_msg,addr=udp_server_sock.recvfrom(1024) 14 print('來自[%s:%s]的一條消息:\033[1;44m%s\033[0m' %(addr[0],addr[1],qq_msg.decode('utf-8'))) 15 back_msg=input('回覆消息: ').strip() 16 17 udp_server_sock.sendto(back_msg.encode('utf-8'),addr)
udp_socket_client客戶端：
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 #Author: nulige 4 5 import socket 6 BUFSIZE=1024 7 udp_client_socket=socket.socket(socket.AF_INET,socket.SOCK_DGRAM) 8 9 qq_name_dic={ 10 '強哥':('127.0.0.1',8081), 11 '劉哥':('127.0.0.1',8081), 12 '李哥':('127.0.0.1',8081), 13 '王哥':('127.0.0.1',8081), 14 } 15 16 while True: 17 qq_name=input('請選擇聊天對象: ').strip() #選擇字典中的聊天對象，再發送消息 18 while True: 19 msg=input('請輸入消息,回車發送: ').strip() 20 if msg == 'quit':break 21 if not msg or not qq_name or qq_name not in qq_name_dic:continue 22 udp_client_socket.sendto(msg.encode('utf-8'),qq_name_dic[qq_name]) 23 24 back_msg,addr=udp_client_socket.recvfrom(BUFSIZE) 25 print('來自[%s:%s]的一條消息:\033[1;44m%s\033[0m' %(addr[0],addr[1],back_msg.decode('utf-8'))) 26 27 udp_client_socket.close()
執行結果：
先啓動服務端,再啓動客戶端向服務端發送消息：
1 #客戶端發送消息 2 3 請選擇聊天對象: 努力哥 4 請輸入消息,回車發送: 吃飯沒有 5 來自[127.0.0.1:8081]的一條消息:還沒吃呢 6 請輸入消息,回車發送: 7 8 #服務端接收消息 9 10 來自[127.0.0.1:62642]的一條消息:吃飯沒有 11 回覆消息: 還沒吃呢
補充知識：
一、tcp是可靠傳輸
tcp在數據傳輸時，發送端先把數據發送到本身的緩存中，而後協議控制將緩存中的數據發往對端，對端返回一個ack=1，發送端則清理緩存中的數據，對端返回ack=0，則從新發送數據，因此tcp是可靠的。
二、udp是不可靠傳輸
udp發送數據，對端是不會返回確認信息的，所以不可靠。
10、解決粘包的辦法
法一：比較(LOW)版本
示例：
low_socket_server服務端
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 #Author: nulige 4 5 #low版解決粘包版本服務端 6 from socket import * 7 import subprocess 8 ip_port=('127.0.0.1',8080) 9 back_log=5 10 buffer_size=1024 11 12 tcp_server=socket(AF_INET,SOCK_STREAM) 13 tcp_server.bind(ip_port) 14 tcp_server.listen(back_log) 15 16 while True: 17 conn,addr=tcp_server.accept() 18 print('新的客戶端連接',addr) 19 while True: 20 #收消息 21 try: 22 cmd=conn.recv(buffer_size) 23 if not cmd:break 24 print('收到客戶端的命令',cmd) 25 26 #執行命令，獲得命令的運行結果cmd_res 27 res=subprocess.Popen(cmd.decode('utf-8'),shell=True, 28 stderr=subprocess.PIPE, 29 stdout=subprocess.PIPE, 30 stdin=subprocess.PIPE) 31 err=res.stderr.read() 32 if err: 33 cmd_res=err 34 else: 35 cmd_res=res.stdout.read() 36 37 #發送消息 38 if not cmd_res: 39 cmd_res='執行成功'.encode('gbk') 40 41 length=len(cmd_res) #計算長度 42 conn.send(str(length).encode('utf-8')) #把長度發給客戶端 43 client_ready=conn.recv(buffer_size) #卡着一個recv 44 if client_ready == b'ready': #若是收到客戶端的ready消息，就說明準備好了。 45 conn.send(cmd_res) #就能夠send給客戶端發送消息啦！ 46 except Exception as e: 47 print(e) 48 break
low_socket_client客戶端
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 #Author: nulige 4 5 #low版解決粘包版客戶端 6 from socket import * 7 ip_port=('127.0.0.1',8080) 8 back_log=5 9 buffer_size=1024 10 11 tcp_client=socket(AF_INET,SOCK_STREAM) 12 tcp_client.connect(ip_port) 13 14 while True: 15 cmd=input('>>: ').strip() 16 if not cmd:continue 17 if cmd == 'quit':break 18 19 tcp_client.send(cmd.encode('utf-8')) 20 21 22 #解決粘包 23 length=tcp_client.recv(buffer_size) #接收發送過來的長度（1024*8=8192，2**8192=能夠接收的長度） 24 tcp_client.send(b'ready') #客戶端再send給服務端，告訴服務端我準備好啦！ 25 26 length=int(length.decode('utf-8')) #先解碼，轉成字符串的長度 27 #解決思路：就是提早發一個頭過去，告訴客戶端須要接收的長度（分兩步：一、發送發度 二、再次發送數據） 28 recv_size=0 #接收的尺寸 29 recv_msg=b'' #最後要拼接起來 30 while recv_size < length: #要收多大？，要先判斷接收的尺寸<length 31 recv_msg += tcp_client.recv(buffer_size) #接收到的數據，拼接buffer_size， 32 recv_size=len(recv_msg) #1024 #衡量本身接收了多少數據,有沒有收完（統計recv_msg的長度） 33 34 35 print('命令的執行結果是 ',recv_msg.decode('gbk')) 36 tcp_client.close()
執行結果：
1 #客戶端執行命令： 2 >>: cat /etc/passwd 3 命令的執行結果是 'cat' is not recognized as an internal or external command, 4 operable program or batch file. 5 6 >>: dir 7 命令的執行結果是 Volume in drive D is SSD 8 Volume Serial Number is 687D-EF64 9 10 Directory of D:\python\day30 11 12 2017/01/04 00:36 <DIR> . 13 2017/01/04 00:36 <DIR> .. 14 2017/01/03 11:39 613 client.py 15 2017/01/03 11:40 597 client_01.py 16 2017/01/03 11:40 597 client_02.py 17 2017/01/04 00:35 770 low_socket_client.py 18 2017/01/04 00:36 1,408 low_socket_server.py 19 2017/01/03 15:54 438 ntp_clinet.py 20 2017/01/03 16:01 591 ntp_server.py 21 2017/01/03 19:36 206 s1_server.py 22 2017/01/03 11:26 588 server.py 23 2017/01/03 11:55 717 server01.py 24 2017/01/03 23:57 603 socket_clinet_tcp.py 25 2017/01/04 00:12 531 socket_clinet_udp.py 26 2017/01/03 17:48 1,301 socket_server_tcp.py 27 2017/01/03 18:27 897 socket_server_udp.py 28 2017/01/03 15:38 440 udp_clinet.py 29 2017/01/03 15:23 355 udp_server.py 30 16 File(s) 10,652 bytes 31 2 Dir(s) 638,994,411,520 bytes free 32 33 >>: cd .. 34 命令的執行結果是 執行成功 35 36 37 #服務端返回結果： 38 新的客戶端連接 ('127.0.0.1', 54395) 39 收到客戶端的命令 b'cat /etc/passwd' 40 收到客戶端的命令 b'dir' 41 收到客戶端的命令 b'cd ..'
總結：
（爲什麼low): 程序的運行速度遠快於網絡傳輸速度，因此在發送一段字節前，先用send去發送該字節流長度，這種方式會放大網絡延遲帶來的性能損耗
法二：節省網絡傳輸版本（牛逼版本）
爲字節流加上自定義固定長度報頭，報頭中包含字節流長度，而後一次send到對端，對端在接收時，先從緩存中取出定長的報頭，而後再取真實數據。
示例：(沒實現多客戶端併發）
tcp_socket_server服務端：
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 #Author: nulige 4 5 from socket import * 6 import subprocess 7 import struct 8 ip_port=('127.0.0.1',8080) 9 back_log=5 10 buffer_size=1024 11 12 tcp_server=socket(AF_INET,SOCK_STREAM) 13 tcp_server.bind(ip_port) 14 tcp_server.listen(back_log) 15 16 while True: 17 conn,addr=tcp_server.accept() 18 print('新的客戶端連接',addr) 19 while True: 20 #收 21 try: 22 cmd=conn.recv(buffer_size) 23 if not cmd:break 24 print('收到客戶端的命令',cmd) 25 26 #執行命令，獲得命令的運行結果cmd_res 27 res=subprocess.Popen(cmd.decode('utf-8'),shell=True, 28 stderr=subprocess.PIPE, 29 stdout=subprocess.PIPE, 30 stdin=subprocess.PIPE) 31 err=res.stderr.read() 32 if err: 33 cmd_res=err 34 else: 35 cmd_res=res.stdout.read() 36 37 #發 38 if not cmd_res: 39 cmd_res='執行成功'.encode('gbk') 40 41 length=len(cmd_res) 42 43 data_length=struct.pack('i',length) 44 conn.send(data_length) 45 conn.send(cmd_res) 46 except Exception as e: 47 print(e) 48 break
tcp_socket_client客戶端
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 #Author: nulige 4 5 from socket import * 6 import struct 7 from functools import partial 8 ip_port=('127.0.0.1',8080) 9 back_log=5 10 buffer_size=1024 11 12 tcp_client=socket(AF_INET,SOCK_STREAM) 13 tcp_client.connect(ip_port) 14 15 while True: 16 cmd=input('>>: ').strip() 17 if not cmd:continue 18 if cmd == 'quit':break 19 20 tcp_client.send(cmd.encode('utf-8')) 21 22 23 #解決粘包 24 length_data=tcp_client.recv(4) 25 length=struct.unpack('i',length_data)[0] 26 27 recv_size=0 28 recv_data=b'' 29 while recv_size < length: 30 recv_data+=tcp_client.recv(buffer_size) 31 recv_size=len(recv_data) 32 print('命令的執行結果是 ',recv_data.decode('gbk')) 33 tcp_client.close()
執行結果：
1 #客戶端向服務器發送消息 2 >>: dir 3 命令的執行結果是 Volume in drive D is SSD 4 Volume Serial Number is 687D-EF64 5 6 Directory of D:\python\day31 7 8 2017/01/05 18:31 <DIR> . 9 2017/01/05 18:31 <DIR> .. 10 2017/01/05 14:33 244 s1.py 11 2017/01/05 18:29 752 s1_tcp_socket_client.py 12 2017/01/05 18:31 679 s1_tcp_socket_client01.py 13 2017/01/05 18:28 1,325 s1_tcp_socket_server.py 14 2017/01/05 15:01 498 tcp_socket_client.py 15 2017/01/05 15:00 670 tcp_socket_server.py 16 2017/01/05 17:16 391 udp_socket_clinet.py 17 2017/01/05 17:20 512 udp_socket_server.py 18 8 File(s) 5,071 bytes 19 2 Dir(s) 609,921,380,352 bytes free 20 21 #服務端返回結果： 22 新的客戶端連接 ('127.0.0.1', 53585) 23 收到客戶端的命令 b'dir'
11、socket 實現併發
SocketServer是基於socket寫成的一個更強大的模塊。
SocketServer簡化了網絡服務器的編寫。它有4個類：TCPServer，UDPServer，UnixStreamServer，UnixDatagramServer。這4個類是同步進行處理的，另外經過ForkingMixIn和ThreadingMixIn類來支持異步。
在python3中該模塊是socketserver
在python2中該模塊是Socketserver
1 分狀況導入導入模塊 2 try: 3 import socketserver #Python 3 4 except ImportError: 5 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模塊中主要的有如下幾個類：
關係圖以下：
建立服務器的步驟：
1：首先必須建立一個請求處理類
2：它是BaseRequestHandler的子類
3：該請求處理類是BaseRequestHandler的子類並從新寫其handle()方法
實例化 請求處理類傳入服務器地址和請求處理程序類
最後實例化調用serve_forever() #無限處理client請求
記住一個原則：對tcp來講：self.request=conn
示例：
一、tcp_socket_server服務端
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 #Author: nulige 4 5 #服務端已經實現併發，處理客戶端請求 6 7 import socketserver 8 9 class MyServer(socketserver.BaseRequestHandler): #基本的通訊循環 10 def handle(self): 11 print('conn is: ',self.request) #與client的連接請求信息 12 print('addr is: ',self.client_address) #獲取client的地址和端口號 13 #通訊循環 14 while True: 15 #收消息 16 data=self.request.recv(1024) 17 print('收到客戶端的消息是',data) 18 19 #發消息 20 self.request.sendall(data.upper()) 21 22 if __name__ == '__main__': 23 s=socketserver.ThreadingTCPServer(('127.0.0.1',8000),MyServer) #開啓多線程，綁定地址，和處理通訊的類 24 s.serve_forever() #鏈接循環
tcp_socket_client客戶端
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 #Author: nulige 4 5 from socket import * 6 ip_port=('127.0.0.1',8000) 7 back_log=5 8 buffer_size=1024 9 10 tcp_client=socket(AF_INET,SOCK_STREAM) 11 tcp_client.connect(ip_port) 12 13 while True: 14 msg=input('>>: ').strip() 15 if not msg:continue 16 if msg == 'quit':break 17 18 tcp_client.send(msg.encode('utf-8')) 19 20 data=tcp_client.recv(buffer_size) 21 print('收到服務端發來的消息: ',data.decode('utf-8')) 22 23 tcp_client.close()
執行結果：
開啓一個服務端程序，再開多個客戶端，向服務器發送命令：
1 #客戶端1 2 >>: hello #輸入要發送的消息 3 收到服務端發來的消息: HELLO 4 5 #客戶端2 6 >>: word 7 收到服務端發來的消息: WORD 8 9 #服務端 10 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)> 11 addr is: ('127.0.0.1', 62813) 12 收到客戶端的消息是 b'hello' #客戶端收到的消息 13 14 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)> 15 addr is: ('127.0.0.1', 62816) 16 收到客戶端的消息是 b'word'
二、udp實現併發
記住一個原則：對udp來講：self.request=(client_data_bytes,udp的套接字對象)
實例：
udp_socket_server服務端：
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 #Author: nulige 4 5 import socketserver 6 7 class MyServer(socketserver.BaseRequestHandler): 8 def handle(self): 9 print(self.request) 10 print('收到客戶端的消息是',self.request[0]) 11 self.request[1].sendto(self.request[0].upper(),self.client_address) #發送的是第1個消息，第2個地址 12 13 14 if __name__ == '__main__': 15 s=socketserver.ThreadingUDPServer(('127.0.0.1',8080),MyServer) #多線程 16 s.serve_forever()
udp_socket_client客戶端：
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 #Author: nulige 4 5 from socket import * 6 ip_port=('127.0.0.1',8080) 7 buffer_size=1024 8 9 udp_client=socket(AF_INET,SOCK_DGRAM) #數據報 10 11 while True: 12 msg=input('>>: ').strip() 13 udp_client.sendto(msg.encode('utf-8'),ip_port) 14 15 data,addr=udp_client.recvfrom(buffer_size) 16 # print(data.decode('utf-8')) 17 print(data)
執行結果：
先啓動服務端，再開多個客戶端，向服務端發送消息。
1 #客戶端 2 >>: welcome #輸入要發送的消息 3 b'WELCOME' 4 5 >>: hello 6 b'HELLO' 7 >>: 8 9 #服務端 10 (b'welcome', <socket.socket fd=388, family=AddressFamily.AF_INET, type=SocketKind.SOCK_DGRAM, proto=0, laddr=('127.0.0.1', 8080)>) 11 收到客戶端的消息是 b'welcome' #服務端接收到的消息 12 13 (b'hello', <socket.socket fd=388, family=AddressFamily.AF_INET, type=SocketKind.SOCK_DGRAM, proto=0, laddr=('127.0.0.1', 8080)>) 14 收到客戶端的消息是 b'hello'
12、認證客戶端的連接合法性
若是你想在分佈式系統中實現一個簡單的客戶端連接認證功能，又不像SSL那麼複雜，那麼利用hmac+加鹽的方式來實現
tcp_socket_server服務端：
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 #Author: nulige 4 5 6 from socket import * 7 import hmac,os 8 9 secret_key=b'linhaifeng bang bang bang' #加段代碼（加鹽） 10 def conn_auth(conn): 11 ''' 12 認證客戶端連接 13 :param conn: 14 :return: 15 ''' 16 print('開始驗證新連接的合法性') 17 msg=os.urandom(32) 18 conn.sendall(msg) 19 h=hmac.new(secret_key,msg) 20 digest=h.digest() 21 respone=conn.recv(len(digest)) 22 return hmac.compare_digest(respone,digest) 23 24 def data_handler(conn,bufsize=1024): 25 if not conn_auth(conn): 26 print('該連接不合法,關閉') 27 conn.close() 28 return 29 print('連接合法,開始通訊') 30 while True: 31 data=conn.recv(bufsize) 32 if not data:break 33 conn.sendall(data.upper()) 34 35 def server_handler(ip_port,bufsize,backlog=5): 36 ''' 37 只處理連接 38 :param ip_port: 39 :return: 40 ''' 41 tcp_socket_server=socket(AF_INET,SOCK_STREAM) 42 tcp_socket_server.bind(ip_port) 43 tcp_socket_server.listen(backlog) 44 while True: 45 conn,addr=tcp_socket_server.accept() 46 print('新鏈接[%s:%s]' %(addr[0],addr[1])) 47 data_handler(conn,bufsize) 48 49 if __name__ == '__main__': 50 ip_port=('127.0.0.1',9999) 51 bufsize=1024 52 server_handler(ip_port,bufsize)
tcp_socket_client客戶端：
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 #Author: nulige 4 5 from socket import * 6 import hmac,os 7 8 secret_key=b'linhaifeng bang bang bang' #加鹽 9 def conn_auth(conn): 10 ''' 11 驗證客戶端到服務器的連接 12 :param conn: 13 :return: 14 ''' 15 msg=conn.recv(32) 16 h=hmac.new(secret_key,msg) 17 digest=h.digest() 18 conn.sendall(digest) 19 20 def client_handler(ip_port,bufsize=1024): 21 tcp_socket_client=socket(AF_INET,SOCK_STREAM) 22 tcp_socket_client.connect(ip_port) 23 24 conn_auth(tcp_socket_client) 25 26 while True: 27 data=input('>>: ').strip() 28 if not data:continue 29 if data == 'quit':break 30 31 tcp_socket_client.sendall(data.encode('utf-8')) 32 respone=tcp_socket_client.recv(bufsize) 33 print(respone.decode('utf-8')) 34 tcp_socket_client.close() 35 36 if __name__ == '__main__': 37 ip_port=('127.0.0.1',9999) 38 bufsize=1024 39 client_handler(ip_port,bufsize)