28 黏包现象 缓冲区 黏包方案解决方案

时间:2022-12-15 17:00:34

九 粘包现象

  
  说粘包之前,我们先说两个内容,1.缓冲区、2.windows下cmd窗口调用系统指令
   9.1 缓冲区(下面粘包现象的图里面还有关于缓冲区的解释)
     28 黏包现象 缓冲区 黏包方案解决方案
28 黏包现象 缓冲区 黏包方案解决方案28 黏包现象 缓冲区 黏包方案解决方案
每个 socket 被创建后,都会分配两个缓冲区,输入缓冲区和输出缓冲区。

write()/send() 并不立即向网络中传输数据,而是先将数据写入缓冲区中,再由TCP协议将数据从缓冲区发送到目标机器。一旦将数据写入到缓冲区,函数就可以成功返回,不管它们有没有到达目标机器,也不管它们何时被发送到网络,这些都是TCP协议负责的事情。

TCP协议独立于 write()/send() 函数,数据有可能刚被写入缓冲区就发送到网络,也可能在缓冲区中不断积压,多次写入的数据被一次性发送到网络,这取决于当时的网络情况、当前线程是否空闲等诸多因素,不由程序员控制。

read()/recv() 函数也是如此,也从输入缓冲区中读取数据,而不是直接从网络中读取。

这些I/O缓冲区特性可整理如下:

1.I/O缓冲区在每个TCP套接字中单独存在;
2.I/O缓冲区在创建套接字时自动生成;
3.即使关闭套接字也会继续传送输出缓冲区中遗留的数据;
4.关闭套接字将丢失输入缓冲区中的数据。

输入输出缓冲区的默认大小一般都是 8K,可以通过 getsockopt() 函数获取:

1.unsigned optVal;
2.int optLen = sizeof(int);
3.getsockopt(servSock, SOL_SOCKET, SO_SNDBUF,(char*)&optVal, &optLen);
4.printf("Buffer length: %d\n", optVal);

socket缓冲区解释
View Code

 9.2 windows下cmd窗口调用系统指令(linux下没有写出来,大家仿照windows的去摸索一下吧)

    a.首先ctrl+r,弹出左下角的下图,输入cmd指令,确定
       28 黏包现象 缓冲区 黏包方案解决方案

    b.在打开的cmd窗口中输入dir(dir:查看当前文件夹下的所有文件和文件夹),你会看到下面的输出结果。

       28 黏包现象 缓冲区 黏包方案解决方案

      另外还有ipconfig(查看当前电脑的网络信息),在windows没有ls这个指令(ls在linux下是查看当前文件夹下所有文件和文件夹的指令,和windows下的dir是类似的),那么没有这个指令就会报下面这个错误

      28 黏包现象 缓冲区 黏包方案解决方案

28 黏包现象 缓冲区 黏包方案解决方案28 黏包现象 缓冲区 黏包方案解决方案
linux shell中一个运行多个命令,命令间用;隔开即可

windows的命令提示符中运行多条命令用的是:&&、||、&

aa && bb
就是执行aa,成功后再执行bb

aa || bb
先执行aa,若执行成功则不再执行bb,若失败则执行bb

a & b
表示执行a再执行b,无论a是否成功

“执行成功”的意思是返回的errorlevel=0

windows下执行多条指令
View Code

 

      

      为什么要说这个系统指令呢,是希望借助系统指令和指令输出的结果来模拟一下粘包现象,那什么是粘包呢?

   今天的内容就先到这里,明天我们认识粘包~~,大家好好理解练习一下把。

-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

  9.3 粘包现象(两种)

    先上图:(本图是我做出来为了让小白同学有个大致的了解用的,其中很多地方更加的复杂,那就需要将来大家有多余的精力的时候去做一些深入的研究了,这里我就不带大家搞啦)

     28 黏包现象 缓冲区 黏包方案解决方案

 

    关于MTU大家可以看看这篇文章 https://yq.aliyun.com/articles/222535  还有百度百科 MTU百科

    MTU简单解释:

MTU是Maximum Transmission Unit的缩写。意思是网络上传送的最大数据包。MTU的单位是字节。 大部分网络设备的MTU都是1500个字节,也就是1500B。如果本机一次需要发送的数据比网关的MTU大,大的数据包就会被拆开来传送,这样会产生很多数据包碎片,增加丢包率,降低网络速度

 

    关于上图中提到的Nagle算法等建议大家去看一看Nagle算法、延迟ACK、linux下的TCP_NODELAY和TCP_CORK,这些内容等你们把python学好以后再去研究吧,网络的内容实在太多啦,也就是说大家需要努力的过程还很长,加油!

  

  超出缓冲区大小会报下面的错误,或者udp协议的时候,你的一个数据包的大小超过了你一次recv能接受的大小,也会报下面的错误,tcp不会,但是超出缓存区大小的时候,肯定会报这个错误。

 
    28 黏包现象 缓冲区 黏包方案解决方案

  9.4 模拟一个粘包现象

    在模拟粘包之前,我们先学习一个模块subprocess。
28 黏包现象 缓冲区 黏包方案解决方案28 黏包现象 缓冲区 黏包方案解决方案
import subprocess
cmd = input('请输入指令>>>')
res = subprocess.Popen(
    cmd,                     #字符串指令:'dir','ipconfig',等等
    shell=True,              #使用shell,就相当于使用cmd窗口
    stderr=subprocess.PIPE,  #标准错误输出,凡是输入错误指令,错误指令输出的报错信息就会被它拿到
    stdout=subprocess.PIPE,  #标准输出,正确指令的输出结果被它拿到
)
print(res.stdout.read().decode('gbk'))
print(res.stderr.read().decode('gbk'))

subprocess的简单使用
View Code

    注意:

        如果是windows,那么res.stdout.read()读出的就是GBK编码的,在接收端需要用GBK解码

        且只能从管道里读一次结果,PIPE称为管道。

 

     下面是subprocess和windows上cmd下的指令的对应示意图:subprocess的stdout.read()和stderr.read(),拿到的结果是bytes类型,所以需要转换为字符串打印出来看。
     28 黏包现象 缓冲区 黏包方案解决方案

    

    好,既然我们会使用subprocess了,那么我们就通过它来模拟一个粘包,终于到模拟粘包现象了,这一天真的是好累。

    tcp粘包演示(一):

      先从上面粘包现象中的第一种开始: 接收方没有及时接收缓冲区的包,造成多个包接收(客户端发送了一段数据,服务端只收了一小部分,服务端下次再收的时候还是从缓冲区拿上次遗留的数据,产生粘包) 
      server端代码示例:
28 黏包现象 缓冲区 黏包方案解决方案28 黏包现象 缓冲区 黏包方案解决方案
cket import *
import subprocess

ip_port=('127.0.0.1',8080)
BUFSIZE=1024

tcp_socket_server=socket(AF_INET,SOCK_STREAM)
tcp_socket_server.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
tcp_socket_server.bind(ip_port)
tcp_socket_server.listen(5)

while True:
    conn,addr=tcp_socket_server.accept()
    print('客户端>>>',addr)

    while True:
        cmd=conn.recv(BUFSIZE)
        if len(cmd) == 0:break

        res=subprocess.Popen(cmd.decode('gbk'),shell=True,
                         stdout=subprocess.PIPE,
                         stdin=subprocess.PIPE,
                         stderr=subprocess.PIPE)

        stderr=res.stderr.read()
        stdout=res.stdout.read()
        conn.send(stderr)
        conn.send(stdout)

tcp_server.py
View Code

client端代码示例:

28 黏包现象 缓冲区 黏包方案解决方案28 黏包现象 缓冲区 黏包方案解决方案
import socket
ip_port = ('127.0.0.1',8080)
size = 1024
tcp_sk = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
res = tcp_sk.connect(ip_port)
while True:
    msg=input('>>: ').strip()
    if len(msg) == 0:continue
    if msg == 'quit':break

    tcp_sk.send(msg.encode('utf-8'))
    act_res=tcp_sk.recv(size)
    print('接收的返回结果长度为>',len(act_res))
    print('std>>>',act_res.decode('gbk')) #windows返回的内容需要用gbk来解码,因为windows系统的默认编码为gbk

tcp_client.py
View Code

 tcp粘包演示(二):发送数据时间间隔很短,数据也很小,会合到一起,产生粘包

      server端代码示例:(如果两次发送有一定的时间间隔,那么就不会出现这种粘包情况,试着在两次发送的中间加一个time.sleep(1))

28 黏包现象 缓冲区 黏包方案解决方案28 黏包现象 缓冲区 黏包方案解决方案
from socket import *
ip_port=('127.0.0.1',8080)

tcp_socket_server=socket(AF_INET,SOCK_STREAM)
tcp_socket_server.bind(ip_port)
tcp_socket_server.listen(5)
conn,addr=tcp_socket_server.accept()
data1=conn.recv(10)
data2=conn.recv(10)

print('----->',data1.decode('utf-8'))
print('----->',data2.decode('utf-8'))

conn.close()

tcp_server.py
View Code

client端代码示例:

28 黏包现象 缓冲区 黏包方案解决方案28 黏包现象 缓冲区 黏包方案解决方案
import socket
BUFSIZE=1024
ip_port=('127.0.0.1',8080)
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
# res=s.connect_ex(ip_port)
res=s.connect(ip_port)
s.send('hi'.encode('utf-8'))
s.send('meinv'.encode('utf-8'))

tcp_server.py
View Code

 

    示例二的结果:全部被第一个recv接收了
     28 黏包现象 缓冲区 黏包方案解决方案

 

     udp粘包演示:注意:udp是面向包的,所以udp是不存在粘包的
      server端代码示例:
28 黏包现象 缓冲区 黏包方案解决方案28 黏包现象 缓冲区 黏包方案解决方案
import socket
from socket import SOL_SOCKET,SO_REUSEADDR,SO_SNDBUF,SO_RCVBUF
sk = socket.socket(type=socket.SOCK_DGRAM)
# sk.setsockopt(SOL_SOCKET,SO_RCVBUF,80*1024)
sk.bind(('127.0.0.1',8090))
msg,addr = sk.recvfrom(1024)
while True:
    cmd = input('>>>>')
    if cmd == 'q':
        break
    sk.sendto(cmd.encode('utf-8'),addr)
    msg,addr = sk.recvfrom(1032)
    # print('>>>>', sk.getsockopt(SOL_SOCKET, SO_SNDBUF))
    # print('>>>>', sk.getsockopt(SOL_SOCKET, SO_RCVBUF))
    print(len(msg))
    print(msg.decode('utf-8'))

sk.close()

udp_server.py
View Code

   client端代码示例:

28 黏包现象 缓冲区 黏包方案解决方案28 黏包现象 缓冲区 黏包方案解决方案
import socket
from socket import SOL_SOCKET,SO_REUSEADDR,SO_SNDBUF,SO_RCVBUF
sk = socket.socket(type=socket.SOCK_DGRAM)
# sk.setsockopt(SOL_SOCKET,SO_RCVBUF,80*1024)
sk.bind(('127.0.0.1',8090))
msg,addr = sk.recvfrom(1024)
while True:
    cmd = input('>>>>')
    if cmd == 'q':
        break
    sk.sendto(cmd.encode('utf-8'),addr)
    msg,addr = sk.recvfrom(1024)
    # msg,addr = sk.recvfrom(1218)
    # print('>>>>', sk.getsockopt(SOL_SOCKET, SO_SNDBUF))
    # print('>>>>', sk.getsockopt(SOL_SOCKET, SO_RCVBUF))
    print(len(msg))
    print(msg.decode('utf-8'))

sk.close()

udp_server.py
View Code

 

     在udp的代码中,我们在server端接收返回消息的时候,我们设置的recvfrom(1024),那么当我输入的执行指令为‘dir’的时候,dir在我当前文件夹下输出的内容大于1024,然后就报错了,报的错误也是下面这个:

  28 黏包现象 缓冲区 黏包方案解决方案

    解释原因:是因为udp是面向报文的,意思就是每个消息是一个包,你接收端设置接收大小的时候,必须要比你发的这个包要大,不然一次接收不了就会报这个错误,而tcp不会报错,这也是为什么ucp会丢包的原因之一,这个和我们上面缓冲区那个错误的报错原因是不一样的。  

 
   9.5 TCP会粘包、UDP永远不会粘包
    看下面的解释原因:
28 黏包现象 缓冲区 黏包方案解决方案28 黏包现象 缓冲区 黏包方案解决方案
发送端可以是一K一K地发送数据,而接收端的应用程序可以两K两K地提走数据,当然也有可能一次提走3K或6K数据,或者一次只提走几个字节的数据,也就是说,应用程序所看到的数据是一个整体,或说是一个流(stream),一条消息有多少字节对应用程序是不可见的,因此TCP协议是面向流的协议,这也是容易出现粘包问题的原因。而UDP是面向消息的协议,每个UDP段都是一条消息,应用程序必须以消息为单位提取数据,不能一次提取任意字节的数据,这一点和TCP是很不同的。怎样定义消息呢?可以认为对方一次性write/send的数据为一个消息,需要明白的是当对方send一条信息的时候,无论底层怎样分段分片,TCP协议层会把构成整条消息的数据段排序完成后才呈现在内核缓冲区。

例如基于tcp的套接字客户端往服务端上传文件,发送时文件内容是按照一段一段的字节流发送的,在接收方看了,根本不知道该文件的字节流从何处开始,在何处结束

所谓粘包问题主要还是因为接收方不知道消息之间的界限,不知道一次性提取多少字节的数据所造成的。

此外,发送方引起的粘包是由TCP协议本身造成的,TCP为提高传输效率,发送方往往要收集到足够多的数据后才发送一个TCP段。若连续几次需要send的数据都很少,通常TCP会根据优化算法把这些数据合成一个TCP段后一次发送出去,这样接收方就收到了粘包数据。

    1.TCP(transport control protocol,传输控制协议)是面向连接的,面向流的,提供高可靠性服务。收发两端(客户端和服务器端)都要有一一成对的socket,因此,发送端为了将多个发往接收端的包,更有效的发到对方,使用了优化方法(Nagle算法),将多次间隔较小且数据量小的数据,合并成一个大的数据块,然后进行封包。这样,接收端,就难于分辨出来了,必须提供科学的拆包机制。 即面向流的通信是无消息保护边界的。
    2.UDP(user datagram protocol,用户数据报协议)是无连接的,面向消息的,提供高效率服务。不会使用块的合并优化算法,, 由于UDP支持的是一对多的模式,所以接收端的skbuff(套接字缓冲区)采用了链式结构来记录每一个到达的UDP包,在每个UDP包中就有了消息头(消息来源地址,端口等信息),这样,对于接收端来说,就容易进行区分处理了。 即面向消息的通信是有消息保护边界的。
    3.tcp是基于数据流的,于是收发的消息不能为空,这就需要在客户端和服务端都添加空消息的处理机制,防止程序卡住,而udp是基于数据报的,即便是你输入的是空内容(直接回车),那也不是空消息,udp协议会帮你封装上消息头,实验略
udp的recvfrom是阻塞的,一个recvfrom(x)必须对唯一一个sendinto(y),收完了x个字节的数据就算完成,若是y>x数据就丢失,这意味着udp根本不会粘包,但是会丢数据,不可靠

tcp的协议数据不会丢,没有收完包,下次接收,会继续上次继续接收,己端总是在收到ack时才会清除缓冲区内容。数据是可靠的,但是会粘包。

解释原因
View Code

补充两个问题:

补充问题一:为何tcp是可靠传输,udp是不可靠传输

    tcp在数据传输时,发送端先把数据发送到自己的缓存中,然后协议控制将缓存中的数据发往对端,对端返回一个ack=1,发送端则清理缓存中的数据,对端返回ack=0,则重新发送数据,所以tcp是可靠的。
    而udp发送数据,对端是不会返回确认信息的,因此不可靠

补充问题二:send(字节流)和sendall

    send的字节流是先放入己端缓存,然后由协议控制将缓存内容发往对端,如果待发送的字节流大小大于缓存剩余空间,那么数据丢失,用sendall就会循环调用send,数据不会丢失,一般的小数据就用send,因为小数据也用sendall的话有些影响代码性能,简单来讲就是还多while循环这个代码呢。
  

用UDP协议发送时,用sendto函数最大能发送数据的长度为:65535- IP头(20) – UDP头(8)=65507字节。用sendto函数发送数据时,如果发送数据长度大于该值,则函数会返回错误。(丢弃这个包,不进行发送) 

用TCP协议发送时,由于TCP是数据流协议,因此不存在包大小的限制(暂不考虑缓冲区的大小),这是指在用send函数时,数据长度参数不受限制。而实际上,所指定的这段数据并不一定会一次性发送出去,如果这段数据比较长,会被分段发送,如果比较短,可能会等待和下一次数据一起发送。
  粘包的原因: 主要还是因为接收方不知道消息之间的界限,不知道一次性提取多少字节的数据所造成的
     
  学到这里,我们留一个小作业(做不做是你的事情,我的事情是真心的教会你,希望你尊重自己的努力):实现一个简单的网盘功能。
     28 黏包现象 缓冲区 黏包方案解决方案
 
 
 

十 粘包的解决方案

   解决方案(一):
     问题的根源在于,接收端不知道发送端将要传送的字节流的长度,所以解决粘包的方法就是围绕,如何让发送端在发送数据前,把自己将要发送的字节流总大小让接收端知晓,然后接收端发一个确认消息给发送端,然后发送端再发送过来后面的真实内容,接收端再来一个死循环接收完所有数据。
      28 黏包现象 缓冲区 黏包方案解决方案

    看代码示例:

      server端代码 
28 黏包现象 缓冲区 黏包方案解决方案28 黏包现象 缓冲区 黏包方案解决方案
import socket,subprocess
ip_port=('127.0.0.1',8080)
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

s.bind(ip_port)
s.listen(5)

while True:
    conn,addr=s.accept()
    print('客户端',addr)
    while True:
        msg=conn.recv(1024)
        if not msg:break
        res=subprocess.Popen(msg.decode('utf-8'),shell=True,\
                            stdin=subprocess.PIPE,\
                         stderr=subprocess.PIPE,\
                         stdout=subprocess.PIPE)
        err=res.stderr.read()
        if err:
            ret=err
        else:
            ret=res.stdout.read()
        data_length=len(ret)
        conn.send(str(data_length).encode('utf-8'))
        data=conn.recv(1024).decode('utf-8')
        if data == 'recv_ready':
            conn.sendall(ret)
    conn.close()

tcp_server.py
View Code

  client端代码示例

28 黏包现象 缓冲区 黏包方案解决方案28 黏包现象 缓冲区 黏包方案解决方案
import socket,time
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
res=s.connect_ex(('127.0.0.1',8080))

while True:
    msg=input('>>: ').strip()
    if len(msg) == 0:continue
    if msg == 'quit':break

    s.send(msg.encode('utf-8'))
    length=int(s.recv(1024).decode('utf-8'))
    s.send('recv_ready'.encode('utf-8'))
    send_size=0
    recv_size=0
    data=b''
    while recv_size < length:
        data+=s.recv(1024)
        recv_size+=len(data)


    print(data.decode('utf-8'))

tcp_server.py
View Code
 
   解决方案(二):
    通过struck模块将需要发送的内容的长度进行打包,打包成一个4字节长度的数据发送到对端,对端只要取出前4个字节,然后对这四个字节的数据进行解包,拿到你要发送的内容的长度,然后通过这个长度来继续接收我们实际要发送的内容。不是很好理解是吧?哈哈,没关系,看下面的解释~~
       为什么要说一下这个模块呢,因为解决方案(一)里面你发现,我每次要先发送一个我的内容的长度,需要接收端接收,并切需要接收端返回一个确认消息,我发送端才能发后面真实的内容,这样是为了保证数据可靠性,也就是接收双方能顺利沟通,但是多了一次发送接收的过程,为了减少这个过程,我们就要使struck来发送你需要发送的数据的长度,来解决上面我们所说的通过发送内容长度来 解决粘包的问题
     关于struck的介绍:
       了解c语言的人,一定会知道struct结构体在c语言中的作用,不了解C语言的同学也没关系,不影响,其实它就是定义了一种结构,里面包含不同类型的数据(int,char,bool等等),方便对某一结构对象进行处理。而在网络通信当中,大多传递的数据是以二进制流(binary data)存在的。当传递字符串时,不必担心太多的问题,而当传递诸如int、char之类的基本数据的时候,就需要有一种机制将某些特定的结构体类型打包成二进制流的字符串然后再网络传输,而接收端也应该可以通过某种机制进行解包还原出原始的结构体数据。python中的struct模块就提供了这样的机制,该模块的主要作用就是对python基本类型值与用python字符串格式表示的C struct类型间的转化(This module performs conversions between Python values and C structs represented as Python strings.)。
    
    struck模块的使用:struct模块中最重要的两个函数是pack()打包, unpack()解包。
 
     28 黏包现象 缓冲区 黏包方案解决方案

    pack():#我在这里只介绍一下'i'这个int类型,上面的图中列举除了可以打包的所有的数据类型,并且struck除了pack和uppack两个方法之外还有好多别的方法和用法,大家以后找时间可以去研究一下,这里我就不做介绍啦,网上的教程很多~~

import struct
a=12
# 将a变为二进制
bytes=struct.pack('i',a) 
-------------------------------------------------------------------------------
struct.pack('i',1111111111111) 如果int类型数据太大会报错struck.error
struct.error: 'i' format requires -2147483648 <= number <= 2147483647 #这个是范围


      pack方法图解:

       28 黏包现象 缓冲区 黏包方案解决方案

 

    unpack():

# 注意,unpack返回的是tuple !!

a,=struct.unpack('i',bytes) #将bytes类型的数据解包后,拿到int类型数据

   好,到这里我们将struck这个模块将int类型的数据打包成四个字节的方法了,那么我们就来使用它解决粘包吧。

  先看一段伪代码示例:

28 黏包现象 缓冲区 黏包方案解决方案28 黏包现象 缓冲区 黏包方案解决方案
import json,struct
#假设通过客户端上传1T:1073741824000的文件a.txt

#为避免粘包,必须自定制报头
header={'file_size':1073741824000,'file_name':'/a/b/c/d/e/a.txt','md5':'8f6fbf8347faa4924a76856701edb0f3'} #1T数据,文件路径和md5值

#为了该报头能传送,需要序列化并且转为bytes,因为bytes只能将字符串类型的数据转换为bytes类型的,所有需要先序列化一下这个字典,字典不能直接转化为bytes
head_bytes=bytes(json.dumps(header),encoding='utf-8') #序列化并转成bytes,用于传输

#为了让客户端知道报头的长度,用struck将报头长度这个数字转成固定长度:4个字节
head_len_bytes=struct.pack('i',len(head_bytes)) #这4个字节里只包含了一个数字,该数字是报头的长度

#客户端开始发送
conn.send(head_len_bytes) #先发报头的长度,4个bytes
conn.send(head_bytes) #再发报头的字节格式
conn.sendall(文件内容) #然后发真实内容的字节格式

#服务端开始接收
head_len_bytes=s.recv(4) #先收报头4个bytes,得到报头长度的字节格式
x=struct.unpack('i',head_len_bytes)[0] #提取报头的长度

head_bytes=s.recv(x) #按照报头长度x,收取报头的bytes格式
header=json.loads(json.dumps(header)) #提取报头

#最后根据报头的内容提取真实的数据,比如
real_data_len=s.recv(header['file_size'])
s.recv(real_data_len)

伪代码(含解释)
View Code

 下面看正式的代码:

  server端代码示例:报头:就是消息的头部信息,我们要发送的真实内容为报头后面的内容。

28 黏包现象 缓冲区 黏包方案解决方案28 黏包现象 缓冲区 黏包方案解决方案
import socket,struct,json
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',8080))
phone.listen(5)
while True:
    conn,addr=phone.accept()
    while True:
        cmd=conn.recv(1024)
        if not cmd:break
        print('cmd: %s' %cmd)
        res=subprocess.Popen(cmd.decode('utf-8'),
                             shell=True,
                             stdout=subprocess.PIPE,
                             stderr=subprocess.PIPE)
        err=res.stderr.read()
        if err:
            back_msg=err
        else:
            back_msg=res.stdout.read()
        conn.send(struct.pack('i',len(back_msg))) #先发back_msg的长度
        conn.sendall(back_msg) #在发真实的内容
        #其实就是连续的将长度和内容一起发出去,那么整个内容的前4个字节就是我们打包的后面内容的长度,对吧
        
    conn.close(

tcp_server.py(自定制报头)
View Code

client端代码示例:

28 黏包现象 缓冲区 黏包方案解决方案28 黏包现象 缓冲区 黏包方案解决方案
import socket,time,struct
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
res=s.connect_ex(('127.0.0.1',8080))
while True:
    msg=input('>>: ').strip()
    if len(msg) == 0:continue
    if msg == 'quit':break
    s.send(msg.encode('utf-8'))  #发送给一个指令
    l=s.recv(4)     #先接收4个字节的数据,因为我们将要发送过来的内容打包成了4个字节,所以先取出4个字节
    x=struct.unpack('i',l)[0]  #解包,是一个元祖,第一个元素就是我们的内容的长度
    print(type(x),x)
    # print(struct.unpack('I',l))
    r_s=0
    data=b''
    while r_s < x:    #根据内容的长度来继续接收4个字节后面的内容。
        r_d=s.recv(1024)
        data+=r_d
        r_s+=len(r_d)
    # print(data.decode('utf-8'))
    print(data.decode('gbk')) #windows默认gbk编码

tcp_client.py(自定制报头)
View Code

   

  复杂一些的代码示例

  server端:

28 黏包现象 缓冲区 黏包方案解决方案28 黏包现象 缓冲区 黏包方案解决方案
import socket,struct,json
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',8080))
phone.listen(5)

while True:
    conn,addr=phone.accept()
    while True:
        cmd=conn.recv(1024)
        if not cmd:break
        print('cmd: %s' %cmd)

        res=subprocess.Popen(cmd.decode('utf-8'),
                             shell=True,
                             stdout=subprocess.PIPE,
                             stderr=subprocess.PIPE)
        err=res.stderr.read()
        print(err)
        if err:
            back_msg=err
        else:
            back_msg=res.stdout.read()

        headers={'data_size':len(back_msg)}
        head_json=json.dumps(headers)
        head_json_bytes=bytes(head_json,encoding='utf-8')

        conn.send(struct.pack('i',len(head_json_bytes))) #先发报头的长度
        conn.send(head_json_bytes) #再发报头
        conn.sendall(back_msg) #在发真实的内容

    conn.close()

tcp_server.py
View Code

client端:

28 黏包现象 缓冲区 黏包方案解决方案28 黏包现象 缓冲区 黏包方案解决方案
from socket import *
import struct,json

ip_port=('127.0.0.1',8080)
client=socket(AF_INET,SOCK_STREAM)
client.connect(ip_port)

while True:
    cmd=input('>>: ')
    if not cmd:continue
    client.send(bytes(cmd,encoding='utf-8'))

    head=client.recv(4)
    head_json_len=struct.unpack('i',head)[0]
    head_json=json.loads(client.recv(head_json_len).decode('utf-8'))
    data_len=head_json['data_size']

    recv_size=0
    recv_data=b''
    while recv_size < data_len:
        recv_data+=client.recv(1024)
        recv_size+=len(recv_data)

    #print(recv_data.decode('utf-8'))
    print(recv_data.decode('gbk')) #windows默认gbk编码

tcp_client.py
View Code

  其实上面复杂的代码做了个什么事情呢,就是自定制了报头:

  28 黏包现象 缓冲区 黏包方案解决方案

  有同学问:老师,你为啥多次send啊,其实多次send和将数据拼接起来send一次是一样的,因为我们约定好了,你接收的时候先接收4个字节,然后再接收后面的内容。

28 黏包现象 缓冲区 黏包方案解决方案
整个流程的大致解释:
我们可以把报头做成字典,字典里包含将要发送的真实数据的描述信息(大小啊之类的),然后json序列化,然后用struck将序列化后的数据长度打包成4个字节。 我们在网络上传输的所有数据 都叫做数据包,数据包里的所有数据都叫做报文,报文里面不止有你的数据,还有ip地址、mac地址、端口号等等,其实所有的报文都有报头,这个报头是协议规定的,看一下
发送时: 先发报头长度 再编码报头内容然后发送 最后发真实内容 接收时: 先手报头长度,用struct取出来 根据取出的长度收取报头内容,然后解码,反序列化 从反序列化的结果中取出待取数据的描述信息,然后去取真实的数据内容 
28 黏包现象 缓冲区 黏包方案解决方案

  

  FTP上传下载文件的代码(简易版)

28 黏包现象 缓冲区 黏包方案解决方案28 黏包现象 缓冲区 黏包方案解决方案
import socket
import struct
import json
sk = socket.socket()
# buffer = 4096 # 当双方的这个接收发送的大小比较大的时候,就像这个4096,就会丢数据,这个等我查一下再告诉大家,改小了就ok的,在linux上也是ok的。
buffer = 1024 #每次接收数据的大小
sk.bind(('127.0.0.1',8090))
sk.listen()

conn,addr = sk.accept()
#接收
head_len = conn.recv(4)
head_len = struct.unpack('i',head_len)[0] #解包
json_head = conn.recv(head_len).decode('utf-8') #反序列化
head = json.loads(json_head)
filesize = head['filesize']
with open(head['filename'],'wb') as f:
    while filesize:
        if filesize >= buffer: #>=是因为如果刚好等于的情况出现也是可以的。
            content = conn.recv(buffer)
            f.write(content)
            filesize -= buffer
        else:
            content = conn.recv(buffer)
            f.write(content)
            break

conn.close()
sk.close()

tcp_server.py
View Code
28 黏包现象 缓冲区 黏包方案解决方案28 黏包现象 缓冲区 黏包方案解决方案
import os
import json
import socket
import struct
sk = socket.socket()
sk.connect(('127.0.0.1',8090))
buffer = 1024 #读取文件的时候,每次读取的大小
head = {
            'filepath':r'D:\打包程序', #需要下载的文件路径,也就是文件所在的文件夹
            'filename':'xxx.mp4',  #改成上面filepath下的一个文件
            'filesize':None,
        }

file_path = os.path.join(head['filepath'],head['filename'])
filesize = os.path.getsize(file_path)
head['filesize'] = filesize
# json_head = json.dumps(head,ensure_ascii=False)  #字典转换成字符串
json_head = json.dumps(head)  #字典转换成字符串
bytes_head = json_head.encode('utf-8') #字符串转换成bytes类型
print(json_head)
print(bytes_head)

#计算head的长度,因为接收端先接收我们自己定制的报头,对吧
head_len = len(bytes_head) #报头长度
pack_len = struct.pack('i',head_len)
print(head_len)
print(pack_len)
sk.send(pack_len)  #先发送报头长度
sk.send(bytes_head) #再发送bytes类型的报头

#即便是视频文件,也是可以按行来读取的,也可以readline,也可以for循环,但是读取出来的数据大小就不固定了,影响效率,有可能读的比较小,也可能很大,像视频文件一般都是一行的二进制字节流。
#所有我们可以用read,设定一个一次读取内容的大小,一边读一边发,一边收一边写
with open(file_path,'rb') as f:
    while filesize:
        if filesize >= buffer: #>=是因为如果刚好等于的情况出现也是可以的。
            content = f.read(buffer) #每次读取出来的内容
            sk.send(content)
            filesize -= buffer #每次减去读取的大小
        else: #那么说明剩余的不够一次读取的大小了,那么只要把剩下的读取出来发送过去就行了
            content = f.read(filesize)
            sk.send(content)
            break

sk.close()

tcp_client.py
View Code

FTP上传下载文件的代码(升级版)(注:咱们学完网络编程就留FTP作业,这个代码可以参考,当你用函数的方式写完之后,再用面向对象进行改版却没有思路的时候再来看,别骗自己昂~~)

28 黏包现象 缓冲区 黏包方案解决方案28 黏包现象 缓冲区 黏包方案解决方案
import socket
import struct
import json
import subprocess
import os

class MYTCPServer:
    address_family = socket.AF_INET

    socket_type = socket.SOCK_STREAM

    allow_reuse_address = False

    max_packet_size = 8192

    coding='utf-8'

    request_queue_size = 5

    server_dir='file_upload'

    def __init__(self, server_address, bind_and_activate=True):
        """Constructor.  May be extended, do not override."""
        self.server_address=server_address
        self.socket = socket.socket(self.address_family,
                                    self.socket_type)
        if bind_and_activate:
            try:
                self.server_bind()
                self.server_activate()
            except:
                self.server_close()
                raise

    def server_bind(self):
        """Called by constructor to bind the socket.
        """
        if self.allow_reuse_address:
            self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        self.socket.bind(self.server_address)
        self.server_address = self.socket.getsockname()

    def server_activate(self):
        """Called by constructor to activate the server.
        """
        self.socket.listen(self.request_queue_size)

    def server_close(self):
        """Called to clean-up the server.
        """
        self.socket.close()

    def get_request(self):
        """Get the request and client address from the socket.
        """
        return self.socket.accept()

    def close_request(self, request):
        """Called to clean up an individual request."""
        request.close()

    def run(self):
        while True:
            self.conn,self.client_addr=self.get_request()
            print('from client ',self.client_addr)
            while True:
                try:
                    head_struct = self.conn.recv(4)
                    if not head_struct:break

                    head_len = struct.unpack('i', head_struct)[0]
                    head_json = self.conn.recv(head_len).decode(self.coding)
                    head_dic = json.loads(head_json)

                    print(head_dic)
                    #head_dic={'cmd':'put','filename':'a.txt','filesize':123123}
                    cmd=head_dic['cmd']
                    if hasattr(self,cmd):
                        func=getattr(self,cmd)
                        func(head_dic)
                except Exception:
                    break

    def put(self,args):
        file_path=os.path.normpath(os.path.join(
            self.server_dir,
            args['filename']
        ))

        filesize=args['filesize']
        recv_size=0
        print('----->',file_path)
        with open(file_path,'wb') as f:
            while recv_size < filesize:
                recv_data=self.conn.recv(self.max_packet_size)
                f.write(recv_data)
                recv_size+=len(recv_data)
                print('recvsize:%s filesize:%s' %(recv_size,filesize))


tcpserver1=MYTCPServer(('127.0.0.1',8080))

tcpserver1.run()

server.py
View Code
28 黏包现象 缓冲区 黏包方案解决方案28 黏包现象 缓冲区 黏包方案解决方案
import socket
import struct
import json
import os


class MYTCPClient:
    address_family = socket.AF_INET

    socket_type = socket.SOCK_STREAM

    allow_reuse_address = False

    max_packet_size = 8192

    coding='utf-8'

    request_queue_size = 5

    def __init__(self, server_address, connect=True):
        self.server_address=server_address
        self.socket = socket.socket(self.address_family,
                                    self.socket_type)
        if connect:
            try:
                self.client_connect()
            except:
                self.client_close()
                raise

    def client_connect(self):
        self.socket.connect(self.server_address)

    def client_close(self):
        self.socket.close()

    def run(self):
        while True:
            inp=input(">>: ").strip()
            if not inp:continue
            l=inp.split()
            cmd=l[0]
            if hasattr(self,cmd):
                func=getattr(self,cmd)
                func(l)


    def put(self,args):
        cmd=args[0]
        filename=args[1]
        if not os.path.isfile(filename):
            print('file:%s is not exists' %filename)
            return
        else:
            filesize=os.path.getsize(filename)

        head_dic={'cmd':cmd,'filename':os.path.basename(filename),'filesize':filesize}
        print(head_dic)
        head_json=json.dumps(head_dic)
        head_json_bytes=bytes(head_json,encoding=self.coding)

        head_struct=struct.pack('i',len(head_json_bytes))
        self.socket.send(head_struct)
        self.socket.send(head_json_bytes)
        send_size=0
        with open(filename,'rb') as f:
            for line in f:
                self.socket.send(line)
                send_size+=len(line)
                print(send_size)
            else:
                print('upload successful')



client=MYTCPClient(('127.0.0.1',8080))

client.run()

client.py
View Code

ok~今天的内容就到这里,大家别着急,稳扎稳打,把上面学习的这些内容在好好理解理解,写写代码练习练习~~~ 

====================================================================================================================

十一 验证客户端的链接合法性

  首先,我们来探讨一下,什么叫验证合法性, 举个例子:有一天,我开了一个socket服务端,只想让咱们这个班的同学使用,但是有一天,隔壁班的同学过来问了一下我开的这个服务端的ip和端口,然后他是不是就可以去连接我了啊,那怎么办,我是不是不想让他连接我啊,我需要验证一下你的身份,这就是验证连接的合法性,再举个例子,就像我们上面说的你的windows系统是不是连接微软的时间服务器来获取时间的啊,你的mac能到人家微软去获取时间吗,你愿意,人家微软还不愿意呢,对吧,那这时候,你每次连接我来获取时间的时候,我是不是就要验证你的身份啊,也就是你要带着你的系统信息,我要判断你是不是我微软的windows,对吧,如果是mac,我是不是不让你连啊,这就是连接合法性。如果验证你的连接是合法的,那么如果我还要对你的身份进行验证的需求,也就是要验证用户名和密码,那么我们还需要进行身份认证。连接认证>>身份认证>>ok你可以玩了。
  
  好大致描述相信大家基本理解了,如果这还没有理解,那么同学,我要哭晕在厕所了。
    
 
  如果你想在分布式系统中实现一个简单的客户端链接认证功能,又不像SSL那么复杂,那么利用hmac+加盐的方式来实现,直接看代码!(SSL,我们都)
  
28 黏包现象 缓冲区 黏包方案解决方案28 黏包现象 缓冲区 黏包方案解决方案
from socket import *
import hmac,os

secret_key=b'Jedan has a big key!'
def conn_auth(conn):
    '''
    认证客户端链接
    :param conn:
    :return:
    '''
    print('开始验证新链接的合法性')
    msg=os.urandom(32)#生成一个32字节的随机字符串
    conn.sendall(msg)
    h=hmac.new(secret_key,msg) 
    digest=h.digest()
    respone=conn.recv(len(digest))
    return hmac.compare_digest(respone,digest)

def data_handler(conn,bufsize=1024):
    if not conn_auth(conn):
        print('该链接不合法,关闭')
        conn.close()
        return
    print('链接合法,开始通信')
    while True:
        data=conn.recv(bufsize)
        if not data:break
        conn.sendall(data.upper())

def server_handler(ip_port,bufsize,backlog=5):
    '''
    只处理链接
    :param ip_port:
    :return:
    '''
    tcp_socket_server=socket(AF_INET,SOCK_STREAM)
    tcp_socket_server.bind(ip_port)
    tcp_socket_server.listen(backlog)
    while True:
        conn,addr=tcp_socket_server.accept()
        print('新连接[%s:%s]' %(addr[0],addr[1]))
        data_handler(conn,bufsize)

if __name__ == '__main__':
    ip_port=('127.0.0.1',9999)
    bufsize=1024
    server_handler(ip_port,bufsize)

服务端
View Code

 

 

28 黏包现象 缓冲区 黏包方案解决方案28 黏包现象 缓冲区 黏包方案解决方案
from socket import *
import hmac,os

secret_key=b'Jedan has a big key!'
def conn_auth(conn):
    '''
    验证客户端到服务器的链接
    :param conn:
    :return:
    '''
    msg=conn.recv(32)
    h=hmac.new(secret_key,msg)
    digest=h.digest()
    conn.sendall(digest)

def client_handler(ip_port,bufsize=1024):
    tcp_socket_client=socket(AF_INET,SOCK_STREAM)
    tcp_socket_client.connect(ip_port)

    conn_auth(tcp_socket_client)

    while True:
        data=input('>>: ').strip()
        if not data:continue
        if data == 'quit':break

        tcp_socket_client.sendall(data.encode('utf-8'))
        respone=tcp_socket_client.recv(bufsize)
        print(respone.decode('utf-8'))
    tcp_socket_client.close()

if __name__ == '__main__':
    ip_port=('127.0.0.1',9999)
    bufsize=1024
    client_handler(ip_port,bufsize)

客户端
View Code

 

 

 

  介绍代码中使用的两个方法:
   1、os.urandom(n)
    其中os.urandom(n) 是一种bytes类型的随机生成n个字节字符串的方法,而且每次生成的值都不相同。再加上md5等加密的处理,就能够成内容不同长度相同的字符串了。
28 黏包现象 缓冲区 黏包方案解决方案28 黏包现象 缓冲区 黏包方案解决方案
os.urandom(n)函数在python官方文档中做出了这样的解释

函数定位: Return a string of n random bytes suitable for cryptographic use. 
意思就是,返回一个有n个byte那么长的一个string,然后很适合用于加密。

然后这个函数,在文档中,被归结于os这个库的Miscellaneous Functions,意思是不同种类的函数(也可以说是混种函数) 
原因是: This function returns random bytes from an OS-specific randomness source. (函数返回的随机字节是根据不同的操作系统特定的随机函数资源。即,这个函数是调用OS内部自带的随机函数的。有特异性)

os.urandom官方解释
View Code

  使用方法:

import os
from hashlib import md5

for i in range(10):
    print md5(os.urandom(24)).hexdigest()
   2、hmac: 我们完全可以用hashlib来实现,但是学个新的吗,没什么不好的,这个操作更方便一些。
    Python自带的hmac模块实现了标准的Hmac算法,我们首先需要准备待计算的原始消息message,随机key,哈希算法,这里采用MD5,使用hmac的代码如下:
import hmac
message = b'Hello world'
key = b'secret'
h = hmac.new(key,message,digestmod='MD5')
print(h.hexdigest())
比较两个密文是否相同,可以用hmac.compare_digest(密文、密文),然会True或者False。

     可见使用hmac和普通hash算法非常类似。hmac输出的长度和原始哈希算法的长度一致。需要注意传入的key和message都是bytes类型,str类型需要首先编码为bytes

28 黏包现象 缓冲区 黏包方案解决方案
def hmac_md5(key, s):
    return hmac.new(key.encode('utf-8'), s.encode('utf-8'), 'MD5').hexdigest()

class User(object):
    def __init__(self, username, password):
        self.username = username
        self.key = ''.join([chr(random.randint(48, 122)) for i in range(20)])
        self.password = hmac_md5(self.key, password)
28 黏包现象 缓冲区 黏包方案解决方案
 

十二 socketserver模块实现并发

  为什么要讲socketserver?我们之前写的tcp协议的socket是不是一次只能和一个客户端通信,如果用socketserver可以实现和多个客户端通信。它是在socket的基础上进行了一层封装,也就是说底层还是调用的socket,在py2.7里面叫做SocketServer也就是大写了两个S,在py3里面就小写了。后面我们要写的FTP作业,需要用它来实现并发,也就是同时可以和多个客户端进行通信,多个人可以同时进行上传下载等。
 
  那么我们先看socketserver怎么用呢,然后在分析,先看下面的代码
  
28 黏包现象 缓冲区 黏包方案解决方案
import socketserver                              #1、引入模块
class MyServer(socketserver.BaseRequestHandler): #2、自己写一个类,类名自己随便定义,然后继承socketserver这个模块里面的BaseRequestHandler这个类

    def handle(self):                            #3、写一个handle方法,必须叫这个名字
        #self.request                            #6、self.request 相当于一个conn

        self.request.recv(1024)                  #7、收消息
        msg = '亲,学会了吗'
        self.request.send(bytes(msg,encoding='utf-8')) #8、发消息

        self.request.close()                     #9、关闭连接
# 拿到了我们对每个客户端的管道,那么我们自己在这个方法里面的就写我们接收消息发送消息的逻辑就可以了 pass if __name__ == '__mian__': #thread 线程,现在只需要简单理解线程,别着急,后面很快就会讲到啦,看下面的图 server = socketserver.ThreadingTCPServer(('127.0.0.1',8090),MyServer)#4、使用socketserver的ThreadingTCPServer这个类,将IP和端口的元祖传进去,还需要将上面咱们自己定义的类传进去,得到一个对象,相当于我们通过它进行了bind、listen server.serve_forever() #5、使用我们上面这个类的对象来执行serve_forever()方法,他的作用就是说,我的服务一直开启着,就像京东一样,不能关闭网站,对吧,并且serve_forever()帮我们进行了accept #注意: #有socketserver 那么有socketclient的吗? #当然不会有,我要作为客户去访问京东的时候,京东帮我也客户端了吗,客户端是不是在我们自己的电脑啊,并且socketserver对客户端没有太高的要求,只需要自己写一些socket就行了。
28 黏包现象 缓冲区 黏包方案解决方案

 

   ThreadingTCPServer,多线程,简单解释:看图
   28 黏包现象 缓冲区 黏包方案解决方案

  通过上面的代码,我们来分析socket的源码:(大家还记得面向对象的继承吗,来,实战的时候来啦)

28 黏包现象 缓冲区 黏包方案解决方案
在整个socketserver这个模块中,其实就干了两件事情:1、一个是循环建立链接的部分,每个客户链接都可以连接成功  2、一个通讯循环的部分,就是每个客户端链接成功之后,要循环的和客户端进行通信。
看代码中的:server=socketserver.ThreadingTCPServer(('127.0.0.1',8090),MyServer)
还记得面向对象的继承吗?来,大家自己尝试着看看源码:
查找属性的顺序:ThreadingTCPServer->ThreadingMixIn->TCPServer->BaseServer 实例化得到server,先找ThreadMinxIn中的__init__方法,发现没有init方法,然后找类ThreadingTCPServer的__init__,在TCPServer中找到,在里面创建了socket对象,进而执行server_bind(相当于bind),server_active(点进去看执行了listen) 找server下的serve_forever,在BaseServer中找到,进而执行self._handle_request_noblock(),该方法同样是在BaseServer中 执行self._handle_request_noblock()进而执行request, client_address = self.get_request()(就是TCPServer中的self.socket.accept()),然后执行self.process_request(request, client_address) 在ThreadingMixIn中找到process_request,开启多线程应对并发,进而执行process_request_thread,执行self.finish_request(request, client_address) 上述四部分完成了链接循环,本部分开始进入处理通讯部分,在BaseServer中找到finish_request,触发我们自己定义的类的实例化,去找__init__方法,而我们自己定义的类没有该方法,则去它的父类也就是BaseRequestHandler中找.... 源码分析总结: 基于tcp的socketserver我们自己定义的类中的   self.server即套接字对象   self.request即一个链接   self.client_address即客户端地址 基于udp的socketserver我们自己定义的类中的   self.request是一个元组(第一个元素是客户端发来的数据,第二部分是服务端的udp套接字对象),如(b'adsf', <socket.socket fd=200, family=AddressFamily.AF_INET, type=SocketKind.SOCK_DGRAM, proto=0, laddr=('127.0.0.1', 8080)>)   self.client_address即客户端地址
28 黏包现象 缓冲区 黏包方案解决方案
 
 
  一个完整的sockeserver代码示例:
    服务端代码示例:
28 黏包现象 缓冲区 黏包方案解决方案28 黏包现象 缓冲区 黏包方案解决方案
import socketserver
class Myserver(socketserver.BaseRequestHandler):
    def handle(self):
        self.data = self.request.recv(1024).strip()
        print("{} wrote:".format(self.client_address[0]))
        print(self.data)
        self.request.sendall(self.data.upper())

if __name__ == "__main__":
    HOST, PORT = "127.0.0.1", 9999

    # 设置allow_reuse_address允许服务器重用地址
    socketserver.TCPServer.allow_reuse_address = True
    # 创建一个server, 将服务地址绑定到127.0.0.1:9999
    #server = socketserver.TCPServer((HOST, PORT),Myserver)
    server = socketserver.ThreadingTCPServer((HOST, PORT),Myserver)
    # 让server永远运行下去,除非强制停止程序
    server.serve_forever()

tcp_server.py
View Code

  客户端代码示例:

28 黏包现象 缓冲区 黏包方案解决方案28 黏包现象 缓冲区 黏包方案解决方案
import socket

HOST, PORT = "127.0.0.1", 9999
data = "hello"

# 创建一个socket链接,SOCK_STREAM代表使用TCP协议
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
    sock.connect((HOST, PORT))          # 链接到客户端
    sock.sendall(bytes(data + "\n", "utf-8")) # 向服务端发送数据
    received = str(sock.recv(1024), "utf-8")# 从服务端接收数据

print("Sent:     {}".format(data))
print("Received: {}".format(received))

tcp_client.py
View Code

十三 网络编程的作业

   好了同学们,到了这儿,我们的网络编程socket就讲完了,大致就是这些内容,给大家留个作业:(你的努力的成果你自己是看的到的~!)
  加粗的是必须要做的,倾斜的是比较有难度的,大家别放松呀。
     1. 多用户同时登陆
    2. 用户登陆,加密认证
    3. 上传/下载文件,保证文件一致性
    4. 传输过程中现实进度条
    5. 不同用户家目录不同,且只能访问自己的家目录
    6. 对用户进行磁盘配额、不同用户配额可不同
    7. 用户登陆server后,可在家目录权限下切换子目录
    8. 查看当前目录下文件,新建文件夹
    9. 删除文件和空文件夹
    10. 充分使用面向对象知识
    11. 支持断点续传

  简单分析一下实现方式:

  1.字符串操作以及打印 —— 实现上传下载的进度条功能

28 黏包现象 缓冲区 黏包方案解决方案28 黏包现象 缓冲区 黏包方案解决方案
一、
    import sys
    import time
    for i in range(50):
        sys.stdout.write('>')
        sys.stdout.flush()
        time.sleep(0.2)

二、
    #总共接收到的大小和总文件大小的比值:
    #all_size_len表示当前总共接受的多长的数据,是累计的
    #file_size表示文件的总大小
        per_cent = round(all_size_len/file_size,2) #将比值做成两位数的小数
    #通过\r来实现同一行打印,每次打印都回到行首打印
        print('\r'+ '%s%%'%(str(int(per_cent*100))) + '*'*(int(per_cent*100)),end='')  #由于float类型的数据没法通过%s来进行字符串格式化,所以我在这里通过int来转换了一下,并用str转换了一下,后面再拼接上*,这个*的数量根据现在计算出来的比值来确定,就能够出来%3***这样的效果。自行使用上面的sys.stdout来实现一下这个直接print的效果。

打印进度条
View Code

  2.socketserver —— 实现ftp server端和client端的交互

  3.struct模块 —— 自定制报头解决文件上传下载过程中的粘包问题

  4.hashlib或者hmac模块 —— 实现文件的一致性校验和用户密文登录

  5.os模块 —— 实现目录的切换及查看文件文件夹等功能

  6.文件操作 —— 完成上传下载文件及断点续传等功能

  看一下流程图:

  28 黏包现象 缓冲区 黏包方案解决方案