语言基础学习PYTHON——基础学习D08
20180829内容纲要：
socket网络编程
1 socket基础概念
2 socketserver
3 socket实现简单的SSH服务器端和客户端
4 粘包
5 小结
6 练习
0 我是小白
先认识一些关键词：
TCP（Transmission Control Protocol传输控制协议）是一种面向连接的、可靠的、基于字节流的传输层通信协议，
由IETF的RFC 793定义。在简化的计算机网络OSI模型中，它完成第四层传输层所指定的功能，用户数据报协议（UDP）是同一层内另一个重要的传输协议。
SSH（SecureShell 。安全外壳协议）由IETF的网络工作小组所指定；SSH为建立在应用层和传输层基础上的安全协议。
SSH是目前较为可靠，专为远程登录会话和其他网络服务提供安全的协议，利用SSH协议可以有效防止远程管理过程中的信息泄露问题，SSH最初是UNIX系统上的一个程序，后来又迅速扩展到其他操作平台。SSH在正确使用时可弥补网络中的漏洞。SSH客户端适用于多种平台。几乎所有UNIX平台—包括HP-UX、Linux、AIX、Solaris、DigitalUNIX、Irix，以及其他平台，都可运行SSH。
FTP（FileTransfer Protocol。文件传输协议） 是 TCP/IP 协议组中的协议之一。
FTP协议包括两个组成部分，其一为FTP服务器，其二为FTP客户端。
其中FTP服务器用来存储文件，用户可以使用FTP客户端通过FTP协议访问位于FTP服务器上的资源。
在开发网站的时候，通常利用FTP协议把网页或程序传到Web服务器上。此外，由于FTP传输效率非常高，在网络上传输大的文件时，一般也采用该协议。
1 socket基础概念
socket的英文原义是“孔”或“插座”。作为4BDS UNIX的进程通信机制，取后一种意思。通常也称作"套接字"，用于描述IP地址和端口，是一个通信链的句柄。
socket本质上就是在2台网络互通的电脑之间，架设一个通道，两台电脑通过这个通道来实现数据的互相传递。
网络通信都是基于 ip+port 方能定位到目标的具体机器上的具体服务，操作系统有0-65535个端口，每个端口都可以独立对外提供服务
如果 把一个公司比做一台电脑 ，那公司的总机号码就相当于ip地址， 每个员工的分机号就相当于端口， 你想找公司某个人，必须 先打电话到总机，然后再转分机 。
建立一个socket必须至少有2端， 一个服务端，一个客户端， 服务端被动等待并接收请求，客户端主动发起请求， 连接建立之后，双方可以互发数据。
话不多先来看一段最简单的代码：
服务器端：
- Socket( )：第一步创建一个 socket 对象，这是用来封装 TCP/IP的过程，之后就可以利用它来发送 TCP 或者是 UDP. e.g. s = socket.socket( )
- bind( )：第二步是绑定 IP 和端口，它接受一个元组类型的数据。e.g. s.bind((‘127.0.0.1‘,8088,))
- listen( )：第三步是定义最多能挂起的数目，e.g. s.listen(2)，意思说你当前允许一个客户端在连接，两个客户端在等待发送消息（挂起）。
- accept( )：第四步是创建客户端和服务端之间的那条连接 conn，程序在连接前会处于挂起的状态。 e.g. conn, addr = s.accept( )
客户端：
- Socket( )：第一步创建一个 socket 对象，这是用来封装 TCP/IP的过程，之后就可以利用它来发送 TCP 或者是 UDP. e.g. s = socket.socket( )
- connect( )：第二步客户端用自己的对象来连接服务端，它接受一个元组类型的数据。e.g. s.connect((‘127.0.0.1‘,8088,))
1 #Author：ZhangKanghui
2
3 import socket
4 server =socket.socket()
5 #绑定要监听的端口
6 server.bind((‘localhost‘,6969))
7 server.listen() #监听
8
9 print("我的心在等待！")
10 #server.accept() 这个地方不能直接接听，如果这样的话就只能有一个接入
11 conn,addr = server.accept() #等待
12 #coon就是客户端连过来而在服务器端为其生成的一个链接实例
13 #print(conn,addr) 可以通过这样来看看接听了什么
14 print(conn,addr)
15
16 print("一直在等待！")
17 data =conn.recv(1024)
18 print("recv:",data)
19
20
21 conn.send(data.upper())
22 server.close()
socket_server（基础版）
1 #Author：ZhangKanghui
2
3 import socket
4 #首先声明socket类型，同时生成socket链接对象
5 client = socket.socket()
6 # family =AF_INET他就是地址簇，默认就是IPv4，type=SOCK_STWEAM他就是TCP/TCP
7
8 client.connect((‘localhost‘,6969)) #只能传一个参数，所以把链接地址端口放进一个元组。
9 #发送数据
10 client.send(b"hello world") #发送的数据必须是bytes类型
11 #那么能不能发送中文呢
12 #client.send("study 使我快乐".encode("utf-8"))
13 #如果想输出中文
14 #client.send("我想要mopney".encode("utf-8"))
15 #接受服务器的返回
16 data =client.recv(1024) #buffersize缓冲区空间容量，1024字节=1K
17 print("recv:",data)
18 #如果要输出中文
19 #print("recv:",data.decode())
20 client.close()
socket_client(基础版)
接下来依次启动服务器端和客户端：
先启动服务器端：
再启动客户端：
再看服务器端接收了什么？
这么看来基本的功能已经实现了。那么这有没有什么漏洞呢？在执行一次客户端试试看？
这是因为现在还只能接收一个，不能实现并发。c面会有学习。别急慢慢来~而且只能发送一条指令，接收一条指令，这能干毛线啊？
磨刀不误砍柴工，先来看一些基础：关于server =socket.socket()
Socket Families(地址簇)
socket.AF_UNIX unix本机进程间通信
socket.AF_INET IPV4
socket.AF_INET6 IPV6
Socket Types
socket.SOCK_STREAM #for tcp
socket.SOCK_DGRAM #for udp
socket.SOCK_RAW #原始套接字。利用原始套接字，可以通过IP_HDRINCL套接字选项由用户构造IP头。
那么，现在对上面的代码开始进行优化：只能收发一条但是能够实现多用户收发。
1 #Author：ZhangKanghui
2
3 import socket
4 server =socket.socket()
5
6 server.bind((‘localhost‘,6969))
7 server.listen()
8 print("我的心在等待！")
9
10 while True:
11 conn,addr = server.accept()
12 print(conn,addr)
13 print("一直在等待！")
14 data =conn.recv(1024)
15 print("recv:",data)
16 conn.send(data.upper())
17 server.close()
服务器端
1 #Author：ZhangKanghui
2
3 import socket
4
5 client = socket.socket()
6
7 client.connect((‘localhost‘,6969))
8 while True:
9 msg = input(">>:").strip()
10
11 client.send(msg.encode("utf-8"))
12 data =client.recv(1024)
13 print("recv:",data)
14
15 client.close()
客户端
通过运行结果可以发现，每个客户端只能像服务器发送一条数据，下条会自动挂起，因为这个时候服务器在等待第二个响应。
那么接下来怎么再次优化呢？一个用户可以多次收发，但不支持多用户同时收发。
只需要对服务器端进行修改即可：
1 #Author：ZhangKanghui
2
3 import socket
4 server =socket.socket()
5
6 server.bind((‘localhost‘,6969))
7 server.listen()
8 print("我的心在等待！")
9 conn,addr = server.accept()
10 print(conn,addr)
11 print("一直在等待！")
12
13 while True:
14 data =conn.recv(1024)
15 print("recv:",data)
16 conn.send(data.upper())
17 server.close()
服务器端
问题又来了，不能支持多用户，如果先断开，那第二个客户端能不能连进来呢？不能
1 #Author：ZhangKanghui
2
3 import socket
4 server =socket.socket()
5
6 server.bind((‘localhost‘,9999))
7 server.listen()
8 conn,addr = server.accept()
9 print(conn,addr)
10 print("一直在等待！")
11 print("我的心在等待！")
12
13 while True:
14 try:
15 # conn,addr = server.accept()
16 # print(conn,addr)
17 # print("一直在等待！")
18 data =conn.recv(1024)
19 print("recv:",data)
20 conn.send(data.upper())
21 except ConnectionResetError as e:
22 print("Error",e)
23 break
24 server.close()
服务器端改进
当客户端断开时可以通过捕获异常让程序正常进行。这样才能继续接收第二个。
2 socketserver
The socketserver module simplifies the task of writing network servers.
There are five classes in an inheritance diagram, four of which represent synchronous servers of four types:
主要介绍TCPserver：
class socketserver.TCPServer(server_address, RequestHandlerClass, bind_and_activate=True)
This uses the Internet TCP protocol, which provides for continuous streams of data between the client and server. If bind_and_activate is true,
the constructor automatically attempts to invoke server_bind() andserver_activate().
The other parameters are passed to the BaseServer base class.
创建一个socketserver步骤：
1 first，you must create a request handler class by subclassing the BaseRequestHandler class and overrinding(覆盖) its handle() method ;
this method will process incoming request.
你必须创建一个请求处理类，并且这个类要继承BaseRequestHandler，并且还要覆盖父类里的handle（）
2 second, you must instantiate one of the server classes, passing its server‘s address and the request handler class.
你必须实例化TCPServer，并且传递server ip和上面创建的请求处理类传给TCPServer。
3 third, call the handle_request() or server_forever() method of the server object to process one or many requests.
server.handle_request() #只处理一个请求
server.handle_forever() #处理多个请求，永远执行
4 finally, call server_close() to close the socket.
那么接下来就创建一个socketserver：
1 #Author：ZhangKanghui
2
3 import socketserver
4
5 class MyTCPHandler(socketserver.BaseRequestHandler):
6 """
7 The request handler class for our server.
8
9 It is instantiated once per connection to the server, and must
10 override the handle() method to implement communication to the
11 client.
12 """
13 #跟客户端的所有交互都是在handle中完成的
14 def handle(self):
15 while True:
16 try:
17 # self.request is the TCP socket connected to the client
18 self.data = self.request.recv(1024).strip()
19 print("{} wrote:".format(self.client_address[0])) #打印客户端的ip地址
20 print(self.data)
21 # just send back the same data, but upper-cased
22 self.request.sendall(self.data.upper())
23 except ConnectionResetError as e:
24 print("Error",e)
25 break
26
27
28 if __name__ == "__main__":
29 HOST, PORT = "localhost", 9999
30
31 # Create the server, binding to localhost on port 9999
32 server = socketserver.TCPServer((HOST, PORT), MyTCPHandler)
33 #实例化
34 server.serve_forever()
Socketserver
1 #Author：ZhangKanghui
2
3 import socket
4 client = socket.socket()
5 client.connect((‘localhost‘,9999))
6 while True:
7 msg = input(">>:").strip()
8 if len(msg) == 0: continue
9 client.send(msg.encode("utf-8"))
10 data =client.recv(1024)
11 print("recv:",data)
12
13 client.close()
Client
此时，能不能支持多并发呢？我们可以多次启动客户端，发现不能。只有先断开1才会执行2，断开2才会执行3。
那么如何实现多并发呢？其实很简单。 只需要在服务器端修改TCPServer为ThreadingTCPServer即可。
ThreadingTCPServer就是多线程。什么事多线程呢？看后续
3 socket实现简单的SSH服务器端和客户端
通过os模块调用命令行。
1 #Author：ZhangKanghui
2 import os
3 import socket
4 server = socket.socket()
5 server.bind((‘localhost‘,9999))
6
7 server.listen()
8
9 while True:
10 conn,addr = server.accept()
11 print("new coon",addr)
12 while True:
13 data = conn.recv(1024)
14 if not data:
15 print("客户端已断开")
16 break
17 print("执行指令：",data)
18 cmd_res = os.popen(data.decode()).read()
19 if len(cmd_res) == 0:
20 cmd_res = "cmd has no output"
21
22 conn.send(cmd_res.encode("utf-8"))
23
24 server.close()
SSH服务器端
1 #Author：ZhangKanghui
2
3 import socket
4 client = socket.socket()
5
6 client.connect((‘localhost‘,9999))
7
8 while True:
9 cmd = input(">>:").strip()
10 if len(cmd) == 0:continue
11 client.send(cmd.encode("utf-8"))
12 cmd_res = client.recv(1024)
13
14 print(cmd_res.decode())
15
16 client.close()
SSH客户端
当使用存在的指令时，会有正常输出，但是当指令不存在时，通过判断让程序正常进行了。这个以后会有更好的解决办法
可以通过以下几个指令试一下，看一下执行结果
dir pwd ipconfig
运行结果会发现竟然不全，那究竟是为什么呢？客户端接收1024剩下存在服务器端的内存里，就一直存在缓冲区中，如果不接收完会影响下一条指令的正常输出。
那么怎样能够接收完呢？
思路是这样的，在服务器端发送给客户端时先判断数据大小，客户端接收数据大小之后，可以通过循环每次1024接收，直至传输完毕。
修改之后代码是这样的。可以试试对比一下有什么不同？再次执行ipconfig
1 #Author：ZhangKanghui
2 import os
3 import socket
4 server = socket.socket()
5 server.bind((‘localhost‘,9999))
6
7 server.listen()
8
9 while True:
10 conn,addr = server.accept()
11 print("new coon",addr)
12 while True:
13 data = conn.recv(1024)
14 if not data:
15 print("客户端已断开")
16 break
17 print("执行指令：",data)
18 cmd_res = os.popen(data.decode()).read()
19 if len(cmd_res) == 0:
20 cmd_res = "cmd has no output"
21 conn.send(str(len(cmd_res.encode())).encode("utf-8")) #先发大小给客户端
22 conn.send(cmd_res.encode("utf-8"))
23
24 server.close()
SSH服务器端
1 #Author：ZhangKanghui
2
3 import socket
4 client = socket.socket()
5
6 client.connect((‘localhost‘,9999))
7
8 while True:
9 cmd = input(">>:").strip()
10 if len(cmd) == 0:continue
11 client.send(cmd.encode("utf-8"))
12 cmd_res_size = client.recv(1024) #先接收命令结果的大小
13 print("命令结果大小：",cmd_res_size)
14
15 received_size = 0
16 #received_data = b‘‘
17 while received_size != int(cmd_res_size.decode()):
18 data = client.recv(1024)
19 received_size+=len(data)
20 print(received_size)
21 print(data.decode())
22 else:
23 print("cmd res received done",received_size)
24
25 cmd_res = client.recv(1024)
26
27 print(cmd_res.decode())
28
29 client.close()
SSH客户端
我们看一下服务器中的一段代码：
两次发送，系统有时会把它们合在一起发出去，就出现了粘包~！因为不知道缓冲区什么时候会把这两条命令放在一起。
那下面来了解一下粘包。
4 粘包
TCP粘包是在一次接收数据不能完全地体现一个完整的消息数据。TCP通讯为何存在粘包呢？
主要原因是TCP是以流的方式来处理数据，再加上网络上MTU的往往小于在应用处理的消息数据，所以就会引发一次接收的数据无法满足消息的需要，导致粘包的存在。
那么我们如何解决呢？
第一种解决方法：
首先通过一种缓冲区接收数据超时，发送命令来间隔两次命令传输，但这样的后果就是延长数据传输时间，降低了传输效率。
这种方法显然不太可取。太low了~！
下面来个正确姿势解决粘包：
第二种解决方法：
让客户端给服务器端一个确认指令，通过确认指令间隔两次命令传输，这样就能阻隔两次命令的粘包。
1 #Author：ZhangKanghui
2 import os
3 import time
4 import socket
5 server = socket.socket()
6 server.bind((‘localhost‘,9999))
7
8 server.listen()
9
10 while True:
11 conn,addr = server.accept()
12 print("new coon",addr)
13 while True:
14 data = conn.recv(1024)
15 if not data:
16 print("客户端已断开")
17 break
18 print("执行指令：",data)
19 cmd_res = os.popen(data.decode()).read()
20 if len(cmd_res) == 0:
21 cmd_res = "cmd has no output"
22 conn.send(str(len(cmd_res.encode())).encode("utf-8")) #先发大小给客户端
23 #time.sleep(0.5)
24 client_ack = conn.recv(1024) #等待客户端确认，不然就在这里挂起，从而完成上一条发送命令与下一条隔开，解决粘包
25 print("ack from client:",client_ack)
26 conn.send(cmd_res.encode("utf-8"))
27
28 server.close()
服务器端
1 #Author：ZhangKanghui
2
3 import socket
4 client = socket.socket()
5
6 client.connect((‘localhost‘,9999))
7
8 while True:
9 cmd = input(">>:").strip()
10 if len(cmd) == 0:continue
11 client.send(cmd.encode("utf-8"))
12 cmd_res_size = client.recv(1024) #先接收命令结果的大小
13 print("命令结果大小：",cmd_res_size)
14 client("防止粘包发送的确定指令")
15
16 received_size = 0
17 #received_data = b‘‘
18 while received_size != int(cmd_res_size.decode()):
19 data = client.recv(1024)
20 received_size+=len(data)
21 print(received_size)
22 print(data.decode())
23 else:
24 print("cmd res received done",received_size)
25
26 cmd_res = client.recv(1024)
27
28 print(cmd_res.decode())
29
30 client.close()
客户端
第三种方法：
通过服务器发送给客户端需要接受数据的大小，然后客户端自己判断大小通过每次接1024，最后一次把剩下的接收。也就是说刚好接受文件大小，再继续接受下一个。
这样也能解决粘包问题。同时下面的代码中对文件的传输还进行了MD5加密。关于ftp
ftp server：
1 读取文件名
2 检测文件是否存在
3 打开文件
4 检测文件大小
5 发送文件大小给客户端
6 等待客户端确认
7 开始边读边发数据
8 发送md5
1 #Author：ZhangKanghui
2 import os
3 import time
4 import socket
5 import hashlib
6 server = socket.socket()
7 server.bind((‘localhost‘,9999))
8
9 server.listen()
10
11 while True:
12 conn,addr = server.accept()
13 print("new coon",addr)
14 while True:
15 data = conn.recv(1024)
16 if not data:
17 print("客户端已断开")
18 break
19 cmd,filename = data.decode().split()
20 print(filename)
21 if os.path.isfile(filename):
22 f = open(filename,‘rb‘)
23 m =hashlib.md5()
24 file_size = os.stat(filename).st_size
25 conn.send(str(file_size.encode())) #send file size
26 conn.recv(1024) #wait for ack
27 for line in f:
28 m.update(line)
29 conn.send(line)
30 print("file md5:",m.hexdiggest())
31 f.close()
32 conn.send(m.hexdiggest().encode()) #send md5
33 server.close()
ftp服务器端
1 #Author：ZhangKanghui
2
3 import socket
4 import os
5 import hashlib
6 client = socket.socket()
7
8 client.connect((‘localhost‘,9999))
9
10 while True:
11 cmd = input(">>:").strip()
12 if len(cmd) == 0:continue
13 if cmd.startswith("get"):
14 client.send(cmd.encode())
15 server_reponse = client.recv(1024)
16 print("server response:",server_reponse)
17 client.send(b"i am ready to recv file")
18 file_total_size =int(server_reponse.decode())
19 received_size = 0
20 filename = cmd.split()[1]
21 f =open(filename +‘.new‘,‘wb‘)
22 m = hashlib.md5()
23 while received_size < file_total_size:
24 if file_total_size - received_size >1024: #表示要收不止一次
25 size =1024
26 else: #最后一次剩多少收多少
27 size =file_total_size - received_size
28 print("last recv:",size)
29
30 data =client.recv(size)
31 received_size+=len(data)
32 m.update(data)
33 f.write(data)
34 #print(file_total_size,received_size)
35 else:
36 new_file_md5 =m.hexdigest()
37 print("flie recv done",file_total_size,received_size)
38 f.close()
39 server_file_md5 = client.recv(1024)
40 print("server file md5",server_file_md5)
41 print("client file md5",new_file_md5)
42 client.close()
ftp客户端
5 小结
真的不懂，可能以后会明白的。
安慰别人的话说服不了自己。
间歇性踌躇满志，持续性混吃等死~！
6 练习
作业：开发一个支持多用户在线的FTP程序
要求：
- 用户加密认证
- 允许同时多用户登录
- 每个用户有自己的家目录 ，且只能访问自己的家目录
- 对用户进行磁盘配额，每个用户的可用空间不同
- 允许用户在ftp server上随意切换目录
- 允许用户查看当前目录下文件
- 允许上传和下载文件，保证文件一致性
- 文件传输过程中显示进度条
- 附加功能：
新建目录mkdir
.查看当前工作目录的路径pwd
如果对一些基础概念还不够明确，或者这篇博客的逻辑不过清晰，可以看这里
python之socket_ssh实例 http://www.cnblogs.com/0zcl/p/6017088.html
python之socket_ftp实例 http://www.cnblogs.com/0zcl/p/6022774.html
6.1 程序目录结构
服务器端
客户端
都看到这里了，如果真的想弄明白，那就看这篇博客吧，我自己也不会。以后看明白了再补上。说出这句话自己心里都没底气。
点击这里：https://www.cnblogs.com/0zcl/p/6259128.html
我是尾巴~
这次推荐：以后买来新电脑请看这篇文章：https://mp.weixin.qq.com/s/OAQ3Vn3NRRHE4IfzoONjng
可以说是非常用心了！
虽不才，才要坚持。
原文地址：https://www.cnblogs.com/zhangkanghui/p/9551947.html