python,網絡程式設計

網絡知識補充

1、CS架構與BS架構
    CS:用戶端，服務端
    BS：浏覽器，伺服器

2、tcp 三次握手，四次揮手
![img](https://images2015.cnblogs.com/blog/1036857/201610/1036857-20161008185648160-191189690.png)

3、資料包傳輸過程
![img](https://img2020.cnblogs.com/blog/1036857/202004/1036857-20200415215541847-564448301.gif)           

基于TCP協定的套接字

server端：

from socket import *
phone = socket(AF_INET,SOCK_STREAM)     #建立伺服器套接字
phone.bind(('127.0.0.1',8899))        #把位址綁定到套接字
phone.listen(5)                        #監聽連結，括号内為指定半連接配接數
while True:
    conn,client_add = phone.accept()    #接受用戶端連結,conn表示連接配接，client表示用戶端ip和端口
    print(conn)
    print('用戶端的ip和端口',client_add)
    
#conn.close()    #關閉目前連接配接
#phone.close()            # 關閉套接字伺服器




client端：

from socket import *
phone = socket(AF_INET,SOCK_STREAM)        #建立伺服器套接字
phone.connect(('127.0.0.1',8899))        #設定連接配接位址

while True:
    msg = input('請輸入指令:').strip()
    if len(msg) == 0:
        continue
    phone.send(msg.encode('utf-8'))        #設定發送的資料
    data = phone.recv(1024)                #設定接收的資料
    print('接收到伺服器發來的：',data.decode('utf-8'))
phone.close()    #關閉目前連接配接           

基于UDP協定的套接字

伺服器：
from socket import *
phone = socket(AF_INET,SOCK_DGRAM)
while True:
    choice = input('請輸入傳輸内容：').strip()
    phone.sendto(choice.encode('utf-8'),('127.0.0.1',8081))
    func=phone.recv(1024)
    print(func.decode('utf-8'))
    # phone.close()


用戶端
from socket import *
phone = socket(AF_INET,SOCK_DGRAM)
while True:
    choice = input('請輸入傳輸内容：').strip()
    phone.sendto(choice.encode('utf-8'),('127.0.0.1',8081))
    func=phone.recv(1024)
    print(func.decode('utf-8'))
    # phone.close()                             

TCP沾包問題 and 遠端執行指令功能

服務端：
import json
import struct
from socket import *
import subprocess
import string
import _json


phone = socket(AF_INET,SOCK_STREAM)
phone.bind(('127.0.0.1',8899))
phone.listen(5)

while True:
        conn,client_add = phone.accept()
        while True:
            try:
                cmd = conn.recv(1024)
                if len(cmd) ==0:
                    break
                obj = subprocess.Popen(
                    cmd.decode('utf-8'),
                    shell = True,
                    stdout=subprocess.PIPE,
                    stderr=subprocess.PIPE,
                )

                stdout_res = obj.stdout.read()
                stderr_res = obj.stderr.read()
                total_size = len(stderr_res) + len(stdout_res)
                header_dir = {
                    "filename":'a.txt',
                    "total_size":total_size,
                    "md5":'123123ass123'
                }

            #服務端：
                #1、制作頭
                # 将字典轉化成json格式的字元串,然後在轉化為bytes，然後将其打入到header_size裡
                json_str = json.dumps(header_dir)
                json_str_bytes = json_str.encode('utf-8')
                x = struct.pack('i',len(json_str_bytes))

                #2、将頭的長度發送過去
                conn.send(x)

                #3、傳輸頭資訊
                conn.send(json_str_bytes)

                #4、最後發送真時資料
                conn.send(stdout_res)
                conn.send(stderr_res)

            #接收端
                #1、先收4個字，從中提取下來要收的頭的長度
                #2、json_str_bytes = recv (頭的長度)
                #   json_str=json_str_bytes.decode('utf-8')
                #   header_dic = json.loads(json_str)
                #   print(header_dic)
                #   total_size = header_dic["total_size"]
                #3、接收真正的資料

            except Exception:
                break
        # conn.close()
        
        
用戶端：
import struct
from socket import *
import json
client = socket(AF_INET,SOCK_STREAM)
client.connect(('127.0.0.1',8899))

while True:
    cmd = input('請輸入指令:').strip()
    if len(cmd) == 0:
        continue
    client.send(cmd.encode('utf-8'))

    # 1、先收4個字，從中提取下來要收的頭的長度
    x=client.recv(4)
    if not len(x) == 4:
        continue
    header_len = struct.unpack('i',x)[0]     #将拿到的4個集位元組進行反解
    # 2、接收頭并解析
    json_str_bytes = client.recv (header_len)
    json_str=json_str_bytes.decode('utf-8')
    header_dic = json.loads(json_str)
    print(header_dic)
    total_size = header_dic["total_size"]
    # 3、接收真正的資料
    recv_size = 0
    while recv_size < total_size:
        recv_data = client.recv(1024)
        recv_size += len(recv_data)
        print(recv_data.decode('gbk'),end='')
    else:
        print()           

socketserver多并發

基于TCP

#服務端
import socketserver
class MyRequestHandle(socketserver.BaseRequestHandler):
    def handle(self):
        print(self.request) #如果tcp協定，self.request=>conn
        print(self.client_address)
        while True:
            try:
                data = self.request.recv(1024)
                if len(data) == 0:
                    break
                self.request.send(data.upper())
            except Exception:
                break
        self.request.close

#相當于循環的從半連接配接池中取出連接配接請求建立雙向連接配接，拿到連接配接對象
s = socketserver.ThreadingTCPServer(('127.0.0.1',8888),MyRequestHandle)
s.serve_forever()       #這個函數會建連接配接，每建立一個連接配接則生成一個程序來處理

#用戶端
from socket import *
phone = socket(AF_INET,SOCK_STREAM)
phone.connect(('127.0.0.1',8888))

while True:
    msg = input('請輸入指令:').strip()
    if len(msg) == 0:
        continue
    phone.send(msg.encode('utf-8'))
    data = phone.recv(1024)
    print('接收到伺服器發來的：',data.decode('utf-8'))
phone.close()           

基于UDP

#用戶端
from socket import *
phone = socket(AF_INET,SOCK_DGRAM)
while True:
    choice = input('請輸入傳輸内容：').strip()
    phone.sendto(choice.encode('utf-8'),('127.0.0.1',8888))
    func=phone.recvfrom(1024)
    print(func)
    # phone.close()
    
    
#服務端
import socketserver
class MyRequestHandle(socketserver.BaseRequestHandler):
    def handle(self):
        client_data = self.request[0]
        server = self.request[1]
        client_add = self.client_address
        print('用戶端發來的資料%s'%client_data)
        server.sendto(client_data.upper(),client_add)



s = socketserver.ThreadingUDPServer(('127.0.0.1',8888),MyRequestHandle)
s.serve_forever()


#相當于：隻負責循環的收,收到後交給小弟去處理