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()
