o Q_] @szdZddlZddlZddlZddlZddlZddlmZddl m Z ddl Z ddl Z ddlmZddlZddlZddlmZmZmZmZddlmZmZmZddlmZdd lmZmZe ddl 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,rdd l m-Z-dd l.m/Z/ddl0Z0ed de1de1fddZ2Gdddej3j4Z5Gddde6Z7Gddde8Z9Gddde8Z:Gddde6Z;Gddde6ZGd%d&d&eZ?d'e1de(e!e(e@e(e@ffd(d)ZAd*e(e@d+e(e@d,e@de1fd-d.ZBd/e1de(e@fd0d1ZC did2e1d3eDd4e&e1e#eDfd5e&e1e#e?fd6e(e5ddf d7d8ZEd9eDd:eDd4e&e1e#eDfd5e&e1e#e?fddf d;d<ZFd=e'e@eGeHejIejfde1fd>d?ZJeKd@gdAZLe MdBZNdCe1deLfdDdEZOeKdFgdGZPe MdHZQdCe1dePfdIdJZRdKe1de*e1ddffdLdMZSdCe1de!e1e&e1e1fffdNdOZTdPe1dQe&e1e1fde1fdRdSZUdTe'e1eDfdUe'e1eDfdeDfdVdWZVdXdYZWe MdZZXd[e1de!e1e(e@ffd\d]ZYd^e&e1e#e+fde"e!e1e+ffd_d`ZZe MdaZ[e MdbZ\dcj]Z^dKe1de1fdddeZ_dfe1de&e1e1ffdgdhZ`dS)jzHTTP 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) urlencodeurlparse urlunparse parse_qsl) native_strparse_qs_bytesutf8)gen_log) ObjectDict unicode_type) TupleIterableListMappingIteratorDictUnionOptional Awaitable GeneratorAnyStr)Deque)FutureinamereturncCsddd|dDS)ziMap a header name to Http-Header-Case. >>> _normalize_header("coNtent-TYPE") 'Content-Type' -cSsg|]}|qS) capitalize).0wrr2/usr/lib/python3/dist-packages/tornado/httputil.py Isz%_normalize_header..)joinsplit)rrrr#_normalize_headerBsr'c@seZdZdZejdeeeefddfddZ ejdeeefddfddZ ejde eefddfd dZ ejd eddfd dZ dej d eddfd dZ d ededdfddZ d edeefddZ dee eeffddZdeddfddZededdfddZd ededdfddZd edefddZd eddfdd Zdefd!d"Zdeej fd#d$Zd)d%d&ZeZdefd'd(ZeZdS)* HTTPHeadersaA 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__argrNcCdSNrselfr)rrr#__init__izHTTPHeaders.__init__cCr*r+rr,rrr#r.mr/argscGr*r+r)r-r0rrr#r.qr/kwargscKr*r+r)r-r1rrr#r.ur/cOsri|_i|_d|_t|dkr/t|dkr/t|dtr/|dD] \}}|||q"dS|j|i|dS)Nr) _dict_as_list _last_keylen isinstancer(get_alladdupdate)r-r0r1kvrrr#r.ys&rvaluecCsTt|}||_||vr$t||dt||j|<|j||dS|||<dS)z#Adds a new value for the given key.,N)r'r5r r3r4appendr-rr= norm_namerrr#r9s zHTTPHeaders.addcCst|}|j|gS)z2Returns all values for the given header as a list.)r'r4getr-rrArrr#get_listszHTTPHeaders.get_listccs.|jD]\}}|D]}||fVq qdS)zReturns an iterable of all (name, value) pairs. If a header has multiple values, multiple pairs will be returned with the same name. N)r4items)r-rvaluesr=rrr#r8s  zHTTPHeaders.get_alllinecCs|dr-|jdurtdd|}|j|jd|7<|j|j|7<dSz |dd\}}Wn tyBtdw||| dS) zUpdates the dictionary with a single header line. >>> h = HTTPHeaders() >>> h.parse_line("Content-Type: text/html") >>> h.get('content-type') 'text/html' rNz.first header line cannot start with whitespace :r2zno colon in header line) isspacer5HTTPInputErrorlstripr4r3r& ValueErrorr9strip)r-rGnew_partrr=rrr# parse_lines    zHTTPHeaders.parse_lineheaderscCs>|}|dD]}|dr|dd}|r||q|S)aReturns 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`.   NrI)r&endswithrQ)clsrRhrGrrr#parses   zHTTPHeaders.parsecCs"t|}||j|<|g|j|<dSr+r'r3r4r@rrr# __setitem__s zHTTPHeaders.__setitem__cCs|jt|Sr+)r3r')r-rrrr# __getitem__szHTTPHeaders.__getitem__cCst|}|j|=|j|=dSr+rYrCrrr# __delitem__s zHTTPHeaders.__delitem__cC t|jSr+)r6r3r-rrr#__len__ zHTTPHeaders.__len__cCr]r+)iterr3r^rrr#__iter__r`zHTTPHeaders.__iter__cCst|Sr+)r(r^rrr#copyszHTTPHeaders.copycCs2g}|D] \}}|d||fqd|S)Nz%s: %s )r8r?r%)r-linesrr=rrr#__str__s zHTTPHeaders.__str__)rr()__name__ __module__ __qualname____doc__typingoverloadrstrrr.rAnyr9rDrr8rQ classmethodrXrZr[r\intr_rrbrc__copy__rf __unicode__rrrr#r(Ls4    r(c@s eZdZdZdZdZdZ          d"deedeededee dee d eed ee ee d fd ed deddee ddfddZede eejjffddZdefddZdefddZ d#dedede e ffddZd$ddZdefd d!ZdS)%HTTPServerRequesta7 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``. NHTTP/1.0methoduriversionrRbodyhostfilesHTTPFile connectionHTTPConnection start_lineRequestStartLineserver_connectionrc Cs| dur | \}}}||_||_||_|pt|_|pd|_t|dd} t| dd|_t| dd|_|p:|j dp:d|_ t |j d|_ |pIi|_||_| |_t|_d|_|durg|d \|_} |_t|jd d |_t|j|_i|_dS) Ncontext remote_ipprotocolhttpHostz 127.0.0.1r?Tkeep_blank_values)rurvrwr(rRrxgetattrrrrBrysplit_host_and_portlower host_namerzr|rtime _start_time _finish_time partitionpathqueryr argumentsrcdeepcopyquery_argumentsbody_arguments) r-rurvrwrRrxryrzr|r~rrseprrr#r.Zs,       zHTTPServerRequest.__init__c Cst|ds>tj|_d|jvr>z t|jd}Wn ty$Y|jSw|D]\}}z||j|<Wq)ty=Yq)w|jS)z0A dictionary of ``http.cookies.Morsel`` objects._cookiesCookie) hasattrrcookies SimpleCookierrR parse_cookie ExceptionrE)r-parsedr;r<rrr#rs"     zHTTPServerRequest.cookiescCs|jd|j|jS)z+Reconstructs the full URL for this request.z://)rryrvr^rrr#full_urlszHTTPServerRequest.full_urlcCs$|jdur t|jS|j|jS)z?Returns the amount of time it took for this request to execute.N)rrrr^rrr# request_times  zHTTPServerRequest.request_timeF binary_formcCs:z|jdur WdS|jjjj|dWStyYdSw)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|streamsocket getpeercertr)r-rrrr#get_ssl_certificates   z%HTTPServerRequest.get_ssl_certificatecCsNt|jdd|j|j|j|j|jD]\}}|j|g |qdS)N Content-Typerd) parse_body_argumentsrRrBrxrrzrEr setdefaultextend)r-r;r<rrr# _parse_bodys zHTTPServerRequest._parse_bodycs,d}dfdd|D}djj|fS)N)rryrurvrwrz, csg|] }d|t|fqS)z%s=%r)r)r!nr^rr#r$sz.HTTPServerRequest.__repr__..z%s(%s))r% __class__rg)r-attrsr0rr^r#__repr__szHTTPServerRequest.__repr__) NNrtNNNNNNN)FrN)rgrhrirjrr _body_futurerrmr(bytesrrobjectr.propertyrrMorselrfloatrboolrrrrrrrr#rssd\    (   rsc@eZdZdZdS)rLzqException class for malformed HTTP requests or responses from remote sources. .. versionadded:: 4.0 Nrgrhrirjrrrr#rLsrLc@r)HTTPOutputErrorzJException class for errors in HTTP output. .. versionadded:: 4.0 Nrrrrr#rsrc@s8eZdZdZdeddddfddZdedd fd d Zd S) HTTPServerConnectionDelegatez_Implement this interface to handle requests from `.HTTPServer`. .. versionadded:: 4.0 server_conn request_connr}rHTTPMessageDelegatecCt)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-rrrrr# start_requests z*HTTPServerConnectionDelegate.start_requestNcCdS)zThis 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-rrrr#on_closez%HTTPServerConnectionDelegate.on_close)rgrhrirjrrrrrrr#rs rc@s`eZdZdZdeddedeedfddZd e deedfd d Z dd d Z dddZ dS)rz_Implement this interface to handle an HTTP request or response. .. versionadded:: 4.0 r~rResponseStartLinerRrNcCr)aCalled 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~rRrrr#headers_received sz$HTTPMessageDelegate.headers_receivedchunkcCr)ziCalled when a chunk of data has been received. May return a `.Future` for flow control. Nrr-rrrr# data_receivedsz!HTTPMessageDelegate.data_receivedcCr)z6Called after the last chunk of data has been received.Nrr^rrr#finish&r/zHTTPMessageDelegate.finishcCr)zCalled 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. Nrr^rrr#on_connection_close*rz'HTTPMessageDelegate.on_connection_closer) rgrhrirjrr(rrrrrrrrrrr#rs   rc @sReZdZdZ ddeddedeeddfd d Zdeddfd d Z dd dZ dS)r}zYApplications use this interface to write their responses. .. versionadded:: 4.0 Nr~rrRrrz Future[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~rRrrrr# write_headers9szHTTPConnection.write_headerscCr)zWrites a chunk of body data. Returns a future for flow control. .. versionchanged:: 6.0 The ``callback`` argument was removed. rrrrr#writeQs zHTTPConnection.writecCr)z>> 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' NTrz7'args' parameter should be dict, list or tuple. Not {0}rr2)rr7dictrrrrElisttupleformattype TypeErrorrr)rr0 parsed_url parsed_queryerr final_queryrrr# url_concatbs0   rc@r)r{zRepresents a file uploaded via a form. For backwards compatibility, its instance attributes are also accessible as dictionary keys. * ``filename`` * ``body`` * ``content_type`` Nrrrrr#r{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 =rNrrr2)rrO _int_or_nonerN)runit_r=start_bend_bstartendrrr#_parse_request_ranges&  rrrtotalcCs"|pd}|p|d}d|||fS)zReturns 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 rr2zbytes %s-%s/%sr)rrrrrr#_get_content_ranges rvalcCs|}|dkr dSt|S)Nrd)rOrp)rrrr#rsr content_typerxrrzrRc CsT|drN|rd|vrtd|ddSzt|dd}Wnty7}ztd|i}WYd}~nd}~ww|D]\}}|rK||g|q>> format_timestamp(1359312200) 'Sun, 27 Jan 2013 18:43:20 GMT' zunknown timestamp type: %rT)usegmt)r7rprrr struct_timecalendartimegmdatetime utctimetupleremailutils formatdate)rtime_numrrr#format_timestampSs    rr)rurrwz^HTTP/1\.[0-9]$rGcCsNz |d\}}}Wn tytdwt|s!td|t|||S)zReturns a (method, path, version) tuple for an HTTP 1.x request line. The response is a `collections.namedtuple`. >>> parse_request_start_line("GET /foo HTTP/1.1") RequestStartLine(method='GET', path='/foo', version='HTTP/1.1') rHzMalformed HTTP request linez/Malformed HTTP version in HTTP Request-Line: %r)r&rNrL_http_version_rematchr)rGrurrwrrr#parse_request_start_liners   rr)rwcodereasonz (HTTP/1.[0-9]) ([0-9]+) ([^\r]*)cCs@t|}t|}|stdt|dt|d|dS)zReturns a (version, code, reason) tuple for an HTTP 1.x response line. The response is a `collections.namedtuple`. >>> parse_response_start_line("HTTP/1.1 200 OK") ResponseStartLine(version='HTTP/1.1', code=200, reason='OK') z!Error parsing response start liner2rr)r _http_response_line_rerrLrgrouprp)rGrrrr#parse_response_start_lines  "rsccs|dddkrg|dd}|d}|dkrD|dd||dd|drD|d|d}|dkrD|dd||dd|ds(|dkrLt|}|d|}|V||d}|dddks dSdS)Nr2rr"z\"r)rcountr6rO)rrfrrr# _parseparams  ((   r c Cstd|}t|}dg}|D](}|d}|dkr7|d|}||dd}||t|fqtj |}| di} |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)Dummyr=rrNr2rrrI) r nextrrOrr?r rr decode_paramspopcollapse_rfc2231_valuer6) rGrkeyparamspirr=decoded_paramspdict decoded_valuerrr#rs&      $  rr&r+cCsT|s|S|g}t|D]\}}|dur||q |d||fq d|S)zInverse 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' Nz%s=%sz; )sortedrEr?r%)r&r+outr;r<rrr#_encode_headers  r/usernamepasswordcCs@t|tr td|}t|trtd|}t|dt|S)zEncodes 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 NFC:)r7r unicodedata normalizer )r0r1rrr#encode_username_passwords   r6cCsddl}|S)Nr)doctest DocTestSuite)r7rrr#doctestssr9z ^(.+):(\d+)$netloccCs>t|}|r|d}t|d}||fS|}d}||fS)zReturns ``(host, port)`` tuple from ``netloc``. Returned ``port`` will be ``None`` if not present. .. versionadded:: 4.1 r2rN) _netloc_rerrrp)r:rryportrrr#rs  rqsccs,|D]\}}|D]}||fVq qdS)zgGenerator converting a result of ``parse_qs`` back to name-value pairs. .. versionadded:: 5.0 N)rE)r=r;vsr<rrr# qs_to_qsls  r?z\\[0-3][0-7][0-7]z[\\].rdcCsn|dus t|dkr |S|ddks|ddkr|S|dd}d}t|}g}d|kr2|krnt|St||}t||}|sU|sU|||d t|Sd}}|r`|d}|rg|d}|r|ro||kr|||||||d|d}n|||||tt||d|dd|d}d|kr|ks7t|St|S) zHandle double quotes and escaping in cookie values. This method is copied verbatim from the Python 3.5 standard library (http.cookies._unquote) so we don't have to depend on non-public interfaces. NrrrrIr2r) r6 _OctalPattsearch _QuotePattr?rchrrp _nulljoin)rr)rreso_matchq_matchjr;rrr#_unquote_cookie$s@      $rJcookiecCsri}|tdD]-}td|vr|tdd\}}ntd|}}||}}|s0|r6t|||<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 rrr2rd)r&rmrOrJ)rK cookiedictrr&rrrr#rVs   rr+)arjr  collectionsrcr  email.utilsr functoolsr http.clientr http.cookiesrresslrrr4 urllib.parserrrrtornado.escaper r r tornado.logr tornado.utilr rrkrrrrrrrrrrr TYPE_CHECKINGrasynciorunittestrmr'abcMutableMappingr(rrsrrLrrrr}rr{rprrrrrrrrr r namedtuplercompilerrrrrr rr/r6r9r;rr?rArCr%rErJrrrrr#s    4   ,_  ./. / "3  1 :   " #    * 2