def run():
portal = Portal(
FTPRealm('/opt/ffp2/ftp'),
[AllowAnonymousAccess(), CertPasswordDB()])
reactor.listenTCP(2121, CertFTPFactory(fn_uploaded,
portal)) #@UndefinedVariable
reactor.run() # @UndefinedVariable
def launch_server(args):
ftproot_directory = args.root
config = args.auth
if args.verbose:
print(f"[*] Setting ftproot to {ftproot_directory}")
print(f"[*] Setting FilePasswordDB to {config}")
while True:
try:
users = {'offsec': 'offsec'}
if args.verbose:
print(f"[*] Crafting twisted ftp realm")
p = Portal(
FTPRealm(ftproot_directory),
#[AllowAnonymousAccess(), FilePasswordDB(config)]
[AllowAnonymousAccess(),
InMemoryDB(**users)])
if args.verbose:
print(f"[*] Crafting FTPFactory from realm")
f = FTPFactory(p)
if args.verbose:
iface = "all" if args.address == "" else args.address
print(
f"[*] Spawning Twisted reactor and binding to TCP socket {iface}:{args.port}"
)
reactor.listenTCP(args.port, f, interface=args.address)
reactor.run()
except KeyboardInterrupt:
break
def getService(self):
p = Portal(FTPRealm(FTP_PATH), [DenyAllAccess()])
f = FTPFactory(p)
f.protocol = LoggingFTP
f.welcomeMessage = self.banner
f.canaryservice = self
return internet.TCPServer(self.port, f, interface=self.listen_addr)
def setUp(self):
from twisted.protocols.ftp import FTPRealm, FTPFactory
from scrapy.core.downloader.handlers.ftp import FTPDownloadHandler
# setup dir and test file
self.directory = self.mktemp()
os.mkdir(self.directory)
fp = FilePath(self.directory)
fp.child('file.txt').setContent(b"I have the power!")
fp.child('file with spaces.txt').setContent(b"Moooooooooo power!")
# setup server for anonymous access
realm = FTPRealm(anonymousRoot=self.directory)
p = portal.Portal(realm)
p.registerChecker(checkers.AllowAnonymousAccess(),
credentials.IAnonymous)
self.factory = FTPFactory(portal=p, userAnonymous=self.username)
self.port = reactor.listenTCP(0, self.factory, interface="127.0.0.1")
self.portNum = self.port.getHost().port
crawler = get_crawler()
self.download_handler = create_instance(FTPDownloadHandler,
crawler.settings, crawler)
self.addCleanup(self.port.stopListening)
def setUp(self):
from twisted.protocols.ftp import FTPRealm, FTPFactory
from scrapy.core.downloader.handlers.ftp import FTPDownloadHandler
# setup dirs and test file
self.directory = self.mktemp()
os.mkdir(self.directory)
userdir = os.path.join(self.directory, self.username)
os.mkdir(userdir)
fp = FilePath(userdir)
fp.child('file.txt').setContent(b"I have the power!")
fp.child('file with spaces.txt').setContent(b"Moooooooooo power!")
# setup server
realm = FTPRealm(anonymousRoot=self.directory, userHome=self.directory)
p = portal.Portal(realm)
users_checker = checkers.InMemoryUsernamePasswordDatabaseDontUse()
users_checker.addUser(self.username, self.password)
p.registerChecker(users_checker, credentials.IUsernamePassword)
self.factory = FTPFactory(portal=p)
self.port = reactor.listenTCP(0, self.factory, interface="127.0.0.1")
self.portNum = self.port.getHost().port
crawler = get_crawler()
self.download_handler = create_instance(FTPDownloadHandler,
crawler.settings, crawler)
self.addCleanup(self.port.stopListening)
def run():
portal = Portal(
FTPRealm('/home/kyi/delete'),
[AllowAnonymousAccess(), CertPasswordDB()])
reactor.listenTCP(CERT_FTP_PORT,
CertFTPFactory(self.fn_uploaded,
portal)) #@UndefinedVariable
reactor.run() # @UndefinedVariable
def __init__(self, service):
self.service = service
self.FDB = FolderDB()
p = Portal(FTPRealm("", "JobLocation"),
[self.FDB])
FTPFactory.__init__(self, p)
def start(self):
"""
Starts the server.
:return: None
"""
if self.__path is None:
raise AttributeError("The server's root path cannot be None")
p = Portal(FTPRealm(self.__path),
[AllowAnonymousAccess(), FilePasswordDB("pass.dat")])
f = FTPFactory(p)
self.__server = reactor.listenTCP(self.__port, f)
def start():
game = Game()
# Game event server
endpoints.serverFromString(reactor, "tcp:10000").listen(GameFactory(game))
loop = task.LoopingCall(game.loop)
loop.start(0.05)
# Game data server
client_resources = '/tmp/pub/'
p = Portal(FTPRealm(client_resources), [AllowAnonymousAccess()])
f = FTPFactory(p)
reactor.listenTCP(10001, f)
reactor.run()
def startService(self):
log.msg("Starting %s service .." % self.SERVICENAME)
p = Portal(FTPRealm(anonymousRoot='/dev/null', userHome=self.homedir),
[FtpUserDb(self)])
f = CustomFTPFactory(p)
f.allowAnonymous = False
f.passivePortRange = xrange(self.passivePortStart,
self.passivePortEnd + 1)
f.welcomeMessage = "crossbar.io FTP at your service."
f.passivePublicIp = self.passivePublicIp
self.listener = self.reactor.listenTCP(self.port, f)
self.isRunning = True
log.msg(
"embedded FTP server running on port %d (passive FTP ports %d - %d, homedir %s)"
% (self.port, self.passivePortStart, self.passivePortEnd,
self.homedir))
def setUp(self):
# setup dirs and test file
self.directory = self.mktemp()
os.mkdir(self.directory)
userdir = os.path.join(self.directory, self.username)
os.mkdir(userdir)
FilePath(userdir).child('file.txt').setContent("I have the power!")
# setup server
realm = FTPRealm(anonymousRoot=self.directory, userHome=self.directory)
p = portal.Portal(realm)
users_checker = checkers.InMemoryUsernamePasswordDatabaseDontUse()
users_checker.addUser(self.username, self.password)
p.registerChecker(users_checker, credentials.IUsernamePassword)
self.factory = FTPFactory(portal=p)
self.port = reactor.listenTCP(0, self.factory, interface="127.0.0.1")
self.portNum = self.port.getHost().port
self.download_handler = FTPDownloadHandler(Settings())
self.addCleanup(self.port.stopListening)
def init(ftp_port=None):
global _FTPServer
lg.out(4, 'ftp_server.init')
if _FTPServer:
lg.warn('already started')
return
if not ftp_port:
ftp_port = settings.getFTPServerPort()
if not os.path.isfile(settings.FTPServerCredentialsFile()):
bpio.WriteTextFile(settings.FTPServerCredentialsFile(),
'bitdust:bitdust')
# TODO: add protection: accept connections only from local host: 127.0.0.1
_FTPServer = reactor.listenTCP(
ftp_port,
BitDustFTPFactory(
Portal(FTPRealm('./'), [
AllowAnonymousAccess(),
FilePasswordDB(settings.FTPServerCredentialsFile()),
]), ))
lg.out(4, ' started on port %d' % ftp_port)
#!/usr/bin/env python2
from __future__ import print_function, division, absolute_import
# Import twisted things
from twisted.protocols.ftp import FTPFactory
from twisted.protocols.ftp import FTP
from twisted.protocols.ftp import FTPRealm
from twisted.protocols.policies import TimeoutMixin, ThrottlingFactory, WrappingFactory, ThrottlingProtocol
from twisted.internet import reactor
from twisted.cred.portal import Portal
from twisted.cred.checkers import AllowAnonymousAccess
p = Portal(FTPRealm("."), [AllowAnonymousAccess()])
#f = ThrottlingFactory(FTPFactory, readLimit=1000, writeLimit=1000)
#p = Tho(p)
f = FTPFactory(p)
#factory = FTPFactory()
#wrapper = ThrottlingFactory(FTPFactory(p), readLimit=1, writeLimit=1)
#f = f.wrappedFactory(p)
f.timeOut = None
#f = ThrottlingFactory(f, readLimit=1, writeLimit=1)
#f = FileServerFactory()
reactor.listenTCP(5504, f)
reactor.run()
# access to anonymous users and is relatively simple; the second is a very
# primitive password checker. This example uses a plain text password file
# that has one username:password pair per line. This checker *does* provide
# a hashing interface, and one would normally want to use it instead of
# plain text storage for anything remotely resembling a 'live' network. In
# this case, the file "pass.dat" is used, and stored in the same directory
# as the server. BAD.
#
# Create a pass.dat file which looks like this:
#
# =====================
# jeff:bozo
# grimmtooth:bozo2
# =====================
#
p = Portal(FTPRealm("./"), [AllowAnonymousAccess(), FilePasswordDB("pass.dat")])
#
# Once the portal is set up, start up the FTPFactory and pass the portal to
# it on startup. FTPFactory will start up a twisted.protocols.ftp.FTP()
# handler for each incoming OPEN request. Business as usual in Twisted land.
#
f = FTPFactory(p)
#
# You know this part. Point the reactor to port 21 coupled with the above factory,
# and start the event loop.
#
reactor.listenTCP(21, f)
reactor.run()
def start_ftp_server(rootdir):
p = Portal(FTPRealm(rootdir), [AllowAnonymousAccess()])
f = FTPFactory(p)
reactor.listenTCP(2022, f)
#!/usr/bin/env python2
from __future__ import absolute_import, division, print_function
from os.path import isdir
from twisted.cred.checkers import AllowAnonymousAccess
from twisted.cred.portal import Portal
from twisted.internet import reactor
# ftp server imports
from twisted.protocols.ftp import FTPFactory, FTPRealm
from evora.common import netconsts
# TODO: this needs to be specified some other way
# Does not exist on non-observatory computers
data_path = "/home/mro/storage/evora_data/"
if isdir(data_path):
p = Portal(FTPRealm(data_path), [AllowAnonymousAccess()])
f = FTPFactory(p)
f.timeOut = None
reactor.listenTCP(netconsts.FTP_TRANSFER_PORT, f)
else:
print("[ftp_server.py] Directory at '" + data_path +
"' does not exist, exiting...")
quit()
reactor.run()
def __init__( self, anonymousRoot, userHome="/home", callback=None ):
FTPRealm.__init__( self, anonymousRoot, userHome=userHome )
self.callback = callback
