| 1 |
import os |
| 2 |
import re |
| 3 |
import threading |
| 4 |
import socket |
| 5 |
import pyftpdlib.__main__ |
| 6 |
from pyftpdlib.ioloop import IOLoop |
| 7 |
import pyftpdlib.handlers as Handle |
| 8 |
from pyftpdlib.servers import FTPServer |
| 9 |
from pyftpdlib.authorizers import DummyAuthorizer |
| 10 |
from pyftpdlib._compat import PY3, u, b, getcwdu, callable |
| 11 |
|
| 12 |
class FTPDHandler (Handle.FTPHandler): |
| 13 |
|
| 14 |
def ftp_LIST (self, path): |
| 15 |
try: |
| 16 |
iterator = self.run_as_current_user(self.fs.get_list_dir, path) |
| 17 |
except (OSError, FilesystemError): |
| 18 |
err = sys.exc_info()[1] |
| 19 |
why = _strerror (err) |
| 20 |
self.respond ('550 %s. ' % why) |
| 21 |
else: |
| 22 |
if self.isRule ("Bad List") is True: |
| 23 |
iter_list = list () |
| 24 |
for flist in iterator: |
| 25 |
line = re.compile (r'(\s+)').split (flist.decode ('utf-8')) |
| 26 |
line[8] = '0' |
| 27 |
iter_l = ''.join (line).encode ('utf-8') |
| 28 |
iter_list.append (iter_l) |
| 29 |
iterator = (n for n in iter_list) |
| 30 |
producer = Handle.BufferedIteratorProducer (iterator) |
| 31 |
self.push_dtp_data (producer, isproducer=True, cmd="LIST") |
| 32 |
return path |
| 33 |
|
| 34 |
def ftp_PASV (self, line): |
| 35 |
if self._epsvall: |
| 36 |
self.respond ("501 PASV not allowed after EPSV ALL.") |
| 37 |
return |
| 38 |
self._make_epasv(extmode=False) |
| 39 |
if self.isRule ("FailPASV") is True: |
| 40 |
del self.server.global_rules["FailPASV"] |
| 41 |
self.socket.close () |
| 42 |
|
| 43 |
def isRule (self, rule): |
| 44 |
rule_obj = self.server.global_rules[rule] |
| 45 |
return False if not rule_obj else rule_obj[0] |
| 46 |
|
| 47 |
class FTPDServer (FTPServer): |
| 48 |
|
| 49 |
def set_global_rules (self, rules): |
| 50 |
self.global_rules = rules |
| 51 |
|
| 52 |
class FTPd(threading.Thread): |
| 53 |
"""A threaded FTP server used for running tests. |
| 54 |
|
| 55 |
This is basically a modified version of the FTPServer class which |
| 56 |
wraps the polling loop into a thread. |
| 57 |
|
| 58 |
The instance returned can be used to start(), stop() and |
| 59 |
eventually re-start() the server. |
| 60 |
""" |
| 61 |
handler = FTPDHandler |
| 62 |
server_class = FTPDServer |
| 63 |
|
| 64 |
def __init__(self, addr=None): |
| 65 |
os.mkdir ('server') |
| 66 |
os.chdir ('server') |
| 67 |
try: |
| 68 |
HOST = socket.gethostbyname ('localhost') |
| 69 |
except socket.error: |
| 70 |
HOST = 'localhost' |
| 71 |
USER = 'user' |
| 72 |
PASSWD = '12345' |
| 73 |
HOME = getcwdu () |
| 74 |
|
| 75 |
threading.Thread.__init__(self) |
| 76 |
self.__serving = False |
| 77 |
self.__stopped = False |
| 78 |
self.__lock = threading.Lock() |
| 79 |
self.__flag = threading.Event() |
| 80 |
if addr is None: |
| 81 |
addr = (HOST, 0) |
| 82 |
|
| 83 |
authorizer = DummyAuthorizer() |
| 84 |
authorizer.add_user(USER, PASSWD, HOME, perm='elradfmwM') # full perms |
| 85 |
authorizer.add_anonymous(HOME) |
| 86 |
self.handler.authorizer = authorizer |
| 87 |
# lowering buffer sizes = more cycles to transfer data |
| 88 |
# = less false positive test failures |
| 89 |
self.handler.dtp_handler.ac_in_buffer_size = 32768 |
| 90 |
self.handler.dtp_handler.ac_out_buffer_size = 32768 |
| 91 |
self.server = self.server_class(addr, self.handler) |
| 92 |
self.host, self.port = self.server.socket.getsockname()[:2] |
| 93 |
os.chdir ('..') |
| 94 |
|
| 95 |
def set_global_rules (self, rules): |
| 96 |
self.server.set_global_rules (rules) |
| 97 |
|
| 98 |
def __repr__(self): |
| 99 |
status = [self.__class__.__module__ + "." + self.__class__.__name__] |
| 100 |
if self.__serving: |
| 101 |
status.append('active') |
| 102 |
else: |
| 103 |
status.append('inactive') |
| 104 |
status.append('%s:%s' % self.server.socket.getsockname()[:2]) |
| 105 |
return '<%s at %#x>' % (' '.join(status), id(self)) |
| 106 |
|
| 107 |
@property |
| 108 |
def running(self): |
| 109 |
return self.__serving |
| 110 |
|
| 111 |
def start(self, timeout=0.001): |
| 112 |
"""Start serving until an explicit stop() request. |
| 113 |
Polls for shutdown every 'timeout' seconds. |
| 114 |
""" |
| 115 |
if self.__serving: |
| 116 |
raise RuntimeError("Server already started") |
| 117 |
if self.__stopped: |
| 118 |
# ensure the server can be started again |
| 119 |
FTPd.__init__(self, self.server.socket.getsockname(), self.handler) |
| 120 |
self.__timeout = timeout |
| 121 |
threading.Thread.start(self) |
| 122 |
self.__flag.wait() |
| 123 |
|
| 124 |
def run(self): |
| 125 |
self.__serving = True |
| 126 |
self.__flag.set() |
| 127 |
while self.__serving: |
| 128 |
self.__lock.acquire() |
| 129 |
self.server.serve_forever(timeout=self.__timeout, blocking=False) |
| 130 |
self.__lock.release() |
| 131 |
self.server.close_all() |
| 132 |
|
| 133 |
def stop(self): |
| 134 |
"""Stop serving (also disconnecting all currently connected |
| 135 |
clients) by telling the serve_forever() loop to stop and |
| 136 |
waits until it does. |
| 137 |
""" |
| 138 |
if not self.__serving: |
| 139 |
raise RuntimeError("Server not started yet") |
| 140 |
self.__serving = False |
| 141 |
self.__stopped = True |
| 142 |
self.join() |
| 143 |
|
| 144 |
|
| 145 |
def mk_file_sys (file_list): |
| 146 |
os.chdir ('server') |
| 147 |
for name, content in file_list.items (): |
| 148 |
file_h = open (name, 'w') |
| 149 |
file_h.write (content) |
| 150 |
file_h.close () |
| 151 |
os.chdir ('..') |
| 152 |
|
| 153 |
def filesys (): |
| 154 |
fileSys = dict () |
| 155 |
os.chdir ('server') |
| 156 |
for parent, dirs, files in os.walk ('.'): |
| 157 |
for filename in files: |
| 158 |
file_handle = open (filename, 'r') |
| 159 |
file_content = file_handle.read () |
| 160 |
fileSys[filename] = file_content |
| 161 |
os.chdir ('..') |
| 162 |
return fileSys |