o ha@sddlTddlTddlmZmZmZddlmZmZmZddl m Z m Z m Z ddl mZddlmZddlmZgdZed Zed Zd Zd d ZddZGdddeZdS))*)LocalProtocolErrorRemoteProtocolError make_sentinel)ConnectionState_SWITCH_UPGRADE_SWITCH_CONNECT)get_comma_headerset_comma_headerhas_expect_100_continue) ReceiveBuffer)READERS)WRITERS) Connection NEED_DATAPAUSEDrri@cCs0t|jd}d|vr dSt|dddkrdSdS)N connectioncloseF http_version1.1T)r headersgetattr)event connectionrW/var/www/html/magazine_api/magazine_env/lib/python3.10/site-packages/h11/_connection.py _keep_alive0s rcCst|ttfvs Jt|tur4|jdvs+|dks+|dkr-d|jkr)dkr-dSndS|jdks4Jt|jd}|rE|dgksCJd St|jd }|rVd t|d ffSt|tur^dSd S)N)i0HEADCONNECT,)content-length)transfer-encodingschunked)chunkedrcontent-lengthr"r#)http/1.0r)typeRequestResponse status_coder rint)request_methodrZtransfer_encodingsZcontent_lengthsrrr _body_framing8s(     r.c@seZdZdZefddZeddZeddZedd Z ed d Z d d Z ddZ ddZ ddZddZd)ddZeddZddZddZdd Zd!d"Zd#d$Zd%d&Zd'd(ZdS)*raBAn object encapsulating the state of an HTTP connection. Args: our_role: If you're implementing a client, pass :data:`h11.CLIENT`. If you're implementing a server, pass :data:`h11.SERVER`. max_incomplete_event_size (int): The maximum number of bytes we're willing to buffer of an incomplete event. In practice this mostly sets a limit on the maximum size of the request/response line + headers. If this is exceeded, then :meth:`next_event` will raise :exc:`RemoteProtocolError`. cCs||_|ttfvrtd|||_|turt|_nt|_t|_| |jdt |_ | |jdt |_ t|_d|_d|_d|_d|_dS)Nz#expected CLIENT or SERVER, not {!r}F)_max_incomplete_event_sizeCLIENTSERVER ValueErrorformatour_role their_roler_cstate_get_io_objectr_writerr _readerr _receive_buffer_receive_buffer_closedtheir_http_version_request_method"client_is_waiting_for_100_continue)selfr4Zmax_incomplete_event_sizerrr__init__|s"  zConnection.__init__cCs t|jjS)zA dictionary like:: {CLIENT: , SERVER: } See :ref:`state-machine` for details. )dictr6statesr?rrrrBs zConnection.statescC|jj|jS)zjThe current state of whichever role we are playing. See :ref:`state-machine` for details. )r6rBr4rCrrr our_statezConnection.our_statecCrD)znThe current state of whichever role we are NOT playing. See :ref:`state-machine` for details. )r6rBr5rCrrr their_staterFzConnection.their_statecCs|jtuo|jSN)r5r0r>rCrrr!they_are_waiting_for_100_continues z,Connection.they_are_waiting_for_100_continuecCs4t|jj}|jd|_|jrJ||dS)aAttempt to reset our connection state for a new request/response cycle. If both client and server are in :data:`DONE` state, then resets them both to :data:`IDLE` state in preparation for a new request/response cycle on this same connection. Otherwise, raises a :exc:`LocalProtocolError`. See :ref:`keepalive-and-pipelining`. N)rAr6rBstart_next_cycler=r>_respond_to_state_changes)r? old_statesrrrrJs  zConnection.start_next_cyclecCs&t|jj}|j|||dSrH)rAr6rBZ process_errorrK)r?rolerLrrr_process_errors  zConnection._process_errorcCsTt|tur |jdkr tSt|tur(t|jjvr(d|jkr%dkr(tSdSdS)Ner r!)r(InformationalResponser+rr*rr6Zpending_switch_proposals)r?rrrr_server_switch_events  zConnection._server_switch_eventcCs0t|jj}|tur't|tur'|jdkr|jtt |j dr'|jt d}|t ur2| |}|j|t||t|turF|j|_||jurXt|tttfvrX|j|_t|ttfvrit|si|jt|turvt|rvd|_t|ttfvrd|_|turt|ttfvrd|_|||dS)NrsupgradeTF)rAr6rBr0r(r)methodZprocess_client_switch_proposalrr rrr1rQZ process_eventr=r5r*rPrr<rZprocess_keep_alive_disabledr r>ZDataZ EndOfMessagerK)r?rMrrLZserver_switch_eventrrr_process_events0         zConnection._process_eventcCsB|jj|}|turt|j|\}}|t||S|||fSrH)r6rBZ SEND_BODYr.r=get)r?rMrZio_dictstate framing_typeargsrrrr7s zConnection._get_io_objectNcCsL|j||jkr||j|t|_|j||jkr$||j|t|_dSdSrH) rEr4r7rr8rGr5r r9)r?rLrrrrrKs z$Connection._respond_to_state_changescCst|j|jfS)abData that has been received, but not yet processed, represented as a tuple with two elements, where the first is a byte-string containing the unprocessed data itself, and the second is a bool that is True if the receive connection was closed. See :ref:`switching-protocols` for discussion of why you'd want this. )bytesr:r;rCrrr trailing_data$s zConnection.trailing_datacCs.|r|jr td|j|7_dSd|_dS)aAdd data to our internal recieve buffer. This does not actually do any processing on the data, just stores it. To trigger processing, you have to call :meth:`next_event`. Args: data (:term:`bytes-like object`): The new data that was just received. Special case: If *data* is an empty byte-string like ``b""``, then this indicates that the remote side has closed the connection (end of file). Normally this is convenient, because standard Python APIs like :meth:`file.read` or :meth:`socket.recv` use ``b""`` to indicate end-of-file, while other failures to read are indicated using other mechanisms like raising :exc:`TimeoutError`. When using such an API you can just blindly pass through whatever you get from ``read`` to :meth:`receive_data`, and everything will work. But, if you have an API where reading an empty string is a valid non-EOF condition, then you need to be aware of this and make sure to check for such strings and avoid passing them to :meth:`receive_data`. Returns: Nothing, but after calling this you should call :meth:`next_event` to parse the newly received data. Raises: RuntimeError: Raised if you pass an empty *data*, indicating EOF, and then pass a non-empty *data*, indicating more data that somehow arrived after the EOF. (Calling ``receive_data(b"")`` multiple times is fine, and equivalent to calling it once.) z(received close, then received more data?TN)r; RuntimeErrorr:)r?datarrr receive_data/s' zConnection.receive_datacCs|j}|tur |jr tS|tus|turtS|jdusJ||j}|dur<|js<|jr` to send. Returns: If ``type(event) is ConnectionClosed``, then returns ``None``. Otherwise, returns a :term:`bytes-like object`. Raises: LocalProtocolError: Sending this event at this time would violate our understanding of the HTTP/1.1 protocol. If this method raises any exception then it also sets :attr:`Connection.our_state` to :data:`ERROR` -- see :ref:`error-handling` for discussion. N)send_with_data_passthroughjoin)r?r data_listrrrsends  zConnection.sendcCs|jtur tdz/t|tur|||j}||j|t|t ur(WdS|dus.Jg}|||j |WS| |j)ahIdentical to :meth:`send`, except that in situations where :meth:`send` returns a single :term:`bytes-like object`, this instead returns a list of them -- and when sending a :class:`Data` event, this list is guaranteed to contain the exact object you passed in as :attr:`Data.data`. See :ref:`sendfile` for discussion. z'Can't send data when our state is ERRORN) rErarr(r*&_clean_up_response_headers_for_sendingr8rSr4r_appendrN)r?rwriterrkrrrris$       z%Connection.send_with_data_passthroughcCs||jdS)zNotify the state machine that we failed to send the data it gave us. This causes :attr:`Connection.our_state` to immediately become :data:`ERROR` -- see :ref:`error-handling` for discussion. N)rNr4rCrrr send_failedszConnection.send_failedcCst|tusJt|j}d}|j}|dkrd}t||\}}|dvrHt|dg|jdus3|jdkrAt|dg|jdkr@d}nt|dd g|jj rN|rgt t |d }| d | d t|d t|||_dS) NFrsGET)r%r'r&rr$Tr%rs keep-aliver)r(r*listrr=r.r r<r6 keep_alivesetr discardaddsorted)r?responserZ need_closeZmethod_for_choosing_headersrV_rrrrrms,          z1Connection._clean_up_response_headers_for_sendingrH)__name__ __module__ __qualname____doc__!DEFAULT_MAX_INCOMPLETE_EVENT_SIZEr@propertyrBrErGrIrJrNrQrSr7rKrYr\r`rgrlrirprmrrrrrms6 %     ,   /C" rN)Z_events_stateZ_utilrrrrrr_headersr r r Z_receivebufferr _readersr _writersr__all__rrr}rr.objectrrrrrs    5