# 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 Matt Mackall <mpm@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.

from __future__ import absolute_import

# import wsgiref.validate

from ..thirdparty import attr

from .. import (

    error,

    pycompat,

    util,

)

class multidict(object):

    """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:

        return vals[0]

    def asdictoflists(self):

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

@attr.s(frozen=True)

class parsedrequest(object):

    """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

    # (bytes on Python 2 and str on Python 3). 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.

    if pycompat.ispy3:

        env = {k.encode('latin-1'): v for k, v in env.iteritems()}

        env = {

            k: v.encode('latin-1') if isinstance(v, str) else v

            for k, v in env.iteritems()

        }

    # 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:

    if altbaseurl:

        altbaseurl = util.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.

    if altbaseurl and altbaseurl.scheme:

    else:

        advertisedfullurl = fullurl

    def addport(s, port):

        else:

        return s

    else:

    if altbaseurl and altbaseurl.host:

        advertisedfullurl += altbaseurl.host

        if altbaseurl.port:

            port = altbaseurl.port

        else:

        advertisedfullurl = addport(advertisedfullurl, port)

    else:

    baseurl = fullurl

    advertisedbaseurl = advertisedfullurl

    if altbaseurl:

        advertisedfullurl += util.urlreq.quote(path)

    else:

    # If ``reponame`` is defined, that must be a prefix on PATH_INFO

    # that represents the repository being dispatched to. When computing

    # the dispatch info, we ignore these leading path components.

    if altbaseurl:

    else:

    if reponame:

            raise error.ProgrammingError(

            )

            raise error.ProgrammingError(

            )

        else:

            dispatchparts = []

    else:

        dispatchparts = []

        dispatchpath = None

    # We store as a list so we have ordering information. We also store as

    # a dict to facilitate fast lookup.

    qsparams = multidict()

    for k, v in util.urlreq.parseqsl(querystring, keep_blank_values=True):

        qsparams.add(k, v)

    # HTTP_* keys contain HTTP request headers. The Headers structure should

    # perform case normalization for us. We just rewrite underscore to dash

    # so keys match what likely went over the wire.

    headers = []

    for k, v in env.iteritems():

    from . import wsgiheaders  # avoid cycle

    headers = wsgiheaders.Headers(headers)

    # This is kind of a lie because the HTTP header wasn't explicitly

    # sent. But for all intents and purposes it should be OK to lie about

    # this, since a consumer will either either value to determine how many

    # bytes are available to read.

    if bodyfh is None:

            bodyfh = util.cappedreader(

            )

    return parsedrequest(

        url=fullurl,

        baseurl=baseurl,

        advertisedurl=advertisedfullurl,

        advertisedbaseurl=advertisedbaseurl,

        apppath=apppath,

        dispatchparts=dispatchparts,

        dispatchpath=dispatchpath,

        reponame=reponame,

        querystring=querystring,

        qsparams=qsparams,

        headers=headers,

        bodyfh=bodyfh,

        rawenv=env,

    )

class offsettrackingwriter(object):

    """A file object like object that is append only and tracks write count.

    Instances are bound to a callable. This callable is called with data

    whenever a ``write()`` is attempted.

    Instances track the amount of written data so they can answer ``tell()``

    requests.

    The intent of this class is to wrap the ``write()`` function returned by

    a WSGI ``start_response()`` function. Since ``write()`` is a callable and

    not a file object, it doesn't implement other file object methods.

    """

    def __init__(self, writefn):

        self._write = writefn

        self._offset = 0

    def write(self, s):

        res = self._write(s)

        # Some Python objects don't report the number of bytes written.

        if res is None:

            self._offset += len(s)

        else:

            self._offset += res

    def flush(self):

        pass

    def tell(self):

        return self._offset

class wsgiresponse(object):

    """Represents a response to a WSGI request.

    A response consists of a status line, headers, and a body.

    Consumers must populate the ``status`` and ``headers`` fields and

    make a call to a ``setbody*()`` method before the response can be

    issued.

    When it is time to start sending the response over the wire,