a
    ^g1                     @  sL  d dl mZ d dlZd dlZd dlZd dlZd dlmZmZ d dl	m
Z
 d dlmZ d dlmZmZ ddlmZmZmZmZ dd	lmZmZ dd
lmZmZmZmZ ejdkrd dlmZmZ nd dl mZmZ edZ!edZ"e#e#e$e$f df Z%e#e%df Z&G dd deZ'e
ddG dd deZ(e
ddG dd dee( Z)dS )    )annotationsN)CallableMapping)	dataclass)wraps)AnyTypeVar   )BrokenResourceErrorEndOfStreamaclose_forcefullyget_cancelled_exc_class)TypedAttributeSettyped_attribute)AnyByteStream
ByteStreamListener	TaskGroup)      )TypeVarTupleUnpackT_RetvalPosArgsT.c                   @  s   e Zd ZU dZe Zded< e Zded< e Zded< e Z	ded	< e Z
d
ed< e Zded< e Zded< e Zded< e Zded< e Zded< dS )TLSAttributez5Contains Transport Layer Security related attributes.
str | Nonealpn_protocolbyteschannel_binding_tls_uniqueztuple[str, str, int]cipherz*None | dict[str, str | _PCTRTTT | _PCTRTT]peer_certificatezbytes | Nonepeer_certificate_binaryboolserver_sidez!list[tuple[str, str, int]] | Noneshared_ciphersssl.SSLObject
ssl_objectstandard_compatiblestrtls_versionN)__name__
__module____qualname____doc__r   r   __annotations__r   r   r    r!   r#   r$   r&   r'   r)    r/   r/   _/var/www/html/cobodadashboardai.evdpl.com/venv/lib/python3.9/site-packages/anyio/streams/tls.pyr       s   
r   F)eqc                	   @  s   e Zd ZU dZded< ded< ded< ded	< ded
< eddddddddddd dddZddddddZddddZdddd Z	d/d"d#d$d%d&Z
d#dd'd(d)Zddd*d+Zed,dd-d.ZdS )0	TLSStreama  
    A stream wrapper that encrypts all sent data and decrypts received data.

    This class has no public initializer; use :meth:`wrap` instead.
    All extra attributes from :class:`~TLSAttribute` are supported.

    :var AnyByteStream transport_stream: the wrapped stream

    r   transport_streamr"   r'   r%   _ssl_objectzssl.MemoryBIO	_read_bio
_write_bioNT)r#   hostnamessl_contextr'   zbool | Noner   zssl.SSLContext | None)r3   r#   r7   r8   r'   returnc                  s   |du r| }|sL|rt jjnt jj}t |}tt drL| jt j M  _t  }t  }|j	||||d}	| |||	||d}
|

|	jI dH  |
S )a  
        Wrap an existing stream with Transport Layer Security.

        This performs a TLS handshake with the peer.

        :param transport_stream: a bytes-transporting stream to wrap
        :param server_side: ``True`` if this is the server side of the connection,
            ``False`` if this is the client side (if omitted, will be set to ``False``
            if ``hostname`` has been provided, ``False`` otherwise). Used only to create
            a default context when an explicit context has not been provided.
        :param hostname: host name of the peer (if host name checking is desired)
        :param ssl_context: the SSLContext object to use (if not provided, a secure
            default will be created)
        :param standard_compatible: if ``False``, skip the closing handshake when
            closing the connection, and don't raise an exception if the peer does the
            same
        :raises ~ssl.SSLError: if the TLS handshake fails

        NOP_IGNORE_UNEXPECTED_EOF)r#   server_hostname)r3   r'   r4   r5   r6   )sslPurposeCLIENT_AUTHSERVER_AUTHcreate_default_contexthasattroptionsr:   	MemoryBIOwrap_bio_call_sslobject_methoddo_handshake)clsr3   r#   r7   r8   r'   purposeZbio_inZbio_outr&   wrapperr/   r/   r0   wrapN   s,    

zTLSStream.wrapz&Callable[[Unpack[PosArgsT]], T_Retval]zUnpack[PosArgsT]r   )funcargsr9   c                   s  z|| }W n t jy   z4| jjr@| j| j I d H  | j I d H }W nX tyn   | j	
  Y nJ ty } z&| j	
  | j
  t|W Y d }~nd }~0 0 | j	| Y q  t jy   | j| j I d H  Y q  t jy& } z&| j	
  | j
  t|W Y d }~q d }~0  t jy } zZ| j	
  | j
  t|t jsn|jrd|jv r| jr~t|ntd  W Y d }~q d }~0 0 | jjr| j| j I d H  |S q d S )NZUNEXPECTED_EOF_WHILE_READING)r<   SSLWantReadErrorr6   pendingr3   sendreadreceiver   r5   	write_eofOSErrorr
   writeSSLWantWriteErrorSSLSyscallErrorSSLError
isinstanceSSLEOFErrorstrerrorr'   )selfrK   rL   resultdataexcr/   r/   r0   rE      sF    






z TLSStream._call_sslobject_methodztuple[AnyByteStream, bytes]r9   c                   s8   |  | jjI dH  | j  | j  | j| j fS )z
        Does the TLS closing handshake.

        :return: a tuple of (wrapped byte stream, bytes left in the read buffer)

        N)rE   r4   unwrapr5   rR   r6   r3   rP   r[   r/   r/   r0   r`      s    

zTLSStream.unwrapNonec                   sR   | j r>z|  I d H  W n$ ty<   t| jI d H   Y n0 | j I d H  d S N)r'   r`   BaseExceptionr   r3   aclosera   r/   r/   r0   re      s    zTLSStream.aclose   intr   )	max_bytesr9   c                   s"   |  | jj|I d H }|st|S rc   )rE   r4   rP   r   )r[   rh   r]   r/   r/   r0   rQ      s    zTLSStream.receive)itemr9   c                   s   |  | jj|I d H  d S rc   )rE   r4   rT   )r[   ri   r/   r/   r0   rO      s    zTLSStream.sendc                   sd   |  tj}td|}|rXt|dt|dp6d }}||fdk rXtd| tdd S )NzTLSv(\d+)(?:\.(\d+))?   r	   r   )rj   r   z;send_eof() requires at least TLSv1.3; current session uses z7send_eof() has not yet been implemented for TLS streams)extrar   r)   rematchrg   groupNotImplementedError)r[   r)   rm   majorminorr/   r/   r0   send_eof   s    "zTLSStream.send_eofMapping[Any, Callable[[], Any]]c                   s   i  j jtj jjtj jjtj jjtj	 fddtj
 fddtj fddtj fddtj fddtj fddtj jji
S )Nc                     s    j dS )NFr4   getpeercertr/   ra   r/   r0   <lambda>       z,TLSStream.extra_attributes.<locals>.<lambda>c                     s    j dS )NTrt   r/   ra   r/   r0   rv      s   c                     s    j jS rc   )r4   r#   r/   ra   r/   r0   rv      rw   c                     s    j jr j  S d S rc   )r4   r#   r$   r/   ra   r/   r0   rv      s    c                     s    j S rc   r'   r/   ra   r/   r0   rv      rw   c                     s    j S rc   )r4   r/   ra   r/   r0   rv      rw   )r3   extra_attributesr   r   r4   selected_alpn_protocolr   get_channel_bindingr   r    r!   r#   r$   r'   r&   r)   versionra   r/   ra   r0   ry      s    


zTLSStream.extra_attributes)rf   )r*   r+   r,   r-   r.   classmethodrJ   rE   r`   re   rQ   rO   rr   propertyry   r/   r/   r/   r0   r2   <   s(   

8.
r2   c                   @  s   e Zd ZU dZded< ded< dZded< d	Zd
ed< eddddddZdddddddZ	ddddZ
eddddZdS )TLSListenera  
    A convenience listener that wraps another listener and auto-negotiates a TLS session
    on every accepted connection.

    If the TLS handshake times out or raises an exception,
    :meth:`handle_handshake_error` is called to do whatever post-mortem processing is
    deemed necessary.

    Supports only the :attr:`~TLSAttribute.standard_compatible` extra attribute.

    :param Listener listener: the listener to wrap
    :param ssl_context: the SSL context object
    :param standard_compatible: a flag passed through to :meth:`TLSStream.wrap`
    :param handshake_timeout: time limit for the TLS handshake
        (passed to :func:`~anyio.fail_after`)
    zListener[Any]listenerzssl.SSLContextr8   Tr"   r'      floathandshake_timeoutrd   r   rb   )r^   streamr9   c                   sJ   t |I dH  t| t s.ttjd| d t| trDt| t rF dS )a  
        Handle an exception raised during the TLS handshake.

        This method does 3 things:

        #. Forcefully closes the original stream
        #. Logs the exception (unless it was a cancellation exception) using the
           ``anyio.streams.tls`` logger
        #. Reraises the exception if it was a base exception or a cancellation exception

        :param exc: the exception
        :param stream: the original stream

        NzError during TLS handshake)exc_info)r   rX   r   logging	getLoggerr*   	exception	Exception)r^   r   r/   r/   r0   handle_handshake_error  s    
z"TLSListener.handle_handshake_errorNzCallable[[TLSStream], Any]zTaskGroup | None)handler
task_groupr9   c                   s6   t  ddd fdd}j||I d H  d S )Nr   rb   )r   r9   c              
     s   ddl m} zH|j* tj| jjdI d H }W d    n1 sH0    Y  W n6 ty } z|| I d H  W Y d }~nd }~0 0  |I d H  d S )Nr	   )
fail_after)r8   r'   )	 r   r   r2   rJ   r8   r'   rd   r   )r   r   Zwrapped_streamr^   r   r[   r/   r0   handler_wrapper8  s    .(z*TLSListener.serve.<locals>.handler_wrapper)r   r   serve)r[   r   r   r   r/   r   r0   r   3  s    zTLSListener.server_   c                   s   | j  I d H  d S rc   )r   re   ra   r/   r/   r0   re   J  s    zTLSListener.aclosers   c                   s   t j fddiS )Nc                     s    j S rc   rx   r/   ra   r/   r0   rv   P  rw   z.TLSListener.extra_attributes.<locals>.<lambda>)r   r'   ra   r/   ra   r0   ry   M  s    zTLSListener.extra_attributes)N)r*   r+   r,   r-   r.   r'   r   staticmethodr   r   re   r~   ry   r/   r/   r/   r0   r      s   
" r   )*
__future__r   r   rl   r<   syscollections.abcr   r   dataclassesr   	functoolsr   typingr   r   r   r
   r   r   r   Z_core._typedattrr   r   abcr   r   r   r   version_infor   r   Ztyping_extensionsr   r   tupler(   Z_PCTRTTZ_PCTRTTTr   r2   r   r/   r/   r/   r0   <module>   s0   
 ?