EmbeddedPkg: Extend NvVarStoreFormattedLib LIBRARY_CLASS

[mirror_edk2.git] / AppPkg / Applications / Python / Python-2.7.2 / Lib / wsgiref / validate.py

# (c) 2005 Ian Bicking and contributors; written for Paste (http://pythonpaste.org)\r
# Licensed under the MIT license: http://www.opensource.org/licenses/mit-license.php\r
# Also licenced under the Apache License, 2.0: http://opensource.org/licenses/apache2.0.php\r
# Licensed to PSF under a Contributor Agreement\r
"""\r
Middleware to check for obedience to the WSGI specification.\r
\r
Some of the things this checks:\r
\r
* Signature of the application and start_response (including that\r
  keyword arguments are not used).\r
\r
* Environment checks:\r
\r
  - Environment is a dictionary (and not a subclass).\r
\r
  - That all the required keys are in the environment: REQUEST_METHOD,\r
    SERVER_NAME, SERVER_PORT, wsgi.version, wsgi.input, wsgi.errors,\r
    wsgi.multithread, wsgi.multiprocess, wsgi.run_once\r
\r
  - That HTTP_CONTENT_TYPE and HTTP_CONTENT_LENGTH are not in the\r
    environment (these headers should appear as CONTENT_LENGTH and\r
    CONTENT_TYPE).\r
\r
  - Warns if QUERY_STRING is missing, as the cgi module acts\r
    unpredictably in that case.\r
\r
  - That CGI-style variables (that don't contain a .) have\r
    (non-unicode) string values\r
\r
  - That wsgi.version is a tuple\r
\r
  - That wsgi.url_scheme is 'http' or 'https' (@@: is this too\r
    restrictive?)\r
\r
  - Warns if the REQUEST_METHOD is not known (@@: probably too\r
    restrictive).\r
\r
  - That SCRIPT_NAME and PATH_INFO are empty or start with /\r
\r
  - That at least one of SCRIPT_NAME or PATH_INFO are set.\r
\r
  - That CONTENT_LENGTH is a positive integer.\r
\r
  - That SCRIPT_NAME is not '/' (it should be '', and PATH_INFO should\r
    be '/').\r
\r
  - That wsgi.input has the methods read, readline, readlines, and\r
    __iter__\r
\r
  - That wsgi.errors has the methods flush, write, writelines\r
\r
* The status is a string, contains a space, starts with an integer,\r
  and that integer is in range (> 100).\r
\r
* That the headers is a list (not a subclass, not another kind of\r
  sequence).\r
\r
* That the items of the headers are tuples of strings.\r
\r
* That there is no 'status' header (that is used in CGI, but not in\r
  WSGI).\r
\r
* That the headers don't contain newlines or colons, end in _ or -, or\r
  contain characters codes below 037.\r
\r
* That Content-Type is given if there is content (CGI often has a\r
  default content type, but WSGI does not).\r
\r
* That no Content-Type is given when there is no content (@@: is this\r
  too restrictive?)\r
\r
* That the exc_info argument to start_response is a tuple or None.\r
\r
* That all calls to the writer are with strings, and no other methods\r
  on the writer are accessed.\r
\r
* That wsgi.input is used properly:\r
\r
  - .read() is called with zero or one argument\r
\r
  - That it returns a string\r
\r
  - That readline, readlines, and __iter__ return strings\r
\r
  - That .close() is not called\r
\r
  - No other methods are provided\r
\r
* That wsgi.errors is used properly:\r
\r
  - .write() and .writelines() is called with a string\r
\r
  - That .close() is not called, and no other methods are provided.\r
\r
* The response iterator:\r
\r
  - That it is not a string (it should be a list of a single string; a\r
    string will work, but perform horribly).\r
\r
  - That .next() returns a string\r
\r
  - That the iterator is not iterated over until start_response has\r
    been called (that can signal either a server or application\r
    error).\r
\r
  - That .close() is called (doesn't raise exception, only prints to\r
    sys.stderr, because we only know it isn't called when the object\r
    is garbage collected).\r
"""\r
__all__ = ['validator']\r
\r
\r
import re\r
import sys\r
from types import DictType, StringType, TupleType, ListType\r
import warnings\r
\r
header_re = re.compile(r'^[a-zA-Z][a-zA-Z0-9\-_]*$')\r
bad_header_value_re = re.compile(r'[\000-\037]')\r
\r
class WSGIWarning(Warning):\r
    """\r
    Raised in response to WSGI-spec-related warnings\r
    """\r
\r
def assert_(cond, *args):\r
    if not cond:\r
        raise AssertionError(*args)\r
\r
def validator(application):\r
\r
    """\r
    When applied between a WSGI server and a WSGI application, this\r
    middleware will check for WSGI compliancy on a number of levels.\r
    This middleware does not modify the request or response in any\r
    way, but will throw an AssertionError if anything seems off\r
    (except for a failure to close the application iterator, which\r
    will be printed to stderr -- there's no way to throw an exception\r
    at that point).\r
    """\r
\r
    def lint_app(*args, **kw):\r
        assert_(len(args) == 2, "Two arguments required")\r
        assert_(not kw, "No keyword arguments allowed")\r
        environ, start_response = args\r
\r
        check_environ(environ)\r
\r
        # We use this to check if the application returns without\r
        # calling start_response:\r
        start_response_started = []\r
\r
        def start_response_wrapper(*args, **kw):\r
            assert_(len(args) == 2 or len(args) == 3, (\r
                "Invalid number of arguments: %s" % (args,)))\r
            assert_(not kw, "No keyword arguments allowed")\r
            status = args[0]\r
            headers = args[1]\r
            if len(args) == 3:\r
                exc_info = args[2]\r
            else:\r
                exc_info = None\r
\r
            check_status(status)\r
            check_headers(headers)\r
            check_content_type(status, headers)\r
            check_exc_info(exc_info)\r
\r
            start_response_started.append(None)\r
            return WriteWrapper(start_response(*args))\r
\r
        environ['wsgi.input'] = InputWrapper(environ['wsgi.input'])\r
        environ['wsgi.errors'] = ErrorWrapper(environ['wsgi.errors'])\r
\r
        iterator = application(environ, start_response_wrapper)\r
        assert_(iterator is not None and iterator != False,\r
            "The application must return an iterator, if only an empty list")\r
\r
        check_iterator(iterator)\r
\r
        return IteratorWrapper(iterator, start_response_started)\r
\r
    return lint_app\r
\r
class InputWrapper:\r
\r
    def __init__(self, wsgi_input):\r
        self.input = wsgi_input\r
\r
    def read(self, *args):\r
        assert_(len(args) <= 1)\r
        v = self.input.read(*args)\r
        assert_(type(v) is type(""))\r
        return v\r
\r
    def readline(self):\r
        v = self.input.readline()\r
        assert_(type(v) is type(""))\r
        return v\r
\r
    def readlines(self, *args):\r
        assert_(len(args) <= 1)\r
        lines = self.input.readlines(*args)\r
        assert_(type(lines) is type([]))\r
        for line in lines:\r
            assert_(type(line) is type(""))\r
        return lines\r
\r
    def __iter__(self):\r
        while 1:\r
            line = self.readline()\r
            if not line:\r
                return\r
            yield line\r
\r
    def close(self):\r
        assert_(0, "input.close() must not be called")\r
\r
class ErrorWrapper:\r
\r
    def __init__(self, wsgi_errors):\r
        self.errors = wsgi_errors\r
\r
    def write(self, s):\r
        assert_(type(s) is type(""))\r
        self.errors.write(s)\r
\r
    def flush(self):\r
        self.errors.flush()\r
\r
    def writelines(self, seq):\r
        for line in seq:\r
            self.write(line)\r
\r
    def close(self):\r
        assert_(0, "errors.close() must not be called")\r
\r
class WriteWrapper:\r
\r
    def __init__(self, wsgi_writer):\r
        self.writer = wsgi_writer\r
\r
    def __call__(self, s):\r
        assert_(type(s) is type(""))\r
        self.writer(s)\r
\r
class PartialIteratorWrapper:\r
\r
    def __init__(self, wsgi_iterator):\r
        self.iterator = wsgi_iterator\r
\r
    def __iter__(self):\r
        # We want to make sure __iter__ is called\r
        return IteratorWrapper(self.iterator, None)\r
\r
class IteratorWrapper:\r
\r
    def __init__(self, wsgi_iterator, check_start_response):\r
        self.original_iterator = wsgi_iterator\r
        self.iterator = iter(wsgi_iterator)\r
        self.closed = False\r
        self.check_start_response = check_start_response\r
\r
    def __iter__(self):\r
        return self\r
\r
    def next(self):\r
        assert_(not self.closed,\r
            "Iterator read after closed")\r
        v = self.iterator.next()\r
        if self.check_start_response is not None:\r
            assert_(self.check_start_response,\r
                "The application returns and we started iterating over its body, but start_response has not yet been called")\r
            self.check_start_response = None\r
        return v\r
\r
    def close(self):\r
        self.closed = True\r
        if hasattr(self.original_iterator, 'close'):\r
            self.original_iterator.close()\r
\r
    def __del__(self):\r
        if not self.closed:\r
            sys.stderr.write(\r
                "Iterator garbage collected without being closed")\r
        assert_(self.closed,\r
            "Iterator garbage collected without being closed")\r
\r
def check_environ(environ):\r
    assert_(type(environ) is DictType,\r
        "Environment is not of the right type: %r (environment: %r)"\r
        % (type(environ), environ))\r
\r
    for key in ['REQUEST_METHOD', 'SERVER_NAME', 'SERVER_PORT',\r
                'wsgi.version', 'wsgi.input', 'wsgi.errors',\r
                'wsgi.multithread', 'wsgi.multiprocess',\r
                'wsgi.run_once']:\r
        assert_(key in environ,\r
            "Environment missing required key: %r" % (key,))\r
\r
    for key in ['HTTP_CONTENT_TYPE', 'HTTP_CONTENT_LENGTH']:\r
        assert_(key not in environ,\r
            "Environment should not have the key: %s "\r
            "(use %s instead)" % (key, key[5:]))\r
\r
    if 'QUERY_STRING' not in environ:\r
        warnings.warn(\r
            'QUERY_STRING is not in the WSGI environment; the cgi '\r
            'module will use sys.argv when this variable is missing, '\r
            'so application errors are more likely',\r
            WSGIWarning)\r
\r
    for key in environ.keys():\r
        if '.' in key:\r
            # Extension, we don't care about its type\r
            continue\r
        assert_(type(environ[key]) is StringType,\r
            "Environmental variable %s is not a string: %r (value: %r)"\r
            % (key, type(environ[key]), environ[key]))\r
\r
    assert_(type(environ['wsgi.version']) is TupleType,\r
        "wsgi.version should be a tuple (%r)" % (environ['wsgi.version'],))\r
    assert_(environ['wsgi.url_scheme'] in ('http', 'https'),\r
        "wsgi.url_scheme unknown: %r" % environ['wsgi.url_scheme'])\r
\r
    check_input(environ['wsgi.input'])\r
    check_errors(environ['wsgi.errors'])\r
\r
    # @@: these need filling out:\r
    if environ['REQUEST_METHOD'] not in (\r
        'GET', 'HEAD', 'POST', 'OPTIONS','PUT','DELETE','TRACE'):\r
        warnings.warn(\r
            "Unknown REQUEST_METHOD: %r" % environ['REQUEST_METHOD'],\r
            WSGIWarning)\r
\r
    assert_(not environ.get('SCRIPT_NAME')\r
            or environ['SCRIPT_NAME'].startswith('/'),\r
        "SCRIPT_NAME doesn't start with /: %r" % environ['SCRIPT_NAME'])\r
    assert_(not environ.get('PATH_INFO')\r
            or environ['PATH_INFO'].startswith('/'),\r
        "PATH_INFO doesn't start with /: %r" % environ['PATH_INFO'])\r
    if environ.get('CONTENT_LENGTH'):\r
        assert_(int(environ['CONTENT_LENGTH']) >= 0,\r
            "Invalid CONTENT_LENGTH: %r" % environ['CONTENT_LENGTH'])\r
\r
    if not environ.get('SCRIPT_NAME'):\r
        assert_('PATH_INFO' in environ,\r
            "One of SCRIPT_NAME or PATH_INFO are required (PATH_INFO "\r
            "should at least be '/' if SCRIPT_NAME is empty)")\r
    assert_(environ.get('SCRIPT_NAME') != '/',\r
        "SCRIPT_NAME cannot be '/'; it should instead be '', and "\r
        "PATH_INFO should be '/'")\r
\r
def check_input(wsgi_input):\r
    for attr in ['read', 'readline', 'readlines', '__iter__']:\r
        assert_(hasattr(wsgi_input, attr),\r
            "wsgi.input (%r) doesn't have the attribute %s"\r
            % (wsgi_input, attr))\r
\r
def check_errors(wsgi_errors):\r
    for attr in ['flush', 'write', 'writelines']:\r
        assert_(hasattr(wsgi_errors, attr),\r
            "wsgi.errors (%r) doesn't have the attribute %s"\r
            % (wsgi_errors, attr))\r
\r
def check_status(status):\r
    assert_(type(status) is StringType,\r
        "Status must be a string (not %r)" % status)\r
    # Implicitly check that we can turn it into an integer:\r
    status_code = status.split(None, 1)[0]\r
    assert_(len(status_code) == 3,\r
        "Status codes must be three characters: %r" % status_code)\r
    status_int = int(status_code)\r
    assert_(status_int >= 100, "Status code is invalid: %r" % status_int)\r
    if len(status) < 4 or status[3] != ' ':\r
        warnings.warn(\r
            "The status string (%r) should be a three-digit integer "\r
            "followed by a single space and a status explanation"\r
            % status, WSGIWarning)\r
\r
def check_headers(headers):\r
    assert_(type(headers) is ListType,\r
        "Headers (%r) must be of type list: %r"\r
        % (headers, type(headers)))\r
    header_names = {}\r
    for item in headers:\r
        assert_(type(item) is TupleType,\r
            "Individual headers (%r) must be of type tuple: %r"\r
            % (item, type(item)))\r
        assert_(len(item) == 2)\r
        name, value = item\r
        assert_(name.lower() != 'status',\r
            "The Status header cannot be used; it conflicts with CGI "\r
            "script, and HTTP status is not given through headers "\r
            "(value: %r)." % value)\r
        header_names[name.lower()] = None\r
        assert_('\n' not in name and ':' not in name,\r
            "Header names may not contain ':' or '\\n': %r" % name)\r
        assert_(header_re.search(name), "Bad header name: %r" % name)\r
        assert_(not name.endswith('-') and not name.endswith('_'),\r
            "Names may not end in '-' or '_': %r" % name)\r
        if bad_header_value_re.search(value):\r
            assert_(0, "Bad header value: %r (bad char: %r)"\r
            % (value, bad_header_value_re.search(value).group(0)))\r
\r
def check_content_type(status, headers):\r
    code = int(status.split(None, 1)[0])\r
    # @@: need one more person to verify this interpretation of RFC 2616\r
    #     http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html\r
    NO_MESSAGE_BODY = (204, 304)\r
    for name, value in headers:\r
        if name.lower() == 'content-type':\r
            if code not in NO_MESSAGE_BODY:\r
                return\r
            assert_(0, ("Content-Type header found in a %s response, "\r
                        "which must not return content.") % code)\r
    if code not in NO_MESSAGE_BODY:\r
        assert_(0, "No Content-Type header found in headers (%s)" % headers)\r
\r
def check_exc_info(exc_info):\r
    assert_(exc_info is None or type(exc_info) is type(()),\r
        "exc_info (%r) is not a tuple: %r" % (exc_info, type(exc_info)))\r
    # More exc_info checks?\r
\r
def check_iterator(iterator):\r
    # Technically a string is legal, which is why it's a really bad\r
    # idea, because it may cause the response to be returned\r
    # character-by-character\r
    assert_(not isinstance(iterator, str),\r
        "You should not return a string as your application iterator, "\r
        "instead return a single-item list containing that string.")\r