a PҚh@sdZddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl Z ddlmZmZmZmZmZmZddlZddlZddlZddlZddlZddlZddlZddlZddlZddlZddl Zddl!Zddl"ZddZ#ddZ$ej%&dZ'e'rRddl(Z)ddl*Z*e)j+Z,e)j-j.j/Z0Gd d d e,Z1Gd d d e*j2Z3nGd d d Z3e'Z4z ddl5Z5Wn"e6yGdddZ5Yn0e j Z7Gdddej8j9Z:Gdddej8j;Zej?j@Z@ddZAddZBddZCddZDd d!ZEd"d#ZFdvd%d&ZGdwd'd(ZHed)d)d*d+d,ZIGd-d.d.ejJZKdd/ddd0d0dd1d$dd$de jLeKjMfejNjOePeeQeReePeReSeSeeePeSeePeeSePfed)eReKejNjOd2d3d4ZTejUjVeWeWd5d6d7ZXejUjVePeWdd8d9d:ZYdxejNjOePePeeQeReePeReSeSeeSePfeePeSejNjOd< d=d>ZZd?d@Z[dAdBZ\dyeeejNjOeWfeeeQeeReQfdCdDdEZ]dzeeeeeQeSeSeeej^j_ej`jafeeWeSeSeSeejNjOedG dHdIZbd{ejNjOePeeQeReePeReSeSeSeSeeeSejNjOdK dLdMZcd|ejNjOePeeQeReePeReSeSeSeeeeeSeejNjOeSfdN dOdPZddQdRZedSdTZfd}eeejNjOeWfeeQeeReQfdUdVdWZgd~eeeQeSeeej^j_ej`jafeeWeSeejNjOeQfdXdYdZZhd[d\ZidejNjOePeeQeReePeReSeSeeejNjOd] d^d_Zjd`daZkeePeeSePfe5jldbdcddZmdejNjOePeeQeReePeReSeSee5jnee5jleePeeSePfejNjOde dfdgZodejNjOePeeQeReePeReSeSeejUjpeeSePfeePeePejNjOdh didjZUGdkdldlejJZqejrjse j ejNjOeeReeQeQedmdndoZtejujvejwjxddJddd$ddddd0ej`jyf ePeej^j_ePfeejujzePfeejwj{ePfeeQeReeej^j_ej`jafeeej^j_ePfeSeeQeePeReReSeej^j_ePfedpdqdrZ?ddJddddeqj|fePejrjseejNjOeReeQeeQeePeReqdds dtduZ}dS)zTalk to a DNS server.N)AnyDictOptionalTupleUnioncastcCs,|dur dS|t}|dkr(tjj|S)N)timedns exceptionTimeout) expirationtimeoutrD/wd/webapps/venvs/v2025_4um/lib/python3.9/site-packages/dns/query.py _remaining1s  rcCs|dur dStt||SN)minr )rr rrr_expiration_for_this_attempt:srZdohcs0eZdZfddZdddZd ddZZS) _NetworkBackendcs&t||_||_||_||_dSr)super__init__ _local_port _resolver_bootstrap_address_family)selfresolver local_portbootstrap_addressfamily __class__rrrIs  z_NetworkBackend.__init__Nc Csg}t|\}}tj|r(||nP|jdur@||jn8t|}|j} |r^tj|} |j j || |d} | }|D]} tj| } |dus|j dkrtj ||j f| } nd} t| tj| }td|}z(t|tj | |f| |t|WSty Yq|0q|tjdS)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_tcpPsB        z_NetworkBackend.connect_tcpcCstdSrNotImplementedError)rpathrr6rrrconnect_unix_socketwsz#_NetworkBackend.connect_unix_socket)N)N)__name__ __module__ __qualname__rr=rA __classcell__rrr!rrHs   (rcs*eZdZdddejdfdd ZZS)_HTTPTransportrN)rrrr csJ|dur"|dur"ddl}|j}tj|i|t|||||j_dSNr) dns.resolverrResolverrrr_poolZ_network_backend)rrrrr argskwargsr r!rrr}s  z_HTTPTransport.__init__)rBrCrDr- AF_UNSPECrrErrr!rrF|s rFc@seZdZddZdS)rFcCstdSrr>)rr3r4rr5rrrr=sz_HTTPTransport.connect_tcpN)rBrCrDr=rrrrrFsc@sXeZdZdZGdddeZGdddeZGdddZGdd d Ze d d Z d S) sslrc@s eZdZdS)zssl.WantReadExceptionNrBrCrDrrrrWantReadExceptionsrPc@s eZdZdS)zssl.WantWriteExceptionNrOrrrrWantWriteExceptionsrQc@s eZdZdS)zssl.SSLContextNrOrrrr SSLContextsrRc@s eZdZdS)z ssl.SSLSocketNrOrrrr SSLSocketsrScOs tddS)Nzno ssl support)r1)clsrKrLrrrcreate_default_contextszssl.create_default_contextN) rBrCrD CERT_NONEr1rPrQrRrS classmethodrUrrrrrNsrNc@seZdZdZdS)UnexpectedSourcez=A DNS query response came from an unexpected address or port.NrBrCrD__doc__rrrrrXsrXc@seZdZdZdS) BadResponsez|j|d|dWS|WSWntyb|Yn0dS)NF)do_handshake_on_connectserver_hostname)socket_factory setblockingbind wrap_socketr1close)r:typer; ssl_contextrrorrrr,@s     r,zdns.resolver.Resolver)rreturncCs|durddl}|j}|SrG)rHrrI)rr rrr_maybe_get_resolverTs rc@s,eZdZdZdZdZdZdZdZdZ dZ dS) HTTPVersionzWhich version of HTTP should be used? DEFAULT will select the first version from the list [2, 1.1, 3] that is available. rrrN) rBrCrDrZDEFAULTZHTTP_1H1ZHTTP_2H2ZHTTP_3H3rrrrrbsriFz /dns-query)qr|rr4r;r}one_rr_per_rrsetignore_trailingsessionr@postrverifyrr http_versionrc" Cst||||d\}}}|durjtj|rj|tjkrJd|d|| }qn|tjkrnd|d|| }n|}i}| durtj |}|j durt dtj|j r|j } |j |d<|j dur|j }|t jks|t jkrBtsB| dur$t| } |j dusJ| |j |}tt|} t|| |||||||| | d StsLt|rht|tjsht d |}d d i}|t jt jfv}|t jt jfv}|durd}d }n|d }|d}|rt |}n*t!|||| || | |d}tj||| |d}|t}| r2|"d t#t$|d|j%|||||d}n0t&'|(d}|)} |j*|||d| i|d}Wdn1sx0Y|j+dks|j+dkrt |d|j+d|j,tj-j.|j,|j/|j0||d}!|j12|!_3|4|!st5|!S)a Return the response obtained after sending a query via DNS-over-HTTPS. *q*, a ``dns.message.Message``, the query to send. *where*, a ``str``, the nameserver IP address or the full URL. If an IP address is given, the URL will be constructed using the following schema: https://:/. *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-messagerrr)r5http1http2rrrrr )rrr transport)z content-typezcontent-length)headerscontentr extensions=r )rrparamsr+ responded with status code z Response body: keyring request_macrr)6r~r r%r&r-AF_INETAF_INET6urllibparseurlparsehostnamer{r4rrrhave_dohrr)randomchoicelistr*_http3r\r_httpxZClientto_wirerr contextlib nullcontextrFupdatestrlenrbase64urlsafe_b64encoderstripdecodeget status_codermessage from_wirerrelapsed total_secondsr is_responser[)"rr|rr4r;r}rrrr@rrrrr rr:r7Z the_sourceurlrparsedr8wirerZh1Zh2r5rcmrresponseZtwirerrrrhttpsrsG             &   r)rnamercCs2|dur t|D]\}}||kr|SqtdSr)KeyError)rrheadervaluerrr _find_header9s   r)rpeerrrcCst|d}|durtdt|}|dkr2td|dksB|dkrd}t|dkrvzd|}WntytYn0t|d ||dS) Ns:statuszno :status header in responserzstatus is negativerrz: r)rrtintrrr1r{)rrrrstatuserrorrrr _check_statusBs   rU) rr|rrr4r;r}rrrrrrc  Cs.tjjstdtj|} | j} | jdur2| j}d|_ | } tjj | | dd}|| ||||}t |\}}||<}||| | |t|} t||| Wdn1s0Yt}Wdn1s0Ytjj| |j|j||d}t||d|_||s*t|S)Nz DNS-over-HTTP3 is not available.rT) verify_mode server_nameZh3rr)r quic have_quicr\rrrrr4idrSyncQuicManagerconnectr$ make_streamZsend_h3receiverrrr rrrrmaxrr[)rr|rrr4r;r}rrrrrZ url_partsrmanager connectionstartr streamfinishrrrrrSs<    .& rcCs0z ||WSty(t||Yq0qdS)zReads a datagram from the socket. A Timeout exception will be raised if the operation is not completed by the expiration time. N)recvfromBlockingIOErrorrp)r<max_sizer rrr _udp_recvs  rcCsFz"|r|||WS||WSWqty>t||Yq0qdS)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. N)sendtosendrrq)r<datarxr rrr _udp_sends  r)r<whatrxr rcCs4t|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. )r_r rMessagerr r)r<rrxr sent_timenrrrsend_udps r) r<rxr ryrrrrraise_on_truncation ignore_errorsqueryrc  Csd} t|d|\} } t|j| ||s&qt} ztjj| |||||d}Wnntjjy}z6| r| dur| |sWYd}~qnWYd}~n&d}~0t y| rYqnYn0| r| dur| |sq|r|| fS|| | fSqdS)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. r)rrrrrN) rrzr r r rr Truncatedrr1)r<rxr ryrrrrrrrrrw received_timererrr receive_udpsD>    r5) rr|rr4r;r}ryrrrr<rrc  Cs|} t||||\} }}t|\}}| r8t| }nt| tj|}|b}t|| ||t ||||||j |j || | | \}}|||_ | s| |st|WdS1s0YdsJdS)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``. NF)rr~r$rrr,r- SOCK_DGRAMrrrmacr rr[)rr|rr4r;r}ryrrrr<rrr:rx begin_timer rrorrrrrudp&s:8    "r) rr|rr4r;r}ryrrudp_socktcp_sockrrc Csdz(t|||||||||d| | } | dfWStjjy^t||||||||| } | dfYS0dS)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. TFN)rr rrtcp) rr|rr4r;r}ryrrrrrrrrrudp_with_fallbacks:9  rc Csd}|dkrz2||}|dkr(td|t|8}||7}Wqttjfy`t||Yqtjy|t||Yq0q|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) recvEOFErrorrrrNSSLWantReadErrorrpSSLWantWriteErrorrq)r<countr rorrrr _net_reads   r c Cstd}t|}||krpz||||d7}Wq ttjfyPt||Yq tjylt||Yq 0q dS)zWrite the specified data to the socket. A Timeout exception will be raised if the operation is not completed by the expiration time. rN)rrrrNr rqrrp)r<rr currentlrrr _net_writesr)r<rr rcCsPt|tjjr|jdd}nt|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) r_r rrrrto_bytesr r)r<rr tcpmsgrrrrsend_tcps  r)r<r rrrrrc 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)r structunpackr r rr) r<r rrrrldatar rrrrrr receive_tcps!  rcCs`||}|dkrdS|tjtjtjfvrDt|||tjtj }|dkr\t |t |dSrG) connect_exerrnoZ EINPROGRESS EWOULDBLOCKZEALREADYrq getsockoptr- SOL_SOCKETSO_ERROROSErrorosstrerror)ror9r errrrrr/Ks  r/) rr|rr4r;r}rrr<rc Cs|} t|\} } |r$t|} n"t||||\} }}t| tj|} | b}|s\t||| t || | t || ||j |j |\}}|| |_ ||st|WdS1s0YdsJdS)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``. NF)rr$rrr~r,r-r.r/rrrrr rr[)rr|rr4r;r}rrr<rrr rr:rxrorrrrrrVs*+       "rcCsPz|WdStjy,t||YqtjyHt||Yq0qdSr) do_handshakerNrrpr rqrnrrr_tls_handshakesr#)rrrcCsd}d}t|tr>tj|r$|}ntj|r6|}ntdtj||d}tj j |_ |durdd|_ | dg|durtj|_|S)Nzinvalid verify string)cafilecapathFdot)r_rrr@isfileisdirr{rNrU TLSVersionTLSv1_2minimum_versioncheck_hostnameset_alpn_protocolsrVr)rrr$r%rrrr_make_dot_ssl_contexts      r.) rr|rr4r;r}rrr<rrrrc  Cs|rt||||||||| S|} t|\} }t||||\}}}| durZ|sZt| | } t|tj|| | dh}t|||t ||t || |t ||||j |j |\}}|| |_||st|WdS1s0YdsJdS)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)rrF)rrr$r~r.r,r-r.r/r#rrrrr rr[)rr|rr4r;r}rrr<rrrrrr r:rxrorrrrrtlssN=          "r/) rr|rr4r;r}rrrrrrrc  Cs(tjjstd| dur$| dur$| } d|_|} |rFtd} |}ntjj| | d} | }| ||st| ||||}t |\}}| |*}| | d| t|} Wdn1s0Yt}Wdn1s0Ytjj| |j|j||d}t||d|_||s$t|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 rrr]rrrrrrr$rrrrr rrrrrrr[)rr|rr4r;r}rrrrrrrrZthe_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" rrrrN)rBrCrDrZNEVERZ TRY_FIRSTONLYrrrrr0sr0) txn_managerrorserialrr rc csh|jdj}|tjjk}|}|} |jtj k} | rHt || d|n t dt | | } t|| |tj|||| } d} d}| s(t|\}}|dus|dur||kr|}| rt|d|\}}n&t|d|}t d|\}t|||}tjj||j|jd||| |d}| |} |V|j}q|jrD|jsDtjd Wdn1sZ0YdS) z'Given a socket, does the zone transfer.rNrFrrT)rrxfrorigintsig_ctxmultirz missing TSIG)questionrdtyper rdatatypeIXFRZfrom_wire_originrrr-rrrpackrrr5ZInboundr$rr rrrrrZprocess_messager7Zhad_tsigr FormError)r3rorr4rr r:Zis_ixfrr6rZis_udprZinbounddoner7r7Z mexpirationZrwirerr rrrr _inbound_xfrsP        r@)r|zoner:rdclassrr4rkeyname relativizer#r;r}r4use_udp keyalgorithmrccsRGdddtjj}t|tr*tj|}tjj |}tj |||}|tjj kr|j |j|tjjtjjdd}tjddd| }||d|d ur|j|||d t||| | \}}} t| \}}|||}| r|tjj krtd | rtjntj}t||| 4}t|||t|||| ||Ed HWd n1sD0Yd 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@sLeZdZddZddZejjdddZdd Z de ej j d d d Z dS)z$xfr..DummyTransactionManagercSs|||rtjjn|f|_dSr)r remptyinfo)rr6rDrrrr sz-xfr..DummyTransactionManager.__init__cSs|jSr)rHrrrrorigin_information sz7xfr..DummyTransactionManager.origin_information)rcSstdSrr>rIrrr get_classsz.xfr..DummyTransactionManager.get_classcSstdSrr>rIrrrreadersz+xfr..DummyTransactionManager.readerF) replacementrcSsGddd}ttjj|S)Nc@seZdZddZddZdS)zExfr..DummyTransactionManager.writer..DummyTransactionc_sdSrr)rrKkwrrrnopszIxfr..DummyTransactionManager.writer..DummyTransaction.nopcSs|jSr)rO)rr7rrr __getattr__szQxfr..DummyTransactionManager.writer..DummyTransaction.__getattr__N)rBrCrDrOrPrrrrDummyTransactionsrQ)rr transaction Transaction)rrMrQrrrwritersz+xfr..DummyTransactionManager.writerN)F)rBrCrDrrJr rdataclass RdataClassrKrLboolrRrSrTrrrrDummyTransactionManager s rXT)createINSOAz. . %u 0 0 0 0rN) algorithmzcannot do a UDP AXFR)r rRTransactionManagerr_rrZ from_textr; RdataTypemaker make_queryr<Z find_rrset authorityrUrZr[ZrdataaddZuse_tsigr~r$r{r-rr.r,r/r@)r|rAr:rBrr4rrCrDr#r;r}r4rErFrXrZrrsetZsoar:rxr7r tmZ sock_typerorrrr5s0E        r5) r|r3rr4rr#r;r}udp_moderc  CsF|durtj|\}} n tj|} t||||\} } }t|\} } |jdjtjj kr|t j krt | t j|j}t|| | z*t|||| || D]} qWWddStjjy|t jkrȂYn0Wdn1s0Yt | t j|6}t|| | t|||| || D]} qWdn1s80YdS)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 r5r`Zextract_serial_from_queryr~r$r9r:r;r<r0r1r,r-rr/r@ZUseTCPr2r.)r|r3rr4rr#r;r}rdr4r:rxr7r rorrr inbound_xfr9s./      & re)T)NN) NrNrFFTNT)N) NNFFNrFFFN) NrNrFFFFNF) NrNrFFFNNF)N)NFNrF)NrNrFFN) NrNrFFNNNT) NrNrFFNTNN)~rZrrenumrros.pathrrar-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 HTTPTransportrFrrN ImportErrorrr Z DNSExceptionrXr>r[r\r]r5Z TransferErrorr$rlrprqrurzr~r,rIntEnumrrMrrrrfloatrrWrrZHeadersbytesrrrrrrrNameZtsigKeyrrrr rrrr/rr#rRr.rSr/ZSyncQuicConnectionr0rRr]r@r;ZAXFRrUrZZdefault_algorithmr^rVr1rerrrrs    4   ,    H   1    m ^ X  / E    n   ] 6 x