
    Vh%                     d   d Z ddlmZmZmZmZmZmZmZm	Z	m
Z
 ddlmZmZmZmZmZmZmZ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 ddlmZ dd	l m!Z!m"Z"m#Z#m$Z$m%Z%m&Z& dd
l'm(Z( ddl)m*Z* ddl+m,Z, erddl-m.Z.  ee#       G d d             Z/ e0eeg      Z1 e0eg      e e0eg      ee1eiZ2eeeeiZ3eedZ4edediZ5eeeee6e7eee7e6f   ee7e6e6e6f   f   f      Z8 ee"       G d d             Z9 ee"       G d d             Z: ee%       G d d             Z; ee&       G d d             Z<y)z=
IPv6-aware hostname resolution.

@see: L{IHostnameResolver}
    )	AF_INETAF_INET6	AF_UNSPEC
SOCK_DGRAMSOCK_STREAMAddressFamily
SocketKindgaierrorgetaddrinfo)	TYPE_CHECKINGCallableListNoReturnOptionalSequenceTupleTypeUnion)implementer)
_idnaBytes)IPv4AddressIPv6Address)Deferred)DNSLookupError)IAddressIHostnameResolverIHostResolutionIReactorThreadsIResolutionReceiverIResolverSimple)deferToThreadPool)Logger)nativeString)
ThreadPoolc                   (    e Zd ZdZdefdZdefdZy)HostResolutionz9
    The in-progress resolution of a given hostname.
    namec                     || _         y)zA
        Create a L{HostResolution} with the given name.
        N)r'   )selfr'   s     J/home/dcms/DCMS/lib/python3.12/site-packages/twisted/internet/_resolver.py__init__zHostResolution.__init__?   s     	    returnc                     t               N)NotImplementedErrorr)   s    r*   cancelzHostResolution.cancelE   s    !##r,   N)__name__
__module____qualname____doc__strr+   r   r2    r,   r*   r&   r&   9   s    S $ $r,   r&   )TCPUDPr9   r:   c                       e Zd ZdZdefdedeeg df      deee	e	e	ge
f   fdZ	 	 	 dded	ed
e	deeee         dedefdZy)GAIResolverzp
    L{IHostnameResolver} implementation that resolves hostnames by calling
    L{getaddrinfo} in a thread.
    NreactorgetThreadPoolr$   r   c                 J    || _         ||j                  n|| _        || _        y)a  
        Create a L{GAIResolver}.

        @param reactor: the reactor to schedule result-delivery on
        @type reactor: L{IReactorThreads}

        @param getThreadPool: a function to retrieve the thread pool to use for
            scheduling name resolutions.  If not supplied, the use the given
            C{reactor}'s thread pool.
        @type getThreadPool: 0-argument callable returning a
            L{twisted.python.threadpool.ThreadPool}

        @param getaddrinfo: a reference to the L{getaddrinfo} to use - mainly
            parameterized for testing.
        @type getaddrinfo: callable with the same signature as L{getaddrinfo}
        N)_reactorr>   _getThreadPool_getaddrinfo)r)   r=   r>   r   s       r*   r+   zGAIResolver.__init__t   s-    ,  %2%:G!! 	 (r,   resolutionReceiverhostName
portNumberaddressTypestransportSemanticsr-   c                 8     j                         }t        |t        n
t        |         t        |   dt
        f fd}t         j                  ||      }t              }	j                  |	       |j                  dt
        ddffd       }
|	S )<  
        See L{IHostnameResolver.resolveHostName}

        @param resolutionReceiver: see interface

        @param hostName: see interface

        @param portNumber: see interface

        @param addressTypes: see interface

        @param transportSemantics: see interface

        @return: see interface
        Nr-   c                  P    	 j                         S # t        $ r g cY S w xY wr/   )rB   r
   )addressFamilyrD   rE   r)   
socketTypes   r*   getz(GAIResolver.resolveHostName.<locals>.get   s:    ((j-   	s    %%resultc           	          | D ]=  \  }}}}}t         |   }j                   |t        j                  |d      g|        ? j	                          y Nr9   )	_afToTypeaddressResolved_socktypeToTyperM   resolutionComplete)rN   familysocktypeproto	cannonamesockaddraddrTyperC   s          r*   deliverResultsz3GAIResolver.resolveHostName.<locals>.deliverResults   s]    @F <%H$V,"22_005AMHM
 113r,   )rA   
_typesToAF_any	frozenset_transportToSocket_GETADDRINFO_RESULTr!   r@   r&   resolutionBeganaddCallback)r)   rC   rD   rE   rF   rG   poolrM   d
resolutionr[   rK   rL   s   ````       @@r*   resolveHostNamezGAIResolver.resolveHostName   s    . ""$" (Di.E
 ((:;
	( 	 	 dmmT37#H-
**:6	
	4#6 	44 	4 
	4 r,   r   Nr9   )r3   r4   r5   r6   r   r   r   r   r7   intr`   r+   r   r   r   r   r   rf   r8   r,   r*   r<   r<   m   s     ?CKV	( (  \)9 :;( sCc24GGH	(@ ;?"'2/2 2 	2
 xX782  2 
2r,   r<   c                   d    e Zd ZdZ e       ZdefdZ	 	 	 ddede	de
deeee         d	e	d
efdZy)SimpleResolverComplexifierzF
    A converter from L{IResolverSimple} to L{IHostnameResolver}.
    simpleResolverc                     || _         y)zW
        Construct a L{SimpleResolverComplexifier} with an L{IResolverSimple}.
        N)_simpleResolver)r)   rk   s     r*   r+   z#SimpleResolverComplexifier.__init__   s      .r,   NrC   rD   rE   rF   rG   r-   c                 Z    	 j                  d      }t        |      t	              }j                  |        j                  j                        j                  fd      j                   fd      j                  fd       |S # t        $ r t              }Y w xY w)rI   asciic                 <    j                  t        d|             S rP   )rR   r   )addressrE   rC   s    r*   <lambda>z<SimpleResolverComplexifier.resolveHostName.<locals>.<lambda>   s     2 B Bw
;! r,   c                     | j                  t              rd S j                  j                  d| j                        S )Nz'while looking up {name} with {resolver})r'   resolver)checkr   _logfailurerm   )errorrD   r)   s    r*   rr   z<SimpleResolverComplexifier.resolveHostName.<locals>.<lambda>  sD    ;;~. # YY&&=!!11	 '  r,   c                 $    j                         S r/   )rT   )nothingrC   s    r*   rr   z<SimpleResolverComplexifier.resolveHostName.<locals>.<lambda>
  s    );)N)N)P r,   )
encodeUnicodeEncodeErrorr   r#   r&   ra   rm   getHostByNamerb   
addErrback)r)   rC   rD   rE   rF   rG   hostName_bytesre   s   ````    r*   rf   z*SimpleResolverComplexifier.resolveHostName   s    0	2%__W5N  /#H-
**:6  ..x8[
 Z	 [PQ? " 	2
 (1N	2s   B B*)B*rg   )r3   r4   r5   r6   r"   rv   r    r+   r   r7   rh   r   r   r   r   r   rf   r8   r,   r*   rj   rj      st     8D. . ;?"'9/9 9 	9
 xX789  9 
9r,   rj   c                   @    e Zd ZdZd
dZdeddfdZdeddfdZdd	Z	y)FirstOneWinszT
    An L{IResolutionReceiver} which fires a L{Deferred} with its first result.
    c                      || _         d| _        y)zp
        @param deferred: The L{Deferred} to fire when the first resolution
            result arrives.
        FN)	_deferred	_resolved)r)   deferreds     r*   r+   zFirstOneWins.__init__  s    
 "r,   re   r-   Nc                     || _         y)z
        See L{IResolutionReceiver.resolutionBegan}

        @param resolution: See L{IResolutionReceiver.resolutionBegan}
        N)_resolution)r)   re   s     r*   ra   zFirstOneWins.resolutionBegan  s     &r,   rq   c                     | j                   ryd| _         t        |t              sJ | j                  j	                  |j
                         y)z
        See L{IResolutionReceiver.addressResolved}

        @param address: See L{IResolutionReceiver.addressResolved}
        NT)r   
isinstancer   r   callbackhost)r)   rq   s     r*   rR   zFirstOneWins.addressResolved%  s=     >> ';///-r,   c                     | j                   ry| j                  j                  t        | j                  j
                               y)z?
        See L{IResolutionReceiver.resolutionComplete}
        N)r   r   errbackr   r   r'   r1   s    r*   rT   zFirstOneWins.resolutionComplete3  s1     >>~d.>.>.C.CDEr,   )r   Deferred[str])r-   N)
r3   r4   r5   r6   r+   r   ra   r   rR   rT   r8   r,   r*   r   r     s8    &/ &d &.x .D .Fr,   r   c                   8    e Zd ZdZdefdZd
dedee   ddfdZ	y	)ComplexResolverSimplifierzE
    A converter from L{IHostnameResolver} to L{IResolverSimple}
    nameResolverc                     || _         y)z
        Create a L{ComplexResolverSimplifier} with an L{IHostnameResolver}.

        @param nameResolver: The L{IHostnameResolver} to use.
        N)_nameResolver)r)   r   s     r*   r+   z"ComplexResolverSimplifier.__init__B  s     *r,   r'   timeoutsr-   r   c                 r    t               }| j                  j                  t        |      |dt        g       |S )z
        See L{IResolverSimple.getHostByName}

        @param name: see L{IResolverSimple.getHostByName}

        @param timeouts: see L{IResolverSimple.getHostByName}

        @return: see L{IResolverSimple.getHostByName}
        r   )r   r   rf   r   r   )r)   r'   r   rN   s       r*   r}   z'ComplexResolverSimplifier.getHostByNameJ  s1     #+***<+?q;-Xr,   N)r8   )
r3   r4   r5   r6   r   r+   r7   r   rh   r}   r8   r,   r*   r   r   <  s2    *%6 *# #  r,   r   N)=r6   socketr   r   r   r   r   r   r	   r
   r   typingr   r   r   r   r   r   r   r   r   zope.interfacer   twisted.internet._idnar   twisted.internet.addressr   r   twisted.internet.deferr   twisted.internet.errorr   twisted.internet.interfacesr   r   r   r   r   r    twisted.internet.threadsr!   twisted.loggerr"   twisted.python.compatr#   twisted.python.threadpoolr$   r&   r^   r]   r\   rQ   r_   rS   rh   r7   r`   r<   rj   r   r   r8   r,   r*   <module>r      s  

 
 

 
 
 ' - = + 1  7 ! .4 _$ $ $  +{+, {mg{mh)
 [k	    	eCHouS#sC%7889		;  T T  Tn F F  FR  !)F )F ")FX _  r,   