Python_编写UDP通信编解码类、文件的上传、远程执行命令、黏包

1、UDP通信编解码类

　　(1) 类

# ------------------UDP通信解码编码类------------------------

from socket import *

class My_Socket(socket):
    def __init__(self,coding='utf-8'):
        self.coding = coding
        super(My_Socket, self).__init__(type=SOCK_DGRAM)

    def my_recv(self,num):
        msg,addr = self.recvfrom(num)
        return msg.decode(self.coding),addr

    def my_send(self,msg,addr):
        return self.sendto(msg.encode(self.coding),addr)

 

　　(2) UDP通信客户端(调用自己的解码编码类)

# --------------UDP通信客户端(调用自己的解码编码类)-----------------

from MySocket import My_Socket

sk = My_Socket()

msg_s = input('>>>')

sk.my_send(msg_s,('127.0.0.1',8080))

sk.close()

 

　　(3) UDP通信服务器端(调用自己的解码编码类)

# -----------UDP通信服务器端(调用自己的解码编码类)---------------

from MySocket import My_Socket

sk = My_Socket()

sk.bind(('127.0.0.1',8080))

msg_r,addr = sk.my_recv(1024)

print(msg_r)

sk.close()

 

2、文件的上传（服务器端）

 　　（1）只能上传小文件。

import socket
import json
sk = socket.socket()

sk.bind(('127.0.0.1',8080))

sk.listen(5)

conn,addr = sk.accept()

# 上传下载的逻辑
str_dic = conn.recv(1024).decode('utf-8')
dic = json.loads(str_dic)
# dic = {'opt':ls.get(num),'filename':filename,'content':content}
if dic['opt'] == 'upload':
    filename = 'new_'+dic['filename']
    with open(filename,'w',encoding='utf-8') as f:
        f.write(dic['content'])

conn.close()
sk.close()

 

　　（2）通过方法：先获取文件大小，然后把文件大小加入到字典中，把字典发过去接收端就可以知道文件大小了，就可以根据文件大小进行接收大文件了。
　　　　问题：可能黏包的问题，就是send了字典之后，就send了文件内容。
　　　　解决的方法：在两个send之间加了一个recv，接收一个success 。

import socket
import json
sk = socket.socket()

sk.bind(('127.0.0.1',8080))

sk.listen(5)

conn,addr = sk.accept()

# 上传下载的逻辑
str_dic = conn.recv(1024).decode('utf-8')# 先接受到字符串形式的字典
conn.send(b'success')# 给客户端回复一个成功，代表字典接收成功了，也是把字典内容和接下来要接收的文件内容分割开
dic = json.loads(str_dic)# 反序列化，将字典还原出来
# dic = {'opt':ls.get(num),'filename':filename,'content':content}
if dic['opt'] == 'upload':
    filename = 'new_'+dic['filename']# 产生一个新的文件名
    filesize = dic['filesize']# 获取文件的大小
    with open(filename,'wb') as f:
        while filesize:
            content = conn.recv(1024)
            filesize -= len(content)# 减去接收到的长度，而不能直接减去1024
            f.write(content)

conn.close()
sk.close()

 

　　（3）先把字典的大小获取，然后server先接收字典的大小，然后根据字典大小去接收字典，这样就直接解决了2中的问题。

import socket
import json
sk = socket.socket()

sk.bind(('127.0.0.1',8080))

sk.listen(5)

conn,addr = sk.accept()


# 我算出来了字典长度为70（属于作弊），这个‘70’是两个字节的长度，所以接收两个字节长度，把字典大小接收到
len_dic = int(conn.recv(2).decode('utf-8'))#在这里转成int以便下一行代码中当做recv的参数
# 这个len_dic = 70,转码后是字符串

str_dic = conn.recv(len_dic).decode('utf-8')# 根据字典长度去接收字典，防止接收到文件的内容

# 在这里，上边代码我明确了字典大小，就可以按照字典大小接收固定长度，这样之后，就可以防止上边接收到 下边应该接收的文件内容
# 此时我就可以省略一个 sk.send(b'success')这句话，就可以少一个网络传输数据时的延时。
dic = json.loads(str_dic)
# dic = {'opt':ls.get(num),'filename':filename,'filesize':filesize}
if dic['opt'] == 'upload':
    filename = 'new_'+dic['filename']
    filesize = dic['filesize']
    with open(filename,'wb') as f:
        while filesize:
            content = conn.recv(1024)
            filesize -= len(content)
            f.write(content)

conn.close()
sk.close()

 

 

　　（4）字典的大小不固定，所以我使用了struct模块中的pack方法，解决这个事情，使字典的大小这个数字无论多少位，我都固定生成一个4位的bytes,这样server端就可以直接先接收4个字节了，通过unpack获取字典大小。

import socket
import json
import struct
sk = socket.socket()

sk.bind(('127.0.0.1',8080))

sk.listen(5)

conn,addr = sk.accept()


# 上边说了，如果我在这里明确接收2个字节就可以接收到字典的大小，这是作弊
# 因为字典大小如果是 100~999 ，我这里就要接收3个字节
# 如果字典大小是 100000 ~ 999900 ，我这里就要接收6个字节
# 所以为了公正，我使用了struct，在客户端先把‘字典大小’的长度固定为4个字节
len_dic = conn.recv(4)# 此时接收到了 字典的长度，不过是经过struct.pack处理后的
len_str_dic = struct.unpack('i',len_dic)[0] # 在这里，得到int型的字典长度，注意：unpack方法返回一个元组。

str_dic = conn.recv(len_str_dic).decode('utf-8')# 根据字典长度去接收字典，防止接收到文件的内容


dic = json.loads(str_dic)
# dic = {'opt':ls.get(num),'filename':filename,'filesize':filesize}
if dic['opt'] == 'upload':
    filename = 'new_'+dic['filename']
    filesize = dic['filesize']
    with open(filename,'wb') as f:
        while filesize:
            content = conn.recv(1024)
            filesize -= len(content)
            f.write(content)

conn.close()
sk.close()

 

3、远程执行命令

 　　(1) 远程执行命令(服务器端)

# ------------------远程执行命令(服务器端)------------------------

import socket
import subprocess

sk = socket.socket()
sk.bind(("127.0.0.1", 8080))
sk.listen(5)

conn, addr = sk.accept()

while 1:
    cmd = conn.recv(1024).decode('utf-8')
    r = subprocess.Popen(cmd, shell=True,
                         stdout=subprocess.PIPE,
                         stderr=subprocess.PIPE)
    stdout = r.stdout.read()
    stderr = r.stderr.read()
    if stdout:
        conn.send(stdout)
    elif stderr:
        conn.send(stderr)

conn.close()
sk.close()

 

　　(2) 远程执行命令(客户端)

# ---------------远程执行命令(客户端)--------------------

import socket

sk = socket.socket()

sk.connect(('127.0.0.1', 8080))

while 1:
    cmd = input('>>>')
    sk.send(cmd.encode('utf-8'))
    ret_1 = sk.recv(1024).decode('gbk')
    ret_2 = sk.recv(1024).decode('gbk')
    print(ret_1)

sk.close()

 

4、黏包

黏包:是指可能是：接收端和发送端两端在进行收发时，数据大小不统一造成的.

也可能是：合包机制和nagle算法的实现，而没有提供科学的拆包机制，造成的.

一种是因为：client连续发送少量数据，时间间隔短，所以nagle算法帮你合包了,但是此时server不知道要接收多少，所以造成数据混乱

一种是因为：client直接发送了大量数据，但是server端接收的长度不够，所以造成数据混乱

　　(1) UDP_黏包_服务器

import socket

sk = socket.socket(type=socket.SOCK_DGRAM)

sk.bind(('127.0.0.1', 8080))

msg, addr = sk.recvfrom(1024)

print(msg)

sk.close()

 

　　(2) UDP_黏包_客户端

import socket
sk = socket.socket(type=socket.SOCK_DGRAM)

sk.sendto(b'123',('127.0.0.1',8080))
sk.sendto(b'abc',('127.0.0.1',8080))
sk.close()

 

　　(3) TCP_nagle_服务器端

 

 

　　(4) TCP_nagle_客户端

import socket

BUFSIZE = 1024
ip_port = ('127.0.0.1', 8080)

s = socket.socket(family=socket.AF_INET, type=socket.SOCK_STREAM)
res = s.connect_ex(ip_port)

s.send('hello egg'.encode('utf-8'))