
    RPf1                       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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\  r	d 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e      Z' e
d       G d de             Z( e
d       G d dee(                Z)y)    )annotationsN)CallableMapping)	dataclass)wraps)AnyTupleTypeVar   )BrokenResourceErrorEndOfStreamaclose_forcefullyget_cancelled_exc_class)TypedAttributeSettyped_attribute)AnyByteStream
ByteStreamListener	TaskGroup)      )TypeVarTupleUnpackT_RetvalPosArgsT.c                     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<   y)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,        K/var/www/fastapitest/venv/lib/python3.12/site-packages/anyio/streams/tls.pyr   r       s    ? !0 1M:1(7(99#2#4F 4 FUEVBV,;,=\=')K) 9H8IN5I / 1J1 !0 11&(K(r3   r   F)eqc                      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       Z	 	 	 	 	 	 ddZddZddZ	dddZ
ddZddZedd       Zy)	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*   c                 K   || }|s|rt         j                  j                  nt         j                  j                  }t        j                  |      }t        t         d      r$|xj                  t         j                   z  c_        t        j                         }t        j                         }|j                  ||||      }	 | |||	||      }
|
j                  |	j                         d{    |
S 7 w)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)r8   r*   r9   r:   r;   )sslPurposeCLIENT_AUTHSERVER_AUTHcreate_default_contexthasattroptionsr?   	MemoryBIOwrap_bio_call_sslobject_methoddo_handshake)clsr8   r&   r<   r=   r*   purposebio_inbio_outr)   wrappers              r4   wrapzTLSStream.wrapN   s     : &,K+6''CKK<S<S  44W=K s67##(D(D'DD#--/ ))Gh * 

 - 3"
 ,,Z-D-DEEE 	Fs   C/C:1C82C:c                \  K   	 	  || }| j                   j                  r;| j                  j                  | j                   j	                                d {    |S 7 # t
        j                  $ r 	 | j                   j                  r<| j                  j                  | j                   j	                                d {  7   | j                  j                          d {  7  }| j                  j                  |       np# t        $ r | j                  j                          Y nKt        $ r@}| j                  j                          | j                   j                          t        |d }~ww xY wY n2t
        j                  $ r? | j                  j                  | j                   j	                                d {  7   Y nt
        j                  $ r@}| j                  j                          | j                   j                          t        |d }~wt
        j                   $ r|}| j                  j                          | j                   j                          t#        |t
        j$                        sd|j&                  v r| j(                  rt        |t        d  d }~ww xY ww)NUNEXPECTED_EOF_WHILE_READING)r;   pendingr8   sendreadrA   SSLWantReadErrorreceiver:   writer   	write_eofOSErrorr   SSLWantWriteErrorSSLSyscallErrorSSLError
isinstanceSSLEOFErrorstrerrorr*   )selffuncargsresultdataexcs         r4   rJ   z TLSStream._call_sslobject_method   s     )tJ ??**//44T__5I5I5KLLL MK '' //.."33889M9M9OPPP!%!6!6!>!>!@@@D NN((. # /NN,,. 7NN,,.OO--/-367 (( I++001E1E1GHHH&& 3((*))+)s2<< ((*))+sCOO45E//1s:)t31 s   J,A AJ,AJ,J'4AD C"D#C&$D)J'#E2(J'*E22;E--E22J'5J,8AJ' GJ'J,J';HJ'+A7J""J''J,c                  K   | j                  | j                  j                         d{    | j                  j	                          | j
                  j	                          | j                  | j                  j                         fS 7 ^w)z
        Does the TLS closing handshake.

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

        N)rJ   r9   unwrapr:   rZ   r;   r8   rV   rb   s    r4   ri   zTLSStream.unwrap   sl      ))$*:*:*A*ABBB  "!!#$$dnn&9&9&;;; 	Cs   )BB
ABc                   K   | j                   r	 | j                          d {    | j                  j                          d {    y 7 '# t        $ r  t        | j                         d {  7    w xY w7 3wN)r*   ri   BaseExceptionr   r8   acloserj   s    r4   rn   zTLSStream.aclose   sm     ##kkm##
 ##**,,, $  '(=(=>>> 	-sC   A;A AA A;A9A;A !A6.A1/A66A;c                ~   K   | j                  | j                  j                  |       d {   }|st        |S 7 wrl   )rJ   r9   rV   r   )rb   	max_bytesrf   s      r4   rX   zTLSStream.receive   s;     001A1A1F1F	RR	 Ss   *=;=c                l   K   | j                  | j                  j                  |       d {    y 7 wrl   )rJ   r9   rY   )rb   items     r4   rU   zTLSStream.send   s(     ))$*:*:*@*@$GGGs   *424c                (  K   | j                  t        j                        }t        j                  d|      }|rMt        |j                  d            t        |j                  d      xs d      }}||fdk  rt        d|       t        d      w)NzTLSv(\d+)(?:\.(\d+))?   r   r   )rt   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matchintgroupNotImplementedError)rb   r,   rw   majorminors        r4   send_eofzTLSStream.send_eof   s     jj!9!9:1;?u{{1~.EKKN4Ga0H5Eu~&)$$/=2 
 "E
 	
s   BBc                <    i  j                   j                  t        j                   j                  j
                  t        j                   j                  j                  t        j                   j                  j                  t        j                   fdt        j                   fdt        j                   fdt        j                   fdt        j                   fdt        j                   fdt        j                   j                  j                   i
S )Nc                 :     j                   j                  d      S )NFr9   getpeercertrj   s   r4   <lambda>z,TLSStream.extra_attributes.<locals>.<lambda>   s    43C3C3O3OPU3V r3   c                 :     j                   j                  d      S )NTr   rj   s   r4   r   z,TLSStream.extra_attributes.<locals>.<lambda>   s    $:J:J:V:V; r3   c                 0     j                   j                  S rl   )r9   r&   rj   s   r4   r   z,TLSStream.extra_attributes.<locals>.<lambda>   s    d.>.>.J.J r3   c                 h     j                   j                  r j                   j                         S d S rl   )r9   r&   r'   rj   s   r4   r   z,TLSStream.extra_attributes.<locals>.<lambda>   s0    ++ 261A1A1P1P1R  r3   c                      j                   S rl   r*   rj   s   r4   r   z,TLSStream.extra_attributes.<locals>.<lambda>       d6N6N r3   c                      j                   S rl   )r9   rj   s   r4   r   z,TLSStream.extra_attributes.<locals>.<lambda>   s    T-=-= r3   )r8   extra_attributesr   r   r9   selected_alpn_protocolr!   get_channel_bindingr"   r#   r$   r&   r'   r*   r)   r,   versionrj   s   `r4   r   zTLSStream.extra_attributes   s    
##44
&&(8(8(O(O33  44!1!1!8!8))+V00 3 $$&J'' * ,,.N##%=$$d&6&6&>&>#
 	
r3   )r8   r   r&   zbool | Noner<   r   r=   zssl.SSLContext | Noner*   r%   returnr7   )rc   z&Callable[[Unpack[PosArgsT]], T_Retval]rd   zUnpack[PosArgsT]r   r   )r   ztuple[AnyByteStream, bytes]r   None)i   )rp   rx   r   r    )rr   r    r   r   r   zMapping[Any, Callable[[], Any]])r-   r.   r/   r0   r1   classmethodrQ   rJ   ri   rn   rX   rU   r}   propertyr   r2   r3   r4   r7   r7   <   s     $#
 $(#-1$(6'6 !	6
 6 +6 "6 
6 6p-:-CS-	-^
<-H
 
 
r3   r7   c                      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       Z	 d	 	 	 	 	 ddZ	ddZ
edd       Zy)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.SSLContextr=   Tr%   r*      floathandshake_timeoutc                   K   t        |       d{    t        | t                     s*t        j                  t
              j                  d|        t        | t              rt        | t                     r y7 hw)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   r_   r   logging	getLoggerr-   	exception	Exception)rg   streams     r4   handle_handshake_errorz"TLSListener.handle_handshake_error  sr        ''' #689
 h'11,s 2 
 #y)Z=T=V-W .X 	(s   A<A:A)A<Nc                    K   t              d fd       } j                  j                  ||       d {    y 7 w)Nc                \  K   ddl m} 	  |j                        5  t        j	                  | j
                  j                         d {   }d d d                d {    y 7 # 1 sw Y   xY w7 # t        $ r%}j                  ||        d {  7   Y d }~y d }~ww xY ww)Nr   )
fail_after)r=   r*   )	 r   r   r7   rQ   r=   r*   rm   r   )r   r   wrapped_streamrg   handlerrb   s       r4   handler_wrapperz*TLSListener.serve.<locals>.handler_wrapper9  s     %
. 6 67 +4>>$($4$4,0,D,D ,: , &N n---&  . ! ?11#v>>>?su   B,A; 0A-A+A-A; B,%A9&B,+A--A62A; 9B,;	B)B$BB$B,$B))B,)r   r   r   r   )r   r   serve)rb   r   
task_groupr   s   ``  r4   r   zTLSListener.serve4  s;     
 
w	. 
	. mm!!/:>>>s   5A?Ac                T   K   | j                   j                          d {    y 7 wrl   )r   rn   rj   s    r4   rn   zTLSListener.acloseK  s     mm""$$$s   (&(c                .     t         j                   fdiS )Nc                      j                   S rl   r   rj   s   r4   r   z.TLSListener.extra_attributes.<locals>.<lambda>Q  r   r3   )r   r*   rj   s   `r4   r   zTLSListener.extra_attributesN  s     ,,.N
 	
r3   )rg   rm   r   r   r   r   rl   )r   zCallable[[TLSStream], Any]r   zTaskGroup | Noner   r   r   r   )r-   r.   r/   r0   r1   r*   r   staticmethodr   r   rn   r   r   r2   r3   r4   r   r      s}    "  $$!u! D (,?+? %? 
	?.% 
 
r3   r   )*
__future__r   r   rv   rA   syscollections.abcr   r   dataclassesr   	functoolsr   typingr   r	   r
   r   r   r   r   r   _core._typedattrr   r   abcr   r   r   r   version_infor   r   typing_extensionsr   r   r+   _PCTRTT_PCTRTTTr   r7   r   r2   r3   r4   <module>r      s    "  	 
 
 - !  & &  B @ @w++6:
#
c3h$
%#)$ )8 e|

 |
 |
~ eU
(9% U
 U
r3   