python 开发一个支持多用户在线的FTP

Posted 2020-08-22 weiman3389

### 作者介绍：* author：lzl### 博客地址：* http://www.cnblogs.com/lianzhilei/p/5813986.html### 功能实现    作业：开发一个支持多用户在线的FTP程序    要求：        用户加密认证        允许同时多用户登录        每个用户有自己的家目录 ，且只能访问自己的家目录        对用户进行磁盘配额，每个用户的可用空间不同        允许用户在ftp server上随意切换目录        允许用户查看当前目录下文件        允许上传和下载文件，保证文件一致性        文件传输过程中显示进度条        附加功能：支持文件的断点续传### 目录结构：    FTP    │    ├── ftpclient #客户端程序    │      ├── __init__.py    │      └── ftpclient.py  #客户端主程序    └── ftpserver #服务端程序            ├── README.txt            ├── ftpserver.py #服务端入口程序            ├── conf #配置文件目录            │   ├── __init__.py            │   └── setting.py            ├── modules #程序核心目录            │   ├── __init__.py            │   ├── auth_user.py  #用户认证模块            │   └── sokect_server.py  #sokectserver模块            ├── database #用户数据库            │   ├── alex.db            │   ├── lzl.db            │   └── eric.db            ├── home #用户宿主目录            │   ├── alex            │   ├── lzl            │   └── eric            └── log                ├── __init__.py                └── log  #待扩展....### 功能实现    1、conf目录下settings.py模块记录可操作用户信息，根据用户信息生成用户字典和宿主目录，已经生成的不再新建    2、每个用户的宿主目录磁盘空间配额默认为10M，可在settings.py模块里进行修改    3、程序运行在windows系统上，程序要求全部实现，下面是具体命令操作    4、切换目录：cd  ..  返回上一级目录    cd dirname   进入dirname                 用户登录后默认进入宿主目录，只可在宿主目录下随意切换    5、创建目录：mkdir dirname                 在当前目录下创建目录，如果目录存在则报错，不存在创建    6、查看当前路径： pwd    7、查看当前路径下的文件名和目录名： dir    8、下载文件（可续传）：get filename                 ①、服务端当前目录存在此文件，客户端不存在此文件，直接下载                 ②、服务端当前目录存在此文件，客户端存在此文件名，之前下载中断，文件可续传，进行续传                 ③、服务端当前目录存在此文件，客户端存在此文件名，大小与服务端一致，不下载    9、上传文件：put  filename                 判断宿主目录磁盘空间是否够用，可以，上传文件；否则，报错### 状态码    400 用户认证失败    401 命令不正确    402 文件不存在    403 创建文件已经存在    404 磁盘空间不够    405 不续传    200 用户认证成功    201 命令可以执行    202 磁盘空间够用    203 文件具有一致性    205 续传    000 系统交互码

socket是什么

什么是socket所谓socket通常也称作"套接字"，用于描述IP地址和端口，是一个通信链的句柄。应用程序通常通过"套接字"向网络发出请求或者应答网络请求。说白了就是一种通信机制。它类似于银行，电信啊这些部分的电话客服部门。你打电话的时候，那边会分配置一个人回答你的问题，客服部门就相当于socket的服务器端了，你这边呢就相当于客户端了，在和你通话结束前，如果有人在想找和你通话的那个说话，是不可能的，因为你在和他通信，当然客服部门的电话交换机也不会重复分配。我们天天用的http\\smtp\\ftp等网络协议都是基于socket的上层实现，无论使用何种网络协议，最本质上都是在进行数据的接收和发送，只不过发送的数据类型和内容不同罢了，“发送”和“接收”这两个动作就是socket处理数据的主要方式。

socket起源于Unix，而Unix/Linux基本哲学之一就是“一切皆文件”，都可以用“打开open–>读写write/read–> 关闭close”模式来操作。Socket就是该模式的一个实现，socket即是一种特殊的文件，一些socket函数就是对其进行的操作（读/写IO、打开、关闭），python的socket模块是直接调用的unix的socket库，接下来我们一起来看下，如何在python下实现socket。

 

使用socket时需要指定Socket Family（地址簇），包括以下几种：

socket.AF_UNIX       只能够用于单一的Unix系统进程间通信

socket.AF_INET      用于主机之间的网络通信

socket.AF_INET6    IPv6通信

若想实现主机之间的通信，我们就得使用socket.AF_INET

 

确认地址簇后，还需要指定socket数据类型

socket.SOCK_STREAM     流式socket, for TCP

socket.SOCK_DGRAM       数据报式socket, for UDP

socket.SOCK_RAW    原始套接字，普通的套接字无法处理ICMP、IGMP等网络报文，而SOCK_RAW可以；其次，SOCK_RAW也可以处理特殊的IPv4报文；此外，利用原始套接字，可以通过IP_HDRINCL套接字选项由用户构造IP头。

socket.SOCK_RDM   是一种可靠的UDP形式，即保证交付数据报但不保证顺序。SOCK_RAM用来提供对原始协议的低级访问，在需要执行某些特殊操作时使用，如发送ICMP报文。SOCK_RAM通常仅限于高级用户或管理员运行的程序使用。

socket.SOCK_SEQPACKET      可靠的连续数据包服务

 

我们主要用的一般是SOCK_STREAM (for TCP)和SOCK_DGRAM（for UDP）.

 

 

进行socket调用时可能会用到的函数：

s = socket(family,type[,protocal])       使用给定的地址族、套接字类型、协议编号（默认为0）来创建套接字。

 

套接字的实例具有以下方法：

1. s.bind(address) 将套接字绑定到地址。address地址的格式取决于地址族。在AF_INET下，以元组（host,port）的形式表示地址。

2. s.listen(backlog)   开始监听传入连接。backlog指定在拒绝连接之前，操作系统可以挂起的最大连接数量。该值至少为1，大部分应用程序设为5就可以了。

3. s.connect(address)  连接到address处的套接字。一般，address的格式为元组（hostname,port），如果连接同一台机器上的服务器，可以将hostname设为‘localhost’。如果连接出错，返回socket.error错误。

4. s.connect_ex(adddress)  功能与connect(address)相同，但是成功返回0，失败返回errno的值。

5. s.accept() 接受连接并返回（conn,address）,其中conn是新的套接字对象，可以用来接收和发送数据。address是连接客户端的地址。

6. s.close()  关闭套接字。

7. s.fileno()  返回套接字的文件描述符。

8. s.getpeername() 返回连接套接字的远程地址。返回值通常是元组（ipaddr,port）。

9. s.getsockname()  返回套接字自己的地址。通常是一个元组(ipaddr,port)

10. s.getsockopt(level,optname[.buflen]) 返回套接字选项的值。

11. s.gettimeout() 返回当前超时期的值，单位是秒，如果没有设置超时期，则返回None。

12. s.recv(bufsize[,flag])  接受套接字的数据。数据以字符串形式返回，bufsize指定要接收的最大数据量。flag提供有关消息的其他信息，通常可以忽略。

13. s.recvfrom(bufsize[.flag])  与recv()类似，但返回值是（data,address）。其中data是包含接收数据的字符串，address是发送数据的套接字地址。

14. s.send(string[,flag])  将string中的数据发送到连接的套接字。返回值是要发送的字节数量，该数量可能小于string的字节大小。

15. s.sendall(string[,flag])  将string中的数据发送到连接的套接字，但在返回之前会尝试发送所有数据。成功返回None，失败则抛出异常。

16. s.sendto(string[,flag],address)  将数据发送到套接字，address是形式为（ipaddr，port）的元组，指定远程地址。返回值是发送的字节数。该函数主要用于UDP协议。

17. s.setblocking(flag)  如果flag为0，则将套接字设为非阻塞模式，否则将套接字设为阻塞模式（默认值）。非阻塞模式下，如果调用recv()没有发现任何数据，或send()调用无法立即发送数据，那么将引起socket.error异常。

18. s.setsockopt(level,optname,value)   设置给定套接字选项的值。

19. s.settimeout(timeout)   设置套接字操作的超时期，timeout是一个浮点数，单位是秒。值为None表示没有超时期。一般，超时期应该在刚创建套接字时设置，因为它们可能用于连接的操作（如connect()）普通的非套接字实例的函数

20. getdefaulttimeout()返回默认的套接字超时时间（以秒为单位）。None表示不设置任何超时时间。

21. gethostbyname(hostname)   将主机名（如“www.baidu.com”）转换为IPv4地址，IP地址将以字符串的形式返回，如“8.8.8.8”。不支持IPv6

22. gethostname() 返回本地机器的主机名。

 

 

正式写代码了噢！！！

 

下面实现一下最简单的socket 通信：

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

Server.py 服务端   #Echo server program import socket   HOST=‘’  #空代表0.0.0.0 PORT= 50007  #监听端口 s= socket.socket(socket.AF_INET,socket.SOCK_STREAM) # 生成socket tcp通信实例， s.bind((HOST,PORT)) #绑定ip和端口，注意bind只接受一个参数，(HOST,PORT) 做成一个元祖传进去 s.listen(1)  #开始监听，里面的数字是代表服务端在拒绝新连接之前可以最多挂起多少连接，不过实验过了没啥用，所以写个1就好了   conn,addr= s.accept()  #接受连接，并返回两个变量，conn代表每个新连接进入后服务端都会为其生成一个新实例，后面可以用这个实例进行发送和接收，addr是连接进来的客户端的地址，accept()方法在有新连接进入时就会返回conn,addr这两个变量，但如果没有连接时，此方法就会阻塞直至有新连接过来。   print\'Connected by\', addr   while  True:     data = conn.recv(1024) #接收1024字节数据     if not data: break     #如果收不到客户端数据了（代表客户端断开了），就断开     conn.sendall(data.upper())    #将收到的数据全变成大写再发给客户端       conn.close() #关闭连接

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

Client.py 客户端   import socket   HOST= \'192.168.3.1\' # 远程socket服务器ip PORT= 50007         # 远程socket服务器端口   s = socket.socket(socket.AF_INET,socket.SOCK_STREAM) #实例化socket s.connect((HOST,PORT)) #连接socket服务器   while True:     msg = raw_input("Your msg::").strip() #让用户输入消息，去除回车和空格     if len(msg) == 0:continue            s.sendall(msg) #向服务器发送消息     data= s.recv(1024)       #接收服务器的消息           print \'Received:\', data s.close()

 

这样我们就能实现服务端和客户端1对1来通信了，但是你会发现，只要客户端一中断，服务器也跟着中断了，这样显然是不合理的，一个客户端断开了，服务端应该能持续为其它客户端提供服务才对。 那服务端为啥会跟着客户端一起关闭呢，因为服务端代码中

1	if not data: break

如果收不到客户端的数据，就跳出循环，我们可以把代表调整成如下:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

#Echo server program import socket   HOST=\'\'  #空代表0.0.0.0 PORT= 50007  #监听端口 s= socket.socket(socket.AF_INET,socket.SOCK_STREAM)  s.bind((HOST,PORT))  s.listen(1)     while True:     conn,addr= s.accept()         print\'Connected by\', addr       while  True:         data = conn.recv(1024) #接收1024字节数据         if not data: break     #如果收不到客户端数据了（代表客户端断开了），就断开         conn.sendall(data.upper())    #将收到的数据全变成大写再发给客户端       conn.close() #关闭此客户端的连接实例

这样如果一个客户端连接断开了，最里面的那个循环会跳出，就又回到第一层的while循环，

1	conn,addr= s.accept()

上面的accept()方法会继续等待一个新的连接进来，这样，服务端就可以持续不断的为客户端提供服务了。

 

解决了不能持续提供服务的问题后，新问题又来了，当你启动服务端后，同时再启动2个客户端，你会发现，只能有一个客户端跟服务端不断的通信，另一个客户端会一直处在挂起状态，当你把可以通信的客户端断开后，你会发现第2个客户端就可以跟服务端进行通信了。 这是为什么呢？哈哈，因为你的服务端同时只能为一个客户提供服务呀。就像你跟一个人在说话的同时，是不能同时跟其它人说话的，对么？

其实想让你的服务端口可以同时为与多个客户端进行通信也很简单，直接用多线程并发就好了，什么？你不会写多线程?没关系，Python已经帮你实现了，你只需要调用一个叫SocketServer的模块就好了。下面咱们就把刚才的单线程socket服务端变成多线程的：

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

import SocketServer   class MyTCPHandler(SocketServer.BaseRequestHandler):     #继承BaseRequestHandler基类，然后必须重写handle方法，并且在handle方法里实现与客户端的所有交互           def handle(self):           while  True:             data = self.request.recv(1024) #接收1024字节数据             if not data: break                  self.request.sendall(data.upper())   if __name__ == "__main__":     HOST, PORT = "localhost", 50007       # 把刚才写的类当作一个参数传给ThreadingTCPServer这个类，下面的代码就创建了一个多线程socket server     server = SocketServer.ThreadingTCPServer((HOST, PORT), MyTCPHandler)       # 启动这个server,这个server会一直运行，除非按ctrl-C停止     server.serve_forever()

 

好了，此时再多启动几个客户端，看看是不是所有的客户端都能同时跟服务器端通信啦。

 

接下来我们看看怎么通过socket模拟实现一个ftp server，允许客户端上传和下载文件。 

 

FTP客户端

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72

#_*_coding:utf-8_*_ __author__ = \'jieli\'     import socket import os class FtpClient(object):     def __init__(self,host,port ):         self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)         self.sock.connect((host, port)) #连接服务器     def start(self): #实例化客户端类后，需要调用此方法启动客户端         self.interactive()  #跟用户的交互都在这个方法里                         def interactive(self):         while True:             user_input = raw_input(">>:").strip()             if len(user_input) == 0:continue             user_input = user_input.split() #用户输入的指令进行拆分，第一个参数是指要进行什么动作，比如get remote_filename               if hasattr(self,user_input[0]):#判断类中是否有get或其它输入的方法                 func = getattr(self,user_input[0]) #通过字符串获取类中对应方法的内存对象                 func(user_input) #调用此内存对象               else:                  print "\\033[31;1mWrong cmd usage\\033[0m"       def get(self,msg): #从服务器端下载文件         print \'--get func---\',msg         if len(msg) ==2 :             file_name = msg[1]             instruction = "FileTransfer|get|%s" % file_name #告诉服务器端要下载什么文件             self.sock.send(instruction)             feedback = self.sock.recv(100) #等待服务器端的消息确认             print \'-->\',feedback             if feedback.startswith("FileTransfer|get|ready"): #代表服务器上文件存在，并且服务器已经准备好了发送此文件到客户端                 file_size = int(feedback.split("|")[-1]) # 服务器端发回来的确认消息中，最后面一个值是文件大小，必须知道文件大小才知道一共要收多少内容                 self.sock.send("FileTransfer|get|recv_ready") #告诉服务器端已经准备好了接收                 recv_size = 0 # 因为文件可能会比较大，一次收不完，所以要循环收，每收到一次，就计个数                 f = file(\'client_recv/%s\' % os.path.basename(file_name),\'wb\') #在本地创建一个新文件来存这个要下载的文件内容                 print \'--->\',file_name                 while not file_size == recv_size:#只要文件总大小和已收到的大小不想等，就代表还没收完                     if file_size - recv_size>1024:#文件总大下减已收到的大小等于还剩下没收到的大小，如果这个数大于1024，代表一次肯定收不完，那就还得多循环几次                         data = self.sock.recv(1024) #这次收1024字节，但实际上收到的可能比1024小，所以需要以实际收到的数为准                         recv_size += len(data) # 已收到的大小加上这一次循环收到的实际大小                     else:# 如果最后剩下的少于1024，那就一次性把剩下的都收过来                         data = self.sock.recv(file_size - recv_size)                          #recv_size = file_size #不能这么写，因为这一次依然不一定能一次性收完，因为实际收到的数据可能比你规定的数据要少， 所以需要按下面这行的方式写                         recv_size += (file_size - recv_size)                      f.write(data) #收到的内容写入文件                     print file_size,recv_size                 else:                     print \'---recv file:%s---\' % file_name                     f.close()              else:                 print feedback         else:             print "\\033[31;1mWrong cmd usage\\033[0m"       def put(self):          pass     def ls(self):         pass     def cd(self):         pass     def delete(self):         pass     if __name__ == "__main__":     f = FtpClient(\'localhost\',9002)     f.start()

 

 

服务器端

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52

#_*_coding:utf-8_*_   import SocketServer   import os class MyTCPHandler(SocketServer.BaseRequestHandler):     def handle(self):         while True:             instruction = self.request.recv(1024).strip() #接收客户端命令             if not instruction :break             instruction = instruction.split(以上是关于python 开发一个支持多用户在线的FTP的主要内容，如果未能解决你的问题，请参考以下文章 开发一个支持多用户在线的FTP程序 python之FTP程序(支持多用户在线) python 多用户在线的FTP程序 支持多用户在线的Ftp程序 小程序支持多用户在线的FTP程序 FTP程序