0/j#f%SrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSK r SSK r SSK r SSK JrJrJrJrJrJr SSKrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSK rSSK!rSSK"r"Sr&Sr'\RPRSS5r*\*(aUSSK+r,SSK-r-\,R\r/\,R`RbRdr3"SS\/5r4"S S \-Rj5r6O "S S 5r6\*r7S \Rp\9-S \RtS\9S\R4Sjr;\;r<\\Rp\9-\Rt\9/\R4\=S'"SS\R|R~5r@"SS\R|R5rB"SS\R|R~5rC"SS\R|R~5rD\RRrFSrGSrHSrISrJSrKSrLS{S!jrMS|S \Rp\9-S"\RtS#\S-S\R4S$jjrNS}S \Rp\9-S"\RtS%\"RS&\RR\R-S-S#\S-S\"R4 S'jjrTS(rUS)\S*SS*4S+jrV"S,S-\R5rXSS.SSS/S/SS0S SS S\R\XR4S1\RRS2\RS3\]S-S4\9S#\RS-S5\9S6\^S7\^S8\S-S9\RS:\^S;\RS-S<\^\R-\"R-S)\S*S=\9S>\XS\RR4"S?jjr_S@\RRSA\bS\b4SBjrcS@\RRSC\RSD\bSS4SEjrdS~S1\RRS2\RSF\RS3\]S-S4\9S#\RS-S5\9S6\^S7\^S<\^\R-\"R-S:\^SG\RRS-S\RR4SHjjrfSIrgSJrhS|SK\SL\RR\b-SM\SN\]S-S\\9\]44 SOjjriSSK\SM\S-SN\]S-SP\^S6\^SQ\\RR\RR4S-SR\bS-S7\^SS\^ST\^SU\RRS-S\4SVjjrlSS1\RRS2\RS3\]S-S4\9S#\RS-S5\9SP\^S6\^S7\^SS\^SK\S-ST\^S\RR4SXjjrmSS1\RRS2\RS3\]S-S4\9S#\RS-S5\9SP\^S6\^S7\^SY\S-SZ\S-ST\^S\\RR\^44S[jjrnS\roS]rpS|SK\SL\RR\b-SN\]S-S\\9\]44S^jjrqSSK\SN\]S-S6\^SQ\\RR\RR4S-SR\bS-S7\^S\\RR\]44S_jjrrS`rsSS1\RRS2\RS3\]S-S4\9S#\RS-S5\9S6\^S7\^SK\S-S\RR4SajjrtSbruSS<\^\R-Sc\^Sd\v\RS-S\"R4SejjrwS&\RS-S<\^\R-S\"R4SfjrxSS1\RRS2\RS3\]S-S4\9S#\RS-S5\9S6\^S7\^SK\"RS-S%\"RS-S&\RS-S<\^\R-S\RR4SgjjrySS1\RRS2\RS3\]S-S4\9S#\RS-S5\9S6\^S7\^SG\RRS-S<\^\R-Sh\RS-S&\RS-S\RR4Sijjr`"SjSk\R5rzSl\RRSm\R\"R-SU\RRSn\9S-S3\]S-SN\]S-S\4Sojr}\RR\GRGRSSWSSS SSSSS/\RGR4 S2\RSp\RR\R-Sq\RGR\R-Sr\GRGR\R-S3\]S-S4\9SQ\\RR\RR4S-Ss\RR\R-S-St\^Su\]S-S#\RS-S5\9Sn\9Sv\^Sw\RR\R-S\4 SxjjrESSWSSSS\zGR 4S2\RSl\RRSU\RRS-S4\9S3\]S-Su\]S-S#\RS-S5\9Sy\zSS4Szjjrg!\#a SSK$J%r" G N6f=f)zTalk to a DNS server.N)AnyCallableDictOptionalTuplecastc~UcgU[R"5- nUS::a[RReU$)N)timedns exceptionTimeout) expirationtimeouts b/var/www/html/health-monitoring.indevconsultancy.in/venv/lib/python3.13/site-packages/dns/query.py _remainingr5s7499;&G#~mm### NcNUcg[[R"5U-U5$N)minr )rrs r_expiration_for_this_attemptr>s# tyy{W$j 11rdohc@^\rSrSrU4SjrSSjrSSjrSrU=r$)_NetworkBackendLcR>[TU]5 X lXlX0lX@lgr)super__init__ _local_port _resolver_bootstrap_address_family)selfresolver local_portbootstrap_addressfamily __class__s rr_NetworkBackend.__init__Ms$ G  ) %N&7 #!Lrc/n[U5upx[RRU5(aUR U5 OUR bUR UR 5 Og[ U5nURn U(a[RRU5n URRXUS9n U R5nUHn [RRU 5n UcURS:wa1UcSn[RRX@R4U 5n OSn [U [R U 5n[#SU5n[%U[RRX4U 5U5 ['U5s $ [*R,e![(a Mf=f)N)r'lifetimerz0.0.0.0g@)_compute_timesr inet is_addressappendr!rr"af_for_addressr resolve_name addressesrlow_level_address_tuple make_socketsocket SOCK_STREAMr_connect_CoreSyncStream Exceptionhttpcore ConnectError)r#hostportr local_addresssocket_optionsr2_rr'answersaddressafsourcesockattempt_expirations r connect_tcp_NetworkBackend.connect_tcpTsI*73MAxx""4((  &((4  !8!89$Z0  XX44]CF..55'6$--/ $XX,,W5 ,0@0@A0E$,(1  XX==&(8(892F"F &r6+=+=vFD)Ec:)V&88'"M* +400%%*'' '!sAF33 GGc[erNotImplementedError)r#pathrr?s rconnect_unix_socket#_NetworkBackend.connect_unix_socket}s & %r)r!r"rr )NNNNN) __name__ __module__ __qualname____firstlineno__rrGrM__static_attributes__ __classcell__r(s@rrrLs$ "PT' (T6: & &rrcJ^\rSrSrSSS\R S.U4SjjrSrU=r$)_HTTPTransportrNr%r&r$r'c>Uc!UcSSKnURR5n[TU]"U0UD6 [ X1X$5UR lgNr) dns.resolverr$Resolverrrr_pool_network_backend) r#r%r&r$r'argskwargsr r(s rr_HTTPTransport.__init__sO$5$=#<<002 G d -f -*9&7+DJJ 'r) rPrQrRrSr5 AF_UNSPECrrTrUrVs@rrXrXs!"##   rrXcB\rSrSrSSS\R S.SjrSrSrg)rXrNrZcgrrd)r#r%r&r$r'rarbs rrrcs rc[errJ)r#r<r=rr>s rrG_HTTPTransport.connect_tcp% %rrd) rPrQrRrSr5rerrGrTrdrrrXrXs "##  &rrCkindprotoreturnc0[R"XU5$r)r5)rCrlrms rdefault_socket_factoryrps ==5 ))rsocket_factoryc\rSrSrSrSrg)UnexpectedSourcez=A DNS query response came from an unexpected address or port.rdNrPrQrRrS__doc__rTrdrrrsrssGrrsc\rSrSrSrSrg) BadResponsez=C>DtyperDc[XS5nURS5 UbURU5 U$![a UR 5 ef=f)a!Make a socket. This function uses the module's ``socket_factory`` to make a socket of the specified address family and type. *af*, a ``socket.AddressFamily`` or ``int`` is the address family, either ``socket.AF_INET`` or ``socket.AF_INET6``. *type*, a ``socket.SocketKind`` is the type of socket, e.g. ``socket.SOCK_DGRAM``, a datagram socket, or ``socket.SOCK_STREAM``, a stream socket. Note that the ``proto`` attribute of a socket is always zero with this API, so a datagram socket will always be a UDP socket, and a stream socket will always be a TCP socket. *source* is the source address and port to bind to, if any. The default is ``None`` which will bind to the wildcard address and a randomly chosen port. If not ``None``, it should be a (low-level) address tuple appropriate for *af*. rF)rq setblockingbindr9close)rCrrDrs rr4r4DsR, r#A e   FF6N    s &5A ssl_contextserver_hostnamec[XU5n[U[RR5(aUR 5nUR USUS9$)aVMake a socket. This function uses the module's ``socket_factory`` to make a socket of the specified address family and type. *af*, a ``socket.AddressFamily`` or ``int`` is the address family, either ``socket.AF_INET`` or ``socket.AF_INET6``. *type*, a ``socket.SocketKind`` is the type of socket, e.g. ``socket.SOCK_DGRAM``, a datagram socket, or ``socket.SOCK_STREAM``, a stream socket. Note that the ``proto`` attribute of a socket is always zero with this API, so a datagram socket will always be a UDP socket, and a stream socket will always be a TCP socket. If *ssl_context* is not ``None``, then it specifies the SSL context to use, typically created with ``make_ssl_context()``. If *server_hostname* is not ``None``, then it is the hostname to use for server certificate validation. A valid hostname must be supplied if *ssl_context* requires hostname checking. *source* is the source address and port to bind to, if any. The default is ``None`` which will bind to the wildcard address and a randomly chosen port. If not ``None``, it should be a (low-level) address tuple appropriate for *af*. F)do_handshake_on_connectr)r4rr nameNameto_text wrap_socket)rCrrrrDrEs rmake_ssl_socketresT> r (D/388==11)113  " " %' # rc:Ub [XX4U5$[XU5$r)rr4)rCrrDrrs r _make_socketrs&rvNN2V,,rr$zdns.resolver.ResolvercHUcSSKnURR5nU$r\)r]r$r^)r$r s r_maybe_get_resolverrs$ <<((* Orc4\rSrSrSrSrSrSrSrSr Sr Sr Sr g) HTTPVersionizzWhich version of HTTP should be used? DEFAULT will select the first version from the list [2, 1.1, 3] that is available. rrrdN) rPrQrRrSrvDEFAULTHTTP_1H1HTTP_2H2HTTP_3H3rTrdrrrrs, G F B F B F BrrFz /dns-queryqrrr=rone_rr_per_rrsetignore_trailingsessionrLpostr&verifyr' http_versionc[XXES5unnnUnUba[RRU5(a=U[R :Xa SUSUU 3nOU[R :Xa SUSUU 3n0nU c[RRU5nURc [S5e[RRUR5(aURn URUS'URb URnU[R:XdU[R:Xa[ (dU cc[#U 5n WRceU R%URU5n[&R("[+UR-555n U(a4[/U[R0R25(d [S 5e[5UU UUUUUUUU U US 9 $[ (d[6eU(a*[/U[8R:5(d [S 5eUR=5nS S 0nU[R>[R4;nU[R@[R4;nUcSnSnO USnUSnU(a[BRD"U5nO'[GUUUU UU U US9n[8R:"UUU US9nUnUceU (a:URIS [K[MU55S.5 UROUUUUUS9nOJ[PRR"U5RUS5nURW5n URYUUUSU 0US9nSSS5 WRZS:dURZS:a'[USURZSUR\35e[R^RaUR\URbURdUUS9n!URfRi5U!l5URmU!5(d[neU!$!,(df  N=f)aReturn 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 URL sni_hostnamez8session parameter must be a dns.quic.SyncQuicConnection.)rr connectionz)session parameter must be an httpx.Clientacceptzapplication/dns-messagerr)r>http1http2rr%r&r$r')rrr transport)z content-typezcontent-length)headerscontentr extensions=r )rrparamsr+ responded with status code z Response body: keyring request_macrr)8rr r-r.r5AF_INETAF_INET6urllibparseurlparsehostnamerr=rrrhave_dohrr1randomchoicelistr2rquicSyncQuicConnection_http3r{httpxClientto_wirerr contextlib nullcontextrXupdatestrlenrbase64urlsafe_b64encoderstripdecodeget status_codermessage from_wirerrelapsed total_secondsr is_responserx)"rrrr=rDrrrrrLrr&rr$r'rrCr@ the_sourceurlrparsedrAwirerh1h2r>r%cmrresponsetwirers" rhttpsrsN2 V%RJ C ~#((--e44  UG1TF4&1C 6?? "eWBtfTF3CJ &&s+ ?? "12 2 88  v / / & )/J~ & ;; ";;D{~~% +++HH  $*84H??. ..++FOOVDG & d73D3D3F.G H  : SXX00  WX X           8 z'5<<88DEE 99;D23G +..+*=*=> >B +..+*=*=> >B  "1 ] 0:0F0Fw0O"'!/  \\Bv  w"""  NN$=&)#d)n  ||% $H++D188>DKKME{{u~% #H+ >c!X%9%9C%?g1(2F2F1G 0 01 3    MM)'  A   + + -AF ==   H] s 3BQ QrrcHUc[eUHup#X!:XdM Us $ [er)KeyError)rrheadervalues r _find_headerrs)  >L! Nrpeerr c[US5nUc [S5e[U5nUS:a [S5eUS:dUS:a7Sn[U5S:aSUR 5-n[ US UU35eg![ a Nf=f) Ns:statuszno :status header in responserzstatus is negativerrz: r)rrintrrr9r)rrr rstatuserrors r _check_statusr s * -E }9:: ZF z.// |v| t9q= t{{},D6!=fXeWMNN$   sA;; BBr rc [RR(d [S5e[R R U5n U Rn U ceU Rb U RnSUl UR5nU (a[R"S5nO [RRXSS9nUnU U (aU nOWRXXV5n[U5unnUR!U5nUR#X.U 5 UR%['U55n[)UR+5X5 SSS5 [,R,"5nSSS5 [R.R1UUR2UR4UUS9n[7WW- S5UlUR9U5(d[:eU$!,(df  N=f!,(df  N=f)Nz DNS-over-HTTP3 is not available.rT) verify_mode server_nameh3rr )r r have_quicr{rrrrr=idrrrSyncQuicManagerconnectr, make_streamsend_h3receiverr rr rrrrmaxr rx)rrr rr=rDrrrrrr url_partsrr manager the_managerthe_connectionstartrstreamfinishrs rrrs 88  677 %%c*I!!H   ~~!~~ AD 99;D5?5K5KD5Q((**+   'N(00VN-W5  ' ' 0F NN3d +>>*Z"89D &..*E 81    MM)'  A% %AF ==   H1 0 s% rr sent_timens rsend_udprCsE,$ ++,,||~ I$k6A >rrrrraise_on_truncation ignore_errorsqueryc Sn [USU5up[URXU5(dM.[R"5n [R R U UUUUUS9nU (aU bU RU5(dMU(aX4$XU 4$![R Ra:nU (a-U b*U RUR 55(dSnAMeSnAf[a U (aGMef=f)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)rrrrrDN) r8rr'r r rr Truncatedr r9)rErrrrrrrrDrErFr r received_timeres r receive_udprLs| D (ujA# KK4E      %%'!1 /$7 &A6 U.u7H7H7K7K  % %l3 31{{$$ %))!))+66   s$"BD7.C,+C,,DD5c UR5n [XXES5upn[U5unnU (a[R"U 5nO U ce[ U [ RU5nUn[UXU5 [UUUUUURURUU U U5 unnUU- Ul U (dURU5(d[eUsSSS5 $!,(df  O=fe)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``. TN)rrr,rrr4r5 SOCK_DGRAMrCrLrmacr r rx)rrrr=rDrrrrrDrErEr rCr begin_timerrrrrJs rudprRsp 99;D 7 V$!Rf .g6Z 0:0F0Ft0L~~ V.. 7 qDz2(     II EE      M+q!1!1 ) ,  s /A(C!! C/udp_socktcp_sockc [UUUUUUUUUSU U 5 n U S4$![RRa [ UUUUUUUUU 5 n U S4s$f=f)aReturn 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)rRr rrItcp) rrrr=rDrrrrrSrTrErs rudp_with_fallbackrWsr              %  ;;            $  s5AAc&SnUS:a=URU5nUS:Xa [S5eU[U5-nX4- nUS:aM=U$![[R 4a [ X5 N1[Ra [X5 NQf=f)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. rrEOF) recvEOFErrorrr6rSSLWantReadErrorrSSLWantWriteErrorr)rEcountrrrBs r _net_readr_7s A !) 1 % ACxuo% SVOE FA !) H  !5!56 1 t 0$$ 1 t 0 1s4A%B/BBcSn[U5nX4:aX0RXS5- nX4:aMgg![[R4a [ X5 N0[R a [X5 NPf=f)zWrite the specified data to the socket. A Timeout exception will be raised if the operation is not completed by the expiration time. rN)rr;r6rr]rr\r)rEr<rcurrentls r _net_writercLsr G D A + 1 yyh0 0G + !6!67 1 t 0## 1 t 0 1s2%A:A:9A:c [U[RR5(aUR SS9nO[ U5R SS5U-n[R"5n[XU5 [ U5U4$)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)prepend_lengthrbig) rr rr@rrto_bytesr rc)rEr>rtcpmsgrAs rsend_tcpri\sl$$ ++,,T2 T##Au-4 ItZ( K ##rc[USU5n[R"SU5un[XU5n[R"5n [R R UUUUUS9n X4$)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) rErrrrrldatarbr rJrs r receive_tcprozsoB dAz *E ==u %DQ Tj )DIIKM  )'  A  rcXURU5nUS:XagU[R[R[R4;a9[ X5 UR [R[R5nUS:wa [U[R"U55egr\) connect_exerrno EINPROGRESS EWOULDBLOCKEALREADYr getsockoptr5 SOL_SOCKETSO_ERROROSErrorosstrerror)rrBrerrs rr7r7s} ,,w C ax u  %"3"3U^^DD1)ll6,,foo> axc2;;s+,,rc UR5n [U5upU(a[R"U5n O0[ XXES5upnU ce[ U [ RU5n U nU(d [UWU 5 [XU 5 [XX`RURU5unnUU - Ul URU5(d[eUsSSS5 $!,(df  O=fe)aUReturn 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``. TN)rr,rrrr4r5r6r7rirorrPr r rx)rrrr=rDrrrrEr rQrrrCrrrrJs rrVrVsV 99;D-g6Z 0:0F0Ft0L$; d% !&~~ V// 8 q Q Z 0*%( +YY M+}}Q    s .A-C%% C3cUR5 g![Ra [X5 O$[Ra [ X5 Of=fMYr) do_handshakerr\rr]rrs r_tls_handshakersO  . NN  ## . q -$$ . q - . sAAAcheck_hostnamealpnsc[RRU5up4[R"X4S9n[R R UlXlUSLa[RUl UbURU5 U$)a%Make an SSL context If *verify* is ``True``, the default, then certificate verification will occur using the standard CA roots. If *verify* is ``False``, then certificate verification will be disabled. If *verify* is a string which is a valid pathname, then if the pathname is a regular file, the CA roots will be taken from the file, otherwise if the pathname is a directory roots will be taken from the directory. If *check_hostname* is ``True``, the default, then the hostname of the server must be specified when connecting and the server's certificate must authorize the hostname. If ``False``, then hostname checking is disabled. *aplns* is ``None`` or a list of TLS ALPN (Application Layer Protocol Negotiation) strings to use in negotiation. For DNS-over-TLS, the right value is `["dot"]`. )cafilecapathF) r _tls_util#convert_verify_to_cafile_and_capathrcreate_default_context TLSVersionTLSv1_2minimum_versionr CERT_NONEr"set_alpn_protocols)rrrrrrs rmake_ssl_contextrsq(]]FFvNNF,,FJK#&.."8"8K!/ "%--  &&u- rc [XSLS/5$)Ndot)r)rrs r_make_dot_ssl_contextr's F4$?% IIrc U(a[UUUUUUUUU5 $UR5n [U5up[XXES5unnnUceU c[ XSLS/5n [ U[ RU U US9n[UUU5 [UU5 [UX5 [UXURURU5unnUU - UlURU5(d[ eUsSSS5 $!,(df  O=fe)aReturn 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``. TNr)rrrD)rVrr,rrrr5r6r7rrirorrPr r rx)rrrr=rDrrrrErrrr rQrrCrrrrJs rtlsr-s0z            99;D-g6Z 7 V$!Rf >>&vd/JUGT  '   K,q*%D%( zQYY M+}}Q !   $  s ;A3C88 Drc >[RR(d [S5eU bU cU n SUlUR 5n U(a[ R"S5n UnO[RRXS9n U nU  U(dWRXXE5n[U5unnWRU5nURU S5 UR[U55n SSS5 [R"5nSSS5 [R R#U UR$UR&UUS9n[)WW- S5UlUR+U5(d[,eU$!,(df  N=f!,(df  N=f)a+Return 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)r"r#Trr )r rr%rr&rrrr'r(r,r)r;r+rr rrrrr,r rx)rrrr=rDrrrrrrrr r.r0r/r1rr2r3rs rrrsbn 88  566"x'7" AD 99;D5?5K5KD5Q#((**+  (00VN-W5  ' ' 0F KKd #>>*Z"89D1    MM)'  A% %AF ==   H1 0 s$ 9F-E=1F= F F Fc$\rSrSrSrSrSrSrSrg)UDPModeizHow 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" rrrrdN) rPrQrRrSrvNEVER TRY_FIRSTONLYrTrdrrrrs EI Drr txn_managerrserialc #n# URSRnU[RR:HnUR 5nUR 5n [U[R5=(a UR[R:Hn U (a[XSU5 O/[R"S[U 55U -n [XU5 [R R#XX:5n Sn SnSnU (d[%U5unnUb UbUU:aUnU (a['USU5unnO3[)USU5n[R*"SU5un[)UUU5n[R,R/UUR0UR2SUUU (+US9nU R5U5n Uv UR6nU (dMUR0(a3Ub0UR8(d[R:R=S 5eSSS5 g!,(df  g=f7f) z'Given a socket, does the zone transfer.rNrkFrHrT)rrxfrorigintsig_ctxmultirz missing TSIG)questionrdtyper rdatatypeIXFRfrom_wire_originrrr5rrOr=rlpackrrcrInboundr,r8r_rmrrrrPprocess_messagerhad_tsigr FormError)rrrFrrrris_ixfrrr is_udprhinbounddonerrr@ mexpirationrwirernrbs r _inbound_xfrrs^^A  % %F ***G  ) ) +F ==?D 6== ) Iaff8I8I.IF !4,T3t9-41j) f =(,-g6 Q "&;+C( &q%= !!Q 4}}T51!!Q 4 %% !II!!z!(& A**1-DGzzH1$2 ==Q]1::--)).9 9= > = =s&C9H5;CH$AH$ H5$ H2.H5zonerrdclasskeyname relativizer+use_udp keyalgorithmc #V# "SS[RR5n[U[5(a[R R U5n[RRRU5n[RRXU5nU[RR:XaURURU[RR [RR"SS9n[R$R SSSU S35nUR'US 5 UbUR)XgUS 9 [+XXS5unnn Uce[-U 5unnU"X5nU (a)U[RR:wa [/S 5eU (a[0R2O[0R4n[7UUU 5n[9UUU5 [;UUUXU5S hvN S S S 5 g N !,(df  g =f7f) a/Return 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\rSrSrSrSrS\RR4Sjr Sr S S\ S\RR4SjjrS rg ) $xfr..DummyTransactionManagericXXU(a[RROU4Ulgr)r remptyinfo)r#rrs rr-xfr..DummyTransactionManager.__init__szSXX^^vVDIrcUR$rrr#s rorigin_information7xfr..DummyTransactionManager.origin_informations 99 rrnc[errJrs r get_class.xfr..DummyTransactionManager.get_classrkrc[errJrs rreader+xfr..DummyTransactionManager.readerrkr replacementch"SS5n[[RRU"55$)Nc \rSrSrSrSrSrg)Exfr..DummyTransactionManager.writer..DummyTransactionicgrrd)r#rakws rnopIxfr..DummyTransactionManager.writer..DummyTransaction.nopsrcUR$r)r)r#r@s r __getattr__Qxfr..DummyTransactionManager.writer..DummyTransaction.__getattr__s 88OrrdN)rPrQrRrSrrrTrdrrDummyTransactionrs $rr)rr transaction Transaction)r#rrs rwriter+xfr..DummyTransactionManager.writers) $ $335E5GH HrrN)F)rPrQrRrSrrr rdataclass RdataClassrrboolrrrrTrdrrDummyTransactionManagerrsN W  &s~~88 & & Id Is7R7R I IrrT)createINSOAz. . z 0 0 0 0rN) algorithmzcannot do a UDP AXFR)r rTransactionManagerrrr from_textr RdataTypemaker make_queryr find_rrset authorityrrrrdataadduse_tsigrr,rr5rOr6r4r7r)rrrrrr=rrrr+rDrrrrrrrrsetsoarCrr@rtm sock_typers rrr;sJI#//"D"DI.$xx!!$' ]] $ $ ) )& 1F tW5A ### KKs~~00#--2C2CD ii!!$fXX/FG #q 7| < 7 V$!Rf >>$X.OQ  2B6S]]////00%,!!&2D2DI RF +qK,Aq&:FFF , +F , +s0G&H)( HH H H)H H&"H)udp_modec DUc"[RRU5up)O[RRU5n [ XXgS5upnU ce[ U5upUR SR[RR:Xa[U[R:waG[U [RU5n[XU 5 [!XX)XM5Hn M SSS5 g[U [R&U5n[XU 5 [!XX)XM5Hn M SSS5 g![RR"a U[R$:XaeOf=fSSS5 M!,(df  N=f!,(df  g=f)aMConduct 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.query.UDPMode.NEVER``, i.e. only use TCP. Other possibilities are ``dns.query.UDPMode.TRY_FIRST``, which means "try UDP but fallback to TCP if needed", and ``dns.query.UDPMode.ONLY``, which means "try UDP and raise ``dns.xfr.UseTCP`` if it does not succeed. Raises on errors. NTr)r rrextract_serial_from_queryrr,rrrrrrr4r5rOr7rUseTCPrr6)rrrFr=rr+rDrrrrCrr@rrs r inbound_xfrrs_^ }'',,[92259 7 V$!Rf >>$X.OQ ~~a3==#5#55(gmm:S V.. 71 QZ 0 %E7A8 7 R++V 4,keWQA R 5 4 77>> w||+, +8 7 7 5 4s6 FD<!F<3E2/F1E22F F F)TrrO) NrNrFFTTN) NNFFNrFFFN) NrMNrFFFFNF) NrMNrFFFNNF)NFNrF)NrMNrFFN)TTN) NUNrFFNNNT) NrNrFFNTNN)rvrrenumrrrzrrr5rlr urllib.parsertypingrrrrrr dns._featuresr dns._tls_util dns.exceptiondns.inet dns.messagedns.namedns.quic dns.rdatadns.rdataclass dns.rdatatypedns.transactiondns.tsigdns.xfrr ImportError dns._no_ssl_no_sslrr _featureshave _have_httpxhttpcore._backends.syncr:rNetworkBackend_CoreNetworkBackend _backendssync SyncStreamr8r HTTPTransportrXr AddressFamilyr SocketKindrprq__annotations__r DNSExceptionrsrrxr{rr TransferErrorr,rrrrrrr4 SSLContextrrrrrrrIntEnumrrerrr@floatrrrHeadersbytesrr rrr8r=rCtsigKeyrLrRrWr_rcriror7rVrrrrrrrrrrAXFRrrdefault_algorithmrrrrrdrrr!s$   == 2 mm  ' ""11((--88O4&-4&l,,, & & *s"*   * * ]] * C!2!2C8&--G Hs}}11HG#--))GCMM & & CMM & & %% $(800 ) "=A)%^s"    $J ]] J37 's"'   ''XX]]S(4/ ' $J '  ]] 'V - ./    $,,  &!"!$(*.26"" + 3 3!L  {{L L T\L   L $J L  L L L 4ZL  L  L TzL  3J 'L ./L  L !L " [[#L ^#((**%EO388++O3OeOO*!"!*.59:  {{: :  : T\ :  : $J : : : :  3J ':  : ++d2:  [[: z 1 1& $   ++   %   3: >###"8< #! %(,g4 g4tg4 g4 g4  g4 #((--- . 5 g4g4g4g4g4 ;;   %g4 g4Z!#"! %Y {{Y YT\Y  Y $J Y  YYYYY *YY [[Y~!#"!U  {{U U T\U   U $J U  U U U U DjU DjU U  3;;   $%U p * 1& $$ $ ++   %$ $ 3: $@ $"8< #! , , ,,#((--- . 5 ,  ,  , 3;;   %&,^-!"!C {{C CT\C  C $J C  CCC *C [[CL." 3J 9t  ^^ DJ4ZJ)-J^^J!"!!%)-"&i {{i iT\i  i $J i  iii --$ i$&i4Zi 3Ji [[i^!"!59"&^  {{^ ^ T\^   ^ $J ^  ^ ^ ^ ++d2^  3J^ Dj^ 4Z^  [[^ B  dll  1:331: }}s}}$1: ;;  1: $J 1: T\ 1:  1: 1:n-0MM,>,>/2~~/@/@ 8<*.!(+(B(BsG sG ((--# sG MM # #c )sG^^ & & , sG T\ sG  sG#((--- . 5sGXX]]S 4 'sGsGdlsG $JsGsG sGsG((--#%sG  !sGr)- ! I I33I ;;   %I  I T\ I dl I $JIII IA4s5f f0/f0