a
    ø£Beþ0  ã                   @  s.  d dl mZ d dlZd dlm  m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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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ÚTupleÚTypeVaré   )ÚBrokenResourceErrorÚEndOfStreamÚaclose_forcefullyÚget_cancelled_exc_class)ÚTypedAttributeSetÚtyped_attribute)ÚAnyByteStreamÚ
ByteStreamÚListenerÚ	TaskGroupÚT_Retval.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+   úT/home/yuhw/wc/wire-cell-python/wcpy/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)r/   r   r3   r4   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)r/   r#   r0   r1   r2   )ÚsslÚPurposeÚCLIENT_AUTHÚSERVER_AUTHÚcreate_default_contextÚhasattrÚoptionsr6   Ú	MemoryBIOÚwrap_bioÚ_call_sslobject_methodÚdo_handshake)Úclsr/   r   r3   r4   r#   ÚpurposeZbio_inZbio_outr"   Úwrapperr+   r+   r,   ÚwrapG   s,    ÿ

ÿûzTLSStream.wrapzCallable[..., T_Retval]Úobjectr   )ÚfuncÚargsr5   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’ } zR| j	 
¡  | j 
¡  t|t jƒ�sfd|jv �r|| j�rvt|‚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)r8   ÚSSLWantReadErrorr2   Úpendingr/   ÚsendÚreadÚreceiver   r1   Ú	write_eofÚOSErrorr   ÚwriteÚSSLWantWriteErrorÚSSLSyscallErrorÚSSLErrorÚ
isinstanceÚSSLEOFErrorÚstrerrorr#   )ÚselfrH   rI   ÚresultÚdataÚexcr+   r+   r,   rA   €   sD    






ÿþ
z TLSStream._call_sslobject_methodztuple[AnyByteStream, bytes]©r5   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)rA   r0   Úunwrapr1   rO   r2   r/   rM   ©rX   r+   r+   r,   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   r/   Úacloser^   r+   r+   r,   rb   »   s    zTLSStream.acloseé   Úintr   )Ú	max_bytesr5   c                 Ã  s"   |   | jj|¡I d H }|st‚|S r`   )rA   r0   rM   r   )rX   re   rZ   r+   r+   r,   rN   Å   s    zTLSStream.receive)Úitemr5   c                 Ã  s   |   | jj|¡I d H  d S r`   )rA   r0   rQ   )rX   rf   r+   r+   r,   rL   Ì   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   )rg   é   z;send_eof() requires at least TLSv1.3; current session uses z7send_eof() has not yet been implemented for TLS streams)Úextrar   r%   ÚreÚmatchrd   ÚgroupÚNotImplementedError)rX   r%   rk   ÚmajorÚminorr+   r+   r,   Ú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©r0   Úgetpeercertr+   r^   r+   r,   Ú<lambda>ç   ó    z,TLSStream.extra_attributes.<locals>.<lambda>c                     s   ˆ j  d¡S )NTrr   r+   r^   r+   r,   rt   è   s   ÿc                     s   ˆ j jS r`   )r0   r   r+   r^   r+   r,   rt   ë   ru   c                     s   ˆ j jrˆ j  ¡ S d S r`   )r0   r   r    r+   r^   r+   r,   rt   ì   s    ÿc                     s   ˆ j S r`   ©r#   r+   r^   r+   r,   rt   ï   ru   c                     s   ˆ j S r`   )r0   r+   r^   r+   r,   rt   ð   ru   )r/   Úextra_attributesr   r   r0   Úselected_alpn_protocolr   Úget_channel_bindingr   r   r   r   r    r#   r"   r%   Úversionr^   r+   r^   r,   rw   Þ   s    ÿ


ïzTLSStream.extra_attributes)rc   )r&   r'   r(   r)   r*   ÚclassmethodrF   rA   r]   rb   rN   rL   rp   Úpropertyrw   r+   r+   r+   r,   r.   5   s(   

ù8/
r.   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.SSLContextr4   Tr   r#   é   ÚfloatÚhandshake_timeoutra   r   r_   )r[   Ústreamr5   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   rU   r   ÚloggingÚ	getLoggerr&   Ú	exceptionÚ	Exception)r[   r‚   r+   r+   r,   Úhandle_handshake_error  s    
ÿz"TLSListener.handle_handshake_errorNzCallable[[TLSStream], Any]zTaskGroup | None)ÚhandlerÚ
task_groupr5   c                 ƒ  s6   t ˆ ƒdddœ‡ ‡fdd„ƒ}ˆj ||¡I d H  d S )Nr   r_   )r‚   r5   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)r4   r#   )	Ú r‹   r�   r.   rF   r4   r#   ra   rˆ   )r‚   r‹   Zwrapped_streamr[   ©r‰   rX   r+   r,   Úhandler_wrapper2  s    ý.(z*TLSListener.serve.<locals>.handler_wrapper)r   r~   Úserve)rX   r‰   rŠ   rŽ   r+   r�   r,   r�   -  s    zTLSListener.server\   c                 Ã  s   | j  ¡ I d H  d S r`   )r~   rb   r^   r+   r+   r,   rb   D  s    zTLSListener.acloserq   c                   s   t j‡ fdd„iS )Nc                     s   ˆ j S r`   rv   r+   r^   r+   r,   rt   J  ru   z.TLSListener.extra_attributes.<locals>.<lambda>)r   r#   r^   r+   r^   r,   rw   G  s    ÿzTLSListener.extra_attributes)N)r&   r'   r(   r)   r*   r#   r�   Ústaticmethodrˆ   r�   rb   r|   rw   r+   r+   r+   r,   r}   õ   s   
" ýr}   )*Ú
__future__r   ÚbuiltinsÚ@py_builtinsÚ_pytest.assertion.rewriteÚ	assertionÚrewriteÚ
@pytest_arr„   rj   r8   Úcollections.abcr   r   Údataclassesr   Ú	functoolsr   Útypingr   r   r	   rŒ   r   r   r   r   Ú_core._typedattrr   r   Úabcr   r   r   r   r   r$   Z_PCTRTTZ_PCTRTTTr   r.   r}   r+   r+   r+   r,   Ú<module>   s&   " @