# hgweb/request.py - An http request from either CGI or the standalone server.

#

# Copyright 21 May 2005 - (c) 2005 Jake Edge <jake@edge2.net>

# Copyright 2005, 2006 Olivia Mackall <olivia@selenic.com>

#

# This software may be used and distributed according to the terms of the

# GNU General Public License version 2 or any later version.

# import wsgiref.validate

from ..thirdparty import attr

from .. import (

    error,

    pycompat,

    util,

)

from ..utils import (

    urlutil,

)

class multidict:

    """A dict like object that can store multiple values for a key.

    Used to store parsed request parameters.

    This is inspired by WebOb's class of the same name.

    """

    def __init__(self):

        self._items = {}

    def __getitem__(self, key):

        """Returns the last set value for a key."""

        return self._items[key][-1]

    def __setitem__(self, key, value):

        """Replace a values for a key with a new value."""

        self._items[key] = [value]

    def __delitem__(self, key):

        """Delete all values for a key."""

        del self._items[key]

    def __contains__(self, key):

        return key in self._items

    def __len__(self):

        return len(self._items)

    def get(self, key, default=None):

        try:

            return self.__getitem__(key)

        except KeyError:

            return default

    def add(self, key, value):

        """Add a new value for a key. Does not replace existing values."""

        self._items.setdefault(key, []).append(value)

    def getall(self, key):

        """Obtains all values for a key."""

        return self._items.get(key, [])

    def getone(self, key):

        """Obtain a single value for a key.

        Raises KeyError if key not defined or it has multiple values set.

        """

        vals = self._items[key]

        if len(vals) > 1:

            raise KeyError(b'multiple values for %r' % key)

        return vals[0]

    def asdictoflists(self):

        return {k: list(v) for k, v in self._items.items()}

@attr.s(frozen=True)

class parsedrequest:

    """Represents a parsed WSGI request.

    Contains both parsed parameters as well as a handle on the input stream.

    """

    # Request method.

    method = attr.ib()

    # Full URL for this request.

    url = attr.ib()

    # URL without any path components. Just <proto>://<host><port>.

    baseurl = attr.ib()

    # Advertised URL. Like ``url`` and ``baseurl`` but uses SERVER_NAME instead

    # of HTTP: Host header for hostname. This is likely what clients used.

    advertisedurl = attr.ib()

    advertisedbaseurl = attr.ib()

    # URL scheme (part before ``://``). e.g. ``http`` or ``https``.

    urlscheme = attr.ib()

    # Value of REMOTE_USER, if set, or None.

    remoteuser = attr.ib()

    # Value of REMOTE_HOST, if set, or None.

    remotehost = attr.ib()

    # Relative WSGI application path. If defined, will begin with a

    # ``/``.

    apppath = attr.ib()

    # List of path parts to be used for dispatch.

    dispatchparts = attr.ib()

    # URL path component (no query string) used for dispatch. Can be

    # ``None`` to signal no path component given to the request, an

    # empty string to signal a request to the application's root URL,

    # or a string not beginning with ``/`` containing the requested

    # path under the application.

    dispatchpath = attr.ib()

    # The name of the repository being accessed.

    reponame = attr.ib()

    # Raw query string (part after "?" in URL).

    querystring = attr.ib()

    # multidict of query string parameters.

    qsparams = attr.ib()

    # wsgiref.headers.Headers instance. Operates like a dict with case

    # insensitive keys.

    headers = attr.ib()

    # Request body input stream.

    bodyfh = attr.ib()

    # WSGI environment dict, unmodified.

    rawenv = attr.ib()

def parserequestfromenv(env, reponame=None, altbaseurl=None, bodyfh=None):

    """Parse URL components from environment variables.

    WSGI defines request attributes via environment variables. This function

    parses the environment variables into a data structure.

    If ``reponame`` is defined, the leading path components matching that

    string are effectively shifted from ``PATH_INFO`` to ``SCRIPT_NAME``.

    This simulates the world view of a WSGI application that processes

    requests from the base URL of a repo.

    If ``altbaseurl`` (typically comes from ``web.baseurl`` config option)

    is defined, it is used - instead of the WSGI environment variables - for

    constructing URL components up to and including the WSGI application path.

    For example, if the current WSGI application is at ``/repo`` and a request

    is made to ``/rev/@`` with this argument set to

    ``http://myserver:9000/prefix``, the URL and path components will resolve as

    if the request were to ``http://myserver:9000/prefix/rev/@``. In other

    words, ``wsgi.url_scheme``, ``SERVER_NAME``, ``SERVER_PORT``, and

    ``SCRIPT_NAME`` are all effectively replaced by components from this URL.

    ``bodyfh`` can be used to specify a file object to read the request body

    from. If not defined, ``wsgi.input`` from the environment dict is used.

    """

    # PEP 3333 defines the WSGI spec and is a useful reference for this code.

    # We first validate that the incoming object conforms with the WSGI spec.

    # We only want to be dealing with spec-conforming WSGI implementations.

    # TODO enable this once we fix internal violations.

    # wsgiref.validate.check_environ(env)

    # PEP-0333 states that environment keys and values are native strings.

    # The code points for the Unicode strings on Python 3 must be between

    # \00000-\000FF. We deal with bytes in Mercurial, so mass convert string

    # keys and values to bytes.

    def tobytes(s):

        if not isinstance(s, str):

            return s

        return s.encode('iso8859-1')

    env = {tobytes(k): tobytes(v) for k, v in env.items()}

    # Some hosting solutions are emulating hgwebdir, and dispatching directly

    # to an hgweb instance using this environment variable.  This was always

    # checked prior to d7fd203e36cc; keep doing so to avoid breaking them.

    if not reponame:

        reponame = env.get(b'REPO_NAME')

    if altbaseurl:

        altbaseurl = urlutil.url(altbaseurl)

    # https://www.python.org/dev/peps/pep-0333/#environ-variables defines

    # the environment variables.

    # https://www.python.org/dev/peps/pep-0333/#url-reconstruction defines

    # how URLs are reconstructed.

    fullurl = env[b'wsgi.url_scheme'] + b'://'

    if altbaseurl and altbaseurl.scheme:

        advertisedfullurl = altbaseurl.scheme + b'://'

    else:

        advertisedfullurl = fullurl

    def addport(s, port):

        if s.startswith(b'https://'):

            if port != b'443':

                s += b':' + port

        else:

            if port != b'80':

                s += b':' + port

        return s

    if env.get(b'HTTP_HOST'):

        fullurl += env[b'HTTP_HOST']

    else:

        fullurl += env[b'SERVER_NAME']

        fullurl = addport(fullurl, env[b'SERVER_PORT'])

    if altbaseurl and altbaseurl.host:

        advertisedfullurl += altbaseurl.host

        if altbaseurl.port:

            port = altbaseurl.port

        elif altbaseurl.scheme == b'http' and not altbaseurl.port:

            port = b'80'

        elif altbaseurl.scheme == b'https' and not altbaseurl.port:

            port = b'443'

        else:

            port = env[b'SERVER_PORT']

        advertisedfullurl = addport(advertisedfullurl, port)

    else:

        advertisedfullurl += env[b'SERVER_NAME']

        advertisedfullurl = addport(advertisedfullurl, env[b'SERVER_PORT'])

    baseurl = fullurl

    advertisedbaseurl = advertisedfullurl

    fullurl += util.urlreq.quote(env.get(b'SCRIPT_NAME', b''))

    fullurl += util.urlreq.quote(env.get(b'PATH_INFO', b''))

    if altbaseurl:

        path = altbaseurl.path or b''

        if path and not path.startswith(b'/'):

            path = b'/' + path

        advertisedfullurl += util.urlreq.quote(path)

    else:

        advertisedfullurl += util.urlreq.quote(env.get(b'SCRIPT_NAME', b''))

    advertisedfullurl += util.urlreq.quote(env.get(b'PATH_INFO', b''))

    if env.get(b'QUERY_STRING'):

        fullurl += b'?' + env[b'QUERY_STRING']