def main(): authorizer = ftpserver.DummyAuthorizer() authorizer.add_user('user', '12345', os.getcwd(), perm='elradfmw') authorizer.add_anonymous(os.getcwd()) dtp_handler = ftpserver.ThrottledDTPHandler dtp_handler.read_limit = 30720 # 30 Kb/sec (30 * 1024) dtp_handler.write_limit = 30720 # 30 Kb/sec (30 * 1024) ftp_handler = ftpserver.FTPHandler ftp_handler.authorizer = authorizer # have the ftp handler use the alternative dtp handler class ftp_handler.dtp_handler = dtp_handler ftpd = ftpserver.FTPServer(('', 21), ftp_handler) ftpd.serve_forever()
def startFTPServer(): """ Starts an FTP server so that the encoders, ui, and server can swap files back and forth """ homeDir = os.path.join(os.path.expanduser("~"), 'master') if not os.path.exists(homeDir): os.makedirs(self.homeDir) print homeDir auth = ftpserver.DummyAuthorizer() auth.add_user(ftp_user, ftp_pass, homeDir, perm='elrwda') handler = ftpserver.FTPHandler handler.authorizer = auth address = ("0.0.0.0", ftp_port) ftpd = ftpserver.FTPServer(address, handler) ftpd.serve_forever()
def main(): global f1, f2 f1 = open('%sftpd.log' % settings.FTP_LOG_DIR, 'a') f2 = open('%sftpd.lines.log' % settings.FTP_LOG_DIR, 'a') ftpserver.log = standard_logger ftpserver.logline = line_logger ftp_handler = ftpserver.FTPHandler ftp_handler.authorizer = PortalAuthorizer() ftp_handler.banner = "UsablePortal FTP Service ready." ftpd = ftpserver.FTPServer((settings.FTP_IP, settings.FTP_PORT), ftp_handler) ftpd.max_cons = 256 ftpd.max_cons_per_ip = 5 ftpd.serve_forever()
def __init__(self, homedir, user=G.FTP_USER, password=G.FTP_PASSWORD, port=G.FTP_PORT, db_host=G.DB_HOST): """ Initialize FTP settings """ logger.debug("* Starting Incoming FTP Server") self.user = user self.password = password # Instantiate a dummy authorizer for managing 'virtual' users authorizer = ftpserver.DummyAuthorizer() # Ensure our root directory exists if not os.path.exists(homedir): os.makedirs(homedir) # create upload directory if it doesn't exist if not os.path.exists(os.path.join(homedir,'upload')): os.makedirs(os.path.join(homedir,'upload')) # Define a new user having full r/w permissions and a read-only # anonymous user authorizer.add_user(user, password=password, homedir=homedir, perm='elradfmw') # Instantiate FTP handler class handler = JobHandler handler.authorizer = authorizer # TODO: check if this works # create connection to our db handler.datastore = DatastoreSamples(db_host) # Define a customized banner (string returned when client connects) handler.banner = "LO-PHI FTP Server at your service!" # Instantiate FTP server class and listen to 0.0.0.0:21 address = ('', port) self.server = ftpserver.FTPServer(address, handler) # set a limit for connections self.server.max_cons = 256 self.server.max_cons_per_ip = 5
def main(): config = _parse_args() port = config['port'] address = ('0.0.0.0', port) basedir = config['basedir'].replace('$LOGINSPECT_HOME', homing.LOGINSPECT_HOME) db_file = os.path.join(basedir, 'checksums.pdict') ftpd = ftpserver.FTPServer( address, lambda conn, server: FTPHandler(conn, server, config, db_file)) make_inet6_compatible(ftpd, port) ftpd.max_cons = 256 ftpd.max_cons_per_ip = 5 ftpd.serve_forever()
def runpool(number_of_processes): # create a single server object -- children will each inherit a copy authorizer = ftpserver.DummyAuthorizer() authorizer.add_user('user', password="******", homedir=os.getcwd() + "/REV", perm='elradfmw') # handler = YourHandler # If we use our logic handler = ftpserver.FTPHandler handler.tcp_no_delay = True handler.authorizer = authorizer address = ('192.168.203.167', 21) server = ftpserver.FTPServer(address, handler) # create child processes to act as workers for i in range(number_of_processes-1): Process(target=serve_forever, args=(server,)).start() # main process also acts as a worker serve_forever(server)
def __init__(self, eframe, ftp_dir): self.__eframe = eframe authorizer = ftpserver.DummyAuthorizer() authorizer.add_user(self.__eframe.ftp_username, self.__eframe.ftp_password, ftp_dir, perm="elr") ftp_handler = EFrameFTPHandler ftp_handler.authorizer = authorizer ftp_handler.abstracted_fs = EFrameAbstractedFS self.__ftpd = ftpserver.FTPServer(("0.0.0.0", self.__eframe.ftp_port), ftp_handler) self.__ftp_thread = threading.Thread(target=self.__ftpd.serve_forever) self.__ftp_thread.setDaemon(True) ftpserver.log = self.nolog ftpserver.logline = self.nolog self.__ftp_thread.start()
def start_server (host, port): def line_logger(msg): if "kill" in msg: raise KeyboardInterrupt() try: from pyftpdlib import ftpserver except ImportError: pytest.skip("pyftpdlib is not available") return authorizer = ftpserver.DummyAuthorizer() datadir = os.path.join(os.path.dirname(__file__), 'data') authorizer.add_anonymous(datadir) # Instantiate FTP handler class ftp_handler = ftpserver.FTPHandler ftp_handler.authorizer = authorizer ftp_handler.timeout = TIMEOUT ftpserver.logline = line_logger # Define a customized banner (string returned when client connects) ftp_handler.banner = "pyftpdlib %s based ftpd ready." % ftpserver.__ver__ # Instantiate FTP server class and listen to host:port address = (host, port) server = ftpserver.FTPServer(address, ftp_handler) port = server.address[1] t = threading.Thread(None, server.serve_forever) t.start() # wait for server to start up tries = 0 while tries < 5: tries += 1 try: ftp = FTP() ftp.connect(host, port, TIMEOUT) ftp.login() ftp.close() break except: time.sleep(0.5) return port
def main(): #config = {'port':221, 'username':'******', 'password':'******', 'permission': 'lr', 'basedir':'c:\\test1\\'} config = _parse_args() config = textual.utf8(config) _prepare_application_directory(config) port = config['port'] address = ('0.0.0.0', port) logging.warn('starting fileinspect ftp server') ftpd = ftpserver.FTPServer( address, lambda conn, server: FTPHandler(conn, server, config)) FTPHandler.use_sendfile = False make_inet6_compatible(ftpd, port) ftpd.max_cons = 256 ftpd.max_cons_per_ip = 5 ftpd.serve_forever()
def main(): parser = create_option_parser(usage='%prog [options]') parser.add_option( "--ftp_host", nargs=1, dest="ftp_host", help= "Server host or IP address to bind on. Only change if running in an isolated network!", default='localhost') parser.add_option("--ftp_port", nargs=1, dest="ftp_port", help="Server port to bind on.", default=2121) options = parser.parse_args()[0] authorizer = ftpserver.DummyAuthorizer() authorizer.add_anonymous('/', perm=('r', 'w')) address = (options.ftp_host, options.ftp_port) if options.ftp_host != 'localhost': import warnings warnings.warn( 'Running aksyftpd on non-local address %s' % options.ftp_host, RuntimeWarning) sampler = Devices.get_instance(options.sampler_type, options.connector) try: ftp_handler = ftpserver.FTPHandler ftp_handler.authorizer = authorizer ftp_handler.banner = "aksyftpd (pyftpd version %s) ready." % ftpserver.__ver__ ftp_handler.abstracted_fs = AksyFtpFS(sampler) ftpd = ftpserver.FTPServer(address, ftp_handler) ftpd.max_cons = 256 ftpd.max_cons_per_ip = ftpd.max_cons ftpd.serve_forever() finally: sampler.close()
def listen(db, config, updater): repo = config["repo"] localfile = get_downloaded_file(db, repo) if localfile: logging.warn("file already downloaded at %r", localfile) return localfile channel = config["upload_channel"] username = channel["username"] password = channel["password"] home = channel["home"].replace("$LOGINSPECT_HOME", homing.LOGINSPECT_HOME).replace("$repo", repo) disk.prepare_path(home + '/') address = ('0.0.0.0', channel["port"]) authorizer = ftpserver.DummyAuthorizer() authorizer.add_user(username, password, home, "elradfmwM") FTPHandler.authorizer = authorizer ftpd = ftpserver.FTPServer(address, lambda conn, server: FTPHandler(conn, server, db, repo)) logging.warn("ftp server starting at %r", address) ftpd.serve_forever() return DOWNLOADED_FILE
def setUp(self): self.port = random.choice(range(9000,11000)) authorizer = ftpserver.DummyAuthorizer() self.dir = tempfile.mkdtemp() self.user = '******' self.password = '******' ftpserver.log = lambda x : None ftpserver.logline = lambda x : None authorizer.add_user(self.user, self.password, self.dir, perm='elradfmw') address = ('127.0.0.1', self.port) ftp_handler = ftpserver.FTPHandler ftp_handler.authorizer = authorizer self.ftpd = ftpserver.FTPServer(address, ftp_handler) class RunServer(Thread): def run(self): try: self.ftpd.serve_forever() except Exception: pass s = RunServer() s.ftpd = self.ftpd s.start()
def __init__(self): object.__init__(self) from optparse import OptionParser parser = OptionParser() parser.add_option("--secure", default=False, action="store_true", help="Require explicit TLS on command and data connections") parser.add_option("--port", default=1337, action="store", type="int", help="Set the {0} FTP port".format(self.__program__)) options, posargs = parser.parse_args() #print options, posargs from config import Config config = Config() from pyftpdlib import ftpserver if options.secure: from pyftpdlib.contrib.handlers import TLS_FTPHandler as handler handler.tls_control_required = True handler.certfile = "wotevs.pem" else: handler = ftpserver.FTPHandler handler.banner = "{0} ready".format(self.__title__) from filesys import LanshareFS LanshareFS.shares = config.shares handler.abstracted_fs = LanshareFS authorizer = ftpserver.DummyAuthorizer() authorizer.add_anonymous(homedir=None) handler.authorizer = authorizer import socket server = ftpserver.FTPServer(("0.0.0.0", options.port), handler) print "FTP server listening on {0}".format(server.socket.getsockname()) self.server = server self.config = config self.port = options.port
parser_name = profile.get("parser") charset = profile.get("charset") parser = None if parser_name: try: parser = GetParser(parser_name, sid, charset, profile.get("regex_pattern"), profile.get("regexparser_name")) except InvalidParserException, err: logging.warn(err) profile["parser"] = parser outself.handle_file_received(localfile, profile) ftpd = ftpserver.FTPServer(address, lambda conn, server: FTPHandler(conn, server, outself.__config, db_file, outself.__ftp_parser_name_only)) outself.make_inet6_compatible(ftpd, outself.__ftp_port) ftpd.max_cons = 256 ftpd.max_cons_per_ip = 5 ftpd.serve_forever() """ Turn flags on to start desired servers """ def turn_tcp_server_on(self): self.__tcp_server_on = True def turn_tcp_ssl_server_on(self): self.__tcp_ssl_server_on = True
return True except pywintypes.error: return False def impersonate_user(self, username, password): if (username == "anonymous") and self.has_user('anonymous'): username = self.anon_user password = self.anon_pwd handler = win32security.LogonUser(username, None, password, win32con.LOGON32_LOGON_INTERACTIVE, win32con.LOGON32_PROVIDER_DEFAULT) win32security.ImpersonateLoggedOnUser(handler) handler.Close() def terminate_impersonation(self): win32security.RevertToSelf() if __name__ == "__main__": authorizer = WinNtAuthorizer() # add a user (note: user must already exists) authorizer.add_user('user', perm='elradfmw') # add an anonymous user using Guest account to handle the anonymous # sessions (note: Guest must be enabled first) authorizer.add_anonymous(os.getcwd()) ftp_handler = ftpserver.FTPHandler ftp_handler.authorizer = authorizer address = ('', 21) ftpd = ftpserver.FTPServer(address, ftp_handler) ftpd.serve_forever()
def unsleep(): self._sleeping = False self._sleeping = True self._throttler = ftpserver.CallLater(sleepfor * 2, unsleep) self._timenext = now + 1 def close(self): if self._throttler is not None and not self._throttler.cancelled: self._throttler.cancel() ftpserver.DTPHandler.close(self) if __name__ == '__main__': authorizer = ftpserver.DummyAuthorizer() authorizer.add_user('user', '12345', os.getcwd(), perm='elradfmw') authorizer.add_anonymous(os.getcwd()) # use the modified DTPHandler class and set a speed limit for both # sending and receiving dtp_handler = ThrottledDTPHandler dtp_handler.read_limit = 30072 # 30 Kb/sec (30 * 1024) dtp_handler.write_limit = 30072 # 30 Kb/sec (30 * 1024) ftp_handler = ftpserver.FTPHandler ftp_handler.authorizer = authorizer # have the ftp handler use the different dtp handler ftp_handler.dtp_handler = dtp_handler ftpd = ftpserver.FTPServer(('', 21), ftp_handler) ftpd.serve_forever()
#------------------------------------------------------------------------------- # Name: myFTPServer # # Author: lkumaresan # # Created: 09/11/2010 # Copyright: (c) lkumaresan 2010 # Licence: Personal # # Description: # # My Simple FTP Server (Not CLIENT its SERVER) to server files. with user authentication. # #------------------------------------------------------------------------------- #!/usr/bin/env python from pyftpdlib import ftpserver auth = ftpserver.DummyAuthorizer() auth.add_user('user1', 'root', '/', perm='elradfmw') hdl = ftpserver.FTPHandler hdl.authorizer = auth address = ('192.168.1.2', 21) ftpd = ftpserver.FTPServer(address, hdl) ftpd.serve_forever()
def main(): ftp_handler = ftpserver.FTPHandler ftp_handler.authorizer = PortalAuthorizer() ftpd = ftpserver.FTPServer((settings.FTP_IP, settings.FTP_PORT), ftp_handler) ftpd.serve_forever()