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

# Copyright 2005-2007 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 contextlib

import struct

import threading

from .i18n import _

from . import (

    encoding,

    error,

    pycompat,

    util,

    wireprototypes,

    wireprotov1server,

    wireprotov2server,

)

from .interfaces import util as interfaceutil

from .utils import (

    cborutil,

    compression,

)

stringio = util.stringio

urlerr = util.urlerr

urlreq = util.urlreq

HTTP_OK = 200

HGTYPE = b'application/mercurial-0.1'

HGTYPE2 = b'application/mercurial-0.2'

HGERRTYPE = b'application/hg-error'

SSHV1 = wireprototypes.SSHV1

SSHV2 = wireprototypes.SSHV2

def decodevaluefromheaders(req, headerprefix):

    """Decode a long value from multiple HTTP request headers.

    Returns the value as a bytes, not a str.

    """

    chunks = []

    i = 1

    while True:

        v = req.headers.get(b'%s-%d' % (headerprefix, i))

        if v is None:

            break

        chunks.append(pycompat.bytesurl(v))

        i += 1

    return b''.join(chunks)

@interfaceutil.implementer(wireprototypes.baseprotocolhandler)

class httpv1protocolhandler(object):

    def __init__(self, req, ui, checkperm):

        self._req = req

        self._ui = ui

        self._checkperm = checkperm

        self._protocaps = None

    @property

    def name(self):

        return b'http-v1'

    def getargs(self, args):

        knownargs = self._args()

        data = {}

        keys = args.split()

        for k in keys:

            if k == b'*':

                star = {}

                for key in knownargs.keys():

                    if key != b'cmd' and key not in keys:

                        star[key] = knownargs[key][0]

                data[b'*'] = star

            else:

                data[k] = knownargs[k][0]

        return [data[k] for k in keys]

    def _args(self):

        args = self._req.qsparams.asdictoflists()

        postlen = int(self._req.headers.get(b'X-HgArgs-Post', 0))

        if postlen:

            args.update(

                urlreq.parseqs(

                    self._req.bodyfh.read(postlen), keep_blank_values=True

                )

            )

            return args

        argvalue = decodevaluefromheaders(self._req, b'X-HgArg')

        args.update(urlreq.parseqs(argvalue, keep_blank_values=True))

        return args

    def getprotocaps(self):

        if self._protocaps is None:

            value = decodevaluefromheaders(self._req, b'X-HgProto')

            self._protocaps = set(value.split(b' '))

        return self._protocaps

    def getpayload(self):

        # Existing clients *always* send Content-Length.

        length = int(self._req.headers[b'Content-Length'])

        # If httppostargs is used, we need to read Content-Length

        # minus the amount that was consumed by args.

        length -= int(self._req.headers.get(b'X-HgArgs-Post', 0))

        return util.filechunkiter(self._req.bodyfh, limit=length)

    @contextlib.contextmanager

    def mayberedirectstdio(self):

        oldout = self._ui.fout

        olderr = self._ui.ferr

        out = util.stringio()

        try:

            self._ui.fout = out

            self._ui.ferr = out

            yield out

        finally:

            self._ui.fout = oldout

            self._ui.ferr = olderr

    def client(self):

        return b'remote:%s:%s:%s' % (

            self._req.urlscheme,

            urlreq.quote(self._req.remotehost or b''),

            urlreq.quote(self._req.remoteuser or b''),

        )

    def addcapabilities(self, repo, caps):

        caps.append(b'batch')

        caps.append(

            b'httpheader=%d' % repo.ui.configint(b'server', b'maxhttpheaderlen')

        )

        if repo.ui.configbool(b'experimental', b'httppostargs'):

            caps.append(b'httppostargs')

        # FUTURE advertise 0.2rx once support is implemented

        # FUTURE advertise minrx and mintx after consulting config option

        caps.append(b'httpmediatype=0.1rx,0.1tx,0.2tx')

        compengines = wireprototypes.supportedcompengines(

            repo.ui, compression.SERVERROLE

        )

        if compengines:

            comptypes = b','.join(

                urlreq.quote(e.wireprotosupport().name) for e in compengines

            )

            caps.append(b'compression=%s' % comptypes)

        return caps

    def checkperm(self, perm):

        return self._checkperm(perm)

# This method exists mostly so that extensions like remotefilelog can

# disable a kludgey legacy method only over http. As of early 2018,

# there are no other known users, so with any luck we can discard this

# hook if remotefilelog becomes a first-party extension.

def iscmd(cmd):

    return cmd in wireprotov1server.commands

def handlewsgirequest(rctx, req, res, checkperm):

    """Possibly process a wire protocol request.

    If the current request is a wire protocol request, the request is

    processed by this function.

    ``req`` is a ``parsedrequest`` instance.

    ``res`` is a ``wsgiresponse`` instance.

    Returns a bool indicating if the request was serviced. If set, the caller

    should stop processing the request, as a response has already been issued.

    """

    # Avoid cycle involving hg module.

    from .hgweb import common as hgwebcommon

    repo = rctx.repo

    # HTTP version 1 wire protocol requests are denoted by a "cmd" query

    # string parameter. If it isn't present, this isn't a wire protocol

    # request.

    if b'cmd' not in req.qsparams:

        return False

    cmd = req.qsparams[b'cmd']

    # The "cmd" request parameter is used by both the wire protocol and hgweb.

    # While not all wire protocol commands are available for all transports,

    # if we see a "cmd" value that resembles a known wire protocol command, we

    # route it to a protocol handler. This is better than routing possible

    # wire protocol requests to hgweb because it prevents hgweb from using

    # known wire protocol commands and it is less confusing for machine

    # clients.

    if not iscmd(cmd):

        return False

    # The "cmd" query string argument is only valid on the root path of the

    # repo. e.g. ``/?cmd=foo``, ``/repo?cmd=foo``. URL paths within the repo

    # like ``/blah?cmd=foo`` are not allowed. So don't recognize the request

    # in this case. We send an HTTP 404 for backwards compatibility reasons.

    if req.dispatchpath:

        res.status = hgwebcommon.statusmessage(404)

        res.headers[b'Content-Type'] = HGTYPE

        # TODO This is not a good response to issue for this request. This

        # is mostly for BC for now.

        res.setbodybytes(b'0\n%s\n' % b'Not Found')

        return True

    proto = httpv1protocolhandler(

        req, repo.ui, lambda perm: checkperm(rctx, req, perm)

    )

    # The permissions checker should be the only thing that can raise an

    # ErrorResponse. It is kind of a layer violation to catch an hgweb

    # exception here. So consider refactoring into a exception type that

    # is associated with the wire protocol.

    try:

        _callhttp(repo, req, res, proto, cmd)

    except hgwebcommon.ErrorResponse as e:

        for k, v in e.headers:

            res.headers[k] = v

        res.status = hgwebcommon.statusmessage(e.code, pycompat.bytestr(e))

        # TODO This response body assumes the failed command was

        # "unbundle." That assumption is not always valid.

        res.setbodybytes(b'0\n%s\n' % pycompat.bytestr(e))

    return True

def _availableapis(repo):

    apis = set()

    # Registered APIs are made available via config options of the name of

    # the protocol.

    for k, v in API_HANDLERS.items():

        section, option = v[b'config']

        if repo.ui.configbool(section, option):

            apis.add(k)

    return apis

def handlewsgiapirequest(rctx, req, res, checkperm):

    """Handle requests to /api/*."""

    assert req.dispatchparts[0] == b'api'

    repo = rctx.repo

    # This whole URL space is experimental for now. But we want to

    # reserve the URL space. So, 404 all URLs if the feature isn't enabled.

    if not repo.ui.configbool(b'experimental', b'web.apiserver'):

        res.status = b'404 Not Found'

        res.headers[b'Content-Type'] = b'text/plain'

        res.setbodybytes(_(b'Experimental API server endpoint not enabled'))

        return

    # The URL space is /api/<protocol>/*. The structure of URLs under varies

    # by <protocol>.

    availableapis = _availableapis(repo)

    # Requests to /api/ list available APIs.

    if req.dispatchparts == [b'api']:

        res.status = b'200 OK'

        res.headers[b'Content-Type'] = b'text/plain'

        lines = [

            _(

                b'APIs can be accessed at /api/<name>, where <name> can be '

                b'one of the following:\n'

            )

        ]

        if availableapis:

            lines.extend(sorted(availableapis))

        else:

            lines.append(_(b'(no available APIs)\n'))

        res.setbodybytes(b'\n'.join(lines))

        return

    proto = req.dispatchparts[1]

    if proto not in API_HANDLERS:

        res.status = b'404 Not Found'

        res.headers[b'Content-Type'] = b'text/plain'

        res.setbodybytes(

            _(b'Unknown API: %s\nKnown APIs: %s')

            % (proto, b', '.join(sorted(availableapis)))

        )

        return

    if proto not in availableapis:

        res.status = b'404 Not Found'

        res.headers[b'Content-Type'] = b'text/plain'

        res.setbodybytes(_(b'API %s not enabled\n') % proto)

        return

    API_HANDLERS[proto][b'handler'](

        rctx, req, res, checkperm, req.dispatchparts[2:]

    )

# Maps API name to metadata so custom API can be registered.

# Keys are:

#

# config

#    Config option that controls whether service is enabled.

# handler

#    Callable receiving (rctx, req, res, checkperm, urlparts) that is called

#    when a request to this API is received.

# apidescriptor

#    Callable receiving (req, repo) that is called to obtain an API

#    descriptor for this service. The response must be serializable to CBOR.

API_HANDLERS = {

    wireprotov2server.HTTP_WIREPROTO_V2: {

        b'config': (b'experimental', b'web.api.http-v2'),

        b'handler': wireprotov2server.handlehttpv2request,

        b'apidescriptor': wireprotov2server.httpv2apidescriptor,

    },

}

def _httpresponsetype(ui, proto, prefer_uncompressed):

    """Determine the appropriate response type and compression settings.

    Returns a tuple of (mediatype, compengine, engineopts).

    """

    # Determine the response media type and compression engine based

    # on the request parameters.

    if b'0.2' in proto.getprotocaps():

        # All clients are expected to support uncompressed data.

        if prefer_uncompressed:

            return HGTYPE2, compression._noopengine(), {}

        # Now find an agreed upon compression format.

        compformats = wireprotov1server.clientcompressionsupport(proto)

        for engine in wireprototypes.supportedcompengines(

            ui, compression.SERVERROLE

        ):

            if engine.wireprotosupport().name in compformats:

                opts = {}

                level = ui.configint(b'server', b'%slevel' % engine.name())

                if level is not None:

                    opts[b'level'] = level

                return HGTYPE2, engine, opts

        # No mutually supported compression format. Fall back to the

        # legacy protocol.

    # Don't allow untrusted settings because disabling compression or

    # setting a very high compression level could lead to flooding

    # the server's network or CPU.

    opts = {b'level': ui.configint(b'server', b'zliblevel')}

    return HGTYPE, util.compengines[b'zlib'], opts

def processcapabilitieshandshake(repo, req, res, proto):

    """Called during a ?cmd=capabilities request.

    If the client is advertising support for a newer protocol, we send

    a CBOR response with information about available services. If no

    advertised services are available, we don't handle the request.

    """

    # Fall back to old behavior unless the API server is enabled.

    if not repo.ui.configbool(b'experimental', b'web.apiserver'):

        return False

    clientapis = decodevaluefromheaders(req, b'X-HgUpgrade')

    protocaps = decodevaluefromheaders(req, b'X-HgProto')

    if not clientapis or not protocaps:

        return False

    # We currently only support CBOR responses.