Gecko [ www.floatingcartbutton.com ]

Name	Size	Permission	Date
__pycache__	[ DIR ]	drwxr-xr-x	2026-05-29 09:01
actions	[ DIR ]	drwxr-xr-x	2026-05-29 09:01
__init__.py	132 B	-rw-r--r--	2026-04-24 15:42
connections.py	666 B	-rw-r--r--	2026-04-24 15:42
i18n.py	1.73 KB	-rw-r--r--	2026-04-24 15:42
rhnLockfile.py	3.35 KB	-rw-r--r--	2026-04-24 15:42
rpclib.py	4.6 KB	-rw-r--r--	2026-04-27 12:46
transports.py	3.98 KB	-rw-r--r--	2026-04-27 12:46

Rename

#
# This module contains all the RPC-related functions the RHN code uses
#
# Copyright (c) 2005--2020 Red Hat, Inc.
#
# This software is licensed to you under the GNU General Public License,
# version 2 (GPLv2). There is NO WARRANTY for this software, express or
# implied, including the implied warranties of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. You should have received a copy of GPLv2
# along with this software; if not, see
# http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
#
# Red Hat trademarks are not licensed under GPLv2. No permission is
# granted to use or replicate Red Hat trademarks that are incorporated
# in this software or its documentation.
#

__version__ = "3.0.3-1.module_el8.10.0+7020+fd2ced8d.cloudlinux-"

import xmlrpc.client as xmlrpclib

from urllib.parse import (
    urlparse,
    urlunparse,
    splittype,
    splithost,
)

from rhn import transports

class MalformedURIError(IOError):
    pass

class Server(xmlrpclib.ServerProxy):
    """uri [,options] -> a logical connection to an XML-RPC server

uri is the connection point on the server, given as
    scheme://host/target.

If the target part and the slash preceding it are both omitted,
    "/RPC2" is assumed.

The following options can be given as keyword arguments:

transport: a transport factory
        verbose: verbosity level
        proxy: use an HTTP proxy
        username: username for authenticated HTTP proxy
        password: password for authenticated HTTP proxy

"""

def __init__(
            self, uri, transport=None, verbose=0,
            proxy=None, username=None, password=None, timeout=None):

use_https = uri.startswith('https')
        if transport is None:
            transport = transports.RequestsTransport(
                use_https=use_https,
                timeout=timeout,
                proxy=self.get_proxy_uri(proxy, username, password, use_https)
            )

self._reset_host_handler_and_type(uri)

super().__init__(uri, transport, verbose=verbose)

def get_proxy_uri(self, proxy_host, proxy_user, proxy_pass, use_https):
        if proxy_host is None:
            return None

parts = urlparse('http://' + proxy_host)

auth_string = None
        if proxy_user is not None:
            auth_string = proxy_user

if auth_string and proxy_pass is not None:
            auth_string = auth_string + ':' + proxy_pass

if auth_string:
            parts = parts._replace(netloc=auth_string + "@" + parts.netloc)

if use_https:
            parts = parts._replace(scheme='https')
        else:
            parts = parts._replace(scheme='http')

return urlunparse(parts)

def _reset_host_handler_and_type(self, uri):
        """
        Reset the attributes:
        self._host, self._handler, self._type
        according the value of self._uri.

Kept for backwards compatibility.
        """
        # get the url
        type, uri = splittype(uri)
        if type is None:
            raise MalformedURIError("missing protocol in uri")
        # with a real uri passed in, uri will now contain "//hostname..." so we
        # need at least 3 chars for it to maybe be ok...
        if len(uri) < 3 or uri[0:2] != "//":
            raise MalformedURIError
        self._type = type.lower()
        if self._type not in ("http", "https"):
            raise IOError("unsupported XML-RPC protocol")
        self._host, self._handler = splithost(uri)
        if not self._handler:
            self._handler = "/RPC2"

def set_header(self, name, arg):
        return self._ServerProxy__transport.set_header(name, arg)

def add_header(self, name, arg):
        return self._ServerProxy__transport.add_header(name, arg)

def clear_headers(self):
        return self._ServerProxy__transport.clear_headers()

def set_trusted_cert(self, certfile):
        self._ServerProxy__transport.set_trusted_cert(certfile)

def getHeaderValues(headers, name):
    import mimetools
    if not isinstance(headers, mimetools.Message):
        if name in headers:
            return [headers[name]]
        return []

return [x.split(':', 1)[1].strip() for x in
            headers.getallmatchingheaders(name)]

def reportError(headers):
    """ Reports the error from the headers. """
    errcode = 0
    errmsg = ""
    s = "X-RHN-Fault-Code"
    if s in headers:
        errcode = int(headers[s])
    s = "X-RHN-Fault-String"
    if s in headers:
        _sList = getHeaderValues(headers, s)
        if _sList:
            _s = ''.join(_sList)
            import base64
            errmsg = "%s" % base64.decodestring(_s)

return errcode, errmsg