Loading

python socket

python socket

客户端和服务端ssh

 1 import socket,struct
 2 import subprocess
 3 
 4 phone = socket.socket( socket.AF_INET , socket.SOCK_STREAM )
 5 phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
 6 phone.bind(( '127.0.0.1', 8090 ))
 7 phone.listen(5)
 8 
 9 while True:
10     conn,addr = phone.accept()
11     while True:
12         try:
13             cmd = conn.recv(1024)
14             if not cmd:continue
15             res = subprocess.Popen(cmd.decode('utf-8'),
16                                    shell = True ,
17                                    stdout= subprocess.PIPE ,
18                                    stderr= subprocess.PIPE )
19             out_data = res.stdout.read()
20             error_data = res.stderr.read()
21             data_size = len(out_data) + len(error_data)
22             conn.send(struct.pack("i",data_size))
23             conn.send(out_data)
24             conn.send(error_data)
25 
26         except Exception:
27             break
28     conn.close()
29 phone.close()
30 
31 服务端
服务端
 1 import socket,struct
 2 
 3 phone = socket.socket(socket.AF_INET , socket.SOCK_STREAM)
 4 phone.connect(('127.0.0.1' , 8090))
 5 
 6 while True:
 7     cmd = input('input cmd:').strip()
 8     if not cmd: continue
 9     phone.send(bytes(cmd,encoding='utf-8'))
10     baotou = phone.recv(4)
11     data_size = struct.unpack("i",baotou)[0]
12     recive_data = b""
13     recive_size = 0
14     while recive_size < data_size:
15         data = phone.recv(1024)
16         recive_size += len(data)
17         recive_data += data
18     print(recive_data.decode("utf-8"))
19 phone.close()
20 
21 客户端
客户端

发送报头长度 报头 数据 ssh

 1 #coding:utf-8
 2 import socket
 3 import struct
 4 import json
 5 import subprocess
 6 phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
 7 ip_port=('127.0.0.1',8081)
 8 phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
 9 phone.bind(ip_port)
10 phone.listen(100)
11 
12 #链接循环
13 while True:
14     conn,addr=phone.accept()
15     #通讯循环
16     while True:
17         try:
18             cmd=conn.recv(1024)
19             res=subprocess.Popen(cmd.decode('utf-8'),
20                              shell=True,
21                              stdout=subprocess.PIPE,
22                              stderr=subprocess.PIPE)
23             out_res=res.stdout.read()
24             err_res=res.stderr.read()
25             data_size=len(out_res)+len(err_res)
26             head_dic={'data_size':data_size}
27             head_json=json.dumps(head_dic)
28             head_bytes=head_json.encode('utf-8')
29 
30             #part1:先发报头的长度
31             head_len=len(head_bytes)
32             conn.send(struct.pack('i',head_len))
33             #part2:再发送报头
34             conn.send(head_bytes)
35             #part3:最后发送数据部分
36             conn.send(out_res)
37             conn.send(err_res)
38 
39         except Exception:
40             break
41 
42     conn.close()
43 phone.close()
44 
45 服务端
服务端
 1 import socket
 2 import struct
 3 import json
 4 phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 5 ip_port = ('127.0.0.1', 8081)
 6 phone.connect(ip_port)
 7 while True:
 8     cmd = input('>>: ').strip()
 9     if not cmd: continue
10     phone.send(bytes(cmd, encoding='utf-8'))
11 
12     # part1:先收报头的长度
13     head_struct=phone.recv(4)
14     head_len=struct.unpack('i',head_struct)[0]
15 
16     # part2:再收报头
17     head_bytes=phone.recv(head_len)
18     head_json=head_bytes.decode('utf-8')
19 
20     head_dic=json.loads(head_json)
21     data_size = head_dic['data_size']
22 
23     #part3：收数据
24     recv_size = 0
25     recv_data = b''
26     while recv_size < data_size:
27         data = phone.recv(1024)
28         recv_size += len(data)
29         recv_data += data
30 
31     print(recv_data.decode('utf-8'))
32 phone.close()
33 
34 客户端
客户端

FTP

 1 import socket,json,os,struct,subprocess
 2 
 3 
 4 class Ftp_Server:
 5     sock_famiy = socket.AF_INET
 6     sock_type = socket.SOCK_STREAM
 7     allow_reuse_address = False
 8     request_queue_size = 100
 9     max_package_size = 1024
10     coding = "utf-8"
11     server_dir = '/Users/centos/PycharmProjects/py_fullstack_s4/day35/file_upload'
12 
13     def __init__(self,server_addr,bind_active=True):
14         self.server_addr=server_addr
15         self.socket = socket.socket(self.sock_famiy,self.sock_type)
16 
17         if bind_active:
18             try:
19                 self.server_bind()
20 
21             except Exception:
22                 self.server_close()
23 
24     def server_bind(self):
25         if self.allow_reuse_address:
26             self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
27         self.socket.bind(self.server_addr)
28         self.socket.listen(self.request_queue_size)
29     def get_request(self):
30         return self.socket.accept()
31 
32     def server_close(self):
33         self.socket.close()
34 
35     def run(self):
36         while True:
37             self.conn,self.client_addr = self.get_request()
38             while True:
39                 try:
40                     head_struck = self.conn.recv(4)
41                     if not head_struck:break
42                     head_len = struct.unpack("i",head_struck)[0]
43                     head_json = self.conn.recv(head_len).decode(self.coding)
44                     head_dic = json.loads(head_json)
45                     cmd = head_dic["cmd"]
46                     if hasattr(self,cmd):
47                         func = getattr(self,cmd)
48                         func(head_dic)
49                 except Exception:
50                     break
51 
52     def put(self,args):
53         filepath = os.path.join(self.server_dir,args["filename"])
54         filesize = args["filesize"]
55         recv_size = 0
56         with open(filepath,"wb") as f:
57             while recv_size < filesize:
58                 recv_data = self.conn.recv(self.max_package_size)
59                 f.write(recv_data)
60                 recv_size += len(recv_data)
61                 print('recvsize:%s filesize:%s' % (recv_size, filesize))
62 
63     def get(self,args):
64         filepath = os.path.join(self.server_dir,args["filename"])
65 
66         filename = args["filename"]
67         filesize = os.path.getsize(filepath)
68         head_dict={"filename":os.path.basename(filepath),"filesize":filesize}
69         print(head_dict)
70         head_json=json.dumps(head_dict)
71         head_json_bates=bytes(head_json,encoding=self.coding)
72         head_struck=struct.pack("i",len(head_json_bates))
73         self.conn.send(head_struck)
74         self.conn.send(head_json_bates)
75 
76         with open(filepath,"rb") as f:
77             for i in f:
78                 self.conn.send(i)
79 
80 
81 
82 obj = Ftp_Server(("127.0.0.1",9020))
83 obj.run()
84 
85 服务端
服务端
 1 import socket,json,os,struct
 2 
 3 class Ftpclient:
 4     address_family = socket.AF_INET
 5     socket_type = socket.SOCK_STREAM
 6     allow_reuse_address = False
 7     max_packet_size = 1024
 8     coding = "utf-8"
 9     request_queue_size = 100
10     server_dir = "/Users/centos/PycharmProjects/py_fullstack_s4/day37/file_upload"
11 
12     def __init__(self,server_address,connect=True):
13         self.server_address=server_address
14         self.socket=socket.socket(self.address_family,self.socket_type)
15         if connect:
16             try:
17                 self.client_connect()
18             except Exception:
19                 self.client_clode()
20 
21     def client_connect(self):
22         self.socket.connect(self.server_address)
23     def client_close(self):
24         self.socket.close()
25     def run(self):
26         while True:
27             inp = input(">>: ").strip()
28             if not inp:continue
29             l= inp.split()
30             cmd=l[0]
31             if hasattr(self,cmd):
32                 func=getattr(self,cmd)
33                 func(l)
34 
35     def put(self,arg):
36         cmd=arg[0]
37         filename=arg[1]
38         filesize=os.path.getsize(filename)
39         head_dict={"cmd":cmd,"filename":os.path.basename(filename),"filesize":filesize}
40         head_json=json.dumps(head_dict)
41         head_json_bates=bytes(head_json,encoding=self.coding)
42         head_struck=struct.pack("i",len(head_json_bates))
43         self.socket.send(head_struck)
44         self.socket.send(head_json_bates)
45         send_size=0
46         with open(filename,"rb") as f:
47             for line in f:
48                 self.socket.send(line)
49                 send_size+=len(line)
50                 print(send_size)
51             else:
52                 print("upload successful")
53 
54     def get(self,args):
55         cmd = args[0]
56         filename = args[1]
57         filesize = len(args)
58         head_dict={"cmd":cmd,"filename":os.path.basename(filename),"filesize":filesize}
59         head_json=json.dumps(head_dict)
60         head_json_bates=bytes(head_json,encoding=self.coding)
61         head_struck=struct.pack("i",len(head_json_bates))
62         self.socket.send(head_struck)
63         self.socket.send(head_json_bates)
64 
65         filepath = os.path.join(self.server_dir,filename)
66         while True:
67             try:
68                 head_struck = self.socket.recv(4)
69 
70                 head_len = struct.unpack("i", head_struck)[0]
71                 head_json = self.socket.recv(head_len).decode(self.coding)
72                 head_dic = json.loads(head_json)
73                 print(head_dict)
74                 recv_size = 0
75                 print(filepath)
76                 with open(filepath,"wb") as f:
77                     while recv_size < head_dic["filesize"]:
78                         data = self.socket.recv(self.max_packet_size)
79                         f.write(data)
80                         recv_size += len(data)
81 
82             except Exception:
83                 break
84 
85 
86 
87 obj = Ftpclient(("127.0.0.1",9020))
88 obj.run()
89 
90 客户端
客户端

socketserver

　　基于tcp的套接字，关键就是两个循环，一个链接循环，一个通信循环

　　socketserver模块中分两大类：server类（解决链接问题)

　　　　　　　　　　　　　　　　 request类（解决通信问题）

 　　server类

　　　　

 

　　request类

 

　　

　　继承关系:

　　

 

 

 1 import socketserver,json,os,struct,subprocess
 2 
 3 
 4 class Ftp_Server(socketserver.BaseRequestHandler):
 5 
 6     request_queue_size = 100
 7     max_package_size = 1024
 8     coding = "utf-8"
 9     server_dir = '/Users/centos/PycharmProjects/py_fullstack_s4/day35/file_upload'
10 
11 
12     def handle(self):
13         while True:
14             try:
15                 head_struck = self.request.recv(4)
16                 if not head_struck:break
17                 head_len = struct.unpack("i",head_struck)[0]
18                 head_json = self.request.recv(head_len).decode(self.coding)
19                 head_dic = json.loads(head_json)
20                 cmd = head_dic["cmd"]
21                 if hasattr(self,cmd):
22                     func = getattr(self,cmd)
23                     func(head_dic)
24             except Exception:
25                 break
26 
27     def put(self,args):
28         filepath = os.path.join(self.server_dir,args["filename"])
29         filesize = args["filesize"]
30         recv_size = 0
31         with open(filepath,"wb") as f:
32             while recv_size < filesize:
33                 recv_data = self.request.recv(self.max_package_size)
34                 f.write(recv_data)
35                 recv_size += len(recv_data)
36                 print('recvsize:%s filesize:%s' % (recv_size, filesize))
37 
38     def get(self,args):
39         filepath = os.path.join(self.server_dir,args["filename"])
40 
41         filename = args["filename"]
42         filesize = os.path.getsize(filepath)
43         head_dict={"filename":os.path.basename(filepath),"filesize":filesize}
44         print(head_dict)
45         head_json=json.dumps(head_dict)
46         head_json_bates=bytes(head_json,encoding=self.coding)
47         head_struck=struct.pack("i",len(head_json_bates))
48         self.request.send(head_struck)
49         self.request.send(head_json_bates)
50 
51         with open(filepath,"rb") as f:
52             for i in f:
53                 self.request.send(i)
54 
55 
56 
57 
58 obj = socketserver.ThreadingTCPServer(("127.0.0.1",9000),Ftp_Server)
59 
60 obj.serve_forever()
61 
62 Ftp服务端 多用户
Ftp服务端 多用户
 1 import socket,json,os,struct
 2 
 3 class Ftpclient:
 4     address_family = socket.AF_INET
 5     socket_type = socket.SOCK_STREAM
 6     allow_reuse_address = False
 7     max_packet_size = 1024
 8     coding = "utf-8"
 9     request_queue_size = 100
10     server_dir = "/Users/centos/PycharmProjects/py_fullstack_s4/day37/file_upload"
11 
12     def __init__(self,server_address,connect=True):
13         self.server_address=server_address
14         self.socket=socket.socket(self.address_family,self.socket_type)
15         if connect:
16             try:
17                 self.client_connect()
18             except Exception:
19                 self.client_clode()
20 
21     def client_connect(self):
22         self.socket.connect(self.server_address)
23     def client_close(self):
24         self.socket.close()
25     def run(self):
26         while True:
27             inp = input(">>: ").strip()
28             if not inp:continue
29             l= inp.split()
30             cmd=l[0]
31             if hasattr(self,cmd):
32                 func=getattr(self,cmd)
33                 func(l)
34 
35     def put(self,arg):
36         cmd=arg[0]
37         filename=arg[1]
38         filesize=os.path.getsize(filename)
39         head_dict={"cmd":cmd,"filename":os.path.basename(filename),"filesize":filesize}
40         head_json=json.dumps(head_dict)
41         head_json_bates=bytes(head_json,encoding=self.coding)
42         head_struck=struct.pack("i",len(head_json_bates))
43         self.socket.send(head_struck)
44         self.socket.send(head_json_bates)
45         send_size=0
46         with open(filename,"rb") as f:
47             for line in f:
48                 self.socket.send(line)
49                 send_size+=len(line)
50                 print(send_size)
51             else:
52                 print("upload successful")
53 
54     def get(self,args):
55         cmd = args[0]
56         filename = args[1]
57         filesize = len(args)
58         head_dict={"cmd":cmd,"filename":os.path.basename(filename),"filesize":filesize}
59         head_json=json.dumps(head_dict)
60         head_json_bates=bytes(head_json,encoding=self.coding)
61         head_struck=struct.pack("i",len(head_json_bates))
62         self.socket.send(head_struck)
63         self.socket.send(head_json_bates)
64 
65         filepath = os.path.join(self.server_dir,filename)
66         while True:
67             try:
68                 head_struck = self.socket.recv(4)
69 
70                 head_len = struct.unpack("i", head_struck)[0]
71                 head_json = self.socket.recv(head_len).decode(self.coding)
72                 head_dic = json.loads(head_json)
73                 print(head_dict)
74                 recv_size = 0
75                 print(filepath)
76                 with open(filepath,"wb") as f:
77                     while recv_size < head_dic["filesize"]:
78                         data = self.socket.recv(self.max_packet_size)
79                         f.write(data)
80                         recv_size += len(data)
81 
82             except Exception:
83                 break
84 
85 
86 
87 obj = Ftpclient(("127.0.0.1",9000))
88 obj.run()
89 
90 Ftp客户端
Ftp客户端
posted @ 2017-06-27 23:28  Meet~  阅读(360)  评论(0)    收藏  举报