HEX

File: //usr/local/CyberCP/lib/python3.10/site-packages/websockets/sync/__pycache__/server.cpython-310.pyc
o

�h,k�@s�ddlmZddlZddlZddlZddlZddlZddlZddlZddl	Z
ddlZddlZddl
Z
ddlmZmZddlmZddlmZmZmZmZddlmZddlmZdd	lmZdd
lmZddl m!Z!m"Z"m#Z#ddl$m%Z%m&Z&m'Z'dd
l(m)Z)m*Z*m+Z+ddl,m-Z-ddlm.Z.m/Z/m0Z0m1Z1ddl2m3Z3ddl4m5Z5gd�Z6Gdd�de3�Z7Gdd�d�Z8dZdd�Z9		d[ddddddddde%dd d dd!d"ddd#�d\dIdJ�Z:	d]d^dLdM�Z;d_dPdQ�Z<	R		d`dadXdY�Z=dS)b�)�annotationsN)�Iterable�Sequence)�
TracebackType)�Any�Callable�Mapping�cast�)�
InvalidHeader)�ServerExtensionFactory)� enable_server_permessage_deflate)�	CloseCode)�build_www_authenticate_basic�parse_authorization_basic�validate_subprotocols)�SERVER�Request�Response)�
CONNECTING�OPEN�Event)�ServerProtocol)�
LoggerLike�Origin�
StatusLike�Subprotocol�)�
Connection)�Deadline)�serve�
unix_serve�ServerConnection�Server�
basic_authcsheZdZdZddddd�d+�fdd�Zd,dd�Zddedfd-d#d$�Zd.�fd'd(�Zd/�fd)d*�Z	�Z
S)0r"a/
    :mod:`threading` implementation of a WebSocket server connection.

    :class:`ServerConnection` provides :meth:`recv` and :meth:`send` methods for
    receiving and sending messages.

    It supports iteration to receive messages::

        for message in websocket:
            process(message)

    The iterator exits normally when the connection is closed with close code
    1000 (OK) or 1001 (going away) or without a close code. It raises a
    :exc:`~websockets.exceptions.ConnectionClosedError` when the connection is
    closed with any other code.

    The ``ping_interval``, ``ping_timeout``, ``close_timeout``, and
    ``max_queue`` arguments have the same meaning as in :func:`serve`.

    Args:
        socket: Socket connected to a WebSocket client.
        protocol: Sans-I/O connection.

    ��
���
ping_interval�ping_timeout�
close_timeout�	max_queue�socket�
socket.socket�protocolrr)�float | Noner*r+r,�*int | None | tuple[int | None, int | None]�return�Nonecs6|t��|_t�j||||||d�|||dS)Nr()�	threadingr�request_rcvd�super�__init__)�selfr-r/r)r*r+r,��	__class__��I/usr/local/CyberCP/lib/python3.10/site-packages/websockets/sync/server.pyr7@s

�zServerConnection.__init__�statusr�text�strrcCs|j�||�S)a
        Create a plain text HTTP response.

        ``process_request`` and ``process_response`` may call this method to
        return an HTTP response instead of performing the WebSocket opening
        handshake.

        You can modify the response before returning it, for example by changing
        HTTP headers.

        Args:
            status: HTTP status code.
            text: HTTP response body; it will be encoded to UTF-8.

        Returns:
            HTTP response to send to the client.

        )r/�reject)r8r=r>r;r;r<�respondXszServerConnection.respondN�process_request�=Callable[[ServerConnection, Request], Response | None] | None�process_response�GCallable[[ServerConnection, Request, Response], Response | None] | None�
server_header�
str | None�timeoutcCsj|j�|�s
td��|jdur�|jtd���d}|durDz|||j�}WntyC}z||j_|j�	t
jjd�}WYd}~nd}~ww|durQ|j�
|j�|_n||_|r\||jjd<d}|dur�z
|||j|j�}Wnty�}z||j_|j�	t
jjd�}WYd}~nd}~ww|dur�||_|j�|j�Wd�n1s�wY|jjdur�|jj�dS)z1
        Perform the opening handshake.

        z-timed out while waiting for handshake requestN)�expected_statezLFailed to open a WebSocket connection.
See server log for more information.
r#)r5�wait�TimeoutError�request�send_contextr�	Exceptionr/�
handshake_excr@�http�
HTTPStatus�INTERNAL_SERVER_ERROR�accept�response�headers�
send_response)r8rBrDrFrHrT�excr;r;r<�	handshakemsP
���
���
�4�zServerConnection.handshake�eventrcs<|jdurt|t�sJ�||_|j��dSt��|�dS)z.
        Process one incoming event.

        N)rL�
isinstancerr5�setr6�
process_event)r8rYr9r;r<r\�s

zServerConnection.process_eventcs(z
t���W|j��dS|j��w)zI
        Read incoming data from the socket and process events.

        N)r6�recv_eventsr5r[�r8r9r;r<r]�szServerConnection.recv_events)r-r.r/rr)r0r*r0r+r0r,r1r2r3)r=rr>r?r2r)
rBrCrDrErFrGrHr0r2r3)rYrr2r3�r2r3)�__name__�
__module__�__qualname__�__doc__r7rArrXr\r]�
__classcell__r;r;r9r<r"&s�
�Rr"c@sPeZdZdZ	dddd�Zd d
d�Zd dd�Zd!dd�Zd"dd�Zd#dd�Z	dS)$r#a�
    WebSocket server returned by :func:`serve`.

    This class mirrors the API of :class:`~socketserver.BaseServer`, notably the
    :meth:`~socketserver.BaseServer.serve_forever` and
    :meth:`~socketserver.BaseServer.shutdown` methods, as well as the context
    manager protocol.

    Args:
        socket: Server socket listening for new connections.
        handler: Handler for one connection. Receives the socket and address
            returned by :meth:`~socket.socket.accept`.
        logger: Logger for this server.
            It defaults to ``logging.getLogger("websockets.server")``.
            See the :doc:`logging guide <../../topics/logging>` for details.

    Nr-r.�handler�$Callable[[socket.socket, Any], None]�logger�LoggerLike | Noner2r3cCsF||_||_|durt�d�}||_tjdkr!t��\|_	|_
dSdS)Nzwebsockets.server�win32)r-re�logging�	getLoggerrg�sys�platform�os�pipe�shutdown_watcher�shutdown_notifier)r8r-rergr;r;r<r7�s

�zServer.__init__cCs�t��}z
|�|jtj�Wn
tyYdSwtjdkr&|�|jtj�	|�	�z	|j�
�\}}Wn
ty>YdSwtj
|j||fd�}|��q')a
        See :meth:`socketserver.BaseServer.serve_forever`.

        This method doesn't return. Calling :meth:`shutdown` from another thread
        stops the server.

        Typical use::

            with serve(...) as server:
                server.serve_forever()

        NriT)�target�args)�	selectors�DefaultSelector�registerr-�
EVENT_READ�
ValueErrorrlrmrp�selectrS�OSErrorr4�Threadre�start)r8�poller�sock�addr�threadr;r;r<�
serve_forever�s$
�
��zServer.serve_forevercCs*|j��tjdkrt�|jd�dSdS)z@
        See :meth:`socketserver.BaseServer.shutdown`.

        ri�xN)r-�closerlrmrn�writerqr^r;r;r<�shutdown s

�zServer.shutdown�intcCs
|j��S)z>
        See :meth:`socketserver.BaseServer.fileno`.

        )r-�filenor^r;r;r<r�)s
z
Server.filenocCs|S�Nr;r^r;r;r<�	__enter__0szServer.__enter__�exc_type�type[BaseException] | None�	exc_value�BaseException | None�	traceback�TracebackType | NonecCs|��dSr�)r�)r8r�r�r�r;r;r<�__exit__3szServer.__exit__r�)r-r.rerfrgrhr2r3r_)r2r�)r2r#)r�r�r�r�r�r�r2r3)
r`rarbrcr7r�r�r�r�r�r;r;r;r<r#�s�

&
	
r#�namer?r2rcCs,|dkrt�dt�tStdt�d|����)N�WebSocketServerz%WebSocketServer was renamed to Serverzmodule z has no attribute )�warnings�warn�DeprecationWarningr#�AttributeErrorr`)r�r;r;r<�__getattr__<s�r��deflater&r%ir')r~�ssl�origins�
extensions�subprotocols�select_subprotocol�compressionrBrDrF�open_timeoutr)r*r+�max_sizer,rg�create_connectionre�"Callable[[ServerConnection], None]�hostrG�port�
int | Noner~�socket.socket | Noner��ssl_module.SSLContext | Noner��0Sequence[Origin | re.Pattern[str] | None] | Noner��'Sequence[ServerExtensionFactory] | Noner��Sequence[Subprotocol] | Noner��NCallable[[ServerConnection, Sequence[Subprotocol]], Subprotocol | None] | Noner�rBrCrDrErFr�r0r)r*r+r�r,r1rgrhr��type[ServerConnection] | None�kwargscs<�durd|vr|�d��t�dt��durt��|	dkr$t���n|	dur/td|	�����dur5t�|�dd��|�dd�}|durl�r`|durOtd	��|�d
t	j
�t	j|fi|��}nt	j||ffi|��}n|durttd���dur��j|ddd
�}d����������	�
���
����fdd�}t
||��S)a�
    Create a WebSocket server listening on ``host`` and ``port``.

    Whenever a client connects, the server creates a :class:`ServerConnection`,
    performs the opening handshake, and delegates to the ``handler``.

    The handler receives the :class:`ServerConnection` instance, which you can
    use to send and receive messages.

    Once the handler completes, either normally or with an exception, the server
    performs the closing handshake and closes the connection.

    This function returns a :class:`Server` whose API mirrors
    :class:`~socketserver.BaseServer`. Treat it as a context manager to ensure
    that it will be closed and call :meth:`~Server.serve_forever` to serve
    requests::

        from websockets.sync.server import serve

        def handler(websocket):
            ...

        with serve(handler, ...) as server:
            server.serve_forever()

    Args:
        handler: Connection handler. It receives the WebSocket connection,
            which is a :class:`ServerConnection`, in argument.
        host: Network interfaces the server binds to.
            See :func:`~socket.create_server` for details.
        port: TCP port the server listens on.
            See :func:`~socket.create_server` for details.
        sock: Preexisting TCP socket. ``sock`` replaces ``host`` and ``port``.
            You may call :func:`socket.create_server` to create a suitable TCP
            socket.
        ssl: Configuration for enabling TLS on the connection.
        origins: Acceptable values of the ``Origin`` header, for defending
            against Cross-Site WebSocket Hijacking attacks. Values can be
            :class:`str` to test for an exact match or regular expressions
            compiled by :func:`re.compile` to test against a pattern. Include
            :obj:`None` in the list if the lack of an origin is acceptable.
        extensions: List of supported extensions, in order in which they
            should be negotiated and run.
        subprotocols: List of supported subprotocols, in order of decreasing
            preference.
        select_subprotocol: Callback for selecting a subprotocol among
            those supported by the client and the server. It receives a
            :class:`ServerConnection` (not a
            :class:`~websockets.server.ServerProtocol`!) instance and a list of
            subprotocols offered by the client. Other than the first argument,
            it has the same behavior as the
            :meth:`ServerProtocol.select_subprotocol
            <websockets.server.ServerProtocol.select_subprotocol>` method.
        compression: The "permessage-deflate" extension is enabled by default.
            Set ``compression`` to :obj:`None` to disable it. See the
            :doc:`compression guide <../../topics/compression>` for details.
        process_request: Intercept the request during the opening handshake.
            Return an HTTP response to force the response. Return :obj:`None` to
            continue normally. When you force an HTTP 101 Continue response, the
            handshake is successful. Else, the connection is aborted.
        process_response: Intercept the response during the opening handshake.
            Modify the response or return a new HTTP response to force the
            response. Return :obj:`None` to continue normally. When you force an
            HTTP 101 Continue response, the handshake is successful. Else, the
            connection is aborted.
        server_header: Value of  the ``Server`` response header.
            It defaults to ``"Python/x.y.z websockets/X.Y"``. Setting it to
            :obj:`None` removes the header.
        open_timeout: Timeout for opening connections in seconds.
            :obj:`None` disables the timeout.
        ping_interval: Interval between keepalive pings in seconds.
            :obj:`None` disables keepalive.
        ping_timeout: Timeout for keepalive pings in seconds.
            :obj:`None` disables timeouts.
        close_timeout: Timeout for closing connections in seconds.
            :obj:`None` disables the timeout.
        max_size: Maximum size of incoming messages in bytes.
            :obj:`None` disables the limit.
        max_queue: High-water mark of the buffer where frames are received.
            It defaults to 16 frames. The low-water mark defaults to ``max_queue
            // 4``. You may pass a ``(high, low)`` tuple to set the high-water
            and low-water marks. If you want to disable flow control entirely,
            you may set it to ``None``, although that's a bad idea.
        logger: Logger for this server.
            It defaults to ``logging.getLogger("websockets.server")``. See the
            :doc:`logging guide <../../topics/logging>` for details.
        create_connection: Factory for the :class:`ServerConnection` managing
            the connection. Set it to a wrapper or a subclass to customize
            connection handling.

    Any other keyword arguments are passed to :func:`~socket.create_server`.

    N�ssl_contextzssl_context was renamed to sslr�zunsupported compression: �unixF�pathzmissing path argument�familyz(path and sock arguments are incompatibleT)�server_side�do_handshake_on_connectr~r.rrr2r3cs�t��}zQ�s|�tjtjd��dur,|�|���t|tj	�s#J�|�
�|�d�d}�dur:d��fdd	�}t�	��|��d
�}�dusJJ��||�
���d��Wntyc|�
�YdSwzoz����
�|���Wn/ty�����j��YWdSty��jjddd
�����j��YWdSw�jjtus�J�z
������Wnty��jjddd
���
tj�YWdSw��
�WdSty�|�
�YdSw)NTr/rr��Sequence[Subprotocol]r2�Subprotocol | Nonecs$�dusJ�|�jus
J���|�Sr�)r/)r/r�)�
connectionr�r;r<�protocol_select_subprotocol(s
z@serve.<locals>.conn_handler.<locals>.protocol_select_subprotocol)r�r�r�r�r�rgr(zopening handshake failed)�exc_infozconnection handler failed)r/rr�r�r2r�)r�
setsockoptr-�IPPROTO_TCP�TCP_NODELAY�
settimeoutrHrZ�
ssl_module�	SSLSocket�do_handshakerrNr�rXrK�close_socket�recv_events_thread�joinrg�errorr/�stater�start_keepaliver�INTERNAL_ERROR)r~r�deadliner�r/�r+r�r�rergr,r�r�r�r)r*rBrDr�rFr�r�r�)r�r<�conn_handler	s�
	��
���

���zserve.<locals>.conn_handler)r~r.rrr2r3)�popr�r�r�rr
rxr"�
setdefaultr-�AF_UNIX�
create_server�wrap_socketr#)rer�r�r~r�r�r�r�r�r�rBrDrFr�r)r*r+r�r,rgr�r�r�r�r;r�r<r FsD
�
�0	er r�cKst|fd|d�|��S)a�
    Create a WebSocket server listening on a Unix socket.

    This function accepts the same keyword arguments as :func:`serve`.

    It's only available on Unix.

    It's useful for deploying a server behind a reverse proxy such as nginx.

    Args:
        handler: Connection handler. It receives the WebSocket connection,
            which is a :class:`ServerConnection`, in argument.
        path: File system path to the Unix socket.

    T)r�r�)r )rer�r�r;r;r<r!qsr!�credentials�boolc	Cs:z|\}}WnttfyYdSwt|t�ot|t�S�NF)�	TypeErrorrxrZr?)r��username�passwordr;r;r<�is_credentials�s�r���realm�2tuple[str, str] | Iterable[tuple[str, str]] | None�check_credentials�!Callable[[str, str], bool] | None�6Callable[[ServerConnection, Request], Response | None]cs�|du�dukrtd��|durTt|�rttttf|�g}n*t|t�rBttttttf|��}tdd�|D��sAt	d|����nt	d|����t
|��d�fdd���dusZJ�d��fdd�}|S)ah
    Factory for ``process_request`` to enforce HTTP Basic Authentication.

    :func:`basic_auth` is designed to integrate with :func:`serve` as follows::

        from websockets.sync.server import basic_auth, serve

        with serve(
            ...,
            process_request=basic_auth(
                realm="my dev server",
                credentials=("hello", "iloveyou"),
            ),
        ):

    If authentication succeeds, the connection's ``username`` attribute is set.
    If it fails, the server responds with an HTTP 401 Unauthorized status.

    One of ``credentials`` or ``check_credentials`` must be provided; not both.

    Args:
        realm: Scope of protection. It should contain only ASCII characters
            because the encoding of non-ASCII characters is undefined. Refer to
            section 2.2 of :rfc:`7235` for details.
        credentials: Hard coded authorized credentials. It can be a
            ``(username, password)`` pair or a list of such pairs.
        check_credentials: Function that verifies credentials.
            It receives ``username`` and ``password`` arguments and returns
            whether they're valid.
    Raises:
        TypeError: If ``credentials`` or ``check_credentials`` is wrong.
        ValueError: If ``credentials`` and ``check_credentials`` are both
            provided or both not provided.

    Nz/provide either credentials or check_credentialscss�|]}t|�VqdSr�)r�)�.0�itemr;r;r<�	<genexpr>�s�zbasic_auth.<locals>.<genexpr>zinvalid credentials argument: r�r?r�r2r�cs.z�|}Wn
tyYdSwt�||�Sr�)�KeyError�hmac�compare_digest)r�r��expected_password)�credentials_dictr;r<r��s�z%basic_auth.<locals>.check_credentialsr�r"rLr�Response | Nonecs�z|jd}Wnty!|�tjjd�}t��|jd<|YSwzt|�\}}WntyD|�tjjd�}t��|jd<|YSw�||�s[|�tjjd�}t��|jd<|S||_	dS)z�
        Perform HTTP Basic Authentication.

        If it succeeds, set the connection's ``username`` attribute and return
        :obj:`None`. If it fails, return an HTTP 401 Unauthorized responss.

        �
AuthorizationzMissing credentials
zWWW-AuthenticatezUnsupported credentials
zInvalid credentials
N)
rUr�rArPrQ�UNAUTHORIZEDrrrr�)r�rL�
authorizationrTr�r�)r�r�r;r<rB�s:����
�z#basic_auth.<locals>.process_request)r�r?r�r?r2r�)r�r"rLrr2r�)rxr�r	�tupler?rZr�list�allr��dict)r�r�r��credentials_listrBr;)r�r�r�r<r$�s (
�*r$)r�r?r2r)NN).rer�r�rGr�r�r~r�r�r�r�r�r�r�r�r�r�r�r�rGrBrCrDrErFrGr�r0r)r0r*r0r+r0r�r�r,r1rgrhr�r�r�rr2r#r�)rer�r�rGr�rr2r#)r�rr2r�)r�NN)r�r?r�r�r�r�r2r�)>�
__future__rr�rPrjrn�rertr-r�r�rlr4r��collections.abcrr�typesr�typingrrrr	�
exceptionsr�extensions.baser�extensions.permessage_deflater
�framesrrUrrr�http11rrrr/rrr�serverrrrrrr�r�utilsr�__all__r"r#r�r r!r�r$r;r;r;r<�<module>s|4
c��/�

�