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

import threading

from .i18n import _

from . import (

    encoding,

    error,

    hook,

    pycompat,

    util,

    wireproto,

    wireprotoframing,

    wireprototypes,

)

stringio = util.stringio

urlerr = util.urlerr

urlreq = util.urlreq

HTTP_OK = 200

HGTYPE = 'application/mercurial-0.1'

HGTYPE2 = 'application/mercurial-0.2'

HGERRTYPE = 'application/hg-error'

FRAMINGTYPE = b'application/mercurial-exp-framing-0001'

HTTPV2 = wireprototypes.HTTPV2

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 ''.join(chunks)

class httpv1protocolhandler(wireprototypes.baseprotocolhandler):

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

        self._req = req

        self._ui = ui

        self._checkperm = checkperm

    @property

    def name(self):

        return 'http-v1'

    def getargs(self, args):

        knownargs = self._args()

        data = {}

        keys = args.split()

        for k in keys:

            if k == '*':

                star = {}

                for key in knownargs.keys():

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

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

                data['*'] = 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 forwardpayload(self, fp):

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

        for s in util.filechunkiter(self._req.bodyfh, limit=length):

            fp.write(s)

    @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 'remote:%s:%s:%s' % (

            self._req.urlscheme,

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

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

    def addcapabilities(self, repo, caps):

        caps.append(b'batch')

        caps.append('httpheader=%d' %

                    repo.ui.configint('server', 'maxhttpheaderlen'))

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

            caps.append('httppostargs')

        # FUTURE advertise 0.2rx once support is implemented

        # FUTURE advertise minrx and mintx after consulting config option

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

        compengines = wireproto.supportedcompengines(repo.ui, util.SERVERROLE)

        if compengines:

            comptypes = ','.join(urlreq.quote(e.wireprotosupport().name)

                                 for e in compengines)

            caps.append('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 wireproto.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 'cmd' not in req.qsparams:

        return False

    cmd = req.qsparams['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['Content-Type'] = HGTYPE

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

        # is mostly for BC for now.

        res.setbodybytes('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('0\n%s\n' % pycompat.bytestr(e))

    return True

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('experimental', 'web.apiserver'):

        res.status = b'404 Not Found'

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

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

        return

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

    # by <protocol>.

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

    # the protocol.

    availableapis = set()

    for k, v in API_HANDLERS.items():

        section, option = v['config']

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

            availableapis.add(k)

    # 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 = [_('APIs can be accessed at /api/<name>, where <name> can be '

                   'one of the following:\n')]

        if availableapis:

            lines.extend(sorted(availableapis))

        else:

            lines.append(_('(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(_('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(_('API %s not enabled\n') % proto)

        return

    API_HANDLERS[proto]['handler'](rctx, req, res, checkperm,

                                   req.dispatchparts[2:])

def _handlehttpv2request(rctx, req, res, checkperm, urlparts):

    from .hgweb import common as hgwebcommon

    # URL space looks like: <permissions>/<command>, where <permission> can

    # be ``ro`` or ``rw`` to signal read-only or read-write, respectively.

    # Root URL does nothing meaningful... yet.

    if not urlparts:

        res.status = b'200 OK'

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

        res.setbodybytes(_('HTTP version 2 API handler'))

        return

    if len(urlparts) == 1:

        res.status = b'404 Not Found'

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

        res.setbodybytes(_('do not know how to process %s\n') %

                         req.dispatchpath)

        return

    permission, command = urlparts[0:2]

    if permission not in (b'ro', b'rw'):

        res.status = b'404 Not Found'

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

        res.setbodybytes(_('unknown permission: %s') % permission)

        return

    if req.method != 'POST':

        res.status = b'405 Method Not Allowed'

        res.headers[b'Allow'] = b'POST'

        res.setbodybytes(_('commands require POST requests'))

        return

    # At some point we'll want to use our own API instead of recycling the

    # behavior of version 1 of the wire protocol...

    # TODO return reasonable responses - not responses that overload the

    # HTTP status line message for error reporting.

    try:

        checkperm(rctx, req, 'pull' if permission == b'ro' else 'push')

    except hgwebcommon.ErrorResponse as e:

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

        for k, v in e.headers:

            res.headers[k] = v

        res.setbodybytes('permission denied')

        return

    # We have a special endpoint to reflect the request back at the client.

    if command == b'debugreflect':

        _processhttpv2reflectrequest(rctx.repo.ui, rctx.repo, req, res)

        return

    if command not in wireproto.commands:

        res.status = b'404 Not Found'

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

        res.setbodybytes(_('unknown wire protocol command: %s\n') % command)

        return

    repo = rctx.repo

    ui = repo.ui

    proto = httpv2protocolhandler(req, ui)

    if not wireproto.commands.commandavailable(command, proto):

        res.status = b'404 Not Found'

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

        res.setbodybytes(_('invalid wire protocol command: %s') % command)

        return

    if req.headers.get(b'Accept') != FRAMINGTYPE:

        res.status = b'406 Not Acceptable'

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

        res.setbodybytes(_('client MUST specify Accept header with value: %s\n')

                           % FRAMINGTYPE)

        return

    if req.headers.get(b'Content-Type') != FRAMINGTYPE:

        res.status = b'415 Unsupported Media Type'

        # TODO we should send a response with appropriate media type,

        # since client does Accept it.

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

        res.setbodybytes(_('client MUST send Content-Type header with '

                           'value: %s\n') % FRAMINGTYPE)

        return

    _processhttpv2request(ui, repo, req, res, permission, command, proto)

def _processhttpv2reflectrequest(ui, repo, req, res):

    """Reads unified frame protocol request and dumps out state to client.

    This special endpoint can be used to help debug the wire protocol.

    Instead of routing the request through the normal dispatch mechanism,

    we instead read all frames, decode them, and feed them into our state

    tracker. We then dump the log of all that activity back out to the

    client.

    """

    import json

    # Reflection APIs have a history of being abused, accidentally disclosing

    # sensitive data, etc. So we have a config knob.

    if not ui.configbool('experimental', 'web.api.debugreflect'):

        res.status = b'404 Not Found'

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