tcp/udp

基于tcp的subprocess操作:

服务端：
import  socketserver
import  subprocess

class Myserver(socketserver.BaseRequestHandler):
    def handle(self):
        print('3次握手conn is', self.request)#conn,3次握手，建立3次握手的过程
        print('客户端返回的ip地址是',self.client_address)#打印的是客户端的ip地址,addr
        while True:
            try:
                print('开始通信循环了')
                cmd=self.request.recv(1024)
                # if not cmd:
                #     break  # 解决死循环的情况
                print('收到客户端的消息', cmd.decode('utf-8'))  # 一字节的形式接收到的数据
                # 执行命令，得到命令的运行结果
                res = subprocess.Popen(cmd.decode('utf-8'), shell=True,
                                       stderr=subprocess.PIPE,
                                       stdin=subprocess.PIPE,
                                       stdout=subprocess.PIPE)  # 获取的是对象

                response = res.stdout.read()

                if response:
                    print('程序已经执行out')
                    cmd_res = response  # 加入err没有问题的话就读取到stderr的
                elif not response:
                    print('程序已经执行err')
                    cmd_res = res.stderr.read()


                # 发消息
                self.request.send(cmd_res)



            except Exception as e:
                print(e)
                break

if __name__ == '__main__':
    s=socketserver.ThreadingTCPServer(('127.0.2.1',8080),Myserver)#实例化过程，传入2个参数，一个是ip地址，建立链接循环，第二个建立通信循环
    print('已经建立链接')
    s.serve_forever()#永远服务下去

客户端：


from socket import *
ip_port=('127.0.2.1',8080)
buffer_size=1024
back_log=5
tcp_client=socket(AF_INET,SOCK_STREAM)
# tcp_client.bind(ip_port)
tcp_client.connect(ip_port)

while True:
    try:
        print('开始运行客户端1')
        msg=input('输入：').strip()
        if not msg: continue
        else:
            tcp_client.send(msg.encode('utf-8'))
            print('客户端已经发送消息给服务端')
            data=tcp_client.recv(buffer_size)
            print('客户端接收的数据是',data.decode('gbk'))
    except Exception as e:
        print(e)
        break

基于udp的并发操作:

request返回的是元组形式的，request【0】是客户端发来的消息
request【1】是套接字对象

addr是客户端的地址

服务端：
import  socketserver
import  subprocess
#基于udp通信，返回的request为元组形式的，第一个是客户端发送的消息，得个是套接字对象，最后一个是客户单的ip地址，addr
class Myserver(socketserver.BaseRequestHandler):
    def handle(self):
        print('接收到客户端的命令是',self.request[0].decode('utf-8'))  # 接收的是客户端的消息
        print(self.request[1])  # 接收的是客户端的socket对象
        print(self.client_address)  # 接收的客户端的地址
        while True:
            try:
            #发消息给客户端
                data=self.request[0].decode('utf-8')
                res=subprocess.Popen(data,shell=True,
                             stdout=subprocess.PIPE,
                             stdin=subprocess.PIPE,
                             stderr=subprocess.PIPE)
                cmd_res=res.stdout.read()
                if cmd_res:
                    content=cmd_res
                else:
                    content=res.stderr.read()
                self.request[1].sendto(content,self.client_address)
                print('服务端已经发送消息给客户端')
                break
            except Exception as e:
                print(e)
                break

        # msg=input('输入:').strip()
        # self.request[1].sendto(msg.encode('utf-8'),self.client_address)
        # print('已经发送消息给客户端了',msg)



#建立udp链接循环
if __name__ == '__main__':
    s=socketserver.ThreadingUDPServer(('127.1.1.1',8080),Myserver)#传入的第一个参数是ip地址，第二个参数是通信循环
    s.serve_forever()

客户端：
import  socketserver
import subprocess
from socket import *
ip_port=('127.1.1.1',8080)
buffer_size=10240
back_log=5
tcp_client=socket(AF_INET,SOCK_DGRAM)
tcp_client.connect(ip_port)

while True:
    print('开始运行客户端了')
    msg=input('输入:').strip()
    tcp_client.sendto(msg.encode('utf-8'),ip_port)
    print('已经发送消息给服务端了')
    data,addr=tcp_client.recvfrom(buffer_size)
    print('已经接收服务端发来的消息了',data.decode('gbk'))