基于TCP协议的socket套接字编程

时间：2021-01-01 10:59:00

基于TCP协议的socket套接字编程

服务端

import socket

# 1. 符合TCP协议的手机
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  # TCP

# 2. 绑定手机号 110
server.bind(('127.0.0.1', 8000))  # 127.0.0.1代表本地
# server.bind(('192.168.11.210',8000))  # 127.0.0.1代表本地

server.listen(5)  # 半连接池

# 3. 等待客户端连接
print('start...')
# 链接循环


while True:
    # 通信循环
    conn, client_addr = server.accept()
    while True:
        try:
            # 4. 收到消息receive
            data = conn.recv(1024)
            print(data)

            # 5. 回消息
            conn.send(data.upper())
        except ConnectionAbortedError:
            continue
        except ConnectionResetError:
            break

客户端

import socket

# 1. 创建符合TCp协议的手机
client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

# 2. 拨号
client.connect(('127.0.0.1',8000))

while True:
    msg = input('please enter your msg')  # dir
    # 3. 发送消息
    client.send(msg.encode('utf8'))

    # 4. 接收消息
    data = client.recv(1024)
    print(data)

模拟ssh远程执行命令

在客户端处模拟ssh发送命令，服务端通过subprocess执行该命令，然后返回命令的结果

服务端

import socket
import subprocess

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

server.bind(('192.168.11.210', 8000))
server.listen(5)

print('start...')
while True:
    conn, client_addr = server.accept()
    print(client_addr)

    while True:
        try:
            cmd = conn.recv(1024)  # dir
            print(cmd)

            # 帮你执行cmd命令,然后把执行结果保存到管道里
            pipeline = subprocess.Popen(cmd.decode('utf8'),
                                        shell=True,
                                        stderr=subprocess.PIPE,
                                        stdout=subprocess.PIPE)

            stderr = pipeline.stderr.read()
            stdout = pipeline.stdout.read()

            conn.send(stderr)
            conn.send(stdout)

        except ConnectionResetError:
            break

客户端

import socket

# 1. 创建符合TCp协议的手机
client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

# 2. 拨号
client.connect(('192.168.11.210',8000))

while True:
    msg = input('please enter your msg')  # dir
    # 3. 发送消息
    client.send(msg.encode('utf8'))

    # 4. 接收消息
    data = client.recv(10)
    print(data.decode('gbk'))

粘包问题

TCP发送数据的四种情况

基于TCP协议的socket套接字编程

假如客户端分别发送了两个数据包D1和D2给服务端，由于服务端一次读取到的字节是不确定的，故可能存在以下4种情况:

1.服务端分两次读取到了两个独立的数据包，分别是D1和D2，没有粘包和拆包；

2.服务端一次接收到了两个数据包，D1和D2粘合在一起，被称为TCP粘包；

3.服务端分两次读取到了两个数据包，第一次读取到了完整的D1包和D2包的内容，第二次读取到了D2包的剩余内容，这被称为TCP拆包；

4.服务端分两次读取到了两个数据包，第一次读取到了D1包的部分内容D1_1，第二次读取到了D1包的剩余内容D1_2和D2包的整包。

特例：如果此时服务端TCP接收滑窗非常小，而数据包D1和D2比较大，很有可能会发生第五种可能，即服务端分多次才能将D1和D2包接受完全，期间发生多次拆包。

注意：只有TCP有粘包现象，UDP永远不会粘包。

粘包的两种情况

1.发送端需要等缓冲区满才发送出去，造成粘包（发送数据时间间隔很短，数据量很小，会合到一起，产生粘包）

2.接收方不及时接收缓冲区的包，造成多个包接收（客户端发送了一段数据，服务端只是接收了一小部分，服务端下次再接收的时候还是从缓冲区拿上次遗留的数据，产生粘包）

解决粘包问题

服务端

from socket import *
import subprocess
import struct

server = socket(AF_INET, SOCK_STREAM)
server.bind(('127.0.0.1', 8000))
server.listen(5)

print('start...')
while True:
    conn, client_addr = server.accept()
    print(conn, client_addr)

    while True:
        try:
            cmd = conn.recv(1024)

            obj = subprocess.Popen(cmd.decode('utf8'),
                                   shell=True,
                                   stderr=subprocess.PIPE,
                                   stdout=subprocess.PIPE)

            stderr = obj.stderr.read()
            stdout = obj.stdout.read()

            count_len=len(stderr)+len(stdout)
            guding_bytes=struct.pack('i',count_len)

            conn.send(guding_bytes)
            conn.send(stderr+stdout)
        except ConnectionResetError:
            break

客户端

from socket import *
import struct

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

while True:
    cmd = input('please enter your cmd you want>>>')

    if len(cmd) == 0: continue

    client.send(cmd.encode('utf8'))

    # 1. 先收4个字节，这4个字节中包含报头的长度
    header_len = struct.unpack('i', client.recv(4))[0]

    # 2. 再接收报头
    header_bytes = client.recv(header_len)
    print(header_bytes.decode('gbk'))

基于UDP协议的socket套接字编程

服务端

import socket

server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
server.bind(('127.0.0.1', 8000))

print('start...')
while True:
    data, client_addr = server.recvfrom(1024)
    print(client_addr)
    print(data)
    server.sendto(data.upper(), client_addr)

客户端

import socket

client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

while True:
    msg = input('please enter your msg:')
    client.sendto(msg.encode('utf8'), ('127.0.0.1', 8000))

    data = client.recvfrom(1024)
    print(data)

基于socketserver实现并发的socket套接字编程

服务端

# 同一时刻有多个人在接听
import socketserver
import subprocess
import struct


class MyHandler(socketserver.BaseRequestHandler):
    # 通信循环
    def handle(self):

        while True:
            try:
                cmd = self.request.recv(1024)
                print(cmd)

                pipeline = subprocess.Popen(cmd.decode('utf8'),
                                            shell=True,
                                            stderr=subprocess.PIPE,
                                            stdout=subprocess.PIPE)

                stdout = pipeline.stdout.read()
                stderr = pipeline.stderr.read()

                count_len = len(stdout) + len(stderr)
                guding_bytes = struct.pack('i', count_len)

                self.request.send(guding_bytes)  # 4

                self.request.send(stderr + stdout)

            except ConnectionResetError:
                break


# 使用socketserver的连接循环(并发),但是使用了自己的通信循环
# myhandler = MyHandler()
if __name__ == '__main__':
    server = socketserver.ThreadingTCPServer(('127.0.0.1', 8000), MyHandler, bind_and_activate=True)
    print('start...')
    server.serve_forever()
标签：

相关文章