HEX

File: //opt/saltstack/salt/lib/python3.10/site-packages/tornado/__pycache__/httputil.cpython-310.pyc
o

;jJ��@s�dZddlZddlZddlZddlZddlZddlZddl	m
Z
ddlmZddl
ZddlZddlmZddlZddlZddlmZmZmZmZddlmZmZmZmZddlmZm Z eddl!Z!dd	l!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,e!j-r�dd
l!m.Z.ddl/m0Z0ddl1Z1ej2j3e4e4fZ5nej2j3Z5dZ6e�7d
�Z8Gdd�d�Z9e
d�de4de4fdd��Z:Gdd�de5�Z;Gdd�d�Z<Gdd�de=�Z>Gdd�de=�Z?Gdd�d�Z@Gdd �d �ZAGd!d"�d"�ZBd#e4d$e(de'e4e4fe$e"e4e4fe"e"e4e4fd%ffde4fd&d'�ZCGd(d)�d)e�ZDd*e4de)e"e)eEe)eEffd+d,�ZFd-e)eEd.e)eEd/eEde4fd0d1�ZGd2e4de)eEfd3d4�ZHejIGd5d6�d6��ZJejIGd7d8�d8��ZKeK�aLd9eKddfd:d;�ZM	dsdd<�d=e4d>eNd?e'e4e$eNfd@e'e4e$eDfdAe)e;d9e)eKddfdBdC�ZOdd<�dDeNdEeNd?e'e4e$eNfd@e'e4e$eDfd9e)eJddfdFdG�ZPdHe(eEeQeRejSejfde4fdIdJ�ZTGdKdL�dLe!jU�ZVdMe4deVfdNdO�ZWGdPdQ�dQe!jU�ZXdMe4deXfdRdS�ZYdTe4de+e4ddffdUdV�ZZdMe4de"e4e'e4e4fffdWdX�Z[dYe4dZe'e4e4fde4fd[d\�Z\d]e(e4eNfd^e(e4eNfdeNfd_d`�Z]dadb�Z^e�7dc�Z_dde4de"e4e)eEffdedf�Z`dge'e4e$e,fde#e"e4e,ffdhdi�Zae�7dj�jbZcdkejdde4fdldm�ZedTe4de4fdndo�Zfdpe4de'e4e4ffdqdr�ZgdS)tz�HTTP utility code shared by clients and servers.

This module also defines the `HTTPServerRequest` class which is exposed
via `tornado.web.RequestHandler.request`.
�N)�	lru_cache)�	responses)�SSLError)�	urlencode�urlparse�
urlunparse�	parse_qsl)�
native_str�parse_qs_bytes�utf8�
to_unicode)�
ObjectDict�unicode_type)�Tuple�Iterable�List�Mapping�Iterator�Dict�Union�Optional�	Awaitable�	Generator�AnyStr)�Deque)�Futurez 	z[\x00-\x08\x0A-\x1F\x7F]c
@s�eZdZdZe�d�Ze�d�Ze�d�Ze�dej	�dej	�dej	�d��Z
e�d�Ze�d	�Ze�d
�Z
e�dej	�de
j	�d��Ze�dej	�dej	�dej	�d
ej	���Ze�d�Ze�ej	�d��ZeZeZe�de
j	�dej	�d��Ze�d�Ze�dej	�de
j	�d��Ze�ej	�d��Ze�dej	�dej	�dej	�d��Ze�d�Ze�dej	�dej	�dej	�d��ZdS)�_ABNFa}Class that holds a subset of ABNF rules from RFC 9110 and friends.

    Class attributes are re.Pattern objects, with the same name as in the RFC
    (with hyphens changed to underscores). Currently contains only the subset
    we use (which is why this class is not public). Unfortunately the fields
    cannot be alphabetized as they are in the RFCs because of dependencies.
    z[A-Za-z0-9\-._~]z
[!$&'()*+,;=]z%[0-9A-Fa-f]{2}z(?:[\[\]:]|�|z)*z[0-9]*z[\x21-\x7E]z[\x80-\xFF]z(?:�)z| |\t)*z[!#$%&'*+\-.^_`|~0-9A-Za-z]�+z)(?::z)?zHTTP/[0-9]\.[0-9]z	(?:[\t ]|z)+�(z) (z[0-9]{3}N)�__name__�
__module__�__qualname__�__doc__�re�compileZuri_unreservedZuri_sub_delimsZuri_pct_encoded�patternZuri_hostZuri_portZVCHARZobs_textZfield_vchar�field_valueZtchar�token�
field_name�method�hostZHTTP_versionZ
reason_phraseZrequest_target�request_lineZstatus_code�status_line�r/r/�D/opt/saltstack/salt/lib/python3.10/site-packages/tornado/httputil.pyrOsL


�


�����

�
�ri��name�returncCsd�dd�|�d�D��S)ziMap a header name to Http-Header-Case.

    >>> _normalize_header("coNtent-TYPE")
    'Content-Type'
    �-cSsg|]}|���qSr/)�
capitalize)�.0�wr/r/r0�
<listcomp>�sz%_normalize_header.<locals>.<listcomp>)�join�split)r1r/r/r0�_normalize_header�sr:c	@s�eZdZdZejdeeeefddfdd��Z	ejdeeefddfdd��Z	ejde
eefddfd	d��Z	ejd
eddfdd��Z	dejd
eddfdd�Z	d
d�dedededdfdd�Z
dedeefdd�Zdee
eeffdd�Zd
d�dededdfdd�Zed
d�dededdfdd��Zdededdfdd�Zdedefd d!�Zdedefd"d#�Zdeddfd$d%�Zdefd&d'�Zdeejfd(d)�Zd.d*d+�ZeZdefd,d-�ZeZ dS)/�HTTPHeadersa�A dictionary that maintains ``Http-Header-Case`` for all keys.

    Supports multiple values per key via a pair of new methods,
    `add()` and `get_list()`.  The regular dictionary interface
    returns a single value per key, with multiple values joined by a
    comma.

    >>> h = HTTPHeaders({"content-type": "text/html"})
    >>> list(h.keys())
    ['Content-Type']
    >>> h["Content-Type"]
    'text/html'

    >>> h.add("Set-Cookie", "A=B")
    >>> h.add("Set-Cookie", "C=D")
    >>> h["set-cookie"]
    'A=B,C=D'
    >>> h.get_list("set-cookie")
    ['A=B', 'C=D']

    >>> for (k,v) in sorted(h.get_all()):
    ...    print('%s: %s' % (k,v))
    ...
    Content-Type: text/html
    Set-Cookie: A=B
    Set-Cookie: C=D
    �_HTTPHeaders__argr2NcC�dS�Nr/��selfr<r/r/r0�__init__��zHTTPHeaders.__init__cCr=r>r/r?r/r/r0rA�rB�argscGr=r>r/)r@rCr/r/r0rA�rB�kwargscKr=r>r/)r@rDr/r/r0rA�rBcOsri|_i|_d|_t|�dkr/t|�dkr/t|dt�r/|d��D]
\}}|�||�q"dS|j|i|��dS)N�r)	�_as_list�_combined_cache�	_last_key�len�
isinstancer;�get_all�add�update)r@rCrD�k�vr/r/r0rA�s&�T��_chars_are_bytesr1�valuerQcCs�tj�|�std|��|rtj�t|��std|��nt�|�r(td|��t|�}||_	||vrD|j
�|d�|j|�
|�dS|||<dS)z#Adds a new value for the given key.zInvalid header name %r�Invalid header value %rN)rr*�	fullmatch�HTTPInputErrorr(r�_FORBIDDEN_HEADER_CHARS_RE�searchr:rHrG�poprF�append)r@r1rRrQ�	norm_namer/r/r0rL�s�
zHTTPHeaders.addcCst|�}|j�|g�S)z2Returns all values for the given header as a list.)r:rF�get�r@r1rZr/r/r0�get_list�szHTTPHeaders.get_listccs.�|j��D]\}}|D]}||fVqqdS)z�Returns an iterable of all (name, value) pairs.

        If a header has multiple values, multiple pairs will be
        returned with the same name.
        N)rF�items)r@r1�valuesrRr/r/r0rK�s���zHTTPHeaders.get_all�linecCst�d|�}r|d|���}|sdS|dtvr^|jdur#td��d|�t�}|r=tj�	|dd��s<td|��nt
�|�rHtd|��|j|jd	|7<|j�
|jd�dSz
|�d
d�\}}Wntystd��w|j||�t�|d�dS)
a�Updates the dictionary with a single header line.

        >>> h = HTTPHeaders()
        >>> h.parse_line("Content-Type: text/html")
        >>> h.get('content-type')
        'text/html'
        >>> h.parse_line("Content-Length: 42\r\n")
        >>> h.get('content-type')
        'text/html'

        .. versionchanged:: 6.5
            Now supports lines with or without the trailing CRLF, making it possible
            to pass lines from AsyncHTTPClient's header_callback directly to this method.

        .. deprecated:: 6.5
           In Tornado 7.0, certain deprecated features of HTTP will become errors.
           Specifically, line folding and the use of LF (with CR) as a line separator
           will be removed.
        z\r?\n$Nrz.first header line cannot start with whitespace� rEzInvalid header continuation %rrS����:zno colon in header linerP)r%rW�start�HTTP_WHITESPACErHrU�striprr(rTrVrFrGrXr9�
ValueErrorrL)r@r`rQ�mZnew_partr1rRr/r/r0�
parse_line�s0
�
�
�zHTTPHeaders.parse_line�headerscCsd|�}d}	|�d|�}|dkr|j||d�|d�	|S|||d�}|d}|j||d�q)a�Returns a dictionary from HTTP header text.

        >>> h = HTTPHeaders.parse("Content-Type: text/html\r\nContent-Length: 42\r\n")
        >>> sorted(h.items())
        [('Content-Length', '42'), ('Content-Type', 'text/html')]

        .. versionchanged:: 5.1

           Raises `HTTPInputError` on malformed headers instead of a
           mix of `KeyError`, and `ValueError`.

        rT�
rbNrPrE)�findri)�clsrjrQ�hrdZlfr`r/r/r0�parse(s��zHTTPHeaders.parsecCs"t|�}||j|<|g|j|<dSr>�r:rGrF)r@r1rRrZr/r/r0�__setitem__Ss
zHTTPHeaders.__setitem__cCs t|t�sdSt|�}||jvS)NF)rJ�strr:rFr\r/r/r0�__contains__Xs

zHTTPHeaders.__contains__cCs2t|�}||jvrd�|j|�|j|<|j|S)N�,)r:rGr8rF)r@r1�headerr/r/r0�__getitem__`s

zHTTPHeaders.__getitem__cCst|�}|j|=|j|=dSr>rpr\r/r/r0�__delitem__fszHTTPHeaders.__delitem__cC�
t|j�Sr>)rIrF�r@r/r/r0�__len__k�
zHTTPHeaders.__len__cCrxr>)�iterrFryr/r/r0�__iter__nr{zHTTPHeaders.__iter__cCst|�Sr>)r;ryr/r/r0�copyqszHTTPHeaders.copycCs6g}|��D]\}}|�|�d|�d��qd�|�S)Nz: rk�)rKrYr8)r@�linesr1rRr/r/r0�__str__zs
zHTTPHeaders.__str__)r2r;)!r!r"r#r$�typing�overloadrrrrrAr�Any�boolrLr]rrKri�classmethodrorq�objectrsrvrw�intrzrr}r~�__copy__r�Z__unicode__r/r/r/r0r;�s6  
3*
r;c@s
eZdZdZdZdZdZ										d"deedeededee	dee
d	eed
eeeedfded
deddee
ddfdd�Zedeeejjffdd��Zdefdd�Zdefdd�Z	d#dededee
ffdd�Zd$dd�Zdefd d!�ZdS)%�HTTPServerRequesta/A single HTTP request.

    All attributes are type `str` unless otherwise noted.

    .. attribute:: method

       HTTP request method, e.g. "GET" or "POST"

    .. attribute:: uri

       The requested uri.

    .. attribute:: path

       The path portion of `uri`

    .. attribute:: query

       The query portion of `uri`

    .. attribute:: version

       HTTP version specified in request, e.g. "HTTP/1.1"

    .. attribute:: headers

       `.HTTPHeaders` dictionary-like object for request headers.  Acts like
       a case-insensitive dictionary with additional methods for repeated
       headers.

    .. attribute:: body

       Request body, if present, as a byte string.

    .. attribute:: remote_ip

       Client's IP address as a string.  If ``HTTPServer.xheaders`` is set,
       will pass along the real IP address provided by a load balancer
       in the ``X-Real-Ip`` or ``X-Forwarded-For`` header.

    .. versionchanged:: 3.1
       The list format of ``X-Forwarded-For`` is now supported.

    .. attribute:: protocol

       The protocol used, either "http" or "https".  If ``HTTPServer.xheaders``
       is set, will pass along the protocol used by a load balancer if
       reported via an ``X-Scheme`` header.

    .. attribute:: host

       The requested hostname, usually taken from the ``Host`` header.

    .. attribute:: arguments

       GET/POST arguments are available in the arguments property, which
       maps arguments names to lists of values (to support multiple values
       for individual names). Names are of type `str`, while arguments
       are byte strings.  Note that this is different from
       `.RequestHandler.get_argument`, which returns argument values as
       unicode strings.

    .. attribute:: query_arguments

       Same format as ``arguments``, but contains only arguments extracted
       from the query string.

       .. versionadded:: 3.2

    .. attribute:: body_arguments

       Same format as ``arguments``, but contains only arguments extracted
       from the request body.

       .. versionadded:: 3.2

    .. attribute:: files

       File uploads are available in the files property, which maps file
       names to lists of `.HTTPFile`.

    .. attribute:: connection

       An HTTP request is attached to a single HTTP connection, which can
       be accessed through the "connection" attribute. Since connections
       are typically kept open in HTTP/1.1, multiple requests can be handled
       sequentially on a single connection.

    .. versionchanged:: 4.0
       Moved from ``tornado.httpserver.HTTPRequest``.

    .. deprecated:: 6.5.2
       The ``host`` argument to the ``HTTPServerRequest`` constructor is deprecated. Use
       ``headers["Host"]`` instead. This argument was mistakenly removed in Tornado 6.5.0 and
       temporarily restored in 6.5.2.
    N�HTTP/1.0r+�uri�versionrj�bodyr,�files�HTTPFile�
connection�HTTPConnection�
start_line�RequestStartLine�server_connectionr2c
CsT|	dur	|	\}}}||_||_||_|pt�|_|pd|_t|dd�}t|dd�|_t|dd�|_z
|p8|jd|_	Wnt
yP|dkrJd|_	ntd	��Ynwtj	�
|j	�s_td
|j	��d|j	vrktd|j	��t|j	���d
|_|pxi|_||_|
|_t��|_d|_|dur�|�d�\|_}|_t|jdd�|_t�|j�|_i|_dS)N��context�	remote_ip�protocol�http�Hostr�z	127.0.0.1zMissing Host headerzInvalid Host header: %rrtz%Multiple host headers not allowed: %rr�?T��keep_blank_values) r+r�r�r;rjr��getattrr�r�r,�KeyErrorrUrrT�split_host_and_port�lowerZ	host_namer�r�r��time�_start_time�_finish_time�	partition�path�queryr
�	argumentsr~�deepcopyZquery_arguments�body_arguments)
r@r+r�r�rjr�r,r�r�r�r�r��sepr/r/r0rA�sB

��



zHTTPServerRequest.__init__c	Cs�t|d�s>tj��|_d|jvr>z	t|jd�}Wnty$Y|jSw|��D]\}}z||j|<Wq)ty=Yq)w|jS)z0A dictionary of ``http.cookies.Morsel`` objects.�_cookiesZCookie)	�hasattrr��cookiesZSimpleCookier�rj�parse_cookie�	Exceptionr^)r@�parsedrNrOr/r/r0r�.s"
�

��zHTTPServerRequest.cookiescCs|jd|j|jS)z+Reconstructs the full URL for this request.z://)r�r,r�ryr/r/r0�full_urlEszHTTPServerRequest.full_urlcCs$|jdurt��|jS|j|jS)z?Returns the amount of time it took for this request to execute.N)r�r�r�ryr/r/r0�request_timeIs
zHTTPServerRequest.request_timeF�binary_formcCs:z|jdur	WdS|jjjj|d�WStyYdSw)a>Returns the client's SSL certificate, if any.

        To use client certificates, the HTTPServer's
        `ssl.SSLContext.verify_mode` field must be set, e.g.::

            ssl_ctx = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
            ssl_ctx.load_cert_chain("foo.crt", "foo.key")
            ssl_ctx.load_verify_locations("cacerts.pem")
            ssl_ctx.verify_mode = ssl.CERT_REQUIRED
            server = HTTPServer(app, ssl_options=ssl_ctx)

        By default, the return value is a dictionary (or None, if no
        client certificate is present).  If ``binary_form`` is true, a
        DER-encoded form of the certificate is returned instead.  See
        SSLSocket.getpeercert() in the standard library for more
        details.
        http://docs.python.org/library/ssl.html#sslsocket-objects
        N)r�)r��stream�socket�getpeercertr)r@r�r/r/r0�get_ssl_certificatePs

��z%HTTPServerRequest.get_ssl_certificatecCsNt|j�dd�|j|j|j|j�|j��D]\}}|j�|g��	|�qdS)N�Content-Typer)
�parse_body_argumentsrjr[r�r�r�r^r��
setdefault�extend)r@rNrOr/r/r0�_parse_bodyos��zHTTPServerRequest._parse_bodycs0d}d��fdd�|D��}�jj�d|�d�S)N)r�r,r+r�r�r�z, cs g|]}|�dt�|����qS)�=)r�)r5�nryr/r0r7}s z.HTTPServerRequest.__repr__.<locals>.<listcomp>r r)r8�	__class__r!)r@�attrsrCr/ryr0�__repr__{szHTTPServerRequest.__repr__)
NNr�NNNNNNN)F�r2N)r!r"r#r$r�r�Z_body_futurerrrr;�bytesrrr�rA�propertyr�r�ZMorselr��floatr�r�rr�r�r�r/r/r/r0r��sda��������	�
��
�C��
�
r�c@�eZdZdZdS)rUzqException class for malformed HTTP requests or responses
    from remote sources.

    .. versionadded:: 4.0
    N�r!r"r#r$r/r/r/r0rU�srUc@r�)�HTTPOutputErrorzJException class for errors in HTTP output.

    .. versionadded:: 4.0
    Nr�r/r/r/r0r��sr�c@s8eZdZdZdeddddfdd�Zdedd	fd
d�Zd	S)�HTTPServerConnectionDelegatez_Implement this interface to handle requests from `.HTTPServer`.

    .. versionadded:: 4.0
    �server_conn�request_connr�r2�HTTPMessageDelegatecC�t��)ajThis method is called by the server when a new request has started.

        :arg server_conn: is an opaque object representing the long-lived
            (e.g. tcp-level) connection.
        :arg request_conn: is a `.HTTPConnection` object for a single
            request/response exchange.

        This method should return a `.HTTPMessageDelegate`.
        ��NotImplementedError)r@r�r�r/r/r0�
start_request�sz*HTTPServerConnectionDelegate.start_requestNcC�dS)z�This method is called when a connection has been closed.

        :arg server_conn: is a server connection that has previously been
            passed to ``start_request``.
        Nr/)r@r�r/r/r0�on_close��z%HTTPServerConnectionDelegate.on_close)r!r"r#r$r�r�r�r/r/r/r0r��s��
�r�c@s`eZdZdZdeddedeedfdd�Zd	e	deedfd
d�Z
ddd
�Zddd�ZdS)r�z_Implement this interface to handle an HTTP request or response.

    .. versionadded:: 4.0
    r��r��ResponseStartLinerjr2NcCr�)a�Called when the HTTP headers have been received and parsed.

        :arg start_line: a `.RequestStartLine` or `.ResponseStartLine`
            depending on whether this is a client or server message.
        :arg headers: a `.HTTPHeaders` instance.

        Some `.HTTPConnection` methods can only be called during
        ``headers_received``.

        May return a `.Future`; if it does the body will not be read
        until it is done.
        Nr/)r@r�rjr/r/r0�headers_received�sz$HTTPMessageDelegate.headers_received�chunkcCr�)ziCalled when a chunk of data has been received.

        May return a `.Future` for flow control.
        Nr/�r@r�r/r/r0�
data_received�sz!HTTPMessageDelegate.data_receivedcCr�)z6Called after the last chunk of data has been received.Nr/ryr/r/r0�finish�rBzHTTPMessageDelegate.finishcCr�)z�Called if the connection is closed without finishing the request.

        If ``headers_received`` is called, either ``finish`` or
        ``on_connection_close`` will be called, but not both.
        Nr/ryr/r/r0�on_connection_close�r�z'HTTPMessageDelegate.on_connection_closer�)
r!r"r#r$rr;rrr�r�r�r�r�r/r/r/r0r��s��

�
r�c	@sReZdZdZ	ddeddedeeddfd	d
�Zdeddfdd�Z	dd
d�Z
dS)r�zYApplications use this interface to write their responses.

    .. versionadded:: 4.0
    Nr�r�rjr�r2zFuture[None]cCr�)aWrite an HTTP header block.

        :arg start_line: a `.RequestStartLine` or `.ResponseStartLine`.
        :arg headers: a `.HTTPHeaders` instance.
        :arg chunk: the first (optional) chunk of data.  This is an optimization
            so that small responses can be written in the same call as their
            headers.

        The ``version`` field of ``start_line`` is ignored.

        Returns a future for flow control.

        .. versionchanged:: 6.0

           The ``callback`` argument was removed.
        r�)r@r�rjr�r/r/r0�
write_headers�szHTTPConnection.write_headerscCr�)z�Writes a chunk of body data.

        Returns a future for flow control.

        .. versionchanged:: 6.0

           The ``callback`` argument was removed.
        r�r�r/r/r0�write�s	zHTTPConnection.writecCr�)z3Indicates that the last body data has been written.r�ryr/r/r0r�szHTTPConnection.finishr>r�)r!r"r#r$rr;rr�r�r�r�r/r/r/r0r��s	����
�r��urlrC.cCs�|dur|St|�}t|t�rt|jdd�}|�|���n"t|t�s(t|t�r5t|jdd�}|�|�nd�	t
|��}t|��t|�}t
|d|d|d|d||d	f�}|S)
aConcatenate url and arguments regardless of whether
    url has existing query parameters.

    ``args`` may be either a dictionary or a list of key-value pairs
    (the latter allows for multiple values with the same key.

    >>> url_concat("http://example.com/foo", dict(c="d"))
    'http://example.com/foo?c=d'
    >>> url_concat("http://example.com/foo?a=b", dict(c="d"))
    'http://example.com/foo?a=b&c=d'
    >>> url_concat("http://example.com/foo?a=b", [("c", "d"), ("c", "d2")])
    'http://example.com/foo?a=b&c=d&c=d2'
    NTr�z7'args' parameter should be dict, list or tuple. Not {0}rrE���)rrJ�dictrr�r�r^�list�tuple�format�type�	TypeErrorrr)r�rCZ
parsed_urlZparsed_query�errZfinal_queryr/r/r0�
url_concat
s0
���
r�c@s*eZdZUdZeed<eed<eed<dS)r�z�Represents a file uploaded via a form.

    For backwards compatibility, its instance attributes are also
    accessible as dictionary keys.

    * ``filename``
    * ``body``
    * ``content_type``
    �filenamer��content_typeN)r!r"r#r$rr�__annotations__r�r/r/r/r0r�<s


r��range_headercCs�|�d�\}}}|��|��}}|dkrdS|�d�\}}}z
t|�}t|�}Wn
ty3YdSw|durM|durI|dkrE|}d}||fS|d7}||fS)agParses a Range header.

    Returns either ``None`` or tuple ``(start, end)``.
    Note that while the HTTP headers use inclusive byte positions,
    this method returns indexes suitable for use in slices.

    >>> start, end = _parse_request_range("bytes=1-2")
    >>> start, end
    (1, 3)
    >>> [0, 1, 2, 3, 4][start:end]
    [1, 2]
    >>> _parse_request_range("bytes=6-")
    (6, None)
    >>> _parse_request_range("bytes=-6")
    (-6, None)
    >>> _parse_request_range("bytes=-0")
    (None, 0)
    >>> _parse_request_range("bytes=")
    (None, None)
    >>> _parse_request_range("foo=42")
    >>> _parse_request_range("bytes=1-2,6-10")

    Note: only supports one range (ex, ``bytes=1-2,6-10`` is not allowed).

    See [0] for the details of the range header.

    [0]: http://greenbytes.de/tech/webdav/draft-ietf-httpbis-p5-range-latest.html#byte.ranges
    r�r�Nr3rrE)r�rf�_int_or_nonerg)r�Zunit�_rRZstart_bZend_brd�endr/r/r0�_parse_request_rangeLs&��r�rdr��totalcCs*|pd}|p|d}d|�d|�d|��S)z�Returns a suitable Content-Range header:

    >>> print(_get_content_range(None, 1, 4))
    bytes 0-0/4
    >>> print(_get_content_range(1, 3, 4))
    bytes 1-2/4
    >>> print(_get_content_range(None, None, 4))
    bytes 0-3/4
    rrEzbytes r3�/r/)rdr�r�r/r/r0�_get_content_ranges
r��valcCs|��}|dkr
dSt|�S)Nr)rfr�)r�r/r/r0r��sr�c@s:eZdZUdZdZeed<	dZeed<	dZ	eed<dS)	�ParseMultipartConfigz�This class configures the parsing of ``multipart/form-data`` request bodies.

    Its primary purpose is to place limits on the size and complexity of request messages
    to avoid potential denial-of-service attacks.

    .. versionadded:: 6.5.5
    T�enabled�d�	max_partsi(�max_part_header_sizeN)
r!r"r#r$r�r�r�r�r�r�r/r/r/r0r��s
	r�c@s&eZdZUdZejed�Zeed<dS)�ParseBodyConfigzVThis class configures the parsing of request bodies.

    .. versionadded:: 6.5.5
    )�default_factory�	multipartN)	r!r"r#r$�dataclasses�fieldr�r�r�r/r/r/r0r��s
�r��configcCs|adS)a�Sets the **global** default configuration for parsing request bodies.

    This global setting is provided as a stopgap for applications that need to raise the limits
    introduced in Tornado 6.5.5, or who wish to disable the parsing of multipart/form-data bodies
    entirely. Non-global configuration for this functionality will be introduced in a future
    release.

    >>> content_type = "multipart/form-data; boundary=foo"
    >>> multipart_body = b"--foo--\r\n"
    >>> parse_body_arguments(content_type, multipart_body, {}, {})
    >>> multipart_config = ParseMultipartConfig(enabled=False)
    >>> config = ParseBodyConfig(multipart=multipart_config)
    >>> set_parse_body_config(config)
    >>> parse_body_arguments(content_type, multipart_body, {}, {})
    Traceback (most recent call last):
        ...
    tornado.httputil.HTTPInputError: ...: multipart/form-data parsing is disabled
    >>> set_parse_body_config(ParseBodyConfig())  # reset to defaults

    .. versionadded:: 6.5.5
    N)�_DEFAULT_PARSE_BODY_CONFIG�rr/r/r0�set_parse_body_config�srrr�r�r�r�rjc
Cs\|durt}|�d�rK|rd|vrtd|d��zt|dd�}Wnty4}ztd|�|�d}~ww|��D]\}}	|	rH|�|g��|	�q9dS|�d�r�|r^d|vr^td|d��z:|�d	�}
|
d
�	�dkrptd��|
D]"}|�	��
d�\}}
}|d
kr�|r�tt|�||||j
d�WdSqrtd��ty�}ztd|�|�d}~wwdS)aFParses a form request body.

    Supports ``application/x-www-form-urlencoded`` and
    ``multipart/form-data``.  The ``content_type`` parameter should be
    a string and ``body`` should be a byte string.  The ``arguments``
    and ``files`` parameters are dictionaries that will be updated
    with the parsed contents.
    Nz!application/x-www-form-urlencodedzContent-Encodingz Unsupported Content-Encoding: %sTr�z&Invalid x-www-form-urlencoded body: %szmultipart/form-data�;rzInvalid content typer��boundaryrzmultipart boundary not foundzInvalid multipart/form-data: %s)r�
startswithrUr
r�r^r�r�r9rfr��parse_multipart_form_datarr�)r�r�r�r�rjrZ
uri_arguments�er1r_�fieldsrrNr�rOr/r/r0r��sR

�����

�
�����r�r�datacCs�|durtj}|jstd��|�d�r|�d�r|dd�}|�d|d�}|dkr/td��|d|��d|d�}t|�|j	krGtd	��|D]|}|sNqI|�
d
�}|dkr[td��||jkrdtd��tj
|d|��d
�dd�}	|	�dd�}
t|
�\}}|dks�|�d�s�td��||dd�}
|�d�s�td��|d}|�d�r�|	�dd�}|�|g��t|d|
|d��qI|�|g��|
�qIdS)a]Parses a ``multipart/form-data`` body.

    The ``boundary`` and ``data`` parameters are both byte strings.
    The dictionaries given in the arguments and files parameters
    will be updated with the contents of the body.

    .. versionchanged:: 5.1

       Now recognizes non-ASCII filenames in RFC 2231/5987
       (``filename*=``) format.
    Nz'multipart/form-data parsing is disabled�"rErbs--z4Invalid multipart/form-data: no final boundary founds
z&multipart/form-data has too many partss

z#multipart/form-data missing headersz)multipart/form-data part header too largezutf-8FrPzContent-Dispositionrz	form-datazInvalid multipart/form-data����r1z multipart/form-data missing namer�r�zapplication/unknown)r�r�r�)rr�r�rUr�endswith�rfindr9rIr�rlr�r;ro�decoder[�
_parse_headerr�rYr�)rrr�r�rZfinal_boundary_index�parts�partZeohrjZdisp_headerZdispositionZdisp_paramsrRr1�ctyper/r/r0r	sL




���r	�tscCsht|ttf�r
|}n"t|ttjf�rt�|�}nt|tj�r&t�|�	��}nt
d|��tjj
|dd�S)a�Formats a timestamp in the format used by HTTP.

    The argument may be a numeric timestamp as returned by `time.time`,
    a time tuple as returned by `time.gmtime`, or a `datetime.datetime`
    object. Naive `datetime.datetime` objects are assumed to represent
    UTC; aware objects are converted to UTC before formatting.

    >>> format_timestamp(1359312200)
    'Sun, 27 Jan 2013 18:43:20 GMT'
    zunknown timestamp type: %rT)�usegmt)rJr�r�r�r��struct_time�calendar�timegm�datetime�utctimetupler��email�utils�
formatdate)rZtime_numr/r/r0�format_timestampXs
r!c@s&eZdZUeed<eed<eed<dS)r�r+r�r�N)r!r"r#rrr�r/r/r/r0r�p�
r�r`cCsTtj�|�}|std��t|�d�|�d�|�d��}|j�d�s(td|j��|S)z�Returns a (method, path, version) tuple for an HTTP 1.x request line.

    The response is a `typing.NamedTuple`.

    >>> parse_request_start_line("GET /foo HTTP/1.1")
    RequestStartLine(method='GET', path='/foo', version='HTTP/1.1')
    zMalformed HTTP request linerEr�r��HTTP/1�Unexpected HTTP version %r)rr-rTrUr��groupr�r�r`�match�rr/r/r0�parse_request_start_linevsr)c@s&eZdZUeed<eed<eed<dS)r�r��code�reasonN)r!r"r#rrr�r�r/r/r/r0r��r"r�cCsXtj�|�}|std��t|�d�t|�d��|�d��}|j�d�s*td|j��|S)z�Returns a (version, code, reason) tuple for an HTTP 1.x response line.

    The response is a `typing.NamedTuple`.

    >>> parse_response_start_line("HTTP/1.1 200 OK")
    ResponseStartLine(version='HTTP/1.1', code=200, reason='OK')
    z!Error parsing response start linerEr�r�r#r$)	rr.rTrUr�r%r�r�rr&r/r/r0�parse_response_start_line�s"r,�sccs��d}|�d|�|krc|d7}|�d|�}|d}}|dkrD||�d||�|�d||�7}|ddkr5n||�d|d�}}|dks|dkrLt|�}|||�}|��V|}|�d|�|ksdSdS)NrrrE�"z\"r�)rl�countrIrf)r-rdr��ind�diff�fr/r/r0�_parseparam�s$�
 �
�r3cCs�td|�}t|�}dg}|D](}|�d�}|dkr7|d|�����}||dd���}|�|t|�f�qtj�	|�}|�
d�i}	|D]&\}}
tj�|
�}t|�dkri|ddkri|d	dkri|dd	�}||	|<qG||	fS)
aYParse a Content-type like header.

    Return the main content-type and a dictionary of options.

    >>> d = "form-data; foo=\"b\\\\a\\\"r\"; file*=utf-8''T%C3%A4st"
    >>> ct, d = _parse_header(d)
    >>> ct
    'form-data'
    >>> d['file'] == r'T\u00e4st'.encode('ascii').decode('unicode_escape')
    True
    >>> d['foo']
    'b\\a"r'
    r)ZDummyrRr�rNrEr�r.rb)
r3�nextrlrfr�rYr	rr�
decode_paramsrX�collapse_rfc2231_valuerI)r`r�key�params�p�ir1rRZdecoded_params�pdictZ
decoded_valuer/r/r0r�s&
�
$
rr7r;cCsV|s|S|g}t|���D]\}}|dur|�|�q
|�|�d|���q
d�|�S)z�Inverse of _parse_header.

    >>> _encode_header('permessage-deflate',
    ...     {'client_max_window_bits': 15, 'client_no_context_takeover': None})
    'permessage-deflate; client_max_window_bits=15; client_no_context_takeover'
    Nr�z; )�sortedr^rYr8)r7r;�outrNrOr/r/r0�_encode_header�s
r>�username�passwordcCs@t|t�rt�d|�}t|t�rt�d|�}t|�dt|�S)z�Encodes a username/password pair in the format used by HTTP auth.

    The return value is a byte string in the form ``username:password``.

    .. versionadded:: 5.1
    ZNFC�:)rJr�unicodedata�	normalizer)r?r@r/r/r0�encode_username_password�s

	
rDcCsddl}|j|jd�S)Nr)Zoptionflags)�doctestZDocTestSuite�ELLIPSIS)rEr/r/r0�doctestssrGz^(.+):(\d+)$�netloccCs>t�|�}|r|�d�}t|�d��}||fS|}d}||fS)z�Returns ``(host, port)`` tuple from ``netloc``.

    Returned ``port`` will be ``None`` if not present.

    .. versionadded:: 4.1
    rEr�N)�
_netloc_rer'r%r�)rHr'r,�portr/r/r0r�s

�r��qsccs,�|��D]\}}|D]}||fVqqdS)zgGenerator converting a result of ``parse_qs`` back to name-value pairs.

    .. versionadded:: 5.0
    N)r^)rKrNZvsrOr/r/r0�	qs_to_qsl*s���rLz\\(?:([0-3][0-7][0-7])|(.))rhcCs"|dr
tt|dd��S|dS)NrE�r�)�chrr�)rhr/r/r0�_unquote_replace7srOcCsJ|dus
t|�dkr|S|ddks|ddkr|S|dd�}tt|�S)z�Handle double quotes and escaping in cookie values.

    This method is copied verbatim from the Python 3.13 standard
    library (http.cookies._unquote) so we don't have to depend on
    non-public interfaces.
    Nr�rr.rbrE)rI�_unquote_subrO)r-r/r/r0�_unquote_cookie>s	
rQ�cookiecCsbi}|�d�D]'}d|vr|�dd�\}}nd|}}|��|��}}|s(|r.t|�||<q|S)a[Parse a ``Cookie`` HTTP header into a dict of name/value pairs.

    This function attempts to mimic browser cookie parsing behavior;
    it specifically does not follow any of the cookie-related RFCs
    (because browsers don't either).

    The algorithm used is identical to that used by Django version 1.9.10.

    .. versionadded:: 4.4.2
    rr�rEr)r9rfrQ)rRZ
cookiedictr�r7r�r/r/r0r�Ys
�r�r>)hr$r�collections.abc�collectionsr~rr�email.utilsr�	functoolsr�http.clientrZhttp.cookiesr�r%�sslrr�rB�urllib.parserrrrZtornado.escaper	r
rrZtornado.utilr
rr�rrrrrrrrrrr�
TYPE_CHECKINGrZasynciorZunittest�abc�MutableMappingrrZStrMutableMappingrer&rVrr:r;r�r�rUr�r�r�r�r�r�r�r�r�r�Z	dataclassr�r�rrr�r�r	r�r�rr!�
NamedTupler�r)r�r,r3rr>rDrGrIr�rL�subrP�MatchrOrQr�r/r/r/r0�<module>s�4
8	s
	..�.��
�/�
�"3!��������
�=������
�@�
�$"#
�
�
�
*