Python入门day37——tcp/udp进阶

一：基于TCP协议实现远程执行命令

服务端：

# 服务端应该满足两个特点：
# 1、一直对外提供服务
# 2、并发地服务多个客户端
import subprocess
from socket import *

server = socket(AF_INET, SOCK_STREAM)
server.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)  # 就是它，在bind前加
server.bind(('127.0.0.1', 8082))
server.listen(5)

#  服务端应该做两件事
# 第一件事：循环地从板连接池中取出链接请求与其建立双向链接，拿到链接对象
while True:
    conn, client_addr = server.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()
            print(len(stdout_res) + len(stderr_res))
            # conn.send(stdout_res+stderr_res) # ???
            conn.send(stdout_res)
            conn.send(stderr_res)

            # with open("1.mp4",mode='rb') as f:
            #     for line in f:
            #         conn.send(line)
        except Exception:
            break
    conn.close()

客户端：

from socket import *

client = socket(AF_INET, SOCK_STREAM)
client.connect(('127.0.0.1', 8082))

while True:
    cmd = input('请输入命令>>：').strip()
    if len(cmd) == 0:
        continue
    client.send(cmd.encode('UTF-8'))

    # 解决粘包问题思路：
    # 1、拿到数据的总大小total_size
    # 2、recv_size=0,循环接收，每接收一次，recv_size+=接收的长度
    # 3、直到recv_size=total_size，结束循环
    cmd_res = client.recv(1024)  # 本次接收，最大接收1024Bytes
    print(cmd_res.decode('GBK'))  # 强调：windows系统用gbk

# 粘包问题出现的原因
# 1、tcp是流式协议，数据像水流一样粘在一起，没有任何边界区分
# 2、收数据没收干净，有残留，就会下一次结果混淆在一起

# 解决的核心法门就是：每次都收干净，不要任何残留

二：UDP协议没有粘包问题

服务端：

import socket

server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
server.bind(('127.0.0.1', 8080))
res1 = server.recvfrom(2)  # b"hello"
print(res1)
res2 = server.recvfrom(3)  # b"world"
print(res2)

server.close()

客户端：

import socket

client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
client.sendto(b'hello', ('127.0.0.1', 8080))
client.sendto(b'world', ('127.0.0.1', 8080))

client.close()

三：解决粘包问题

服务端：

# 服务端应该满足两个特点：
# 1、一直对外提供服务
# 2、并发地服务多个客户端
import subprocess
import struct
from socket import *

server = socket(AF_INET, SOCK_STREAM)
server.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)  # 就是它，在bind前加
server.bind(('127.0.0.1', 8083))
server.listen(5)

#  服务端应该做两件事
# 第一件事：循环地从板连接池中取出链接请求与其建立双向链接，拿到链接对象
while True:
    conn, client_addr = server.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(stdout_res) + len(stderr_res)

            # 1、先发头信息（固定长度的bytes）：对数据描述信息
            # int->固定长度的bytes
            header = struct.pack('i', total_size)
            conn.send(header)

            # 2、再发真实的数据
            conn.send(stdout_res)
            conn.send(stderr_res)

        except Exception:
            break
    conn.close()

客户端：

import struct
from socket import *

client = socket(AF_INET, SOCK_STREAM)
client.connect(('127.0.0.1', 8083))

while True:
    cmd = input('请输入命令>>：').strip()
    if len(cmd) == 0: continue
    client.send(cmd.encode('utf-8'))

    # 解决粘包问题思路：
    # 一、先收固定长度的头：解析出数据的描述信息，包括数据的总大小total_size
    header = client.recv(4)
    total_size = struct.unpack('i', header)[0]

    # 二、根据解析出的描述信息，接收真实的数据
    # 2、recv_size=0,循环接收，每接收一次，recv_size+=接收的长度
    # 3、直到recv_size=total_size，结束循环
    recv_size = 0
    while recv_size < total_size:
        recv_data = client.recv(1024)
        recv_size += len(recv_data)
        print(recv_data.decode('utf-8'), end='')
    else:
        print()

# 粘包问题出现的原因
# 1、tcp是流式协议，数据像水流一样粘在一起，没有任何边界区分
# 2、收数据没收干净，有残留，就会下一次结果混淆在一起

# 解决的核心法门就是：每次都收干净，不要任何残留

四：解决粘包问题(终极版)

test.py:

import json
import struct

header_dic = {
    "filename": "a.txt",
    "total_size": 12312312,
    "asf": "123123xi12ix12",
    "asf1": "123123xi12ix12",
    "asf2": "123123xi12ix12",
    "asf3": "123123xi12ix12",
}

json_str = json.dumps(header_dic)
json_str_bytes = json_str.encode('utf-8')

print(len(json_str_bytes))

# res=struct.pack('i',999999999)
# print(res,len(res))

# res=struct.pack('i',len(json_str_bytes))

服务端：

# 服务端应该满足两个特点：
# 1、一直对外提供服务
# 2、并发地服务多个客户端
import subprocess
import struct
import json
from socket import *

server = socket(AF_INET, SOCK_STREAM)
server.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)  # 就是它，在bind前加
server.bind(('127.0.0.1', 8083))
server.listen(5)

#  服务端应该做两件事
# 第一件事：循环地从板连接池中取出链接请求与其建立双向链接，拿到链接对象
while True:
    conn, client_addr = server.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(stdout_res) + len(stderr_res)

            # 1、制作头
            header_dic = {
                "filename": "a.txt",
                "total_size": total_size,
                "md5": "123123xi12ix12"
            }

            json_str = json.dumps(header_dic)
            json_str_bytes = json_str.encode('utf-8')

            # 2、先把头的长度发过去
            x = struct.pack('i', len(json_str_bytes))
            conn.send(x)

            # 3、发头信息
            conn.send(json_str_bytes)
            # 4、再发真实的数据
            conn.send(stdout_res)
            conn.send(stderr_res)

        except Exception:
            break
    conn.close()

客户端：

import struct
import json
from socket import *

client = socket(AF_INET, SOCK_STREAM)
client.connect(('127.0.0.1', 8083))

while True:
    cmd = input('请输入命令>>：').strip()
    if len(cmd) == 0: continue
    client.send(cmd.encode('utf-8'))

    # 接收端
    # 1、先手4个字节，从中提取接下来要收的头的长度
    x = client.recv(4)
    header_len = struct.unpack('i', x)[0]

    # 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('utf-8'), end='')
    else:
        print()

# 粘包问题出现的原因
# 1、tcp是流式协议，数据像水流一样粘在一起，没有任何边界区分
# 2、收数据没收干净，有残留，就会下一次结果混淆在一起

# 解决的核心法门就是：每次都收干净，不要任何残留

五：SocketServer模块的基本使用

基于tcp协议的使用：

服务端：

import socketserver


class MyRequestHandle(socketserver.BaseRequestHandler):
    def handle(self):
        # 如果tcp协议，self.request=>conn
        print(self.client_address)
        while True:
            try:
                msg = self.request.recv(1024)
                if len(msg) == 0: break
                self.request.send(msg.upper())
            except Exception:
                break
        self.request.close()


#  服务端应该做两件事
# 第一件事：循环地从半连接池中取出链接请求与其建立双向链接，拿到链接对象
s = socketserver.ThreadingTCPServer(('127.0.0.1', 8889), MyRequestHandle)
s.serve_forever()
# 等同于
# while True:
#     conn,client_addr=server.accept()
#     启动一个线程(conn,client_addr)

# 第二件事：拿到链接对象，与其进行通信循环===>handle

客户端1：

from socket import *

client = socket(AF_INET, SOCK_STREAM)
client.connect(('127.0.0.1', 8889))

while True:
    msg = input('请输入命令>>：').strip()
    if len(msg) == 0:
        continue
    client.send(msg.encode('utf-8'))

    res = client.recv(1024)
    print(res.decode('utf-8'))

客户端2：

from socket import *

client = socket(AF_INET, SOCK_STREAM)
client.connect(('127.0.0.1', 8889))

while True:
    msg = input('请输入命令>>：').strip()
    if len(msg) == 0:
        continue
    client.send(msg.encode('utf-8'))

    res = client.recv(1024)
    print(res.decode('utf-8'))

客户端3：

from socket import *

client = socket(AF_INET, SOCK_STREAM)
client.connect(('127.0.0.1', 8889))

while True:
    msg = input('请输入命令>>：').strip()
    if len(msg) == 0:
        continue
    client.send(msg.encode('utf-8'))

    res = client.recv(1024)
    print(res.decode('utf-8'))

基于udp协议的使用：

服务端：

import socketserver


class MyRequestHanlde(socketserver.BaseRequestHandler):
    def handle(self):
        client_data = self.request[0]
        server = self.request[1]
        client_address = self.client_address
        print('客户端发来的数据%s' % client_data)
        server.sendto(client_data.upper(), client_address)


s = socketserver.ThreadingUDPServer(("127.0.0.1", 8888), MyRequestHanlde)
s.serve_forever()
# 相当于:只负责循环地收
# while True:
#     data,client_addr=server.recvfrom(1024)
#     启动一个线程处理后续的事情(data,client_addr)

客户端1：

import socket

client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)  # 流式协议=》tcp协议

while True:
    msg = input('>>>: ').strip()
    client.sendto(msg.encode('utf-8'), ('115.29.65.16', 8888))
    res = client.recvfrom(1024)
    print(res)

client.close()

客户端2：

import socket

client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)  # 流式协议=》tcp协议

while True:
    msg = input('>>>: ').strip()
    client.sendto(msg.encode('utf-8'), ('115.29.65.16', 8888))
    res = client.recvfrom(1024)
    print(res)

client.close()