o h#@sdZddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl Z ddlmZmZmZmZmZmZddlZddlZddlZddlZddlZddlZddlZddlZddlZddlZddl Zddl!Zddl"ZddZ#ddZ$ej%&dZ'e'rddl(Z)ddl*Z*e)j+Z,e)j-j.j/Z0Gd d d e,Z1Gd d d e*j2Z3nGd d d Z3e'Z4zddl5Z5Wne6yGdddZ5Ynwe j Z7Gdddej8j9Z:Gdddej8j;Zej?j@Z@ddZAddZBddZCddZDd d!ZEd"d#ZF $dd%d&ZGdd'd(ZHd)ed*d+d*fd,d-ZIGd.d/d/ejJZKdd0ddd1d1dd2d$dd$de jLeKjMfd3ejNjOd4ePd5eeQd6eRd7eePd8eRd9eSd:eSd;eedeePd?eeSePfd)ed*d@eRdAeKd+ejNjOf"dBdCZTdDejUjVdEeWd+eWfdFdGZXdDejUjVdHePdIeWd+dfdJdKZY  L   1 1 $  $dd3ejNjOd4ePdMePd5eeQd6eRd7eePd8eRd9eSd:eSd?eeSePfdNeePd=eSd+ejNjOfdOdPZZdQdRZ[dSdTZ\ ddUedVeejNjOeWfdWedXeeQd+eeReQff dYdZZ]   1 1  [ 1 1 1 ddUedWeedXeeQd\eSd9eSd]eeej^j_ej`jafd^eeWd:eSd_eSd`eSdaeejNjOd+efdbdcZb  d   1 1 1 1  1dd3ejNjOd4ePd5eeQd6eRd7eePd8eRd\eSd9eSd:eSd_eSdUeed`eSd+ejNjOfdedfZc  d   1 1 1   1dd3ejNjOd4ePd5eeQd6eRd7eePd8eRd\eSd9eSd:eSdgeedheed`eSd+eejNjOeSffdidjZddkdlZedmdnZf ddUedVeejNjOeWfdXeeQd+eeReQffdodpZg  1  [ 1ddUedXeeQd9eSd]eeej^j_ej`jafd^eeWd:eSd+eejNjOeQffdqdrZhdsdtZi  d   1 1 dd3ejNjOd4ePd5eeQd6eRd7eePd8eRd9eSd:eSdUeed+ejNjOfdudvZjdwdxZkdyeePd?eeSePfd+e5jlfdzd{Zm  L   1 1    $dd3ejNjOd4ePd5eeQd6eRd7eePd8eRd9eSd:eSdUee5jnd|ee5jldyeePd?eeSePfd+ejNjOfd}d~Zo  L   1 1  $  dd3ejNjOd4ePd5eeQd6eRd7eePd8eRd9eSd:eSdeejUjpd?eeSePfdNeePdyeePd+ejNjOfddZUGdddejJZqdejrjsde j daejNjOdeeRd5eeQdXeQd+efddZtejujvejwjxdddddd$ddddd1ej`jyf d4ePdeej^j_ePfdeejujzePfdeejwj{ePfd5eeQd6eRd]eeej^j_ej`jafdeeej^j_ePfdeSdeeQd7eePd8eRdeRdeSdeej^j_ePfd+ef ddZ?dddddddeqj|fd4ePdejrjsdaeejNjOd6eRd5eeQdeeQd7eePd8eRdeqd+dfddZ}dS)zTalk to a DNS server.N)AnyDictOptionalTupleUnioncastcCs,|durdS|t}|dkrtjj|S)N)timedns exceptionTimeout) expirationtimeoutrwtj)N)r lifetimerg@)_compute_timesr inet is_addressappendrrraf_for_addressr resolve_name addressesrlow_level_address_tuple _make_socketsocket SOCK_STREAMr_connect_CoreSyncStream ExceptionhttpcoreZ ConnectError)rhostportr local_addresssocket_optionsr*_r r answersaddressafsourcesockZattempt_expirationrrr connect_tcpPsD         z_NetworkBackend.connect_tcpcCtrNotImplementedError)rpathrr6rrrconnect_unix_socketwsz#_NetworkBackend.connect_unix_socketr)__name__ __module__ __qualname__rr=rB __classcell__rrr!rrHs   (rcs*eZdZdddejdfdd ZZS)_HTTPTransportrN)rrrr csJ|dur|durddl}|j}tj|i|t|||||j_dSNr) dns.resolverrResolverrrr_poolZ_network_backend)rrrrr argskwargsr r!rrr}s   z_HTTPTransport.__init__)rCrDrEr- AF_UNSPECrrFrrr!rrG|s rGc@seZdZddZdS)rGcCr>rr?)rr3r4rr5rrrr=z_HTTPTransport.connect_tcpN)rCrDrEr=rrrrrGs c@sXeZdZdZGdddeZGdddeZGdddZGdd d Ze d d Z d S) sslrc@ eZdZdS)zssl.WantReadExceptionNrCrDrErrrrWantReadExceptionrSc@rQ)zssl.WantWriteExceptionNrRrrrrWantWriteExceptionrTrUc@rQ)zssl.SSLContextNrRrrrr SSLContextrTrVc@rQ)z ssl.SSLSocketNrRrrrr SSLSocketrTrWcOstd)Nzno ssl support)r1)clsrLrMrrrcreate_default_contextszssl.create_default_contextN) rCrDrE CERT_NONEr1rSrUrVrW classmethodrYrrrrrPsrPc@eZdZdZdS)UnexpectedSourcez=A DNS query response came from an unexpected address or port.NrCrDrE__doc__rrrrr]r]c@r\) BadResponsez:/. *timeout*, a ``float`` or ``None``, the number of seconds to wait before the query times out. If ``None``, the default, wait forever. *port*, a ``int``, the port to send the query to. The default is 443. *source*, a ``str`` containing an IPv4 or IPv6 address, specifying the source address. The default is the wildcard address. *source_port*, an ``int``, the port from which to send the message. The default is 0. *one_rr_per_rrset*, a ``bool``. If ``True``, put each RR into its own RRset. *ignore_trailing*, a ``bool``. If ``True``, ignore trailing junk at end of the received message. *session*, an ``httpx.Client``. If provided, the client session to use to send the queries. *path*, a ``str``. If *where* is an IP address, then *path* will be used to construct the URL to send the DNS query to. *post*, a ``bool``. If ``True``, the default, POST method will be used. *bootstrap_address*, a ``str``, the IP address to use to bypass resolution. *verify*, a ``bool`` or ``str``. If a ``True``, then TLS certificate verification of the server is done using the default CA bundle; if ``False``, then no verification is done; if a `str` then it specifies the path to a certificate file or directory which will be used for verification. *resolver*, a ``dns.resolver.Resolver`` or ``None``, the resolver to use for resolution of hostnames in URLs. If not specified, a new resolver with a default configuration will be used; note this is *not* the default resolver as that resolver might have been configured to use DoH causing a chicken-and-egg problem. This parameter only has an effect if the HTTP library is httpx. *family*, an ``int``, the address family. If socket.AF_UNSPEC (the default), both A and AAAA records will be retrieved. *http_version*, a ``dns.query.HTTPVersion``, indicating which HTTP version to use. Returns a ``dns.message.Message``. FNzhttps://:z https://[z]:zno hostname in URLZ sni_hostname)rrz)session parameter must be an httpx.Clientacceptzapplication/dns-messagerry)r5http1http2rrrrr )rrr transport)z content-typezcontent-length)headerscontentr extensions=r )rrparamsr+ responded with status code z Response body: keyring request_macrr)6rr r%r&r-AF_INETAF_INET6urllibparseurlparsehostnamerr4rrrhave_dohrr)randomchoicelistr*_http3rbrehttpxZClientto_wirerr contextlib nullcontextrGupdatestrlenrbase64urlsafe_b64encoderstripdecodeget status_codermessage from_wirerrelapsed total_secondsr is_responsera)"rrrr4r;rrrrrArrrrr rr:r7Z the_sourceurlrparsedr8wirerZh1Zh2r5rcmrresponseZtwirerrrrhttpsrsG              rrnamecCs.|durt|D] \}}||kr|Sqtr)KeyError)rrheadervaluerrr _find_header9s rpeerrcCst|d}|dur tdt|}|dkrtd|dks!|dkrFd}t|dkr;zd|}Wn ty:Ynwt|d ||dS) Ns:statuszno :status header in responserzstatus is negativerrz: r)rr{intrrr1r)rrrrstatuserrorrrr _check_statusBs   rUrrc  Cs,tjjstdtj|} | j} | jdur| j}d|_ | } tjj | | dd}|E| ||||}t |\}}||}||| | |t|} t||| Wdn1s`wYt}Wdn1sswYtjj| |j|j||d}t||d|_||st|S)Nz DNS-over-HTTP3 is not available.rT) verify_mode server_nameZh3rr)r quic have_quicrbrrrrr4idrSyncQuicManagerconnectr$ make_streamZsend_h3receiverrrr rrrrmaxrra)rrrrr4r;rrrrrrZ url_partsrmanager connectionstartr streamfinishrrrrrSs@      rcCs. z||WStyt||Ynwq)zReads a datagram from the socket. A Timeout exception will be raised if the operation is not completed by the expiration time. )recvfromBlockingIOErrorrv)r<max_sizer rrr _udp_recvs  rcCs@ z|r |||WS||WStyt||Ynwq)zSends the specified datagram to destination over the socket. A Timeout exception will be raised if the operation is not completed by the expiration time. )sendtosendrrx)r<datarr rrr _udp_sends  rr<whatrr cCs4t|tjjr |}t}t||||}||fS)aSend a DNS message to the specified UDP socket. *sock*, a ``socket``. *what*, a ``bytes`` or ``dns.message.Message``, the message to send. *destination*, a destination tuple appropriate for the address family of the socket, specifying where to send the query. *expiration*, a ``float`` or ``None``, the absolute time at which a timeout exception should be raised. If ``None``, no timeout will occur. Returns an ``(int, float)`` tuple of bytes sent and the sent time. )rer rMessagerr r)r<rrr sent_timenrrrsend_udps rrrrraise_on_truncation ignore_errorsqueryc  Csd} t|d|\} } t|j| ||sqt} ztjj| |||||d}Wn-tjjyH}z| rC| durC| |sCWYd}~qd}~wt yS| rRYqw| r`| dur`| |s`q|rf|| fS|| | fS)aRead a DNS message from a UDP socket. *sock*, a ``socket``. *destination*, a destination tuple appropriate for the address family of the socket, specifying where the message is expected to arrive from. When receiving a response, this would be where the associated query was sent. *expiration*, a ``float`` or ``None``, the absolute time at which a timeout exception should be raised. If ``None``, no timeout will occur. *ignore_unexpected*, a ``bool``. If ``True``, ignore responses from unexpected sources. *one_rr_per_rrset*, a ``bool``. If ``True``, put each RR into its own RRset. *keyring*, a ``dict``, the keyring to use for TSIG. *request_mac*, a ``bytes`` or ``None``, the MAC of the request (for TSIG). *ignore_trailing*, a ``bool``. If ``True``, ignore trailing junk at end of the received message. *raise_on_truncation*, a ``bool``. If ``True``, raise an exception if the TC bit is set. Raises if the message is malformed, if network errors occur, of if there is a timeout. If *destination* is not ``None``, returns a ``(dns.message.Message, float)`` tuple of the received message and the received time. If *destination* is ``None``, returns a ``(dns.message.Message, float, tuple)`` tuple of the received message, the received time, and the address where the message arrived from. *ignore_errors*, a ``bool``. If various format errors or response mismatches occur, ignore them and keep listening for a valid response. The default is ``False``. *query*, a ``dns.message.Message`` or ``None``. If not ``None`` and *ignore_errors* is ``True``, check that the received message is a response to this query, and if not keep listening for a valid response. rT)rrrrrN) rrr r r rr Truncatedrr1)r<rr rrrrrrrrrr~ received_timererrr receive_udpsH>      r5c  Cs|} t||||\} }}t|\}}| rt| }nt| tj|}|1}t|| ||t ||||||j |j || | | \}}|||_ | sM| |sMt|WdS1sYwY J)aReturn the response obtained after sending a query via UDP. *q*, a ``dns.message.Message``, the query to send *where*, a ``str`` containing an IPv4 or IPv6 address, where to send the message. *timeout*, a ``float`` or ``None``, the number of seconds to wait before the query times out. If ``None``, the default, wait forever. *port*, an ``int``, the port send the message to. The default is 53. *source*, a ``str`` containing an IPv4 or IPv6 address, specifying the source address. The default is the wildcard address. *source_port*, an ``int``, the port from which to send the message. The default is 0. *ignore_unexpected*, a ``bool``. If ``True``, ignore responses from unexpected sources. *one_rr_per_rrset*, a ``bool``. If ``True``, put each RR into its own RRset. *ignore_trailing*, a ``bool``. If ``True``, ignore trailing junk at end of the received message. *raise_on_truncation*, a ``bool``. If ``True``, raise an exception if the TC bit is set. *sock*, a ``socket.socket``, or ``None``, the socket to use for the query. If ``None``, the default, a socket is created. Note that if a socket is provided, it must be a nonblocking datagram socket, and the *source* and *source_port* are ignored. *ignore_errors*, a ``bool``. If various format errors or response mismatches occur, ignore them and keep listening for a valid response. The default is ``False``. Returns a ``dns.message.Message``. N)rrr$rrr,r- SOCK_DGRAMrrrmacr rra)rrrr4r;rrrrrr<rrr:r begin_timer rrurrrrrudp&s<8    rudp_socktcp_sockc Cs`zt|||||||||d| | } | dfWStjjy/t||||||||| } | dfYSw)a|Return the response to the query, trying UDP first and falling back to TCP if UDP results in a truncated response. *q*, a ``dns.message.Message``, the query to send *where*, a ``str`` containing an IPv4 or IPv6 address, where to send the message. *timeout*, a ``float`` or ``None``, the number of seconds to wait before the query times out. If ``None``, the default, wait forever. *port*, an ``int``, the port send the message to. The default is 53. *source*, a ``str`` containing an IPv4 or IPv6 address, specifying the source address. The default is the wildcard address. *source_port*, an ``int``, the port from which to send the message. The default is 0. *ignore_unexpected*, a ``bool``. If ``True``, ignore responses from unexpected sources. *one_rr_per_rrset*, a ``bool``. If ``True``, put each RR into its own RRset. *ignore_trailing*, a ``bool``. If ``True``, ignore trailing junk at end of the received message. *udp_sock*, a ``socket.socket``, or ``None``, the socket to use for the UDP query. If ``None``, the default, a socket is created. Note that if a socket is provided, it must be a nonblocking datagram socket, and the *source* and *source_port* are ignored for the UDP query. *tcp_sock*, a ``socket.socket``, or ``None``, the connected socket to use for the TCP query. If ``None``, the default, a socket is created. Note that if a socket is provided, it must be a nonblocking connected stream socket, and *where*, *source* and *source_port* are ignored for the TCP query. *ignore_errors*, a ``bool``. If various format errors or response mismatches occur while listening for UDP, ignore them and keep listening for a valid response. The default is ``False``. Returns a (``dns.message.Message``, tcp) tuple where tcp is ``True`` if and only if TCP was used. TF)rr rrtcp) rrrr4r;rrrrr r rrrrrudp_with_fallbacks<9  r c Csd}|dkrCz||}|dkrtd|t|8}||7}Wnttjfy0t||Yntjy>t||Ynw|dks|S)zRead the specified number of bytes from sock. Keep trying until we either get the desired amount, or we hit EOF. A Timeout exception will be raised if the operation is not completed by the expiration time. rrZEOF) recvEOFErrorrrrPSSLWantReadErrorrvSSLWantWriteErrorrx)r<countr rurrrr _net_reads    rc Cs~d}t|}||kr=z ||||d7}Wnttjfy(t||Yntjy6t||Ynw||ks dSdS)zWrite the specified data to the socket. A Timeout exception will be raised if the operation is not completed by the expiration time. rN)rrrrPrrxrrv)r<rr currentlrrr _net_writesrcCsPt|tjjr|jdd}n t|dd|}t}t|||t||fS)a{Send a DNS message to the specified TCP socket. *sock*, a ``socket``. *what*, a ``bytes`` or ``dns.message.Message``, the message to send. *expiration*, a ``float`` or ``None``, the absolute time at which a timeout exception should be raised. If ``None``, no timeout will occur. Returns an ``(int, float)`` tuple of bytes sent and the sent time. T)Zprepend_lengthrbig) rer rrrrto_bytesr r)r<rr tcpmsgrrrrsend_tcps   rc CsLt|d|}td|\}t|||}t} tjj|||||d} | | fS)aRead a DNS message from a TCP socket. *sock*, a ``socket``. *expiration*, a ``float`` or ``None``, the absolute time at which a timeout exception should be raised. If ``None``, no timeout will occur. *one_rr_per_rrset*, a ``bool``. If ``True``, put each RR into its own RRset. *keyring*, a ``dict``, the keyring to use for TSIG. *request_mac*, a ``bytes`` or ``None``, the MAC of the request (for TSIG). *ignore_trailing*, a ``bool``. If ``True``, ignore trailing junk at end of the received message. Raises if the message is malformed, if network errors occur, of if there is a timeout. Returns a ``(dns.message.Message, float)`` tuple of the received message and the received time. r!Hr)rstructunpackr r rr) r<r rrrrldatarrrrrrr receive_tcps ! rcCs`||}|dkr dS|tjtjtjfvr"t|||tjtj }|dkr.t |t |dSrH) connect_exerrnoZ EINPROGRESS EWOULDBLOCKZEALREADYrx getsockoptr- SOL_SOCKETSO_ERROROSErrorosstrerror)rur9r errrrrr/Ks  r/c Cs|} t|\} } |rt|} nt||||\} }}t| tj|} | 1}|s.t||| t || | t || ||j |j |\}}|| |_ ||sMt|WdS1sYwY J)aReturn the response obtained after sending a query via TCP. *q*, a ``dns.message.Message``, the query to send *where*, a ``str`` containing an IPv4 or IPv6 address, where to send the message. *timeout*, a ``float`` or ``None``, the number of seconds to wait before the query times out. If ``None``, the default, wait forever. *port*, an ``int``, the port send the message to. The default is 53. *source*, a ``str`` containing an IPv4 or IPv6 address, specifying the source address. The default is the wildcard address. *source_port*, an ``int``, the port from which to send the message. The default is 0. *one_rr_per_rrset*, a ``bool``. If ``True``, put each RR into its own RRset. *ignore_trailing*, a ``bool``. If ``True``, ignore trailing junk at end of the received message. *sock*, a ``socket.socket``, or ``None``, the connected socket to use for the query. If ``None``, the default, a socket is created. Note that if a socket is provided, it must be a nonblocking connected stream socket, and *where*, *port*, *source* and *source_port* are ignored. Returns a ``dns.message.Message``. N)rr$rrrr,r-r.r/rrrrr rra)rrrr4r;rrrr<rrr rr:rrurrrrrr Vs,+         r cCsN z|WdStjyt||Yntjy%t||Ynwqr) do_handshakerPrrvrrxrtrrr_tls_handshakesr*rcCsd}d}t|trtj|r|}n tj|r|}ntdtj||d}tj j |_ |dur2d|_ | dg|dur@tj|_|S)Nzinvalid verify string)cafilecapathFdot)rerr&rAisfileisdirrrPrY TLSVersionTLSv1_2minimum_versioncheck_hostnameset_alpn_protocolsrZr)rrr+r,rrrr_make_dot_ssl_contexts      r5rc  Cs|rt||||||||| S|} t|\} }t||||\}}}| dur-|s-t| | } t|tj|| | d4}t|||t ||t || |t ||||j |j |\}}|| |_||sbt|WdS1snwY J)akReturn the response obtained after sending a query via TLS. *q*, a ``dns.message.Message``, the query to send *where*, a ``str`` containing an IPv4 or IPv6 address, where to send the message. *timeout*, a ``float`` or ``None``, the number of seconds to wait before the query times out. If ``None``, the default, wait forever. *port*, an ``int``, the port send the message to. The default is 853. *source*, a ``str`` containing an IPv4 or IPv6 address, specifying the source address. The default is the wildcard address. *source_port*, an ``int``, the port from which to send the message. The default is 0. *one_rr_per_rrset*, a ``bool``. If ``True``, put each RR into its own RRset. *ignore_trailing*, a ``bool``. If ``True``, ignore trailing junk at end of the received message. *sock*, an ``ssl.SSLSocket``, or ``None``, the socket to use for the query. If ``None``, the default, a socket is created. Note that if a socket is provided, it must be a nonblocking connected SSL stream socket, and *where*, *port*, *source*, *source_port*, and *ssl_context* are ignored. *ssl_context*, an ``ssl.SSLContext``, the context to use when establishing a TLS connection. If ``None``, the default, creates one with the default configuration. *server_hostname*, a ``str`` containing the server's hostname. The default is ``None``, which means that no hostname is known, and if an SSL context is created, hostname checking will be disabled. *verify*, a ``bool`` or ``str``. If a ``True``, then TLS certificate verification of the server is done using the default CA bundle; if ``False``, then no verification is done; if a `str` then it specifies the path to a certificate file or directory which will be used for verification. Returns a ``dns.message.Message``. N)rr)r rr$rr5r,r-r.r/r*rrrrr rra)rrrr4r;rrrr<rrrrrr r:rrurrrrrtlssP=         r6rc  Cs&tjjstd| dur| dur| } d|_|} |r#td} |}n tjj| | d} | }| >|s:| ||||}t |\}}| |}| | d| t|} Wdn1s]wYt}Wdn1spwYtjj| |j|j||d}t||d|_||st|S)aReturn the response obtained after sending a query via DNS-over-QUIC. *q*, a ``dns.message.Message``, the query to send. *where*, a ``str``, the nameserver IP address. *timeout*, a ``float`` or ``None``, the number of seconds to wait before the query times out. If ``None``, the default, wait forever. *port*, a ``int``, the port to send the query to. The default is 853. *source*, a ``str`` containing an IPv4 or IPv6 address, specifying the source address. The default is the wildcard address. *source_port*, an ``int``, the port from which to send the message. The default is 0. *one_rr_per_rrset*, a ``bool``. If ``True``, put each RR into its own RRset. *ignore_trailing*, a ``bool``. If ``True``, ignore trailing junk at end of the received message. *connection*, a ``dns.quic.SyncQuicConnection``. If provided, the connection to use to send the query. *verify*, a ``bool`` or ``str``. If a ``True``, then TLS certificate verification of the server is done using the default CA bundle; if ``False``, then no verification is done; if a `str` then it specifies the path to a certificate file or directory which will be used for verification. *hostname*, a ``str`` containing the server's hostname or ``None``. The default is ``None``, which means that no hostname is known, and if an SSL context is created, hostname checking will be disabled. This value is ignored if *url* is not ``None``. *server_hostname*, a ``str`` or ``None``. This item is for backwards compatibility only, and has the same meaning as *hostname*. Returns a ``dns.message.Message``. zDNS-over-QUIC is not available.Nr)rrTrr)r rrrcrrrrrrr$rrrrr rrrrrrra)rrrr4r;rrrrrrrrrZthe_connectionZ the_managerrr rrrrrrr's@7      rc@seZdZdZdZdZdZdS)UDPModeaHow should UDP be used in an IXFR from :py:func:`inbound_xfr()`? NEVER means "never use UDP; always use TCP" TRY_FIRST means "try to use UDP but fall back to TCP if needed" ONLY means "raise ``dns.xfr.UseTCP`` if trying UDP does not succeed" rryrN)rCrDrEr_NEVERZ TRY_FIRSTONLYrrrrr7s r7 txn_managerruserialc csv|jdj}|tjjk}|}|} |jtj k} | r%t || d|nt dt | | } t|| |tj|||| s} d} d}| st|\}}|dusW|durY||krY|}| rdt|d|\}}nt|d|}t d|\}t|||}tjj||j|jd||| |d}| |} |V|j}| rE|jr|jstjd WddSWddS1swYdS) z'Given a socket, does the zone transfer.rNrFrrT)rrxfrorigintsig_ctxmultirz missing TSIG)questionrdtyper rdatatypeIXFRZfrom_wire_originrrr-rrrpackrrr<ZInboundr$rrrrrrrZprocess_messager>Zhad_tsigr FormError)r:rurr;rr rAZis_ixfrr=rZis_udprZinbounddoner>r7Z mexpirationZrwirerrrrrr _inbound_xfrsV         "rGzonerArdclasskeyname relativizer#use_udp keyalgorithmccsTGdddtjj}t|trtj|}tjj |}tj |||}|tjj krJ|j |j|tjjtjjdd}tjddd| }||d|d urV|j|||d t||| | \}}} t| \}}|||}| rw|tjj krwtd | r|tjntj}t||| }t|||t|||| ||Ed HWd d S1swYd S) aReturn a generator for the responses to a zone transfer. *where*, a ``str`` containing an IPv4 or IPv6 address, where to send the message. *zone*, a ``dns.name.Name`` or ``str``, the name of the zone to transfer. *rdtype*, an ``int`` or ``str``, the type of zone transfer. The default is ``dns.rdatatype.AXFR``. ``dns.rdatatype.IXFR`` can be used to do an incremental transfer instead. *rdclass*, an ``int`` or ``str``, the class of the zone transfer. The default is ``dns.rdataclass.IN``. *timeout*, a ``float``, the number of seconds to wait for each response message. If None, the default, wait forever. *port*, an ``int``, the port send the message to. The default is 53. *keyring*, a ``dict``, the keyring to use for TSIG. *keyname*, a ``dns.name.Name`` or ``str``, the name of the TSIG key to use. *relativize*, a ``bool``. If ``True``, all names in the zone will be relativized to the zone origin. It is essential that the relativize setting matches the one specified to ``dns.zone.from_xfr()`` if using this generator to make a zone. *lifetime*, a ``float``, the total number of seconds to spend doing the transfer. If ``None``, the default, then there is no limit on the time the transfer may take. *source*, a ``str`` containing an IPv4 or IPv6 address, specifying the source address. The default is the wildcard address. *source_port*, an ``int``, the port from which to send the message. The default is 0. *serial*, an ``int``, the SOA serial number to use as the base for an IXFR diff sequence (only meaningful if *rdtype* is ``dns.rdatatype.IXFR``). *use_udp*, a ``bool``. If ``True``, use UDP (only meaningful for IXFR). *keyalgorithm*, a ``dns.name.Name`` or ``str``, the TSIG algorithm to use. Raises on errors, and so does the generator. Returns a generator of ``dns.message.Message`` objects. c@sNeZdZddZddZdejjfddZdd Z dd e dej j fd d Z dS)z$xfr..DummyTransactionManagercSs|||rtjjn|f|_dSr)r remptyinfo)rr=rKrrrr sz-xfr..DummyTransactionManager.__init__cS|jSr)rOrrrrorigin_information z7xfr..DummyTransactionManager.origin_informationrcSr>rr?rQrrr get_classrOz.xfr..DummyTransactionManager.get_classcSr>rr?rQrrrreaderrOz+xfr..DummyTransactionManager.readerF replacementcSsGddd}ttjj|S)Nc@seZdZddZddZdS)zExfr..DummyTransactionManager.writer..DummyTransactionc_sdSrr)rrLkwrrrnoprOzIxfr..DummyTransactionManager.writer..DummyTransaction.nopcSrPr)rX)rr7rrr __getattr__rSzQxfr..DummyTransactionManager.writer..DummyTransaction.__getattr__N)rCrDrErXrYrrrrDummyTransactions rZ)rr transaction Transaction)rrVrZrrrwritersz+xfr..DummyTransactionManager.writerN)F)rCrDrErrRr rdataclass RdataClassrTrUboolr[r\r]rrrrDummyTransactionManager s raT)createINSOAz. . %u 0 0 0 0rN) algorithmzcannot do a UDP AXFR)r r[TransactionManagerrerrZ from_textrB RdataTypemaker make_queryrCZ find_rrset authorityr^rcrdZrdataaddZuse_tsigrr$rr-rr.r,r/rG)rrHrArIrr4rrJrKr#r;rr;rLrMrarZrrsetZsoar:rr7r tmZ sock_typerurrrr<s4E       "r<udp_modec  CsD|dur tj|\}} ntj|} t||||\} } }t|\} } |jdjtjj krv|t j krvt | t j|5}t|| | zt|||| || D]} qJWWddStjjyf|t jkrdYnwWdn1sqwYt | t j|}t|| | t|||| || D]} qWddS1swYdS)aConduct an inbound transfer and apply it via a transaction from the txn_manager. *where*, a ``str`` containing an IPv4 or IPv6 address, where to send the message. *txn_manager*, a ``dns.transaction.TransactionManager``, the txn_manager for this transfer (typically a ``dns.zone.Zone``). *query*, the query to send. If not supplied, a default query is constructed using information from the *txn_manager*. *port*, an ``int``, the port send the message to. The default is 53. *timeout*, a ``float``, the number of seconds to wait for each response message. If None, the default, wait forever. *lifetime*, a ``float``, the total number of seconds to spend doing the transfer. If ``None``, the default, then there is no limit on the time the transfer may take. *source*, a ``str`` containing an IPv4 or IPv6 address, specifying the source address. The default is the wildcard address. *source_port*, an ``int``, the port from which to send the message. The default is 0. *udp_mode*, a ``dns.query.UDPMode``, determines how UDP is used for IXFRs. The default is ``dns.UDPMode.NEVER``, i.e. only use TCP. Other possibilities are ``dns.UDPMode.TRY_FIRST``, which means "try UDP but fallback to TCP if needed", and ``dns.UDPMode.ONLY``, which means "try UDP and raise ``dns.xfr.UseTCP`` if it does not succeed. Raises on errors. Nr)r r<riZextract_serial_from_queryrr$r@rArBrCr7r8r,r-rr/rGZUseTCPr9r.)rr:rr4rr#r;rrmr;r:rr7r rurrr inbound_xfr9s</      "rn)T)NN) NrNrFFTNTr) NNFFNrFFFN) NrNrFFFFNF) NrNrFFFNNF)NFNrF)NrNrFFN) NrNrFFNNNT) NrNrFFNTNN)~r_rrenumr r&Zos.pathrrgr-rr urllib.parsertypingrrrrrrZ dns._featuresr Z dns.exceptionZdns.inetZ dns.messageZdns.nameZdns.quicZ dns.rcodeZdns.rdataclassZ dns.rdatatypeZ dns.serialZdns.transactionZdns.tsigZdns.xfrrrZ _featuresZhaveZ _have_httpxZhttpcore._backends.syncr2rZNetworkBackendZ_CoreNetworkBackendZ _backendssyncZ SyncStreamr0rZ HTTPTransportrGrrP ImportErrorrr Z DNSExceptionr]rErarbrcr<Z TransferErrorr$rrrvrxr|rrr,rIntEnumrrNrrrrfloatrr`rrZHeadersbytesrrrrrrrNameZtsigKeyrrr rrrrr/r r*rVr5rWr6ZSyncQuicConnectionr7r[rfrGrBZAXFRr^rcZdefault_algorithmrgr_r8rnrrrrs   4    ,       H      1       m     ^     X    /  E        n     ]  6      x