ui` DSrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSK r SSK r SSK r SSKr SSKr SSKr SSKr SSKr SSKr SSKr SSKr SSKrSSKJr SSKJr SrSSKr\R r"S S \ R>R@5r!"S S \ R>RD5r#"S S\ R>R@5r$\ RJRLr&Sr'Sr(Sr)\*"\S5(a \RVq,O \RZq,Sr.Sr/Sr0Sr1S-Sjr2S.Sjr3S/Sjr4Sr5Sr6S0Sjr7S1Sjr8S2Sjr9S3S jr:S!r;S"rS%r?S5S&jr@S'rAS6S(jrB\ RR\ RRSSSSSSSSSS\ RR4 S)jr%"S*S+\R5rJSSSSSS\JR4S,jrLg!\a SrGNf=f!\a "SS5rGNf=f)7zTalk to a DNS server.N)SourceAddressAdapter)HostHeaderSSLAdapterTFcZ\rSrSr"SS\5r"SS\5r"SS5rSrS r g ) ssl4c\rSrSrSrg)ssl.WantReadException6N__name__ __module__ __qualname____firstlineno____static_attributes__r @/home/kodi/.kodi/addons/script.module.dnspython/lib/dns/query.pyWantReadExceptionr 6 rrc\rSrSrSrg)ssl.WantWriteException9r Nr r rrWantWriteExceptionr9rrrc\rSrSrSrg) ssl.SSLSocket<r Nr r rr SSLSocketr<rrrc[S5e)Nzno ssl support) Exception)selfargskwargss rcreate_default_contextssl.create_default_context?s,- -rr N) r rrrrrrrr#rr rrrr4s)        .rrc\rSrSrSrSrg)UnexpectedSourceFz=A DNS query response came from an unexpected address or port.r Nr rrr__doc__rr rrr&r&FsGrr&c\rSrSrSrSrg) BadResponseJz--'' ' ::g  mm### rcUqgr1)r9)selector_classs r_set_selector_classrL{s %Or PollSelectorc"[USSSU5 g)NTFrIsrFs r_wait_for_readablerRs audJ/rc"[USSSU5 g)NFTrOrPs r_wait_for_writablerTs adJ/rc[RRXS5n[RRXS5nX4:H=(a USSUSS:H$![RRa gf=f)NrF)r>inet inet_ptonr? SyntaxError)afa1a2n1n2s r_addresses_equalr_su XX  qE * XX  qE * 8 (12"QR&(( == $ $sAAA=<A=cU(dg[XU5(d3[RRUS5(a USSUSS:XagU(ag[ SUSU35e)NTrrVFzgot a response from z instead of )r_r>rW is_multicastr&)rZ from_address destinationignore_unexpecteds r_matches_destinationresn +66 k!n--QRKO+  1,|)], --rc4SnSn[RRU5nUnU(a9[RRU5nU(aXu:wa [ S5eOUnU(a@U(d9U[ R :XaSnO"U[ R:XaSnO [ S5eU(a![RRXa4U5nU(a![RRX#4U5nXVU4$![a U(aeNf=f)Nz5different address families for source and destinationz0.0.0.0z::z3source_port specified but address family is unknown) r>rWaf_for_addressr ValueErrorsocketAF_INETAF_INET6low_level_address_tuple)whereportsource source_portwhere_must_be_addressrZrcsafs r_destination_and_sourcerss BK XX $ $U + hh%%f- y "344 B6  F 6?? "F'( (hh66 7JBO  1162GL V $$A   !s!DDDc[X5nURS5 UbURU5 U(aURUSUS9$U$![a UR 5 ef=f)NF)do_handshake_on_connectserver_hostname)socket_factory setblockingbind wrap_socketrclose)rZtypero ssl_contextrvrQs r _make_socketr~str A  e   FF6N **1e;J+L LH    s:/. *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*, a ``requests.session.Session``. If provided, the 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 the system's DNS resolver. *verify*, a ``str``, containing a path to a certificate file or directory. Returns a ``dns.message.Message``. FNacceptzapplication/dns-messagezhttps://{}:{}{}zhttps://[{}]:{}{}Host)z content-typezcontent-length)headersdatar3verify=r>)rr3rparamsi+z2{} responded with status code {} Response body: {}keyring request_macone_rr_per_rrsetignore_trailing)*have_dohr.to_wirersrirjformatrkurllibparseurlsplithostnamereplacerr contextlib ExitStack enter_contextrequestssessionsSessionmountupdatestrlenpostbase64urlsafe_b64encoderstripget status_coderhcontentr>message from_wirerrelapsedr2 is_responser+)qrmr3rnrorprrsessionpathrbootstrap_addressrwirerZrEtransport_adapterrurl split_urlstackresponsers rhttpsrsgZ 8 99;D-e6.35ORF+G ~  #**5=C 6?? "%,,U$?C  &LL))%0 #,,mmI..0AB02 08    5))(*;*;*C*C*EFG  MM#0 1  NN 9"%c$i. ||Ct,3$DH++D188>D{{3+2+0$-#9H% 0c!X%9%9C%?//5ve6>6J6J6>6F6F0HI I h..&'ii*+--/?.=  ?A   AF ==   HK s CJ J!cbURU5$![a [X5 Of=fM/)zReads a datagram from the socket. A Timeout exception will be raised if the operation is not completed by the expiration time. )recvfromBlockingIOErrorrR)sockmax_sizerFs r _udp_recvrVs7  1==* * 1 t 0 1 s ,,cU(aURX5$URU5$![a [X5 Of=fMG)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. )sendtosendrrT)rrrcrFs r _udp_sendrbsH  1{{455yy& 1 t 0 1 s,,AAc[U[RR5(aUR 5n[ R "5n[ XX#5nXT4$)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. )r7r>rMessagerr2r)rwhatrcrF sent_timens rsend_udprqsE"$ ++,,||~ I$k6A >rc Sn [USU5up[URXU5(aOM.[R"5n [R R XUUUUS9n U(aX4$XU 4$)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``, 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. r)rrrrraise_on_truncation)rrefamilyr2r>rr) rrcrFrdrrrrrrrb received_timers r receive_udprsZ D (ujA  \ 1 3 3   IIKM d/?.=2E  GA!!,//r5c UR5n [XXE5upn[U5up[R"5nU (aU nO*UR [ U [RU55n[UXU5 [UXXgURURUU 5 unnUU- Ul URU5(d[eUsSSS5 $!,(df  g=f)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. Returns a ``dns.message.Message``. N)rrsr5rrrr~ri SOCK_DGRAMrrrmacr2rr+)rrmr3rnrorprdrrrrrrZrc begin_timerFrrQrrs rudprsR 99;D 78>!MRf-g6Z    5 A##LV5F5F$OPADz2(K):)*AEE?)<>M+}}Q   s BC C+c [XX#XEXgUSU 5 n U S4$![RRa [ XX#XEXxU 5 n U S4s$f=f)aBReturn 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 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. Returns a (``dns.message.Message``, tcp) tuple where tcp is ``True`` if and only if TCP was used. TF)rr>r Truncatedtcp) rrmr3rnrorprdrrudp_socktcp_sockrs rudp_with_fallbackrsi\ q(&h8%  ;;  q'(D$ s1A  A cSnUS:a8URU5nUS:Xa[eU[U5-nX4- nUS:aM8U$![[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. rr) recvEOFErrorrrrSSLWantReadErrorrRSSLWantWriteErrorrT)rcountrFrQrs r _net_readr:s A !) 1 % ACx SVOE FA !) H  !5!56 1 t 0$$ 1 t 0 1s/A%B *B  B cSn[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)rrrrrrTrrR)rrrFcurrentls r _net_writerOsr G D A + 1 yyh0 0G + !6!67 1 t 0## 1 t 0 1s2%A:A:9A:c[U[RR5(aUR 5n[ U5n[ R"SU5U-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. !H) r7r>rrrrstructpackr2r)rrrFrtcpmsgrs rsend_tcpr_sj$ ++,,||~ D A[[q !D (F ItZ( K ##rc[USU5n[R"SU5un[XU5n[R"5n [R R XUUUS9n 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``, 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. rr)rrunpackr2r>rr) rrFrrrrldatarrrrs r receive_tcprxsi6 dAz *E ==u %DQ Tj )DIIKM d/?.=  ?A  rcXURU5nUS:XagU[R[R[R4;a9[ X5 UR [R[R5nUS:wa [U[R"U55eg)Nr) connect_exerrno EINPROGRESS EWOULDBLOCKEALREADYrT getsockoptri SOL_SOCKETSO_ERROROSErrorosstrerror)rQaddressrFerrs r_connectrs} ,,w C ax u  %"3"3U^^DD1)ll6,,foo> axc2;;s+,,rc UR5n [U5up[R"5n U(aUn OF[ XUU5upnU R [ U[RU55n [XU 5 [XU 5 [XUURURU5unnUU - UlURU5(d[ eUsSSS5 $!,(df  g=f)aKReturn 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 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)rr5rrrsrr~ri SOCK_STREAMrrrrrr2rr+)rrmr3rnrorprrrrrrFrrQrZrcrrs rrrsD 99;D-g6Z    5 A(?@F@K)M %Rf##LV5G5G17%9:A QZ 0*%(8H)*AEE?LM+}}Q !  s B*C'' C5cUR5 g![Ra [X5 O$[Ra [ X5 Of=fMYr1) do_handshakerrrRrrTrPs r_tls_handshakersO  . NN  ## . q -$$ . q - . sAAAc &U(a[XX#XEXgU5 $UR5n [U5up[XXE5upnU c&U(d[R "5n U cSU l[U[RXIU S9n[UX5 [UU 5 [UX5 [UXURURU5unnUU - UlUR#U5(d[$eUsSSS5 $!,(df  g=f)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. Returns a ``dns.message.Message``. NF)r}rv)rrr5rsrr#check_hostnamer~rirrrrrrrr2rr+)rrmr3rnrorprrrr}rvrrrFrZrcrQrrs rtlsrsZ 1WF#d< < 99;D-g6Z 78>!MRf4002  ").K & b&,,f&5 7:;K,q*%D%(J)*AEE?LM+}}Q  7 7 7s A2D Dc # # [U[5(a[RR U5n[R R RU5n[RRXU5nU[R R:XaA[RR USSSSU -5nURRU5 UbURXgUS9 UR5n[!XX5unnn U (a)U[R R:wa [#S5eU (a[$R&O[$R(n[+UUU 5n[-U 5unn[/UUU5 [1U5nU (a[3UUSU5 O'[4R6"SU5U-n[9UUU5 S nS nS nSnU(aUn[RR:nOSnUnSn U(Gd[-U5unn!U!b UbU!U:aUn!U (a[=US U!5unnO3[?US U!5n"[4R@"SU"5un[?UUU!5nU[R R:Hn#[RRCUURDURFS UU S U#S 9n$U$RI5n%U%[RHRJ:wa [MU%5eU$RNn Sn&UGcU$RP(aU$RPSRU:wa[RRRUS5eU$RPSnURV[R RX:wa[RRRUS5eSn&UR[5nU[R R:Xa5[R\R_USR\5U ::aS nOS nU$RPU&SGH@nU(a[RRRUS5eURV[R RX:XaURU:XaU(a5USR\U :wa[RRRUS5eS nO%U[R R:XaU(+nUU:XaNU[R R`:Xd%U[R R:XaU(aS nGMGMGMGMU(dGM$[R R`nS nGMC U(aAURD(a0U$Rb(d[RRRUS5eU$v U(dGMSSS5 g!,(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. rINSOAz. . %u 0 0 0 0N) algorithmzcannot do a UDP AXFRrFTrrrrxfrorigintsig_ctxmultirz No answer or RRset not for qnamezfirst RRset is not an SOArVzanswers after final SOAzIXFR base serial mismatch missing TSIG)2r7rr>name from_text rdatatype RdataTypemaker make_queryIXFRrrset authorityappenduse_tsigrrsrhrirrr~r5rrrrrremptyrrrrrrrcodeNOERROR TransferErrorr answerr? FormErrorrdtypercopyserialSerialAXFRhad_tsig)'rmzoner rdclassr3rnrkeyname relativizelifetimerorpr"use_udp keyalgorithmrrrrZrc sock_typerQrErFrrdone delete_mode expecting_SOA soa_rrsetr onamer  mexpirationris_ixfrrr answer_indexs' rr r 3sp$xx!!$' ]] $ $ ) )& 1F tW5A ### ##D!T5$4v$=? 5! 7| < 99;D 78>!MRf6S]]////00%,!!&2D2DI b)V ,(2JK, I  atZ 0[[q)D0F q&* -   FHHNNEFE-g6 Q "&;+C( %a < q!!Q 4}}T51 A{3!3!33G %%dAII23%%T-3h,07&LAGGIE )))#E**zzHL xx188A;#3#3u#<--11:<< <<3==#4#44--112MNN !JJL S]]///zz((1)<)<=G $(, ,-0--112KLL<<3==#4#44u9L$ 8??f4"%--"9"9 ;#==(- 3==#5#55*5o  )#s}}'9'99$ (:(::{#@K:*#] !]]//F$)M718 !**mm--n==GQ$) - , ,s&E4W'6OWA4W W' W$ W'c$\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" rrVrr N) r rrrr)NEVER TRY_FIRSTONLYrr rrr7r7s EI Drr7c dUc"[RRU5up)O[RRU5n URSR n U [R R:Hn UR5n UR5n [XXg5upn[U5unnSnU(GaSnU (a'U[R:wa[RnSnO[R nSn[#UUU5n[%UUU5 U(a['UU SU5 O0[(R*"S[-U 55U -n[/UUU5 [RR1XU U5nSnSnU(d[U5unnUb UbUU:aUnU(a[3USU5unnO3[5USU5n[(R6"SU5un[5UUU5n8R;UUR<UR>SU UU(+U S9nURAU5nURFnU(dMU(dAUR<(a0WRH(d[RJRMS 5eSSS5 SSS5 U(aGMgg![RRBa. U[RD:XaeSnSn[RnGMf=f!,(df  Nq=f!,(df  Nz=f) a;Conduct 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 possibilites 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 succeeed. Raises on errors. NrTFrrrr r)'r>r rextract_serial_from_queryquestionr rrfrom_wire_originrrsr5r7r8rirrr~rrrrrrInboundrrrrrrrprocess_messageUseTCPr:r r%r?r)rm txn_managerqueryrnr3r*rorpudp_moder"r r4r rrZrcrErFretryr-is_udprQrinboundr.r r3rwirerrrs r inbound_xfrrIsN }'',,[92259 ^^A  % %F ***G  ) ) +F ==?D 78>!MRf$X.OQ E  x7==0))IF**IF "i 0A Q Z 0!T44T3t95<1fj1f!'),3'5g'>$Q "*".;3K&0 %.q%%E  )!Q <%}}T59 )!Q < --eU]]:?))5;h9?Z?F .HA !&66q9 !zzH5$6qzz--11.AAA)1 %J77>>!#w||3!# $#*== !-))1 0sRA5L!B0L7KLAL%L!AL L L  L L L!! L/)T)NN) NiNrFFNz /dns-queryTNTr1)NNFFNrFF) NrNrFFFFN) NrNrFFFNN)NFNrF)NrNrFFN) NiUNrFFNNN)Mr)renumrrr:rirr2r urllib.parser dns.exceptionr>dns.inetdns.name dns.message dns.rcodedns.rdataclass dns.rdatatype dns.serialdns.xfrr!requests_toolbelt.adapters.sourcer*requests_toolbelt.adapters.host_header_sslrr ImportErrorrrwr? DNSExceptionr&rr+r.r rr5rIrLhasattrrMr9SelectSelectorrRrTr_rersr~rrrrrrrrrrrrrrrrr$ rdataclassrtsigdefault_algorithmIntEnumr7r8rIr rrr_sk$  FOH.$Hs}}11HG#--))GCMM & & %% $$8% 9n%% ,,O..O00 ) - 37)%V FG2704)-l \ 1 1048:??D$);0zCDIN(,:x?C7<>C.26 p * 1 $29>?D"H-CD<@4n.DE<@*.GT MM..8I8I2tTdd!CHH$>$>dN  dll  +/T bBqH  . . . .s$G<#H <HH HH