def __init__(self, no_introspection=False):
if sys.version_info[:2] < (2, 5):
SimpleXMLRPCDispatcher.__init__(self)
else:
SimpleXMLRPCDispatcher.__init__(self, False, 'utf-8')
if not no_introspection:
self.register_introspection_functions()
def __init__(self, path):
path = to_unicode(path)
SimpleXMLRPCDispatcher.__init__(self, True, 'utf-8')
self.register_introspection_functions()
self.register_multicall_functions()
self.instance = self.instance_class(path)
self.path = path
def __init__(self):
#: Python 2.5 requires some arguments like `allow_none`
#: and the encoding. Python 2.4 and 2.3 doesn't.
if sys.version_info[:2] < (2, 5):
SimpleXMLRPCDispatcher.__init__(self)
else:
SimpleXMLRPCDispatcher.__init__(self, True, 'utf-8')
def __init__(self, requestHandler, logRequests=True, allow_none=False,
encoding=None):
self.logRequests = logRequests
SimpleXMLRPCDispatcher.__init__(self, allow_none=allow_none,
encoding=encoding)
ConnectedTCPServer.__init__(self, requestHandler)
def __init__(self, allow_none=False, encoding=None):
try:
SimpleXMLRPCDispatcher.__init__(self, allow_none, encoding)
except TypeError:
# see http://bugs.debian.org/470645
# python2.4 and before only took one argument
SimpleXMLRPCDispatcher.__init__(self)
def __init__(self, registerInstance, server_address, keyFile=DEFAULTKEYFILE,
certFile=DEFAULTCERTFILE, caFile = DEFAULTCAFILE, logRequests=True):
"""Secure Documenting XML-RPC server.
It it very similar to DocXMLRPCServer but it uses HTTPS for transporting XML data.
"""
SimpleXMLRPCServer.__init__(self, server_address, SecureXMLRPCRequestHandler, logRequests)
self.logRequests = logRequests
self.register_introspection_functions()
# init stuff, handle different versions:
try:
SimpleXMLRPCDispatcher.__init__(self)
except TypeError:
# An exception is raised in Python 2.5 as the prototype of the __init__
# method has changed and now has 3 arguments (self, allow_none, encoding)
SimpleXMLRPCDispatcher.__init__(self, False, None)
SocketServer.BaseServer.__init__(self, server_address, SecureXMLRPCRequestHandler)
self.register_instance(registerInstance) # for some reason, have to register instance down here!
# SSL socket stuff
ctx = SSL.Context(SSL.SSLv23_METHOD)
ctx.use_privatekey_file(keyFile)
ctx.use_certificate_file(certFile)
# verify
ctx.load_verify_locations(caFile)
ctx.set_verify(SSL.VERIFY_PEER|SSL.VERIFY_FAIL_IF_NO_PEER_CERT, self._verify)
self.socket = SSL.Connection(ctx, socket.socket(self.address_family, self.socket_type))
self.server_bind()
self.server_activate()
# requests count and condition, to allow for keyboard quit via CTL-C
self.requests = 0
self.rCondition = Condition()
def __init__(self,application, request, transforms=None): tornado.web.RequestHandler.__init__(self,application, request, transforms) SimpleXMLRPCDispatcher.__init__(self,True,None) self.register_multicall_functions() self.register_methods()
def __init__(self, clientHost, clientPort):
SimpleXMLRPCDispatcher.__init__(self)
ThreadingTCPServer.__init__(self,
(clientHost, clientPort),
SimpleXMLRPCRequestHandler)
self.logRequests = 1
self.client = AdminControlInterface()
self.register_introspection_functions()
self.register_instance(self.client)
def __init__(self, addr, requestHandler=RequestHandler):
self.logRequests = 0
if os.path.exists(addr):
os.unlink(addr)
dir = os.path.dirname(addr)
if not(os.path.exists(dir)):
os.makedirs(dir)
SimpleXMLRPCDispatcher.__init__(self)
UnixStreamServer.__init__(self, addr, requestHandler)
def __init__(self, addr, requestHandler=DroidPresRequestHandler, logRequests=False, allow_none=False, encoding=None, bind_and_activate=True):
self.logRequests = logRequests
SimpleXMLRPCDispatcher.__init__(self, allow_none, encoding)
ThreadingTCPServer.__init__(self, addr, requestHandler, bind_and_activate)
if fcntl is not None and hasattr(fcntl, 'FD_CLOEXEC'):
flags = fcntl.fcntl(self.fileno(), fcntl.F_GETFD)
flags |= fcntl.FD_CLOEXEC
fcntl.fcntl(self.fileno(), fcntl.F_SETFD, flags)
def __init__(self, requestHandler=IPXMLRPCRequestHandler,
logRequests=False, allow_none=False, encoding=None):
SimpleXMLRPCDispatcher.__init__(self, allow_none=allow_none,
encoding=encoding)
self.requestHandler = requestHandler
self.logRequests = logRequests
# TODO provide proper limit for this queue
self.queue = TaskQueue(sys.maxint)
def __init__(self, allow_none=True, encoding=None):
if sys.version_info[:2] == (2, 4):
# doesn't support extra args in python 2.4
SimpleXMLRPCDispatcher.__init__(self)
else:
SimpleXMLRPCDispatcher.__init__(self, allow_none, encoding)
self.allow_none = allow_none
self.encoding = encoding
self.register_multicall_functions()
def __init__(self):
try:
# older Pythons like 2.4.3 demand a single parameter
# newest Python versions handle 1, 2 or 3 parameters
# supplying defaults for the 2nd and 3rd
SimpleXMLRPCDispatcher.__init__(self)
except:
# some mid-age Python versions demand 3 parameters without
# offering default values for the 2nd and 3rd
SimpleXMLRPCDispatcher.__init__(self, False, None)
def __init__(self, apis):
SimpleXMLRPCDispatcher.__init__(self, True, 'utf-8')
funcs = {}
for api in apis:
prefix = api.prefix
for attr_name in dir(api):
attr = getattr(api, attr_name)
if callable(attr):
funcs[prefix + attr_name] = attr
self.funcs = funcs
self.register_introspection_functions()
def __init__(self, addr, requestHandler,
logRequests, allow_none, encoding, bind_and_activate):
self.logRequests = logRequests
SimpleXMLRPCDispatcher.__init__(self, allow_none, encoding)
ForkingTCPServer.__init__(self, addr, requestHandler, bind_and_activate)
if fcntl is not None and hasattr(fcntl, 'FD_COLEXEC'):
flags = fcntl.fcntl(self.fileno(), fcntl.F_GETFD)
flags |= fcntl.FD_COLEXEC
fcntl.fcntl(self.fileno(), fcntl.F_SETFD, flags)
def __init__(self, host, port):
"""create a XML-RPC server
Takes two initial inputs:
host -- hostname of XML-RPC server host
port -- port number for server requests
"""
Server.__init__(self)
SimpleXMLRPCDispatcher.__init__(self, allow_none=False, encoding=None)
self._installSocket(host, port)
self._activeProcesses = {} # { fd : pid }
def __init__(self):
SimpleXMLRPCDispatcher.__init__(self, True, 'utf-8')
self.register_function(list_packages)
self.register_function(package_releases)
self.register_function(release_urls)
self.register_function(release_urls, name='package_urls') # Deprecated
self.register_function(release_data)
self.register_function(release_data, name='package_data') # Deprecated
self.register_function(search)
self.register_function(updated_releases)
self.register_function(changelog)
self.register_function(post_cheesecake_for_release)
self.register_introspection_functions()
self.register_multicall_functions()
def __init__(self):
SimpleXMLRPCDispatcher.__init__(self, allow_none=False,
encoding=None)
XMLRPCDocGenerator.__init__(self)
def _dumps(obj, *args, **kwargs):
kwargs['allow_none'] = self.allow_none
kwargs['encoding'] = self.encoding
return xmlrpclib.dumps(obj, *args, **kwargs)
self.dumps = _dumps
# map of name => (auth, func)
self.func_map = {}
def __init__(self, addr, requestHandler=SimpleXMLRPCRequestHandler,
logRequests=True, allow_none=False, encoding=None, bind_and_activate=True):
self.logRequests = logRequests
SimpleXMLRPCDispatcher.__init__(self, allow_none, encoding)
ThreadingTCPServer.__init__(self, addr, requestHandler, bind_and_activate)
# [Bug #1222790] If possible, set close-on-exec flag; if a
# method spawns a subprocess, the subprocess shouldn't have
# the listening socket open.
if fcntl is not None and hasattr(fcntl, 'FD_CLOEXEC'):
flags = fcntl.fcntl(self.fileno(), fcntl.F_GETFD)
flags |= fcntl.FD_CLOEXEC
fcntl.fcntl(self.fileno(), fcntl.F_SETFD, flags)
def __init__(self, server_address, requestHandler, keyfile, certfile, logRequests=True, allow_none=False):
"""Secure XML-RPC server.
It it very similar to SimpleXMLRPCServer but it uses HTTPS for transporting XML data.
"""
self.logRequests = logRequests
SimpleXMLRPCDispatcher.__init__(self, allow_none=allow_none)
SocketServer.BaseServer.__init__(self, server_address, requestHandler)
ctx = SSL.Context(SSL.SSLv23_METHOD)
ctx.use_privatekey_file(keyfile)
ctx.use_certificate_file(certfile)
self.socket = SSL.Connection(ctx, socket.socket(self.address_family, self.socket_type))
self.server_bind()
self.server_activate()
def __init__(self, addr, KEYFILE, CERTFILE):
SimpleXMLRPCDispatcher.__init__(self)
VerifyingServer.__init__(self, addr)
self.socket = ssl.wrap_socket(
socket.socket(self.address_family, self.socket_type),
server_side=True,
keyfile=KEYFILE,
certfile=CERTFILE,
cert_reqs=ssl.CERT_NONE,
ssl_version=ssl.PROTOCOL_SSLv23,
)
self.server_bind()
self.server_activate()
def __init__ (self, ) :
SimpleXMLRPCDispatcher.__init__(self, True, "utf-8", )
#self.register_function(self._list_packages)
#self.register_function(self._package_releases, )
#self.register_function(self._release_urls)
#self.register_function(self._release_urls, name="package_urls") # Deprecated
#self.register_function(self._release_data)
#self.register_function(self._release_data, name="package_data") # Deprecated
self.register_function(self._search, name="search", )
#self.register_function(self._updated_releases)
#self.register_function(self._changelog)
#self.register_function(self._changed_packages)
#self.register_function(self._post_cheesecake_for_release)
self.register_introspection_functions()
self.register_multicall_functions()
def __init__(self):
if sys.version_info[:3] >= (2,5,):
SimpleXMLRPCDispatcher.__init__(self, allow_none=False,
encoding=None)
def _dumps(obj, *args, **kwargs):
kwargs['allow_none'] = self.allow_none
kwargs['encoding'] = self.encoding
return xmlrpclib.dumps(obj, *args, **kwargs)
else:
def _dumps(obj, *args, **kwargs):
return xmlrpclib.dumps(obj, *args, **kwargs)
SimpleXMLRPCDispatcher.__init__(self)
self.dumps = _dumps
# map of name => (auth, func)
self.func_map = {}
def __init__(self, addr, logger, allow_none=False, logRequests=1,
encoding='iso-8859-1'):
class AuthenticatedRequestHandler(SimpleXMLRPCRequestHandler):
def parse_request(myself):
if SimpleXMLRPCRequestHandler.parse_request(myself):
header = myself.headers.get('Authorization')
if header == None:
username = None
password = None
else:
(basic, encoded) = \
header.split(' ', 2)
assert basic == 'Basic', 'Only basic authentication supported'
(username,
password) = base64.b64decode(encoded).split(':', 2)
if self.authenticate(username, password):
return True
else:
myself.send_response(401, 'Authentication failed')
myself.send_header('WWW-Authenticate',
'Basic realm="XML-RPC"')
myself.end_headers()
myself.wfile.write('Authentication failed.')
return False
self.logRequests = logRequests
if sys.version_info[:2] < (2, 5):
SimpleXMLRPCDispatcher.__init__(self)
else:
SimpleXMLRPCDispatcher.__init__(self, allow_none=allow_none,
encoding=encoding)
ThreadingTCPServer.__init__(self, addr, AuthenticatedRequestHandler)
self.required_username = None
self.required_password = None
self.logger = logger
def __init__(self, server_address,
keyfile, certfile, ssl_version=ssl.PROTOCOL_TLSv1,
requestHandler=SimpleXMLRPCRequestHandler,
logRequests=True, allow_none=False, encoding=None,
bind_and_activate=True):
self.logRequests = logRequests
self.keyfile = keyfile
self.certfile = certfile
self.ssl_version = ssl_version
SimpleXMLRPCDispatcher.__init__(self, allow_none, encoding)
TCPServer.__init__(
self, server_address, requestHandler, bind_and_activate)
if fcntl is not None and hasattr(fcntl, 'FD_CLOEXEC'):
flags = fcntl.fcntl(self.fileno(), fcntl.F_GETFD)
flags |= fcntl.FD_CLOEXEC
fcntl.fcntl(self.fileno(), fcntl.F_SETFD, flags)
def __init__(self, server_address,
requestHandler=UnixStreamSimpleXMLRPCRequestHandler,
allow_none=False, encoding=None, bind_and_activate=True):
# cleanup leftover address
if not server_address.startswith('\x00'):
try:
os.unlink(server_address)
except OSError:
if os.path.exists(server_address):
raise
# logging fails with UnixStreamServer
self.logRequests = True
SimpleXMLRPCDispatcher.__init__(self, allow_none, encoding)
UnixStreamServer.__init__(
self, server_address, requestHandler, bind_and_activate)
if fcntl is not None and hasattr(fcntl, 'FD_CLOEXEC'):
flags = fcntl.fcntl(self.fileno(), fcntl.F_GETFD)
flags |= fcntl.FD_CLOEXEC
fcntl.fcntl(self.fileno(), fcntl.F_SETFD, flags)
def __init__(self):
SimpleXMLRPCDispatcher.__init__(self, True, 'utf-8')
self.register_function(list_packages)
self.register_function(package_releases)
self.register_function(release_urls)
self.register_function(release_urls, name='package_urls') # Deprecated
self.register_function(release_data)
self.register_function(release_data, name='package_data') # Deprecated
self.register_function(search)
self.register_function(browse)
self.register_function(updated_releases)
self.register_function(changelog)
self.register_function(changelog_last_serial)
self.register_function(changelog_since_serial)
self.register_function(changed_packages)
self.register_function(post_cheesecake_for_release)
self.register_function(release_downloads)
self.register_function(package_roles)
self.register_function(user_packages)
self.register_function(package_hosting_mode)
self.register_function(top_packages)
self.register_function(list_packages_with_serial)
self.register_introspection_functions()
self.register_multicall_functions()
def __init__(self, funcs):
# "UTF-8" must be upper
SimpleXMLRPCDispatcher.__init__(self, True, 'UTF-8')
self.funcs = funcs
self.register_introspection_functions()
def __init__(self, funcs):
# "UTF-8" must be upper
SimpleXMLRPCDispatcher.__init__(self, True, 'UTF-8')
self.funcs = funcs
self.register_introspection_functions()
def __init__(self, addr, requestHandler=SimpleXMLRPCRequestHandler,
logRequests=True, allow_none=False, encoding=None, bind_and_activate=True):
self.logRequests = logRequests
SimpleXMLRPCDispatcher.__init__(self, allow_none, encoding)
MyTCPServer.__init__(self, addr, requestHandler, bind_and_activate)
def __init__(self, *args, **kwargs):
WSGIServer.__init__(self, *args, **kwargs)
SimpleXMLRPCDispatcher.__init__(self, False, None)
def __init__(self, addr, requestHandler=SimpleXMLRPCRequestHandler,
logRequests=True, allow_none=False, encoding=None, bind_and_activate=True):
"""Overriding __init__ method of the SimpleXMLRPCServer
The method is an exact copy, except the TCPServer __init__
call, which is rewritten using TLS
"""
self.logRequests = logRequests
SimpleXMLRPCDispatcher.__init__(self, allow_none, encoding)
"""This is the modified part. Original code was:
SocketServer.TCPServer.__init__(self, addr, requestHandler, bind_and_activate)
which executed:
def __init__(self, server_address, RequestHandlerClass, bind_and_activate=True):
BaseServer.__init__(self, server_address, RequestHandlerClass)
self.socket = socket.socket(self.address_family,
self.socket_type)
if bind_and_activate:
self.server_bind()
self.server_activate()
"""
class VerifyingRequestHandler(SimpleXMLRPCRequestHandler):
'''
Request Handler that verifies username and password passed to
XML RPC server in HTTP URL sent by client.
'''
# this is the method we must override
def parse_request(self):
# first, call the original implementation which returns
# True if all OK so far
if SimpleXMLRPCRequestHandler.parse_request(self):
# next we authenticate
if self.authenticate(self.headers):
return True
else:
# if authentication fails, tell the client
self.send_error(401, 'Authentication failed')
return False
def authenticate(self, headers):
from base64 import b64decode
# Confirm that Authorization header is set to Basic
(basic, _, encoded) = headers.get('Authorization').partition(' ')
assert basic == 'Basic', 'Only basic authentication supported'
# Encoded portion of the header is a string
# Need to convert to bytestring
encodedByteString = encoded.encode()
# Decode Base64 byte String to a decoded Byte String
decodedBytes = b64decode(encodedByteString)
# Convert from byte string to a regular String
decodedString = decodedBytes.decode()
# Get the username and password from the string
(username, _, password) = decodedString.partition(':')
# Check that username and password match internal global dictionary
if username in userPassDict:
if userPassDict[username] == password:
return True
return False
# Override the normal socket methods with an SSL socket
SocketServer.BaseServer.__init__(self, addr, VerifyingRequestHandler)
self.socket = ssl.wrap_socket(
socket.socket(self.address_family, self.socket_type),
server_side=True,
keyfile=KEYFILE,
certfile=CERTFILE,
cert_reqs=ssl.CERT_NONE,
ssl_version=ssl.PROTOCOL_SSLv23,
)
if bind_and_activate:
self.server_bind()
self.server_activate()
"""End of modified part"""
# [Bug #1222790] If possible, set close-on-exec flag; if a
# method spawns a subprocess, the subprocess shouldn't have
# the listening socket open.
if fcntl is not None and hasattr(fcntl, 'FD_CLOEXEC'):
flags = fcntl.fcntl(self.fileno(), fcntl.F_GETFD)
flags |= fcntl.FD_CLOEXEC
fcntl.fcntl(self.fileno(), fcntl.F_SETFD, flags)
def __init__(self):
if sys.version[0:3] == '2.4':
SimpleXMLRPCDispatcher.__init__(self)
else:
SimpleXMLRPCDispatcher.__init__(self, False, None)
self.authMethod = None
def __init__(self):
SimpleXMLRPCDispatcher.__init__(self, allow_none=True)
XMLRPCDocGenerator.__init__(self)
def __init__(self, funcs):
SimpleXMLRPCDispatcher.__init__(self, True, 'utf-8')
self.funcs = funcs
def __init__(self, funcs):
SimpleXMLRPCDispatcher.__init__(self, True, 'utf-8')
self.funcs = funcs
self.register_introspection_functions()
def __init__(self, parent_fd, allow_none=True, encoding=None):
self.env = self._input = self._output = None
_SCGIHandler.__init__(self, parent_fd)
SimpleXMLRPCDispatcher.__init__(self, allow_none, encoding)
def __init__(self):
SimpleXMLRPCDispatcher.__init__(self, allow_none=False, encoding=None)
def __init__(self):
SimpleXMLRPCDispatcher.__init__(self)
def __init__(self, addr, requestHandler=SimpleXMLRPCRequestHandler):
self.logRequests = False # critical, as logging fails with UnixStreamServer
SimpleXMLRPCDispatcher.__init__(self)
UnixStreamServer.__init__(self, addr, requestHandler)
def __init__(self, encoding=None): SimpleXMLRPCDispatcher.__init__(self, allow_none = True, encoding = encoding)
