- 01-计算机基础
- 02-什么是网络
- 03-五层协议详解
- 04-传输层详解
- 05-什么是Socket
- 06-基于socket实现简单套接字通信
- 07-在简单套接字基础上加上通信循环
- 08-客户端与服务端代码bug修复
- 09-实现服务端对多个客户端提供服务
- 10-模式ssh远程执行命令-项目分析
- 11-模拟ssh远程执行命令-代码实现
- 12-粘包现象
- 13-粘包底层原理分析
- 14-解决粘包问题-伪代码实现
- 15-解决粘包问题-简单版本
- 16-解决粘包问题-终极版本
- 17-文件传输功能实现
- 18-文件传输功能-函数版
- 19-文件传输功能-面向对象版
- 20-基于UDP协议的套接字介绍
- 21-作业介绍
01-计算机基础
1、1）计算机硬件->2）安装操作系统（Windows、Linux、MacOS）->3）安装应用软件（腾讯视频、QQ、Wechat、Office）
2、三层的架构：硬件、系统软件、应用软件；
3、人可以指挥机器，掌握一种机器能听懂的表达方式；实现用机器解放人类劳动力的替代；
4、计算机硬件是被操作系统操控的，应用软件是基于操作系统运行的；
5、有专人去开发OS-操作系统，我们通过接口调用操作系统，定位是：一名应用程序员；间接地去控制硬件；
6、操作系统充当一个代理的角色，生活中代理无处不在，反映了哲学的设计思想；
7、C/S架构软件，基于网络通信；学习Python是为了成为一名应用开发程序员；
数据的流向：Client-》客户端OS-》PC机-》网络设备-》服务器-》服务器OS-》Server
02-什么是网络
1、计算机通信比喻——电话通信；
1）生活中通信举例：
- 河北人给辽宁人打电话(有线)；
- 知道对方的电话号码；
- 说东北话，因为可能听不懂河北话（方言）；
-
大家都遵循的标准——普通话；
- 全世界沟通交流的统一标准-英语（English）
2）计算机与计算机之间通信举例；
- 网线连接，进行通信；
- 计算机与计算机之间通信交流的标准-互联网协议；
- 互联网中的协议，就是计算机界的“英语”；
- 互联网协议可分为7层、5层或4层；
3）互联网协议-OSI七层；
- 应用层-L7
- 表示层-L6
- 会话层-L5
- 传输层-L4
- 网络层-L3
- 数据链路层-L2
- 物理层-L1
03-五层协议详解
1、网络的概念；
1）、就是底层的物理链接介质+互联网协议；
2）、互联网协议就是计算机界的“英语”；
2、互联网5层协议详解；
1）、物理层-L1；
功能：发送电信号0101110001；
2）、数据链路层-L2；
形成了统一的标准-Ethernet（以太网协议）；
计算机通信基本靠吼；
3）、网络层-L3；
引出IP地址的概念；
4）、传输层-L4
TCP、UDP协议；
引出端口号的概念；1~65535；
IP+Port可以表示全世界范围内唯一一个软件；
一般来说，服务端会绑定IP和端口；而客户端不需要；
5）、应用层-L5（会话、表示、应用层）
HTTP、FTP；
04-传输层详解
1、自定义与他定义协议两大类；
2、TCP协议属于是流式协议，数据传输需要建立管道；
3、TCP/IP的三次握手，四次挥手；
4、TCP叫做可靠传输协议；
5、UDP协议属于不可靠协议；
6、UDP协议传输效率高，TCP协议效率低；
05-什么是Socket
1、什么是Socket（套接字）；
- Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部。
- socket起源于Unix，而Unix/Linux 基本哲学之一就是“一切皆文件”，都可以用“打开open –> 读写write/read –> 关闭close”模式 来操作。Socket就是该模式的一个实现，socket即是一种特殊的文件，一些socket函数就是对其进行的操作（读/写IO、打开、关闭）
- 我们想给另一台计算机发消息，你知道他的IP地址，他的机器上同时运行着qq、迅雷、word、浏览器等程序，你想给他的qq发消息，那想一下，你现在只能通过ip找到他的机器，但如果让这台机器知道把消息发给qq程序呢？答案就是通过port,一个机器上可以有0-65535个端口，你的程序想从网络上收发数据，就必须绑定一个端口，这样，远程发到这个端口上的数据，就全会转给这个程序啦
2、Socket通信套路；
- 当通过socket建立起2台机器的连接后，本质上socket只干2件事，一是收数据，一是发数据，没数据时就等着。
- socket 建立连接的过程跟我们现实中打电话比较像，打电话必须是打电话方和接电话方共同完成的事情，我们分别看看他们是怎么建立起通话的
1）、接电话方：
1.首先你得有个电话 2.你的电话要有号码 3.你的电话必须连上电话线 4.开始在家等电话 5.电话铃响了，接起电话，听到对方的声音
2）、打电话方：
1.首先你得有个电话 2.输入你想拨打的电话 3.等待对方接听 4.say “hi 约么，我有七天酒店的打折卡噢~” 5.等待回应——》响应回应——》等待回应。。。。
把它翻译成socket通信
1）、接电话方(socket服务器端)：
1.首先你得有个电话\(生成socket对象\) 2.你的电话要有号码\(绑定本机ip+port\) 3.你的电话必须连上电话线\(连网\) 4.开始在家等电话\(开始监听电话listen\) 5.电话铃响了，接起电话，听到对方的声音\(接受新连接\)
2）、打电话方(socket客户端)
1.首先你得有个电话\(生成socket对象\) 2.输入你想拨打的电话\(connect 远程主机ip+port\) 3.等待对方接听 4.say “hi 约么，我有七天酒店的打折卡噢~”\(send\(\) 发消息。。。\) 5.等待回应——》响应回应——》等待回应。。。。
06-基于socket实现简单套接字通信
1、简单的套接字通信；
1）server.py;
import socket #1、买手机； phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM) #2、绑定手机卡； phone.bind(('127.0.0.1',18081))#0~65535,其中0~1024，系统使用 #3、开机； phone.listen(5) #4、等电话来连接； print('starting....') # cxz = phone.accept() # print(cxz) conn,client_addr = phone.accept() #5、收、发消息； data = conn.recv(1024)#1、单位bytes；2、1024代表最大接受1024个bytes； print('客户端数据',data) conn.send(data.upper()) #6、挂电话； conn.close() #7、关机； phone.close()
2) client.py
import socket #1、买手机； phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM) #print(phone)#<socket.socket fd=428, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0> #2、拨号； phone.connect(('127.0.0.1',18081))#ConnectionRefusedError: [WinError 10061] 由于目标计算机积极拒绝，无法连接。 #3、发、收消息； phone.send('hello'.encode('utf-8')) data = phone.recv(1024) print(data) #4、关机； phone.close()
07-在简单套接字基础上加上通信循环
1、加上循环通信；
1）server.py
import socket phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM) phone.bind(('127.0.0.1',18080))#0~65535,其中0~1024，系统使用; phone.listen(5) print('starting....') conn,client_addr = phone.accept() print(client_addr) while True: data = conn.recv(1024)#1、单位bytes；2、1024代表最大接受1024个bytes； print('客户端数据',data) conn.send(data.upper()) conn.close() phone.close()
2)client.py
import socket phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM) phone.connect(('127.0.0.1',18080))#ConnectionRefusedError: [WinError 10061] 由于目标计算机积极拒绝，无法连接。 while True: msg = input('>>>:').strip() phone.send(msg.encode('utf-8')) data = phone.recv(1024) print(data) phone.close()
08-客户端与服务端代码bug修复
1、server.py
import socket phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM) phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) phone.bind(('127.0.0.1',18080))#0~65535,其中0~1024，系统使用; phone.listen(5) print('starting....') conn,client_addr = phone.accept() print(client_addr) while True: try: data = conn.recv(1024)#1、单位bytes；2、1024代表最大接受1024个bytes； if not data:break#仅适用于Linux操作系统； print('客户端数据',data) conn.send(data.upper()) except ConnectionResetError:#适用于Windows操作系统； break conn.close() phone.close()
2、client.py
import socket phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM) phone.connect(('127.0.0.1',18080))#ConnectionRefusedError: [WinError 10061] 由于目标计算机积极拒绝，无法连接。 while True: msg = input('>>>:').strip() if not msg:continue phone.send(msg.encode('utf-8')) data = phone.recv(1024) print(data.decode('utf-8')) phone.close()
09-实现服务端对多个客户端提供服务
1、实现链接循环；
1)server.py
import socket phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM) phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) phone.bind(('127.0.0.1',18080))#0~65535,其中0~1024，系统使用; phone.listen(5) print('starting....') while True:#链接循环； conn,client_addr = phone.accept() print(client_addr) while True:#进入通信循环； try: data = conn.recv(1024)#1、单位bytes；2、1024代表最大接受1024个bytes； if not data:break#仅适用于Linux操作系统； print('客户端数据',data) conn.send(data.upper()) except ConnectionResetError:#适用于Windows操作系统； break conn.close() phone.close()
2)client1.py
import socket phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM) phone.connect(('127.0.0.1',18080))#ConnectionRefusedError: [WinError 10061] 由于目标计算机积极拒绝，无法连接。 while True: msg = input('>>>:').strip() if not msg:continue phone.send(msg.encode('utf-8')) data = phone.recv(1024) print(data.decode('utf-8')) phone.close()
3)client2.py
import socket phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM) phone.connect(('127.0.0.1',18080))#ConnectionRefusedError: [WinError 10061] 由于目标计算机积极拒绝，无法连接。 while True: msg = input('>>>:').strip() if not msg:continue phone.send(msg.encode('utf-8')) data = phone.recv(1024) print(data.decode('utf-8')) phone.close()
10-模式ssh远程执行命令-项目分析
11-模拟ssh远程执行命令-代码实现
1、server.py;
import socket import os import subprocess phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM) phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) phone.bind(('127.0.0.1',18080))#0~65535,其中0~1024，系统使用; phone.listen(5) print('starting....') while True:#链接循环； conn,client_addr = phone.accept() print(client_addr) while True:#进入通信循环； try: #1、收命令； cmd = conn.recv(1024)#1、单位bytes；2、1024代表最大接受1024个bytes； if not cmd:break#仅适用于Linux操作系统； print('客户端数据',cmd) #2、执行命令，拿到结果； obj = subprocess.Popen(cmd.decode('utf-8'), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE) # obj = subprocess.Popen('xxxxxipconfig',shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE) stdout = obj.stdout.read() # stdout1--->: b'\r\nWindows IP \xc5\xe4\xd6\xc3\r\n\r\n\r\n\xd2\xd4\xcc\xab\xcd\xf8\xca\xca\xc5\xe4\xc6\xf7 \xd2\xd4\xcc\xab\xcd\xf8 2:\r\n\r\n \xc1\xac\xbd\xd3\xcc\xd8\xb6\xa8\xb5\xc4 DNS \xba\xf3\xd7\xba . . . . . . . : \r\n \xb1\xbe\xb5\xd8\xc1\xb4\xbd\xd3 IPv6 \xb5\xd8\xd6\xb7. . . . . . . . : fe80::fdc4:7f23:1928:6026%11\r\n IPv4 \xb5\xd8\xd6\xb7 . . . . . . . . . . . . : 192.168.1.5\r\n \xd7\xd3\xcd\xf8\xd1\xda\xc2\xeb . . . . . . . . . . . . : 255.255.255.0\r\n \xc4\xac\xc8\xcf\xcd\xf8\xb9\xd8. . . . . . . . . . . . . : fe80::1%11\r\n 192.168.1.1\r\n\r\n\xd2\xd4\xcc\xab\xcd\xf8\xca\xca\xc5\xe4\xc6\xf7 \xd2\xd4\xcc\xab\xcd\xf8 3:\r\n\r\n \xc3\xbd\xcc\xe5\xd7\xb4\xcc\xac . . . . . . . . . . . . : \xc3\xbd\xcc\xe5\xd2\xd1\xb6\xcf\xbf\xaa\xc1\xac\xbd\xd3\r\n \xc1\xac\xbd\xd3\xcc\xd8\xb6\xa8\xb5\xc4 DNS \xba\xf3\xd7\xba . . . . . . . : \r\n\r\n\xcb\xed\xb5\xc0\xca\xca\xc5\xe4\xc6\xf7 Teredo Tunneling Pseudo-Interface:\r\n\r\n \xc1\xac\xbd\xd3\xcc\xd8\xb6\xa8\xb5\xc4 DNS \xba\xf3\xd7\xba . . . . . . . : \r\n IPv6 \xb5\xd8\xd6\xb7 . . . . . . . . . . . . : 2001:0:9d38:6ab8:242a:88b7:20b7:be6c\r\n \xb1\xbe\xb5\xd8\xc1\xb4\xbd\xd3 IPv6 \xb5\xd8\xd6\xb7. . . . . . . . : fe80::242a:88b7:20b7:be6c%14\r\n \xc4\xac\xc8\xcf\xcd\xf8\xb9\xd8. . . . . . . . . . . . . : ::\r\n' stderr = obj.stderr.read() # stdout3--->: 'xxxxxipconfig' 不是内部或外部命令，也不是可运行的程序或批处理文件。 #3、把命令结果返回给客户端； conn.send(stdout+stderr)#+号是一个可以优化的点子； except ConnectionResetError:#适用于Windows操作系统； break conn.close() phone.close()
2、client.py;
import socket phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM) phone.connect(('127.0.0.1',18080))#ConnectionRefusedError: [WinError 10061] 由于目标计算机积极拒绝，无法连接。 while True: #发送命令； cmd = input('>>>:').strip() if not cmd:continue phone.send(cmd.encode('utf-8')) #2、拿到命令的结果 data = phone.recv(1024) print(data.decode('gbk')) phone.close() """ C:\Users\Administrator\PycharmProjects\LFXC2018\venv\Scripts\python.exe "C:/Users/Administrator/PycharmProjects/LFXC2018/第三模块 面向对象/网络编程/11-模拟ssh远程执行命令-代码实现/11-client.py" >>>:ipconfig Windows IP 配置 以太网适配器 以太网 2: 连接特定的 DNS 后缀 . . . . . . . : 本地链接 IPv6 地址. . . . . . . . : fe80::fdc4:7f23:1928:6026%11 IPv4 地址 . . . . . . . . . . . . : 192.168.1.5 子网掩码 . . . . . . . . . . . . : 255.255.255.0 默认网关. . . . . . . . . . . . . : fe80::1%11 192.168.1.1 以太网适配器 以太网 3: 媒体状态 . . . . . . . . . . . . : 媒体已断开连接 连接特定的 DNS 后缀 . . . . . . . : 隧道适配器 Teredo Tunneling Pseudo-Interface: 连接特定的 DNS 后缀 . . . . . . . : IPv6 地址 . . . . . . . . . . . . : 2001:0:9d38:6ab8:242a:88b7:20b7:be6c 本地链接 IPv6 地址. . . . . . . . : fe80::242a:88b7:20b7:be6c%14 默认网关. . . . . . . . . . . . . : :: >>>: """
12-粘包现象
1、粘包现象初识
某个命令的输出结果字节比较长，但客户端只recv(1024), 可结果比1024长呀，那怎么办，只好在服务器端的IO缓冲区里把客户端还没收走的暂时存下来，等客户端下次再来收。同志们，这个现象叫做粘包，就是指两次结果粘到一起了。它的发生主要是因为socket缓冲区导致的，来看一下
2、粘包问题只存在于TCP中，Not UDP；
还是看上图，发送端可以是一K一K地发送数据，而接收端的应用程序可以两K两K地提走数据，当然也有可能一次提走3K或6K数据，或者一次只提走几个字节的数据，也就是说，应用程序所看到的数据是一个整体，或说是一个流（stream），一条消息有多少字节对应用程序是不可见的，因此TCP协议是面向流的协议，这也是容易出现粘包问题的原因。而UDP是面向消息的协议，每个UDP段都是一条消息，应用程序必须以消息为单位提取数据，不能一次提取任意字节的数据，这一点和TCP是很不同的。怎样定义消息呢？可以认为对方一次性write/send的数据为一个消息，需要明白的是当对方send一条信息的时候，无论底层怎样分段分片，TCP协议层会把构成整条消息的数据段排序完成后才呈现在内核缓冲区。
所谓粘包问题主要还是因为接收方不知道消息之间的界限，不知道一次性提取多少字节的数据所造成的。
小结：
- TCP（transport control protocol，传输控制协议）是面向连接的，面向流的，提供高可靠性服务。收发两端（客户端和服务器端）都要有一一成对的socket，因此，发送端为了将多个发往接收端的包，更有效的发到对方，使用了优化方法（Nagle算法），将多次间隔较小且数据量小的数据，合并成一个大的数据块，然后进行封包。这样，接收端，就难于分辨出来了，必须提供科学的拆包机制。 即面向流的通信是无消息保护边界的。
- UDP（user datagram protocol，用户数据报协议）是无连接的，面向消息的，提供高效率服务。不会使用块的合并优化算法，, 由于UDP支持的是一对多的模式，所以接收端的skbuff(套接字缓冲区）采用了链式结构来记录每一个到达的UDP包，在每个UDP包中就有了消息头（消息来源地址，端口等信息），这样，对于接收端来说，就容易进行区分处理了。 即面向消息的通信是有消息保护边界的。
- tcp是基于数据流的，于是收发的消息不能为空，这就需要在客户端和服务端都添加空消息的处理机制，防止程序卡住，而udp是基于数据报的，即便是你输入的是空内容（直接回车），那也不是空消息，udp协议会帮你封装上消息头
#!/usr/bin/env python3 # -*- coding:utf-8 -*- # __Author__:TQTL911 # Version:python3.6.6 # Time:2018/7/14 16:11 import socket import subprocess phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM) phone.bind(('127.0.0.1',9901))#0~65525,其中0~1024给操作系统使用； phone.listen(5)#5表示最大挂起的链接数； print('starting...') while True:#链接循环 conn,client_addr = phone.accept() print(client_addr) while True:#通信循环 try: #1、接收命令； cmd = conn.recv(1024)#接收数据的最大字节数；1、单位：bytes；2、最大接收1024个bytes； #if not cmd:break#仅适用于Linux操作系统 #2、执行命令，拿到结果并打印； obj = subprocess.Popen(cmd.decode('utf-8'),shell=True, stdout = subprocess.PIPE, stderr = subprocess.PIPE) stdout = obj.stdout.read() stderr = obj.stderr.read() #3、把命令的结果返回给客户端； print(len(stdout)+ len(stderr)) conn.send(stdout + stderr)#+号是一个可以优化的点 except ConnectionResetError:#异常处理； break conn.close() phone.close()
#!/usr/bin/env python3 # -*- coding:utf-8 -*- # __Author__:TQTL911 # Version:python3.6.6 # Time:2018/7/14 16:17 import socket phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM) phone.connect(('127.0.0.1',9901))#0~65525,其中0~1024给操作系统使用； while True: #1、发送命令； cmd = input('>>:').strip()#ls /etc if not cmd:continue phone.send(cmd.encode('utf-8')) #2、拿到命令结果； data = phone.recv(1024)#有可能数据包的大小超过1024bytes； print(data.decode('gbk')) phone.close()
13-粘包底层原理分析
1、send与recv的对比；
- 不管是recv还是send，都不是直接接受对方的数据，而是操作自己的操作系统；
- 不是一个send对应一个recv；
- recv阶段：wait data阶段耗时过长；copy数据，耗时较短；
- send阶段：copy数据耗时较短；
2、粘包存在与客户端或者服务端；
#!/usr/bin/env python3 # -*- coding:utf-8 -*- # __Author__:TQTL911 # Version:python3.6.6 # Time:2018/7/14 16:11 import socket import subprocess server = socket.socket(socket.AF_INET,socket.SOCK_STREAM) server.bind(('127.0.0.1',9001))#0~65525,其中0~1024给操作系统使用； server.listen(5)#5表示最大挂起的链接数； conn,addr = server.accept() res1 = conn.recv(1024) print('第1次',res1) res2 = conn.recv(1024) print('第2次',res2)
#!/usr/bin/env python3 # -*- coding:utf-8 -*- # __Author__:TQTL911 # Version:python3.6.6 # Time:2018/7/14 16:17 import socket import time client = socket.socket(socket.AF_INET,socket.SOCK_STREAM) client.connect(('127.0.0.1',9001)) client.send('hello'.encode('utf-8')) time.sleep(5) client.send('world'.encode('utf-8'))
14-解决粘包问题-伪代码实现
1、伪代码；
1）server.py
import socket import os import subprocess phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM) #phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) phone.bind(('127.0.0.1',18080))#0~65535,其中0~1024，系统使用; phone.listen(5) print('starting....') while True:#链接循环； conn,client_addr = phone.accept() print(client_addr) while True:#进入通信循环； try: #1、收命令； cmd = conn.recv(1024)#1、单位bytes；2、1024代表最大接受1024个bytes； if not cmd:break#仅适用于Linux操作系统； print('客户端数据',cmd) #2、执行命令，拿到结果； obj = subprocess.Popen(cmd.decode('utf-8'), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE) # obj = subprocess.Popen('xxxxxipconfig',shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE) stdout = obj.stdout.read() # stdout1--->: b'\r\nWindows IP \xc5\xe4\xd6\xc3\r\n\r\n\r\n\xd2\xd4\xcc\xab\xcd\xf8\xca\xca\xc5\xe4\xc6\xf7 \xd2\xd4\xcc\xab\xcd\xf8 2:\r\n\r\n \xc1\xac\xbd\xd3\xcc\xd8\xb6\xa8\xb5\xc4 DNS \xba\xf3\xd7\xba . . . . . . . : \r\n \xb1\xbe\xb5\xd8\xc1\xb4\xbd\xd3 IPv6 \xb5\xd8\xd6\xb7. . . . . . . . : fe80::fdc4:7f23:1928:6026%11\r\n IPv4 \xb5\xd8\xd6\xb7 . . . . . . . . . . . . : 192.168.1.5\r\n \xd7\xd3\xcd\xf8\xd1\xda\xc2\xeb . . . . . . . . . . . . : 255.255.255.0\r\n \xc4\xac\xc8\xcf\xcd\xf8\xb9\xd8. . . . . . . . . . . . . : fe80::1%11\r\n 192.168.1.1\r\n\r\n\xd2\xd4\xcc\xab\xcd\xf8\xca\xca\xc5\xe4\xc6\xf7 \xd2\xd4\xcc\xab\xcd\xf8 3:\r\n\r\n \xc3\xbd\xcc\xe5\xd7\xb4\xcc\xac . . . . . . . . . . . . : \xc3\xbd\xcc\xe5\xd2\xd1\xb6\xcf\xbf\xaa\xc1\xac\xbd\xd3\r\n \xc1\xac\xbd\xd3\xcc\xd8\xb6\xa8\xb5\xc4 DNS \xba\xf3\xd7\xba . . . . . . . : \r\n\r\n\xcb\xed\xb5\xc0\xca\xca\xc5\xe4\xc6\xf7 Teredo Tunneling Pseudo-Interface:\r\n\r\n \xc1\xac\xbd\xd3\xcc\xd8\xb6\xa8\xb5\xc4 DNS \xba\xf3\xd7\xba . . . . . . . : \r\n IPv6 \xb5\xd8\xd6\xb7 . . . . . . . . . . . . : 2001:0:9d38:6ab8:242a:88b7:20b7:be6c\r\n \xb1\xbe\xb5\xd8\xc1\xb4\xbd\xd3 IPv6 \xb5\xd8\xd6\xb7. . . . . . . . : fe80::242a:88b7:20b7:be6c%14\r\n \xc4\xac\xc8\xcf\xcd\xf8\xb9\xd8. . . . . . . . . . . . . : ::\r\n' stderr = obj.stderr.read() # stdout3--->: 'xxxxxipconfig' 不是内部或外部命令，也不是可运行的程序或批处理文件。 #3、把命令结果返回给客户端； #3-1把数据的长度发给客户端； #3-2再发送真实的数据 #把报头（固定长度）发送给客户端； total_size = print(len(stdout)+len(stderr)) conn.send(str(total_size).encode('utf-8')) #conn.send(stdout+stderr)#+号是一个可以优化的点子； conn.send(stdout) conn.send(stderr) except ConnectionResetError:#适用于Windows操作系统； break conn.close() phone.close()
2)client.py
import socket phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM) phone.connect(('127.0.0.1',18080))#ConnectionRefusedError: [WinError 10061] 由于目标计算机积极拒绝，无法连接。 while True: cmd = input('>>>:').strip() if not cmd:continue phone.send(cmd.encode('utf-8')) total_size =102400 #第一步，先拿到数据的长度； #接受真实的数据； recv_size = 0 recv_data = b'' while recv_size < total_size: res = phone.recv(1024) recv_data += res recv_size += len(res) print(recv_data.decode('utf-8')) phone.close()
15-解决粘包问题-简单版本
1、简单版本；
1）、sever.py
import socket import os import subprocess import struct phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM) #phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) phone.bind(('127.0.0.1',18081))#0~65535,其中0~1024，系统使用; phone.listen(5) print('starting....') while True:#链接循环； conn,client_addr = phone.accept() print(client_addr) while True:#进入通信循环； try: #1、收命令； cmd = conn.recv(1024)#1、单位bytes；2、1024代表最大接受1024个bytes； if not cmd:break#仅适用于Linux操作系统； print('客户端数据',cmd) #2、执行命令，拿到结果； obj = subprocess.Popen(cmd.decode('utf-8'), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE) # obj = subprocess.Popen('xxxxxipconfig',shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE) stdout = obj.stdout.read() # stdout1--->: b'\r\nWindows IP \xc5\xe4\xd6\xc3\r\n\r\n\r\n\xd2\xd4\xcc\xab\xcd\xf8\xca\xca\xc5\xe4\xc6\xf7 \xd2\xd4\xcc\xab\xcd\xf8 2:\r\n\r\n \xc1\xac\xbd\xd3\xcc\xd8\xb6\xa8\xb5\xc4 DNS \xba\xf3\xd7\xba . . . . . . . : \r\n \xb1\xbe\xb5\xd8\xc1\xb4\xbd\xd3 IPv6 \xb5\xd8\xd6\xb7. . . . . . . . : fe80::fdc4:7f23:1928:6026%11\r\n IPv4 \xb5\xd8\xd6\xb7 . . . . . . . . . . . . : 192.168.1.5\r\n \xd7\xd3\xcd\xf8\xd1\xda\xc2\xeb . . . . . . . . . . . . : 255.255.255.0\r\n \xc4\xac\xc8\xcf\xcd\xf8\xb9\xd8. . . . . . . . . . . . . : fe80::1%11\r\n 192.168.1.1\r\n\r\n\xd2\xd4\xcc\xab\xcd\xf8\xca\xca\xc5\xe4\xc6\xf7 \xd2\xd4\xcc\xab\xcd\xf8 3:\r\n\r\n \xc3\xbd\xcc\xe5\xd7\xb4\xcc\xac . . . . . . . . . . . . : \xc3\xbd\xcc\xe5\xd2\xd1\xb6\xcf\xbf\xaa\xc1\xac\xbd\xd3\r\n \xc1\xac\xbd\xd3\xcc\xd8\xb6\xa8\xb5\xc4 DNS \xba\xf3\xd7\xba . . . . . . . : \r\n\r\n\xcb\xed\xb5\xc0\xca\xca\xc5\xe4\xc6\xf7 Teredo Tunneling Pseudo-Interface:\r\n\r\n \xc1\xac\xbd\xd3\xcc\xd8\xb6\xa8\xb5\xc4 DNS \xba\xf3\xd7\xba . . . . . . . : \r\n IPv6 \xb5\xd8\xd6\xb7 . . . . . . . . . . . . : 2001:0:9d38:6ab8:242a:88b7:20b7:be6c\r\n \xb1\xbe\xb5\xd8\xc1\xb4\xbd\xd3 IPv6 \xb5\xd8\xd6\xb7. . . . . . . . : fe80::242a:88b7:20b7:be6c%14\r\n \xc4\xac\xc8\xcf\xcd\xf8\xb9\xd8. . . . . . . . . . . . . : ::\r\n' stderr = obj.stderr.read() # stdout3--->: 'xxxxxipconfig' 不是内部或外部命令，也不是可运行的程序或批处理文件。 #3、把命令结果返回给客户端； total_size = print(len(stdout) + len(stderr)) header = struct.pack('i',total_size) #第1步：制作固定长度的报头； conn.send(header) # 第2步：把报头发送给客户端； conn.send(str(total_size).encode('utf-8')) # 第3步：再发送真实的数据； conn.send(stdout) conn.send(stderr) except ConnectionResetError:#适用于Windows操作系统； break conn.close() phone.close()
2)、struct模块的使用
#!/usr/bin/env python # -*- coding:utf-8 -*- # __Author__:Administrator # Version:Python3.6.5 # Date:2018/6/23 0023 9:32 import struct res = struct.pack('i',1230) print(res,type(res),len(res)) #client.recv(4) obj = struct.unpack('i',res) print(obj[0])
3）、client.py的使用
import socket import struct phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM) phone.connect(('127.0.0.1',18081))#ConnectionRefusedError: [WinError 10061] 由于目标计算机积极拒绝，无法连接。 while True: #1、发送命令； cmd = input('>>>:').strip() if not cmd:continue phone.send(cmd.encode('utf-8')) #2、拿到命令的结果，并打印； #第1步：先收报头； header = phone.recv(4) # 第2步，从报头中解析出真实的数据； total_size = struct.unpack('i',header)[0] # 第2步：接受真实的数据； recv_size = 0 recv_data = b'' while recv_size < total_size: res = phone.recv(1024) recv_data += res recv_size += len(res) print(recv_data.decode('utf-8')) phone.close()
16-解决粘包问题-终极版本
1、终极版本；
1)、server.py
import socket import os import subprocess import struct import json phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM) #phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) phone.bind(('127.0.0.1',18080))#0~65535,其中0~1024，系统使用; phone.listen(5) print('starting....') while True:#链接循环； conn,client_addr = phone.accept() print(client_addr) while True:#进入通信循环； try: #1、收命令； cmd = conn.recv(8096)#1、单位bytes；2、1024代表最大接受1024个bytes； if not cmd:break#仅适用于Linux操作系统； #2、执行命令，拿到结果； obj = subprocess.Popen(cmd.decode('utf-8'), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE) # obj = subprocess.Popen('xxxxxipconfig',shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE) stdout = obj.stdout.read() # stdout1--->: b'\r\nWindows IP \xc5\xe4\xd6\xc3\r\n\r\n\r\n\xd2\xd4\xcc\xab\xcd\xf8\xca\xca\xc5\xe4\xc6\xf7 \xd2\xd4\xcc\xab\xcd\xf8 2:\r\n\r\n \xc1\xac\xbd\xd3\xcc\xd8\xb6\xa8\xb5\xc4 DNS \xba\xf3\xd7\xba . . . . . . . : \r\n \xb1\xbe\xb5\xd8\xc1\xb4\xbd\xd3 IPv6 \xb5\xd8\xd6\xb7. . . . . . . . : fe80::fdc4:7f23:1928:6026%11\r\n IPv4 \xb5\xd8\xd6\xb7 . . . . . . . . . . . . : 192.168.1.5\r\n \xd7\xd3\xcd\xf8\xd1\xda\xc2\xeb . . . . . . . . . . . . : 255.255.255.0\r\n \xc4\xac\xc8\xcf\xcd\xf8\xb9\xd8. . . . . . . . . . . . . : fe80::1%11\r\n 192.168.1.1\r\n\r\n\xd2\xd4\xcc\xab\xcd\xf8\xca\xca\xc5\xe4\xc6\xf7 \xd2\xd4\xcc\xab\xcd\xf8 3:\r\n\r\n \xc3\xbd\xcc\xe5\xd7\xb4\xcc\xac . . . . . . . . . . . . : \xc3\xbd\xcc\xe5\xd2\xd1\xb6\xcf\xbf\xaa\xc1\xac\xbd\xd3\r\n \xc1\xac\xbd\xd3\xcc\xd8\xb6\xa8\xb5\xc4 DNS \xba\xf3\xd7\xba . . . . . . . : \r\n\r\n\xcb\xed\xb5\xc0\xca\xca\xc5\xe4\xc6\xf7 Teredo Tunneling Pseudo-Interface:\r\n\r\n \xc1\xac\xbd\xd3\xcc\xd8\xb6\xa8\xb5\xc4 DNS \xba\xf3\xd7\xba . . . . . . . : \r\n IPv6 \xb5\xd8\xd6\xb7 . . . . . . . . . . . . : 2001:0:9d38:6ab8:242a:88b7:20b7:be6c\r\n \xb1\xbe\xb5\xd8\xc1\xb4\xbd\xd3 IPv6 \xb5\xd8\xd6\xb7. . . . . . . . : fe80::242a:88b7:20b7:be6c%14\r\n \xc4\xac\xc8\xcf\xcd\xf8\xb9\xd8. . . . . . . . . . . . . : ::\r\n' stderr = obj.stderr.read() # stdout3--->: 'xxxxxipconfig' 不是内部或外部命令，也不是可运行的程序或批处理文件。 #3、把命令结果返回给客户端； # 第1步：制作固定长度的报头； header_dic = { 'filename':'a.txt', 'md5':'xxxx', 'total_size':len(stdout) + len(stderr) } header_json = json.dumps(header_dic) header_bytes = header_json.encode('utf-8') # 第2步：先发送报头的长度； conn.send(struct.pack('i',len(header_bytes))) # 第3步：把报头发送给客户端； conn.send(header_bytes) # 第4步：再发送真实的数据； conn.send(stdout) conn.send(stderr) except ConnectionResetError:#适用于Windows操作系统； break conn.close() phone.close()
2)、client.py
import socket import struct import json phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM) phone.connect(('127.0.0.1',18080))#ConnectionRefusedError: [WinError 10061] 由于目标计算机积极拒绝，无法连接。 while True: #1、发送命令； cmd = input('>>>:').strip() if not cmd:continue phone.send(cmd.encode('utf-8')) #2、拿到命令的结果，并打印； #第1步：先收报头的长度； obj = phone.recv(4) header_size = struct.unpack('i',obj)[0] #第2步，再收报头； header_bytes = phone.recv(header_size) #第3步，从报头中解析出真实的数据的描述信息； header_json= header_bytes.decode('utf-8') header_dic = header_json.loads(header_json) print(header_dic) total_size = header_dic['total_size'] # 第4步：接受真实的数据； recv_size = 0 recv_data = b'' while recv_size < total_size: res = phone.recv(1024) recv_data += res recv_size += len(res) print(recv_data.decode('utf-8')) phone.close()
3)、struct.py
#!/usr/bin/env python # -*- coding:utf-8 -*- # __Author__:Administrator # Version:Python3.6.5 # Date:2018/6/23 0023 9:32 import struct import json header_dic = { 'filename': 'a.txt', 'md5': 'xxxx', 'total_size': 33333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333 } header_json = json.dumps(header_dic) #print(header_json,type(header_json))#{"filename": "a.txt", "md5": "xxxx", "total_size": 33333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333} <class 'str'> header_bytes = header_json.encode('utf-8') print(type(header_bytes))#<class 'bytes'> print(len(header_bytes))#171 # res = struct.pack('i',1230) # print(res,type(res),len(res)) # #client.recv(4) # obj = struct.unpack('i',res) # print(obj[0]) res = struct.pack('l',len(header_bytes)) print(res,len(res))
17-文件传输功能实现
1、简单版本；
1）、server.py
import socket import os import subprocess import struct import json share_dir = r'C:\Users\Administrator\PycharmProjects\LFXC2018\第三模块 面向对象\网络编程\17-文件传输功能实现\server\share' phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM) #phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) phone.bind(('127.0.0.1',28080))#0~65535,其中0~1024，系统使用; phone.listen(5) print('starting....') while True:#链接循环； conn,client_addr = phone.accept() print(client_addr) while True:#进入通信循环； try: #1、收命令； res = conn.recv(8096)#1、单位bytes；2、1024代表最大接受1024个bytes； if not res:break#仅适用于Linux操作系统； #2、解析命令，提取相应命令参数； cmds = res.decode('utf-8').split()#['get','a.txt'] filename = cmds[1] #3、以读的方式打开文件，读取文件内容，发送给客户端； # 第1步：制作固定长度的报头； header_dic = { 'filename':filename,#'filename':'xxx' 'md5':'xxdxxx', 'file_size':os.path.getsize(r'%s\%s'%(share_dir,filename)) } header_json = json.dumps(header_dic) header_bytes = header_json.encode('utf-8') # 第2步：先发送报头的长度； conn.send(struct.pack('i',len(header_bytes))) # 第3步：把报头发送给客户端； conn.send(header_bytes) # 第4步：再发送真实的数据； with open('%s\%s'%(share_dir,filename),'rb') as f: #conn.send(f.read())#避免使用该方法，大文件将会占用过多内存； for line in f:#节省内存的方案； conn.send(line) except ConnectionResetError:#适用于Windows操作系统； break conn.close() phone.close()
2)、client.py
import socket import struct import json download_dir =r'C:\Users\Administrator\PycharmProjects\LFXC2018\第三模块 面向对象\网络编程\17-文件传输功能实现\client\download' phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM) phone.connect(('127.0.0.1',28080))#ConnectionRefusedError: [WinError 10061] 由于目标计算机积极拒绝，无法连接。 while True: #1、发送命令； cmd = input('>>>:').strip()#get a.txt if not cmd:continue phone.send(cmd.encode('utf-8')) #2、以写的方式打开一个新文件，接收服务端发来的文件的内容写入客户的新文件; #第1步：先收报头的长度； obj = phone.recv(4) header_size = struct.unpack('i',obj)[0] #第2步，再收报头； header_bytes = phone.recv(header_size) #第3步，从报头中解析出真实的数据的描述信息； header_json= header_bytes.decode('utf-8') header_dic = json.loads(header_json) print(header_dic) total_size = header_dic['file_size'] filename = header_dic['filename'] # 第4步：接收真实的数据； with open('%s\%s'%(download_dir,filename),'wb') as f: recv_size = 0 while recv_size < total_size: line = phone.recv(1024) f.write(line) recv_size += len(line) print('总大小%s 已下载大小：%s'%(total_size,recv_size)) phone.close()
3)、struct.py
#!/usr/bin/env python # -*- coding:utf-8 -*- # __Author__:Administrator # Version:Python3.6.5 # Date:2018/6/23 0023 9:32 import struct import json header_dic = { 'filename': 'a.txt', 'md5': 'xxxx', 'total_size': 33333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333 } header_json = json.dumps(header_dic) #print(header_json,type(header_json))#{"filename": "a.txt", "md5": "xxxx", "total_size": 33333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333} <class 'str'> header_bytes = header_json.encode('utf-8') print(type(header_bytes))#<class 'bytes'> print(len(header_bytes))#171 # res = struct.pack('i',1230) # print(res,type(res),len(res)) # #client.recv(4) # obj = struct.unpack('i',res) # print(obj[0]) res = struct.pack('l',len(header_bytes)) print(res,len(res))