00多行Python代码实现了一个FTP服务器

﹏ヽ暗。殇╰゛Y 2022-03-25 06:58 177阅读 0赞

# 400多行Python代码实现了一个FTP服务器 #

发布：mdxy-dxy 字体：\[ 增加  减小\] 类型：转载

400多行Python代码实现了一个FTP服务器,实现了比之前的xxftp更多更完善的功能

Python版本   
实现了比之前的xxftp更多更完善的功能   
1、继续支持多用户   
2、继续支持虚拟目录   
3、增加支持用户根目录以及映射虚拟目录的权限设置   
4、增加支持限制用户根目录或者虚拟目录的空间大小   
  
xxftp的特点   
1、开源、跨平台   
2、简单、易用   
3、不需要数据库   
4、可扩展性超强   
5、你可以免费使用xxftp假设自己的私人FTP服务器   
  
测试地址   
ftp://xiaoxia.org   
匿名帐号可以使用！   
匿名根目录只读，映射了一个虚拟目录，可以上传文件但不允许更改！   
  
使用方法   
跟之前用C语言写的xxftp使用方法一样：   
  
1. Create a root directory to hold the user directories.   
Configure it in config.xml.   
2. Create user directories under the root directory.   
If you want to specify a password, create a directory named ".xxftp",   
under which create a text file named "password" containing the MD5   
code of the password.   
3. If you want to specify the welcome and goodbye message, write it in   
xxftp.welcome and xxftp.goodbye under the root directory.   
4. Configure config.xml.   
  
The structure of your FTP server root may be like:   
  
\-/root   
\-xxftp.welcome   
\-xxftp.goodbye   
  
\-user1   
\-.xxftp   
\-password   
\-...   
\-user2   
\-.xxftp   
\-password   
\-...   
\-anonymous源代码

复制代码代码如下:

import socket, threading, os, sys, time   
import hashlib, platform, stat   
  
listen\_ip = "localhost"   
listen\_port = 21   
conn\_list = \[\]   
root\_dir = "./home"   
max\_connections = 500   
conn\_timeout = 120   
  
class FtpConnection(threading.Thread):   
def \_\_init\_\_(self, fd):   
threading.Thread.\_\_init\_\_(self)   
self.fd = fd   
self.running = True   
self.setDaemon(True)   
self.alive\_time = time.time()   
self.option\_utf8 = False   
self.identified = False   
self.option\_pasv = True   
self.username = ""   
def process(self, cmd, arg):   
cmd = cmd.upper();   
if self.option\_utf8:   
arg = unicode(arg, "utf8").encode(sys.getfilesystemencoding())   
print "<<", cmd, arg, self.fd   
\# Ftp Command   
if cmd == "BYE" or cmd == "QUIT":   
if os.path.exists(root\_dir + "/xxftp.goodbye"):   
self.message(221, open(root\_dir + "/xxftp.goodbye").read())   
else:   
self.message(221, "Bye!")   
self.running = False   
return   
elif cmd == "USER":   
\# Set Anonymous User   
if arg == "": arg = "anonymous"   
for c in arg:   
if not c.isalpha() and not c.isdigit() and c!="\_":   
self.message(530, "Incorrect username.")   
return   
self.username = arg   
self.home\_dir = root\_dir + "/" + self.username   
self.curr\_dir = "/"   
self.curr\_dir, self.full\_path, permission, self.vdir\_list, \\   
limit\_size, is\_virtual = self.parse\_path("/")   
if not os.path.isdir(self.home\_dir):   
self.message(530, "User " + self.username + " not exists.")   
return   
self.pass\_path = self.home\_dir + "/.xxftp/password"   
if os.path.isfile(self.pass\_path):   
self.message(331, "Password required for " + self.username)   
else:   
self.message(230, "Identified!")   
self.identified = True   
return   
elif cmd == "PASS":   
if open(self.pass\_path).read() == hashlib.md5(arg).hexdigest():   
self.message(230, "Identified!")   
self.identified = True   
else:   
self.message(530, "Not identified!")   
self.identified = False   
return   
elif not self.identified:   
self.message(530, "Please login with USER and PASS.")   
return   
  
self.alive\_time = time.time()   
finish = True   
if cmd == "NOOP":   
self.message(200, "ok")   
elif cmd == "TYPE":   
self.message(200, "ok")   
elif cmd == "SYST":   
self.message(200, "UNIX")   
elif cmd == "EPSV" or cmd == "PASV":   
self.option\_pasv = True   
try:   
self.data\_fd = socket.socket(socket.AF\_INET, socket.SOCK\_STREAM)   
self.data\_fd.bind((listen\_ip, 0))   
self.data\_fd.listen(1)   
ip, port = self.data\_fd.getsockname()   
if cmd == "EPSV":   
self.message(229, "Entering Extended Passive Mode (|||" + str(port) + "|)")   
else:   
ipnum = socket.inet\_aton(ip)   
self.message(227, "Entering Passive Mode (%s,%u,%u)." %   
(",".join(ip.split(".")), (port>>8&0xff), (port&0xff)))   
except:   
self.message(500, "failed to create data socket.")   
elif cmd == "EPRT":   
self.message(500, "implement EPRT later...")   
elif cmd == "PORT":   
self.option\_pasv = False   
self.data\_fd = socket.socket(socket.AF\_INET, socket.SOCK\_STREAM)   
s = arg.split(",")   
self.data\_ip = ".".join(s\[:4\])   
self.data\_port = int(s\[4\])\*256 + int(s\[5\])   
self.message(200, "ok")   
elif cmd == "PWD" or cmd == "XPWD":   
if self.curr\_dir == "": self.curr\_dir = "/"   
self.message(257, '"' + self.curr\_dir + '"')   
elif cmd == "LIST" or cmd == "NLST":   
if arg != "" and arg\[0\] == "-": arg = "" \# omit parameters   
remote, local, perm, vdir\_list, limit\_size, is\_virtual = self.parse\_path(arg)   
if not os.path.exists(local):   
self.message(550, "failed.")   
return   
if not self.establish(): return   
self.message(150, "ok")   
for v in vdir\_list:   
f = v\[0\]   
if self.option\_utf8:   
f = unicode(f, sys.getfilesystemencoding()).encode("utf8")   
if cmd == "NLST":   
info = f + "\\r\\n"   
else:   
info = "d%s%s------- %04u %8s %8s %8lu %s %s\\r\\n" % (   
"r" if "read" in perm else "-",   
"w" if "write" in perm else "-",   
1, "0", "0", 0,   
time.strftime("%b %d %Y", time.localtime(time.time())),   
f)   
self.data\_fd.send(info)   
for f in os.listdir(local):   
if f\[0\] == ".": continue   
path = local + "/" + f   
if self.option\_utf8:   
f = unicode(f, sys.getfilesystemencoding()).encode("utf8")   
if cmd == "NLST":   
info = f + "\\r\\n"   
else:   
st = os.stat(path)   
info = "%s%s%s------- %04u %8s %8s %8lu %s %s\\r\\n" % (   
"-" if os.path.isfile(path) else "d",   
"r" if "read" in perm else "-",   
"w" if "write" in perm else "-",   
1, "0", "0", st\[stat.ST\_SIZE\],   
time.strftime("%b %d %Y", time.localtime(st\[stat.ST\_MTIME\])),   
f)   
self.data\_fd.send(info)   
self.message(226, "Limit size: " + str(limit\_size))   
self.data\_fd.close()   
self.data\_fd = 0   
elif cmd == "REST":   
self.file\_pos = int(arg)   
self.message(250, "ok")   
elif cmd == "FEAT":   
features = "211-Features:\\r\\nSITES\\r\\nEPRT\\r\\nEPSV\\r\\nMDTM\\r\\nPASV\\r\\n"\\   
"REST STREAM\\r\\nSIZE\\r\\nUTF8\\r\\n211 End\\r\\n"   
self.fd.send(features)   
elif cmd == "OPTS":   
arg = arg.upper()   
if arg == "UTF8 ON":   
self.option\_utf8 = True   
self.message(200, "ok")   
elif arg == "UTF8 OFF":   
self.option\_utf8 = False   
self.message(200, "ok")   
else:   
self.message(500, "unrecognized option")   
elif cmd == "CDUP":   
finish = False   
arg = ".."   
else:   
finish = False   
if finish: return   
\# Parse argument ( It's a path )   
if arg == "":   
self.message(500, "where's my argument?")   
return   
remote, local, permission, vdir\_list, limit\_size, is\_virtual = \\   
self.parse\_path(arg)   
\# can not do anything to virtual directory   
if is\_virtual: permission = "none"   
can\_read, can\_write, can\_modify = "read" in permission, "write" in permission, "modify" in permission   
newpath = local   
try:   
if cmd == "CWD":   
if(os.path.isdir(newpath)):   
self.curr\_dir = remote   
self.full\_path = newpath   
self.message(250, '"' + remote + '"')   
else:   
self.message(550, "failed")   
elif cmd == "MDTM":   
if os.path.exists(newpath):   
self.message(213, time.strftime("%Y%m%d%I%M%S", time.localtime(   
os.path.getmtime(newpath))))   
else:   
self.message(550, "failed")   
elif cmd == "SIZE":   
self.message(231, os.path.getsize(newpath))   
elif cmd == "XMKD" or cmd == "MKD":   
if not can\_modify:   
self.message(550, "permission denied.")   
return   
os.mkdir(newpath)   
self.message(250, "ok")   
elif cmd == "RNFR":   
if not can\_modify:   
self.message(550, "permission denied.")   
return   
self.temp\_path = newpath   
self.message(350, "rename from " + remote)   
elif cmd == "RNTO":   
os.rename(self.temp\_path, newpath)   
self.message(250, "RNTO to " + remote)   
elif cmd == "XRMD" or cmd == "RMD":   
if not can\_modify:   
self.message(550, "permission denied.")   
return   
os.rmdir(newpath)   
self.message(250, "ok")   
elif cmd == "DELE":   
if not can\_modify:   
self.message(550, "permission denied.")   
return   
os.remove(newpath)   
self.message(250, "ok")   
elif cmd == "RETR":   
if not os.path.isfile(newpath):   
self.message(550, "failed")   
return   
if not can\_read:   
self.message(550, "permission denied.")   
return   
if not self.establish(): return   
self.message(150, "ok")   
f = open(newpath, "rb")   
while self.running:   
self.alive\_time = time.time()   
data = f.read(8192)   
if len(data) == 0: break   
self.data\_fd.send(data)   
f.close()   
self.data\_fd.close()   
self.data\_fd = 0   
self.message(226, "ok")   
elif cmd == "STOR" or cmd == "APPE":   
if not can\_write:   
self.message(550, "permission denied.")   
return   
if os.path.exists(newpath) and not can\_modify:   
self.message(550, "permission denied.")   
return   
\# Check space size remained!   
used\_size = 0   
if limit\_size > 0:   
used\_size = self.get\_dir\_size(os.path.dirname(newpath))   
if not self.establish(): return   
self.message(150, "ok")   
f = open(newpath, ("ab" if cmd == "APPE" else "wb") )   
while self.running:   
self.alive\_time = time.time()   
data = self.data\_fd.recv(8192)   
if len(data) == 0: break   
if limit\_size > 0:   
used\_size = used\_size + len(data)   
if used\_size > limit\_size: break   
f.write(data)   
f.close()   
self.data\_fd.close()   
self.data\_fd = 0   
if limit\_size > 0 and used\_size > limit\_size:   
self.message(550, "Exceeding user space limit: " + str(limit\_size) + " bytes")   
else:   
self.message(226, "ok")   
else:   
self.message(500, cmd + " not implemented")   
except:   
self.message(550, "failed.")   
  
def establish(self):   
if self.data\_fd == 0:   
self.message(500, "no data connection")   
return False   
if self.option\_pasv:   
fd = self.data\_fd.accept()\[0\]   
self.data\_fd.close()   
self.data\_fd = fd   
else:   
try:   
self.data\_fd.connect((self.data\_ip, self.data\_port))   
except:   
self.message(500, "failed to establish data connection")   
return False   
return True   
  
def read\_virtual(self, path):   
vdir\_list = \[\]   
path = path + "/.xxftp/virtual"   
if os.path.isfile(path):   
for v in open(path, "r").readlines():   
items = v.split()   
items\[1\] = items\[1\].replace("$root", root\_dir)   
vdir\_list.append(items)   
return vdir\_list   
  
def get\_dir\_size(self, folder):   
size = 0   
for path, dirs, files in os.walk(folder):   
for f in files:   
size += os.path.getsize(os.path.join(path, f))   
return size   
  
def read\_size(self, path):   
size = 0   
path = path + "/.xxftp/size"   
if os.path.isfile(path):   
size = int(open(path, "r").readline())   
return size   
  
def read\_permission(self, path):   
permission = "read,write,modify"   
path = path + "/.xxftp/permission"   
if os.path.isfile(path):   
permission = open(path, "r").readline()   
return permission   
  
def parse\_path(self, path):   
if path == "": path = "."   
if path\[0\] != "/":   
path = self.curr\_dir + "/" + path   
s = os.path.normpath(path).replace("\\\\", "/").split("/")   
local = self.home\_dir   
\# reset directory permission   
vdir\_list = self.read\_virtual(local)   
limit\_size = self.read\_size(local)   
permission = self.read\_permission(local)   
remote = ""   
is\_virtual = False   
for name in s:   
name = name.lstrip(".")   
if name == "": continue   
remote = remote + "/" + name   
is\_virtual = False   
for v in vdir\_list:   
if v\[0\] == name:   
permission = v\[2\]   
local = v\[1\]   
limit\_size = self.read\_size(local)   
is\_virtual = True   
if not is\_virtual: local = local + "/" + name   
vdir\_list = self.read\_virtual(local)   
return (remote, local, permission, vdir\_list, limit\_size, is\_virtual)   
  
def run(self):   
''' Connection Process '''   
try:   
if len(conn\_list) > max\_connections:   
self.message(500, "too many connections!")   
self.fd.close()   
self.running = False   
return   
\# Welcome Message   
if os.path.exists(root\_dir + "/xxftp.welcome"):   
self.message(220, open(root\_dir + "/xxftp.welcome").read())   
else:   
self.message(220, "xxftp(Python) www.xiaoxia.org")   
\# Command Loop   
line = ""   
while self.running:   
data = self.fd.recv(4096)   
if len(data) == 0: break   
line += data   
if line\[-2:\] != "\\r\\n": continue   
line = line\[:-2\]   
space = line.find(" ")   
if space == -1:   
self.process(line, "")   
else:   
self.process(line\[:space\], line\[space+1:\])   
line = ""   
except:   
print "error", sys.exc\_info()   
self.running = False   
self.fd.close()   
print "connection end", self.fd, "user", self.username   
  
def message(self, code, s):   
''' Send Ftp Message '''   
s = str(s).replace("\\r", "")   
ss = s.split("\\n")   
if len(ss) > 1:   
r = (str(code) + "-") + ("\\r\\n" + str(code) + "-").join(ss\[:-1\])   
r += "\\r\\n" + str(code) + " " + ss\[-1\] + "\\r\\n"   
else:   
r = str(code) + " " + ss\[0\] + "\\r\\n"   
if self.option\_utf8:   
r = unicode(r, sys.getfilesystemencoding()).encode("utf8")   
self.fd.send(r)   
  
def server\_listen():   
global conn\_list   
listen\_fd = socket.socket(socket.AF\_INET, socket.SOCK\_STREAM)   
listen\_fd.setsockopt(socket.SOL\_SOCKET, socket.SO\_REUSEADDR, 1)   
listen\_fd.bind((listen\_ip, listen\_port))   
listen\_fd.listen(1024)   
conn\_lock = threading.Lock()   
print "ftpd is listening on ", listen\_ip + ":" + str(listen\_port)   
  
while True:   
conn\_fd, remote\_addr = listen\_fd.accept()   
print "connection from ", remote\_addr, "conn\_list", len(conn\_list)   
conn = FtpConnection(conn\_fd)   
conn.start()   
  
conn\_lock.acquire()   
conn\_list.append(conn)   
\# check timeout   
try:   
curr\_time = time.time()   
for conn in conn\_list:   
if int(curr\_time - conn.alive\_time) > conn\_timeout:   
if conn.running == True:   
conn.fd.shutdown(socket.SHUT\_RDWR)   
conn.running = False   
conn\_list = \[conn for conn in conn\_list if conn.running\]   
except:   
print sys.exc\_info()   
conn\_lock.release()   
  
def main():   
server\_listen()   
  
if \_\_name\_\_ == "\_\_main\_\_":   
main()