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()

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

　　(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()

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

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()

以下解决黏包现象，实现大文件的传输,比较low比的方法

　　（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()

比较高端的方法，使用struct

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()

UDP_黏包_客户端

　　(2) UDP_黏包_客户端

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

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

UDP_黏包_客户端

　　(3) TCP_nagle_服务器端

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'))

TCP_nagle_客户端