首页 > > 网络编程 > 其它 >

异常处理与网络编程（八）

2018-06-18 01:02:04来源：未知阅读 ()

1.1 异常处理

1.1.1 什么是异常？

异常是错误发生的信号，一旦程序出错，就会产生一个异常，应用程序未处理该异常，异常便会抛出，程序随之终止

1.1.2 常见异常类型

1.1.2.1 语法错误应该在程序运行前修正

if 1 >2

    print('xxxxx')

这种错误，根本过不了python解释器的语法检测，必须在程序执行前就改正

1.1.2.2 逻辑错误

x  #NameError

l=[]

l[10000] #IndexError

class Foo:

    pass

Foo.x #AttributeError:

k={'x':1}

k['y'] #KeyError

1/0 #ZeroDivisionError 无法完成计算

for i in 3: #TypeError: int类型不可迭代

    pass

age=input('>>: ') #ValueError

age=int(age)

1.1.3 如何处理异常

为了保证程序的健壮性与容错性，即在遇到错误时程序不会崩溃，我们需要对异常进行处理，如果错误发生的条件是可预知的，我们需要用if进行处理：在错误发生之前进行预防

如果错误发生的条件是不可预知的，则需要用到try...except：在错误发生之后进行处理

print('====>start<=====')

 

try:

    l=[]

    print(l[1111])

    print('====>1')

    print('====>2')

    print('====>3')

except IndexError:

    pass

 

print('====>end<=======')

1.1.3.1 异常类只能用来处理指定的异常情况，如果非指定异常则无法处理。

print('====>start<=====')

try:

    l=[]

    print(l[1111])

    print('====>1')

    print('====>2')

    print('====>3')

except IndexError as e: # 未捕获到异常，程序直接报错

    print('===>',e)

 

print('====>end<=======')

1.1.3.2 多分支

print('====>start<=====')

try:

    l=[]

    # print(l[1111])

    print('====>1')

    d={}

    d['k']

    print('====>2')

    print('====>3')

except IndexError as e:

    print('===>',e)

except KeyError as e:

    print('----',e)

 

print('====>end<=======')

1.1.3.3 万能异常Exception

print('====>start<=====')

try:

    l=[]

    # print(l[1111])

    print('====>1')

    d={}

    d['k']

    print('====>2')

    print('====>3')

except IndexError:

    pass

except KeyError:

    pass

except Exception as e:

    print('万能异常--->',e)

 

print('====>end<=======')

1.1.3.4 多分支异常与万能异常

如果你想要的效果是，无论出现什么异常，我们统一丢弃，或者使用同一段代码逻辑去处理他们，那么骚年，大胆的去做吧，只有一个Exception就足够了。

如果你想要的效果是，对于不同的异常我们需要定制不同的处理逻辑，那就需要用到多分支了。

1.1.3.5 也可以在多分支后来一个Exception

print('====>start<=====')

try:

    l=[]

    print(l[1111])

    # print('====>1')

    d={}

    # d['k']

    # print('====>2')

    # print('====>3')

except IndexError:

    pass

except KeyError:

    pass

except Exception as e:

    print('万能异常--->',e)

else:

    print('没有异常发生的时候触发')

finally:

    print('有没有异常都触发')

 

 

print('====>end<=======')

1.1.4 自定义异常

'''

try:

    conn=connect('1.1.1.1',3306)

    conn.execute('select * from db1.t1')

finally:

    conn.close()

'''

stus=['egon','alex','wxxx']

ip_list=[

    # '1.1.1.1:8080',

    # '1.1.1.2:8081',

    # '1.1.1.3:8082',

]

 

if len(ip_list) == 0:

    raise TypeError

assert len(ip_list) > 0

 

print('从ip_list取出ip地址，验证可用性')

 

class MyException(BaseException):

    def __init__(self,msg):

        super(MyException,self).__init__()

        self.msg=msg

 

    def __str__(self):

        return '<%s>' %self.msg

 

raise MyException('类型错误') #异常的值：print(obj)

1.2 基于TCP协议实现简单的套接字协议

1.2.1 客户端/服务器架构

1.2.1.1 硬件C/S架构(打印机)

1.2.1.2 软件C/S架构

　　互联网中处处是C/S架构

　　如网站是服务端，你的浏览器是客户端（B/S架构也是C/S架构的一种）

　　腾讯作为服务端为你提供视频，你得下个腾讯视频客户端才能看它的视频）

1.2.1.3 C/S架构与socket的关系：

我们学习socket就是为了完成C/S架构的开发

1.2.2 osi七层

一个完整的计算机系统是由硬件、操作系统、应用软件三者组成,具备了这三个条件，一台计算机系统就可以自己跟自己玩了（打个单机游戏，玩个扫雷啥的），如果你要跟别人一起玩，那你就需要上网了，什么是互联网？

互联网的核心就是由一堆协议组成，协议就是标准，比如全世界人通信的标准是英语，如果把计算机比作人，互联网协议就是计算机界的英语。所有的计算机都学会了互联网协议，那所有的计算机都就可以按照统一的标准去收发信息从而完成通信了。

人们按照分工不同把互联网协议从逻辑上划分了层级，

互联网协议按照功能不同分为osi七层或tcp/ip五层或tcp/ip四层

图1-1

每层运行常见物理设备

图1-2

1.2.3 tcp/ip五层模型

我们将应用层，表示层，会话层并作应用层，从tcp／ip五层协议的角度来阐述每层的由来与功能，搞清楚了每层的主要协议，就理解了整个互联网通信的原理。

1.2.3.1 物理层

物理层由来：

上面提到，孤立的计算机之间要想一起玩，就必须接入internet，言外之意就是计算机之间必须完成组网

物理层功能：

主要是基于电器特性发送高低电压(电信号)，高电压对应数字1，低电压对应数字0

1.2.3.2 数据链路层

数据链路层由来：

单纯的电信号0和1没有任何意义，必须规定电信号多少位一组，每组什么意思

数据链路层的功能：

定义了电信号的分组方式

早期的时候各个公司都有自己的分组方式，后来形成了统一的标准，即以太网协议ethernet，ethernet规定：

一组电信号构成一个数据包，叫做‘帧’，每一数据帧分成：报头head和数据data两部分。

head包含：(固定18个字节)，发送者／源地址，6个字节，数据类型，6个字节。

data包含：(最短46字节，最长1500字节)，数据包的具体内容

head长度＋data长度＝最短64字节，最长1518字节，超过最大限制就分片发送

mac地址：

head中包含的源和目标地址由来：ethernet规定接入internet的设备都必须具备网卡，发送端和接收端的地址便是指网卡的地址，即mac地址，mac地址：每块网卡出厂时都被烧制上一个世界唯一的mac地址，长度为48位2进制，通常由12位16进制数表示（前六位是厂商编号，后六位是流水线号）

广播：

有了mac地址，同一网络内的两台主机就可以通信了（一台主机通过arp协议获取另外一台主机的mac地址），ethernet采用最原始的方式，广播的方式进行通信，即计算机通信基本靠吼

1.2.3.3 网络层

网络层由来：

有了ethernet、mac地址、广播的发送方式，世界上的计算机就可以彼此通信了，问题是世界范围的互联网是由

一个个彼此隔离的小的局域网组成的，那么如果所有的通信都采用以太网的广播方式，那么一台机器发送的包全世界都会收到，这就不仅仅是效率低的问题了，这会是一种灾难

必须找出一种方法来区分哪些计算机属于同一广播域，哪些不是，如果是就采用广播的方式发送，如果不是，就采用路由的方式（向不同广播域／子网分发数据包），mac地址是无法区分的，它只跟厂商有关

网络层功能：

引入一套新的地址用来区分不同的广播域／子网，这套地址即网络地址

IP协议：

规定网络地址的协议叫ip协议，它定义的地址称之为ip地址，广泛采用的v4版本即ipv4，它规定网络地址由32位2进制表示，范围0.0.0.0-255.255.255.255，一个ip地址通常写成四段十进制数，例：172.16.10.1

ip地址分成两部分

网络部分：标识子网

主机部分：标识主机

注意：单纯的ip地址段只是标识了ip地址的种类，从网络部分或主机部分都无法辨识一个ip所处的子网，例：172.16.10.1与172.16.10.2并不能确定二者处于同一子网

子网掩码：

所谓”子网掩码”，就是表示子网络特征的一个参数。它在形式上等同于IP地址，也是一个32位二进制数字，它的网络部分全部为1，主机部分全部为0。比如，IP地址172.16.10.1，如果已知网络部分是前24位，主机部分是后8位，那么子网络掩码就是11111111.11111111.11111111.00000000，写成十进制就是255.255.255.0。

知道”子网掩码”，我们就能判断，任意两个IP地址是否处在同一个子网络。方法是将两个IP地址与子网掩码分别进行AND运算（两个数位都为1，运算结果为1，否则为0），然后比较结果是否相同，如果是的话，就表明它们在同一个子网络中，否则就不是。

比如，已知IP地址172.16.10.1和172.16.10.2的子网掩码都是255.255.255.0，请问它们是否在同一个子网络？两者与子网掩码分别进行AND运算，

172.16.10.1：10101100.00010000.00001010.000000001

255255.255.255.0:11111111.11111111.11111111.00000000

AND运算得网络地址结果：10101100.00010000.00001010.000000001->172.16.10.0

172.16.10.2：10101100.00010000.00001010.000000010

255255.255.255.0:11111111.11111111.11111111.00000000

AND运算得网络地址结果：10101100.00010000.00001010.000000001->172.16.10.0

结果都是172.16.10.0，因此它们在同一个子网络。

总结一下，IP协议的作用主要有两个，一个是为每一台计算机分配IP地址，另一个是确定哪些地址在同一个子网络。

ip数据包：

ip数据包也分为head和data部分，无须为ip包定义单独的栏位，直接放入以太网包的data部分：

head：长度为20到60字节

data：最长为65,515字节。

而以太网数据包的”数据”部分，最长只有1500字节。因此，如果IP数据包超过了1500字节，它就需要分割成几个以太网数据包，分开发送了。

ARP协议

arp协议由来：计算机通信基本靠吼，即广播的方式，所有上层的包到最后都要封装上以太网头，然后通过以太网协议发送，在谈及以太网协议时候，我门了解到

通信是基于mac的广播方式实现，计算机在发包时，获取自身的mac是容易的，如何获取目标主机的mac，就需要通过arp协议

arp协议功能：广播的方式发送数据包，获取目标主机的mac地址

协议工作方式：每台主机ip都是已知的，首先通过ip地址和子网掩码区分出自己所处的子网，目标主机ip同一子网，目标主机mac，目标主机ip，如果不是同一网络，那么目标ip通过arp获取的是网关的mac，这个包会以广播的方式在发送端所处的自网内传输，所有主机接收后拆开包，发现目标ip为自己的，就响应，返回自己的mac

1.2.3.4 传输层

传输层的由来：

网络层的ip帮我们区分子网，以太网层的mac帮我们找到主机，然后大家使用的都是应用程序，你的电脑上可能同时开启qq，暴风影音，等多个应用程序，那么我们通过ip和mac找到了一台特定的主机，如何标识这台主机上的应用程序，答案就是端口，端口即应用程序与网卡关联的编号。

传输层功能：建立端口到端口的通信

补充：端口范围0-65535，0-1023为系统占用端口

tcp协议：

可靠传输，TCP数据包没有长度限制，理论上可以无限长，但是为了保证网络的效率，通常TCP数据包的长度不会超过IP数据包的长度，以确保单个TCP数据包不必再分割。

udp协议：

不可靠传输，”报头”部分一共只有8个字节，总长度不超过65,535字节，正好放进一个IP数据包。

tcp报文

图1-3

tcp三次握手和四次挥手

图1-4

1.2.3.5 应用层：

应用层由来：用户使用的都是应用程序，均工作于应用层，互联网是开发的，大家都可以开发自己的应用程序，数据多种多样，必须规定好数据的组织形式

应用层功能：规定应用程序的数据格式。

TCP协议可以为各种各样的程序传递数据，比如Email、WWW、FTP等等。那么，必须有不同协议规定电子邮件、网页、FTP数据的格式，这些应用程序协议就构成了”应用层”。

图1-5

1.2.4 socket

我们知道两个进程如果需要进行通讯最基本的一个前提能能够唯一的标示一个进程，在本地进程通讯中我们可以使用PID来唯一标示一个进程，但PID只在本地唯一，网络中的两个进程PID冲突几率很大，这时候我们需要另辟它径了，我们知道IP层的ip地址可以唯一标示主机，而TCP层协议和端口号可以唯一标示主机的一个进程，这样我们可以利用ip地址＋协议＋端口号唯一标示网络中的一个进程。

能够唯一标示网络中的进程后，它们就可以利用socket进行通信了，什么是socket呢？我们经常把socket翻译为套接字，socket是在应用层和传输层之间的一个抽象层，它把TCP/IP层复杂的操作抽象为几个简单的接口供应用层调用已实现进程在网络中通信。

图1-6

socket起源于UNIX，在Unix一切皆文件哲学的思想下，socket是一种"打开—读/写—关闭"模式的实现，服务器和客户端各自维护一个"文件"，在建立连接打开后，可以向自己文件写入内容供对方读取或者读取对方内容，通讯结束时关闭文件。

1.2.4.1 服务端套接字函数

s.bind() 绑定(主机,端口号)到套接字

s.listen() 开始TCP监听

s.accept() 被动接受TCP客户的连接,(阻塞式)等待连接的到来

1.2.4.2 客户端套接字函数

s.connect() 主动初始化TCP服务器连接

s.connect_ex() connect()函数的扩展版本,出错时返回出错码,而不是抛出异常

1.2.4.3 公共用途的套接字函数

s.recv() 接收TCP数据

s.send() 发送TCP数据(send在待发送数据量大于己端缓存区剩余空间时,数据丢失,不会发完)

s.sendall() 发送完整的TCP数据(本质就是循环调用send,sendall在待发送数据量大于己端缓存区剩余空间时,数据不丢失,循环调用send直到发完)

s.recvfrom() 接收UDP数据

s.sendto() 发送UDP数据

s.getpeername() 连接到当前套接字的远端的地址

s.getsockname() 当前套接字的地址

s.getsockopt() 返回指定套接字的参数

s.setsockopt() 设置指定套接字的参数

s.close() 关闭套接字

用打电话的流程快速描述socket通信：

1.2.4.4 基于TCP的套接字

tcp服务端：

ss = socket() #创建服务器套接字

ss.bind()      #把地址绑定到套接字

ss.listen()      #监听链接

inf_loop:      #服务器无限循环

    cs = ss.accept() #接受客户端链接

    comm_loop:         #通讯循环

        cs.recv()/cs.send() #对话(接收与发送)

    cs.close()    #关闭客户端套接字

ss.close()        #关闭服务器套接字(可选)

tcp客户端：

cs = socket()    # 创建客户套接字

cs.connect()    # 尝试连接服务器

comm_loop:        # 通讯循环

     cs.send()/cs.recv()    # 对话(发送/接收)

cs.close()            # 关闭客户套接字

socket通信流程与打电话流程类似，我们就以打电话为例来实现一个low版的套接字通信

1.2.5 客户端：

import socket

 

#1、买手机

phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #tcp协议

 

#2、拨电话

phone.connect(('127.0.0.1',8081)) #0-65535

 

#3、发收消息

phone.send('hello'.encode('utf-8'))

 

data=phone.recv(1024)

print(data)

 

#4、挂电话

phone.close()

1.2.6 服务端：

import socket

 

#1、买手机

phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #tcp协议

 

#2、绑定手机

# phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)

phone.bind(('127.0.0.1',8081)) #0-65535

 

#3、开机

phone.listen(5)

 

#4、等待电话连接

print('starting...')

conn,client_addr=phone.accept() #(conn,client_addr)

print(conn,client_addr)

 

#5、收\发消息

data=conn.recv(1024) #1024bytes?

 

conn.send(data.upper())

 

#6、挂电话连接

conn.close()

 

#7、关机

phone.close()

1.3 加上链接循环与通信循环

1.3.1 服务端：

import socket

 

phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #tcp协议

# print(phone)

# phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)

phone.bind(('127.0.0.1',8083)) #0-65535

phone.listen(5)

 

print('starting...')

while True: #链接循环

    conn,client_addr=phone.accept() #(conn,client_addr)

    # print(conn,client_addr)

    print(client_addr)

 

    while True: #通信循环

        try:

            data=conn.recv(1024) #1024bytes?

            if not data:break #针对的是linux系统

            print('客户端消息',data)

            conn.send(data.upper())

            # print('====has send')

        except ConnectionResetError:

            break

    conn.close()

 

phone.close()

1.3.2 客户端：

1.3.2.1 客户端1：

import socket

 

phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #tcp协议

phone.connect(('127.0.0.1',8083)) #0-65535

 

while True:

    msg=input('>>: ') #msg=' '

    if not msg:continue

 

    phone.send(msg.encode('utf-8'))

    # print('has send===>')

    data=phone.recv(1024)

    # print('has recv===>')

    print(data)

 

phone.close()

1.3.2.2 客户端2：

import socket

 

phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #tcp协议

phone.connect(('127.0.0.1',8083)) #0-65535

 

while True:

    msg=input('>>: ').strip()

    if not msg:continue

 

    phone.send(msg.encode('utf-8'))

    # print('has send===>')

    data=phone.recv(1024)

    # print('has recv===>')

    print(data)

 

phone.close()

在重启服务端时可能会遇到

图1-7

这个是由于你的服务端仍然存在四次挥手的time_wait状态在占用地址（如果不懂，请深入研究1.tcp三次握手，四次挥手 2.syn洪水攻击 3.服务器高并发情况下会有大量的time_wait状态的优化方法）

解决方法：

方法一：

#加入一条socket配置，重用ip和端口

phone=socket(AF_INET,SOCK_STREAM)

phone.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #就是它，在bind前加

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

方法二：

发现系统存在大量TIME_WAIT状态的连接，通过调整linux内核参数解决，

vi /etc/sysctl.conf

 

编辑文件，加入以下内容：

net.ipv4.tcp_syncookies = 1

net.ipv4.tcp_tw_reuse = 1

net.ipv4.tcp_tw_recycle = 1

net.ipv4.tcp_fin_timeout = 30

然后执行 /sbin/sysctl -p 让参数生效。

net.ipv4.tcp_syncookies = 1 表示开启SYN Cookies。当出现SYN等待队列溢出时，启用cookies来处理，可防范少量SYN攻击，默认为0，表示关闭；

net.ipv4.tcp_tw_reuse = 1 表示开启重用。允许将TIME-WAIT sockets重新用于新的TCP连接，默认为0，表示关闭；

net.ipv4.tcp_tw_recycle = 1 表示开启TCP连接中TIME-WAIT sockets的快速回收，默认为0，表示关闭。

net.ipv4.tcp_fin_timeout 修改系統默认的 TIMEOUT 时间

1.4 实现ssh远程执行命令

1.4.1 服务端：

from socket import *

import subprocess

 

server=socket(AF_INET,SOCK_STREAM)

server.bind(('127.0.0.1',8090))

server.listen(5)

 

while True:

    conn,client_addr=server.accept()

    print(client_addr)

 

    while True:

        try:

            cmd=conn.recv(1024)

            if not cmd:break

 

            #ls -l;sadfasdf;pwd;echo 123

            obj=subprocess.Popen(cmd.decode('utf-8'),shell=True,

                             stdout=subprocess.PIPE,

                             stderr=subprocess.PIPE

                             )

            stdout=obj.stdout.read()

            stderr=obj.stderr.read()

 

            cmd_res=stdout+stderr

            print(len(cmd_res))

            conn.send(cmd_res)

        except ConnectionResetError:

            break

    conn.close()

 

server.close()

1.4.2 客户端：

from socket import *

 

client=socket(AF_INET,SOCK_STREAM)

client.connect(('127.0.0.1',8090))

 

while True:

    cmd=input('>>: ').strip()

    if not cmd:continue

    client.send(cmd.encode('utf-8'))

    data=client.recv(1024)

    print(data.decode('gbk'))

 

client.close()

1.5 粘包现象

只有TCP有粘包现象，UDP永远不会粘包，所谓粘包问题主要还是因为接收方不知道消息之间的界限，不知道一次性提取多少字节的数据所造成的。此外，发送方引起的粘包是由TCP协议本身造成的，TCP为提高传输效率，发送方往往要收集到足够多的数据后才发送一个TCP段。若连续几次需要send的数据都很少，通常TCP会根据优化算法把这些数据合成一个TCP段后一次发送出去，这样接收方就收到了粘包数据。

TCP（transport control protocol，传输控制协议）是面向连接的，面向流的，提供高可靠性服务。收发两端（客户端和服务器端）都要有一一成对的socket，因此，发送端为了将多个发往接收端的包，更有效的发到对方，使用了优化方法（Nagle算法），将多次间隔较小且数据量小的数据，合并成一个大的数据块，然后进行封包。这样，接收端，就难于分辨出来了，必须提供科学的拆包机制。即面向流的通信是无消息保护边界的。

tcp是基于数据流的，于是收发的消息不能为空，这就需要在客户端和服务端都添加空消息的处理机制，防止程序卡住，而udp是基于数据报的，即便是你输入的是空内容（直接回车），那也不是空消息，udp协议会帮你封装上消息头。

1.5.1 服务端：

from socket import *

import time

 

server=socket(AF_INET,SOCK_STREAM)

server.bind(('127.0.0.1',8091))

server.listen(5)

 

conn,addr=server.accept()

 

#b'hello'

res1=conn.recv(5) #b'h'

print('res1: ',res1)

 

# b'elloworld'

time.sleep(6)

res2=conn.recv(5)

print('res2: ',res2)

 

conn.close()

server.close()

1.5.2 客户端：

from socket import *

import time

 

client=socket(AF_INET,SOCK_STREAM)

client.connect(('127.0.0.1',8091))

 

client.send('hello'.encode('utf-8')) #b'hello'

time.sleep(5)

client.send('world'.encode('utf-8')) #b'world'

 

client.close()

1.6 解决粘包现象版本1

问题的根源在于，接收端不知道发送端将要传送的字节流的长度，所以解决粘包的方法就是围绕，如何让发送端在发送数据前，把自己将要发送的字节流总大小让接收端知晓，然后接收端来一个死循环接收完所有数据

low版本的解决方法

1.6.1 struct模块的使用

import struct

 

headers=struct.pack('i',132333)

# print(headers,len(headers))

 

res=struct.unpack('i',headers)

print(res[0])

1.6.2 服务端：

from socket import *

import subprocess

import struct

 

server=socket(AF_INET,SOCK_STREAM)

server.bind(('127.0.0.1',8093))

server.listen(5)

 

while True:

    conn,client_addr=server.accept()

    print(client_addr)

 

    while True:

        try:

            cmd=conn.recv(8096)

            if not cmd:break

 

            #ls -l;sadfasdf;pwd;echo 123

            obj=subprocess.Popen(cmd.decode('utf-8'),shell=True,

                             stdout=subprocess.PIPE,

                             stderr=subprocess.PIPE

                             )

            stdout=obj.stdout.read()

            stderr=obj.stderr.read()

 

            #1、制作固定长度的报头

            total_size = len(stdout) + len(stderr)

            headers=struct.pack('i',total_size)

 

            #2、先发送命令长度

            conn.send(headers)

 

            #3、发送命令的执行结果

            conn.send(stdout)

            conn.send(stderr)

        except ConnectionResetError:

            break

    conn.close()

 

server.close()

1.6.3 客户端：

from socket import *

import struct

 

client=socket(AF_INET,SOCK_STREAM)

client.connect(('127.0.0.1',8093))

 

while True:

    cmd=input('>>: ').strip()

    if not cmd:continue

    client.send(cmd.encode('utf-8'))

 

    #1、先接收命令长度

    headers=client.recv(4)

    total_size = struct.unpack('i', headers)[0]

 

    #2、再收命令的结果

    recv_size=0

    data=b''

    while recv_size < total_size:

        recv_data=client.recv(1024)

        data+=recv_data

        recv_size+=len(recv_data)

 

    print(data.decode('gbk'))

 

client.close()

1.7 解决粘包现象版本2

为字节流加上自定义固定长度报头，报头中包含字节流长度，然后一次send到对端，对端在接收时，先从缓存中取出定长的报头，然后再取真实数据

我们可以把报头做成字典，字典里包含将要发送的真实数据的详细信息，然后json序列化，然后用struck将序列化后的数据长度打包成4个字节（4个自己足够用了）发送时：先发报头长度，再编码报头内容然后发送，最后发真实内容。接收时：先手报头长度，用struct取出来，根据取出的长度收取报头内容，然后解码，反序列化，从反序列化的结果中取出待取数据的详细信息，然后去取真实的数据内容

1.7.1 struct模块的使用

import struct

 

 

# headers=struct.pack('q',13233322222222222)

# print(headers,len(headers))

 

# res=struct.unpack('i',headers)

# print(res[0])

 

import json

 

headers={

    'filepath' : 'a.txt',

    'md5' : '123sxd123x123',

    'total_size' : 11111111111111111111111111111111111

}

 

headers_json=json.dumps(headers)

headers_bytes=headers_json.encode('utf-8')

 

# print(len(headers_bytes))

res=struct.pack('i',len(headers_bytes))

print(res,len(res))

1.7.2 服务端：

from socket import *

import subprocess

import struct

import json

 

server=socket(AF_INET,SOCK_STREAM)

server.bind(('127.0.0.1',8093))

server.listen(5)

 

while True:

    conn,client_addr=server.accept()

    print(client_addr)

 

    while True:

        try:

            cmd=conn.recv(8096)

            if not cmd:break

 

            #ls -l;sadfasdf;pwd;echo 123

            obj=subprocess.Popen(cmd.decode('utf-8'),shell=True,

                             stdout=subprocess.PIPE,

                             stderr=subprocess.PIPE

                             )

            stdout=obj.stdout.read()

            stderr=obj.stderr.read()

 

            #1、制作报头

            headers = {

                'filepath': 'a.txt',

                'md5': '123sxd123x123',

                'total_size': len(stdout) + len(stderr)

            }

 

            headers_json = json.dumps(headers)

            headers_bytes = headers_json.encode('utf-8')

 

            #2、先发报头的长度

            conn.send(struct.pack('i',len(headers_bytes)))

 

            #3、发送报头

            conn.send(headers_bytes)

 

            #4、发送命令的执行结果

            conn.send(stdout)

            conn.send(stderr)

        except ConnectionResetError:

            break

    conn.close()

 

server.close()

1.7.3 客户端：

from socket import *

import struct

import json

 

client=socket(AF_INET,SOCK_STREAM)

client.connect(('127.0.0.1',8093))

 

while True:

    cmd=input('>>: ').strip()

    if not cmd:continue

    client.send(cmd.encode('utf-8'))

 

    #1、先接收报头的长度

    headers_size=struct.unpack('i',client.recv(4))[0]

 

    #2、再收报头

    headers_bytes=client.recv(headers_size)

    headers_json=headers_bytes.decode('utf-8')

    headers_dic=json.loads(headers_json)

    print('========>',headers_dic)

    total_size=headers_dic['total_size']

 

    #3、再收命令的结果

    recv_size=0

    data=b''

    while recv_size < total_size:

        recv_data=client.recv(1024)

        data+=recv_data

        recv_size+=len(recv_data)

 

    print(data.decode('gbk'))

 

client.close()

1.8 FTP上传下载文件

文件目录:share

上传目录:DOWNLOAD

1.8.1 客户端：

import socket

import struct

import json

import os

 

DOWNLOAD_DIR=r'F:\Python周末20期\day8\08 上传下载文件\DOWNLOAD'

 

class FtpClient:

    def __init__(self,host,port):

        self.host=host

        self.port=port

        self.client=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

        self.client.connect((self.host,self.port))

 

    def interactive(self):

        while True:

            data=input('>>: ').strip() #get a.txt

            if not data:continue

            params=data.split() #parmas=['get','a.txt']

            cmd=params[0] #cmd='get'

            if hasattr(self,cmd):

                func=getattr(self,cmd)

                func(params) #func(['get','a.txt'])

 

    def get(self,params):

        params_json=json.dumps(params)

        self.client.send(params_json.encode('utf-8'))

 

        # 1、先接收报头的长度

        headers_size = struct.unpack('i', self.client.recv(4))[0]

 

        # 2、再收报头

        headers_bytes = self.client.recv(headers_size)

        headers_json = headers_bytes.decode('utf-8')

        headers_dic = json.loads(headers_json)

        print('========>', headers_dic)

        filename = headers_dic['filename']

        filesize = headers_dic['filesize']

        filepath = os.path.join(DOWNLOAD_DIR, filename)

 

        # 3、再收真实的数据

        with open(filepath, 'wb') as f:

            recv_size = 0

            while recv_size < filesize:

                line = self.client.recv(1024)

                recv_size += len(line)

                f.write(line)

            print('===>下载成功')

 

if __name__ == '__main__':

    client=FtpClient('127.0.0.1',8081)

    client.interactive()

1.8.2 服务端：

import socket

import os

import json

import struct

 

SHARE_DIR=r'F:\Python周末20期\day8\08 上传下载文件\SHARE'

 

class FtpServer:

    def __init__(self,host,port):

        self.host=host

        self.port=port

        self.server=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

        self.server.bind((self.host,self.port))

        self.server.listen(5)

 

    def serve_forever(self):

        print('server starting...')

        while True:

            self.conn,self.client_addr=self.server.accept()

            print(self.client_addr)

 

            while True:

                try:

                    data=self.conn.recv(1024)  #params_json.encode('utf-8')

                    if not data:break

                    params=json.loads(data.decode('utf-8')) #params=['get','a.txt']

                    cmd=params[0] #

                    if hasattr(self,cmd):

                        func=getattr(self,cmd)

                        func(params)

                    else:

                        print('\033[45mcmd not exists\033[0m')

                except ConnectionResetError:

                    break

            self.conn.close()

        self.server.close()

 

    def get(self,params): #params=['get','a.txt']

        filename=params[1] #filename='a.txt'

        filepath=os.path.join(SHARE_DIR,filename) #

        if os.path.exists(filepath):

            #1、制作报头

            headers = {

                'filename': filename,

                'md5': '123sxd123x123',

                'filesize': os.path.getsize(filepath)

            }

 

            headers_json = json.dumps(headers)

            headers_bytes = headers_json.encode('utf-8')

 

            #2、先发报头的长度

            self.conn.send(struct.pack('i',len(headers_bytes)))

 

            #3、发送报头

            self.conn.send(headers_bytes)

 

            #4、发送真实的数据

            with open(filepath,'rb') as f:

                for line in f:

                    self.conn.send(line)

 

    def put(self):

        pass

 

if __name__ == '__main__':

    server=FtpServer('127.0.0.1',8081)

    server.serve_forever()