# Source code for cherrypy.lib.cptools

    """Functions for builtin CherryPy tools."""

    import logging
    import re
    from hashlib import md5
    import urllib.parse

    import cherrypy
    from cherrypy._cpcompat import text_or_bytes
    from cherrypy.lib import httputil as _httputil
    from cherrypy.lib import is_iterator

    #                     Conditional HTTP request support                     #

    def validate_etags(autotags=False, debug=False):
        """Validate the current ETag against If-Match, If-None-Match headers.

        If autotags is True, an ETag response-header value will be provided
        from an MD5 hash of the response body (unless some other code has
        already provided an ETag header). If False (the default), the ETag
        will not be automatic.

        WARNING: the autotags feature is not designed for URL's which allow
        methods other than GET. For example, if a POST to the same URL returns
        no content, the automatic ETag will be incorrect, breaking a fundamental
        use for entity tags in a possibly destructive fashion. Likewise, if you
        raise 304 Not Modified, the response body will be empty, the ETag hash
        will be incorrect, and your application will break.
        See :rfc:`2616` Section 14.24.
        """
        response = cherrypy.serving.response

        # Guard against being run twice.
        if hasattr(response, 'ETag'):
            return

        status, reason, msg = _httputil.valid_status(response.status)

        etag = response.headers.get('ETag')

        # Automatic ETag generation. See warning in docstring.
        if etag:
            if debug:
                cherrypy.log('ETag already set: %s' % etag, 'TOOLS.ETAGS')
        elif not autotags:
            if debug:
                cherrypy.log('Autotags off', 'TOOLS.ETAGS')
        elif status != 200:
            if debug:
                cherrypy.log('Status not 200', 'TOOLS.ETAGS')
        else:
            etag = response.collapse_body()
            etag = '"%s"' % md5(etag).hexdigest()
            if debug:
                cherrypy.log('Setting ETag: %s' % etag, 'TOOLS.ETAGS')
            response.headers['ETag'] = etag

        response.ETag = etag

        # "If the request would, without the If-Match header field, result in
        # anything other than a 2xx or 412 status, then the If-Match header
        # MUST be ignored."
        if debug:
            cherrypy.log('Status: %s' % status, 'TOOLS.ETAGS')
        if status >= 200 and status <= 299:
            request = cherrypy.serving.request

            conditions = request.headers.elements('If-Match') or []
            conditions = [str(x) for x in conditions]
            if debug:
                cherrypy.log('If-Match conditions: %s' % repr(conditions),
                             'TOOLS.ETAGS')
            if conditions and not (conditions == ['*'] or etag in conditions):
                raise cherrypy.HTTPError(412, 'If-Match failed: ETag %r did '
                                         'not match %r' % (etag, conditions))

            conditions = request.headers.elements('If-None-Match') or []
            conditions = [str(x) for x in conditions]
            if debug:
                cherrypy.log('If-None-Match conditions: %s' % repr(conditions),
                             'TOOLS.ETAGS')
            if conditions == ['*'] or etag in conditions:
                if debug:
                    cherrypy.log('request.method: %s' %
                                 request.method, 'TOOLS.ETAGS')
                if request.method in ('GET', 'HEAD'):
                    raise cherrypy.HTTPRedirect([], 304)
                else:
                    raise cherrypy.HTTPError(412, 'If-None-Match failed: ETag %r '
                                             'matched %r' % (etag, conditions))

    def validate_since():
        """Validate the current Last-Modified against If-Modified-Since headers.

        If no code has set the Last-Modified response header, then no
        validation will be performed.
        """
        response = cherrypy.serving.response
        lastmod = response.headers.get('Last-Modified')
        if lastmod:
            status, reason, msg = _httputil.valid_status(response.status)

            request = cherrypy.serving.request

            since = request.headers.get('If-Unmodified-Since')
            if since and since != lastmod:
                if (status >= 200 and status <= 299) or status == 412:
                    raise cherrypy.HTTPError(412)

            since = request.headers.get('If-Modified-Since')
            if since and since == lastmod:
                if (status >= 200 and status <= 299) or status == 304:
                    if request.method in ('GET', 'HEAD'):
                        raise cherrypy.HTTPRedirect([], 304)
                    else:
                        raise cherrypy.HTTPError(412)

    #                                Tool code                                #

    def allow(methods=None, debug=False):
        """Raise 405 if request.method not in methods (default ['GET', 'HEAD']).

        The given methods are case-insensitive, and may be in any order. If
        only one method is allowed, you may supply a single string; if more
        than one, supply a list of strings.

        Regardless of whether the current method is allowed or not, this
        also emits an 'Allow' response header, containing the given methods.
        """
        if not isinstance(methods, (tuple, list)):
            methods = [methods]
        methods = [m.upper() for m in methods if m]
        if not methods:
            methods = ['GET', 'HEAD']
        elif 'GET' in methods and 'HEAD' not in methods:
            methods.append('HEAD')

        cherrypy.response.headers['Allow'] = ', '.join(methods)
        if cherrypy.request.method not in methods:
            if debug:
                cherrypy.log('request.method %r not in methods %r' %
                             (cherrypy.request.method, methods), 'TOOLS.ALLOW')
            raise cherrypy.HTTPError(405)
        else:
            if debug:
                cherrypy.log('request.method %r in methods %r' %
                             (cherrypy.request.method, methods), 'TOOLS.ALLOW')

    def proxy(base=None, local='X-Forwarded-Host', remote='X-Forwarded-For',
              scheme='X-Forwarded-Proto', debug=False):
        """Change the base URL (scheme://host[:port][/path]).

        For running a CP server behind Apache, lighttpd, or other HTTP
        server.

        For Apache and lighttpd, you should leave the 'local' argument at
        the default value of 'X-Forwarded-Host'. For Squid, you probably
        want to set tools.proxy.local = 'Origin'.

        If you want the new request.base to include path info (not just the
        host), you must explicitly set base to the full base path, and ALSO
        set 'local' to '', so that the X-Forwarded-Host request header
        (which never includes path info) does not override it. Regardless,
        the value for 'base' MUST NOT end in a slash.

        cherrypy.request.remote.ip (the IP address of the client) will be
        rewritten if the header specified by the 'remote' arg is valid. By
        default, 'remote' is set to 'X-Forwarded-For'. If you do not want to
        rewrite remote.ip, set the 'remote' arg to an empty string.
        """

        request = cherrypy.serving.request

        if scheme:
            s = request.headers.get(scheme, None)
            if debug:
                cherrypy.log('Testing scheme %r:%r' % (scheme, s), 'TOOLS.PROXY')
            if s == 'on' and 'ssl' in scheme.lower():
                # This handles e.g. webfaction's 'X-Forwarded-Ssl: on' header
                scheme = 'https'
            else:
                # This is for lighttpd/pound/Mongrel's 'X-Forwarded-Proto: https'
                scheme = s
        if not scheme:
            scheme = request.base[:request.base.find('://')]

        if local:
            lbase = request.headers.get(local, None)
            if debug:
                cherrypy.log('Testing local %r:%r' % (local, lbase), 'TOOLS.PROXY')
            if lbase is not None:
                base = lbase.split(',')[0]
        if not base:
            default = urllib.parse.urlparse(request.base).netloc
            base = request.headers.get('Host', default)

        if base.find('://') == -1:
            # add http:// or https:// if needed
            base = scheme + '://' + base

        request.base = base

        if remote:
            xff = request.headers.get(remote)
            if debug:
                cherrypy.log('Testing remote %r:%r' % (remote, xff), 'TOOLS.PROXY')
            if xff:
                if remote == 'X-Forwarded-For':
                    # Grab the first IP in a comma-separated list. Ref #1268.
                    xff = next(ip.strip() for ip in xff.split(','))
                request.remote.ip = xff

    def ignore_headers(headers=('Range',), debug=False):
        """Delete request headers whose field names are included in 'headers'.

        This is a useful tool for working behind certain HTTP servers; for
        example, Apache duplicates the work that CP does for 'Range'
        headers, and will doubly-truncate the response.
        """
        request = cherrypy.serving.request
        for name in headers:
            if name in request.headers:
                if debug:
                    cherrypy.log('Ignoring request header %r' % name,
                                 'TOOLS.IGNORE_HEADERS')
                del request.headers[name]

    def response_headers(headers=None, debug=False):
        """Set headers on the response."""
        if debug:
            cherrypy.log('Setting response headers: %s' % repr(headers),
                         'TOOLS.RESPONSE_HEADERS')
        for name, value in (headers or []):
            cherrypy.serving.response.headers[name] = value

    response_headers.failsafe = True

    def referer(pattern, accept=True, accept_missing=False, error=403,
                message='Forbidden Referer header.', debug=False):
        """Raise HTTPError if Referer header does/does not match the given pattern.

        pattern
            A regular expression pattern to test against the Referer.

        accept
            If True, the Referer must match the pattern; if False,
            the Referer must NOT match the pattern.

        accept_missing
            If True, permit requests with no Referer header.

        error
            The HTTP error code to return to the client on failure.

        message
            A string to include in the response body on failure.

        """
        try:
            ref = cherrypy.serving.request.headers['Referer']
            match = bool(re.match(pattern, ref))
            if debug:
                cherrypy.log('Referer %r matches %r' % (ref, pattern),
                             'TOOLS.REFERER')
            if accept == match:
                return
        except KeyError:
            if debug:
                cherrypy.log('No Referer header', 'TOOLS.REFERER')
            if accept_missing:
                return

        raise cherrypy.HTTPError(error, message)

    class SessionAuth(object):
        """Assert that the user is logged in."""

        session_key = 'username'
        debug = False

        def check_username_and_password(self, username, password):
            pass

        def anonymous(self):
            """Provide a temporary user name for anonymous users."""
            pass

        def on_login(self, username):
            pass

        def on_logout(self, username):
            pass

        def on_check(self, username):
            pass

        def login_screen(self, from_page='..', username='', error_msg='',
                         **kwargs):
            return (str("""<html><body>
    Message: %(error_msg)s
    <form method="post" action="do_login">
        Login: <input type="text" name="username" value="%(username)s" size="10" />
        <br />
        Password: <input type="password" name="password" size="10" />
        <br />
        <input type="hidden" name="from_page" value="%(from_page)s" />
        <br />
        <input type="submit" />
    </form>
    </body></html>""") % vars()).encode('utf-8')

        def do_login(self, username, password, from_page='..', **kwargs):
            """Login.

            May raise redirect, or return True if request handled.
            """
            response = cherrypy.serving.response
            error_msg = self.check_username_and_password(username, password)
            if error_msg:
                body = self.login_screen(from_page, username, error_msg)
                response.body = body
                if 'Content-Length' in response.headers:
                    # Delete Content-Length header so finalize() recalcs it.
                    del response.headers['Content-Length']
                return True
            else:
                cherrypy.serving.request.login = username
                cherrypy.session[self.session_key] = username
                self.on_login(username)
                raise cherrypy.HTTPRedirect(from_page or '/')

        def do_logout(self, from_page='..', **kwargs):
            """Logout.

            May raise redirect, or return True if request handled.
            """
            sess = cherrypy.session
            username = sess.get(self.session_key)
            sess[self.session_key] = None
            if username:
                cherrypy.serving.request.login = None
                self.on_logout(username)
            raise cherrypy.HTTPRedirect(from_page)

        def do_check(self):
            """Assert username.

            Raise redirect, or return True if request handled.
            """
            sess = cherrypy.session
            request = cherrypy.serving.request
            response = cherrypy.serving.response

            username = sess.get(self.session_key)
            if not username:
                sess[self.session_key] = username = self.anonymous()
                self._debug_message('No session[username], trying anonymous')
            if not username:
                url = cherrypy.url(qs=request.query_string)
                self._debug_message(
                    'No username, routing to login_screen with from_page %(url)r',
                    locals(),
                )
                response.body = self.login_screen(url)
                if 'Content-Length' in response.headers:
                    # Delete Content-Length header so finalize() recalcs it.
                    del response.headers['Content-Length']
                return True
            self._debug_message('Setting request.login to %(username)r', locals())
            request.login = username
            self.on_check(username)

        def _debug_message(self, template, context={}):
            if not self.debug:
                return
            cherrypy.log(template % context, 'TOOLS.SESSAUTH')

        def run(self):
            request = cherrypy.serving.request
            response = cherrypy.serving.response

            path = request.path_info
            if path.endswith('login_screen'):
                self._debug_message('routing %(path)r to login_screen', locals())
                response.body = self.login_screen()
                return True
            elif path.endswith('do_login'):
                if request.method != 'POST':
                    response.headers['Allow'] = 'POST'
                    self._debug_message('do_login requires POST')
                    raise cherrypy.HTTPError(405)
                self._debug_message('routing %(path)r to do_login', locals())
                return self.do_login(**request.params)
            elif path.endswith('do_logout'):
                if request.method != 'POST':
                    response.headers['Allow'] = 'POST'
                    raise cherrypy.HTTPError(405)
                self._debug_message('routing %(path)r to do_logout', locals())
                return self.do_logout(**request.params)
            else:
                self._debug_message('No special path, running do_check')
                return self.do_check()

    def session_auth(**kwargs):
        """Session authentication hook.

        Any attribute of the SessionAuth class may be overridden
        via a keyword arg to this function:
        """ + '\n' + '\n    '.join(
            '{!s}: {!s}'.format(k, type(getattr(SessionAuth, k)).__name__)
            for k in dir(SessionAuth)
            if not k.startswith('__')
        )
        sa = SessionAuth()
        for k, v in kwargs.items():
            setattr(sa, k, v)
        return sa.run()

    def log_traceback(severity=logging.ERROR, debug=False):
        """Write the last error's traceback to the cherrypy error log."""
        cherrypy.log('', 'HTTP', severity=severity, traceback=True)

    def log_request_headers(debug=False):
        """Write request headers to the cherrypy error log."""
        h = ['  %s: %s' % (k, v) for k, v in cherrypy.serving.request.header_list]
        cherrypy.log('\nRequest Headers:\n' + '\n'.join(h), 'HTTP')

    def log_hooks(debug=False):
        """Write request.hooks to the cherrypy error log."""
        request = cherrypy.serving.request

        msg = []
        # Sort by the standard points if possible.
        from cherrypy import _cprequest
        points = _cprequest.hookpoints
        for k in request.hooks.keys():
            if k not in points:
                points.append(k)

        for k in points:
            msg.append('    %s:' % k)
            v = request.hooks.get(k, [])
            v.sort()
            for h in v:
                msg.append('        %r' % h)
        cherrypy.log('\nRequest Hooks for ' + cherrypy.url() +
                     ':\n' + '\n'.join(msg), 'HTTP')

    def redirect(url='', internal=True, debug=False):
        """Raise InternalRedirect or HTTPRedirect to the given url."""
        if debug:
            cherrypy.log('Redirecting %sto: %s' %
                         ({True: 'internal ', False: ''}[internal], url),
                         'TOOLS.REDIRECT')
        if internal:
            raise cherrypy.InternalRedirect(url)
        else:
            raise cherrypy.HTTPRedirect(url)

    def trailing_slash(missing=True, extra=False, status=None, debug=False):
        """Redirect if path_info has (missing|extra) trailing slash."""
        request = cherrypy.serving.request
        pi = request.path_info

        if debug:
            cherrypy.log('is_index: %r, missing: %r, extra: %r, path_info: %r' %
                         (request.is_index, missing, extra, pi),
                         'TOOLS.TRAILING_SLASH')
        if request.is_index is True:
            if missing:
                if not pi.endswith('/'):
                    new_url = cherrypy.url(pi + '/', request.query_string)
                    raise cherrypy.HTTPRedirect(new_url, status=status or 301)
        elif request.is_index is False:
            if extra:
                # If pi == '/', don't redirect to ''!
                if pi.endswith('/') and pi != '/':
                    new_url = cherrypy.url(pi[:-1], request.query_string)
                    raise cherrypy.HTTPRedirect(new_url, status=status or 301)

    def flatten(debug=False):
        """Wrap response.body in a generator that recursively iterates over body.

        This allows cherrypy.response.body to consist of 'nested
        generators'; that is, a set of generators that yield generators.
        """
        def flattener(input):
            numchunks = 0
            for x in input:
                if not is_iterator(x):
                    numchunks += 1
                    yield x
                else:
                    for y in flattener(x):
                        numchunks += 1
                        yield y
            if debug:
                cherrypy.log('Flattened %d chunks' % numchunks, 'TOOLS.FLATTEN')
        response = cherrypy.serving.response
        response.body = flattener(response.body)

    def accept(media=None, debug=False):
        """Return the client's preferred media-type (from the given Content-Types).

        If 'media' is None (the default), no test will be performed.

        If 'media' is provided, it should be the Content-Type value (as a string)
        or values (as a list or tuple of strings) which the current resource
        can emit. The client's acceptable media ranges (as declared in the
        Accept request header) will be matched in order to these Content-Type
        values; the first such string is returned. That is, the return value
        will always be one of the strings provided in the 'media' arg (or None
        if 'media' is None).

        If no match is found, then HTTPError 406 (Not Acceptable) is raised.
        Note that most web browsers send */* as a (low-quality) acceptable
        media range, which should match any Content-Type. In addition, "...if
        no Accept header field is present, then it is assumed that the client
        accepts all media types."

        Matching types are checked in order of client preference first,
        and then in the order of the given 'media' values.

        Note that this function does not honor accept-params (other than "q").
        """
        if not media:
            return
        if isinstance(media, text_or_bytes):
            media = [media]
        request = cherrypy.serving.request

        # Parse the Accept request header, and try to match one
        # of the requested media-ranges (in order of preference).
        ranges = request.headers.elements('Accept')
        if not ranges:
            # Any media type is acceptable.
            if debug:
                cherrypy.log('No Accept header elements', 'TOOLS.ACCEPT')
            return media[0]
        else:
            # Note that 'ranges' is sorted in order of preference
            for element in ranges:
                if element.qvalue > 0:
                    if element.value == '*/*':
                        # Matches any type or subtype
                        if debug:
                            cherrypy.log('Match due to */*', 'TOOLS.ACCEPT')
                        return media[0]
                    elif element.value.endswith('/*'):
                        # Matches any subtype
                        mtype = element.value[:-1]  # Keep the slash
                        for m in media:
                            if m.startswith(mtype):
                                if debug:
                                    cherrypy.log('Match due to %s' % element.value,
                                                 'TOOLS.ACCEPT')
                                return m
                    else:
                        # Matches exact value
                        if element.value in media:
                            if debug:
                                cherrypy.log('Match due to %s' % element.value,
                                             'TOOLS.ACCEPT')
                            return element.value

        # No suitable media-range found.
        ah = request.headers.get('Accept')
        if ah is None:
            msg = 'Your client did not send an Accept header.'
        else:
            msg = 'Your client sent this Accept header: %s.' % ah
        msg += (' But this resource only emits these media types: %s.' %
                ', '.join(media))
        raise cherrypy.HTTPError(406, msg)

    class MonitoredHeaderMap(_httputil.HeaderMap):

        def transform_key(self, key):
            self.accessed_headers.add(key)
            return super(MonitoredHeaderMap, self).transform_key(key)

        def __init__(self):
            self.accessed_headers = set()
            super(MonitoredHeaderMap, self).__init__()

    def autovary(ignore=None, debug=False):
        """Auto-populate the Vary response header based on request.header access.
        """
        request = cherrypy.serving.request

        req_h = request.headers
        request.headers = MonitoredHeaderMap()
        request.headers.update(req_h)
        if ignore is None:
            ignore = set(['Content-Disposition', 'Content-Length', 'Content-Type'])

        def set_response_header():
            resp_h = cherrypy.serving.response.headers
            v = set([e.value for e in resp_h.elements('Vary')])
            if debug:
                cherrypy.log(
                    'Accessed headers: %s' % request.headers.accessed_headers,
                    'TOOLS.AUTOVARY')
            v = v.union(request.headers.accessed_headers)
            v = v.difference(ignore)
            v = list(v)
            v.sort()
            resp_h['Vary'] = ', '.join(v)
        request.hooks.attach('before_finalize', set_response_header, 95)

    def convert_params(exception=ValueError, error=400):
        """Convert request params based on function annotations.

        This function also processes errors that are subclasses of ``exception``.

        :param BaseException exception: Exception class to catch.
        :type exception: BaseException

        :param error: The HTTP status code to return to the client on failure.
        :type error: int
        """
        request = cherrypy.serving.request
        types = request.handler.callable.__annotations__
        with cherrypy.HTTPError.handle(exception, error):
            for key in set(types).intersection(request.params):
                request.params[key] = types[key](request.params[key])