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