i#UdZddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl mZmZmZmZmZmZddlZddlZddlZddlZddlZddlZddlZddlZddlZddlZddlZddl Zddl!Z ddl"Z"n#e#$r ddl$m%Z"YnwxYwdZ&dZ'ej()dZ*e*rBddl+Z,ddl-Z-e,j.Z/e,j0j1j2Z3Gdde/Z4Gd d e-j5Z6n Gd d Z6e*Z7d ej8e9zd ej:de9dejfdZ;e;Zj?Z@Gddej>jAZBGddej>j?ZCGddej>j?ZDejEjFZFdZGdZHdZIdZJdZKdZL d}d!ZM d~d ej8e9zd"ej:d#edzdejfd$ZN dd ej8e9zd"ej:d%e"jOd&ejPjQeRzdzd#edzde"jSf d'ZTd(ZUd)ed*dd*fd+ZVGd,d-ejWZXdd.ddd/d/dd0d dd dejYeXjZfd1ej[j\d2eRd3e]dzd4e9d#eRdzd5e9d6e^d7e^d8edzd9eRd:e^d;eRdzdeXdej[j\f"d?Z_d@ej`jadAebdebfdBZcd@ej`jadCeRdDebddfdEZd dd1ej[j\d2eRdFeRd3e]dzd4e9d#eRdzd5e9d6e^d7e^ds(t ty{{W$j 1 11rdohc2eZdZfdZ ddZ ddZxZS)_NetworkBackendct||_||_||_||_dSr)super__init__ _local_port _resolver_bootstrap_address_family)selfresolver local_portbootstrap_addressfamily __class__s rrz_NetworkBackend.__init__Ms; GG     )D %DN&7D #!DLLLrNcxg}t|\}}tj|r||n|j||jnht |}|j} |rtj|} |j || |} | }|D]} tj| } | |j dkr,|d}tj ||j f| } nd} t| tj| }t#d|}t%|tj | |f| |t'|cS#t($rYwxYwt*j)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_optionsr0_rr&answersaddressafsourcesockattempt_expirations r connect_tcpz_NetworkBackend.connect_tcpTsI*733MAzx""4(( 0  &&&&(4  !89999$Z00 D X44]CCF.55'6$--// $  X,,W55 ,0@A0E0E$,(1  X==&(892FF"F &r6+=vFFD)Ec:)V)V&88'4"MM* +400000 D' 's3A*F  F-,F-ctrNotImplementedError)r"pathrr=s rconnect_unix_socketz#_NetworkBackend.connect_unix_socket}s & %r)NNNNN)__name__ __module__ __qualname__rrErJ __classcell__r's@rrrLsm " " " " "PT' (' (' (' (T6: & & & & & & & &rrc4eZdZdddejdfd ZxZS)_HTTPTransportrNr$r%r#r&c||ddl}|j}tj|i|t |||||j_dSNr) dns.resolverr#Resolverrrr_pool_network_backend) r"r$r%r#r&argskwargsr r's rrz_HTTPTransport.__init__sp$5$=####<0022 EGG d -f - - -*9*&7++DJ ' ' 'r)rLrMrNr3 AF_UNSPECrrOrPs@rrRrRsS"#            rrRc0eZdZdddejddZdZdS)rRrNrScdSr)r"r$r%r#r&rZr[s rrz_HTTPTransport.__init__s  DrctrrG)r"r:r;rr<s rrEz_HTTPTransport.connect_tcp% %r)rLrMrNr3r\rrEr_rrrRrRsM"#      & & & & &rrAkindprotoreturnc.tj|||Sr)r3)rArbrcs rdefault_socket_factoryrfs =T5 ) ))rsocket_factoryceZdZdZdS)UnexpectedSourcez=A DNS query response came from an unexpected address or port.NrLrMrN__doc__r_rrririsGGGGrriceZdZdZdS) BadResponsezrseleventsrs r _wait_forrsFJr3=11bjjllQ6F6Ft  " $ $(  + i* *F  , i+ +F  % LLV $ $ $  GG 49;;.G#~~m++zz'"" (-' ' (((((((((((((((((((s BC--C14C1c,t|ddd|dS)NTFrsrs r_wait_for_readablers audJ/////rc,t|ddd|dS)NFTrrs r_wait_for_writablers adJ/////rc  tj||d}tj||d}n#tjj$rYdSwxYw||ko|dd|ddkS)NrF)r r+ inet_ptonr SyntaxError)rAa1a2n1n2s r_addresses_equalrs X  BqE * * X  BqE * * = $uu 8 (122"QRR&((sA AA'&A'c|sdSt|||s;tj|dr|dd|ddkrdS|rdSt d|d|)NTrrFzgot a response from z instead of )rr r+ is_multicastri)rA from_address destinationignore_unexpecteds r_matches_destinationrs tL+66 k!n--2>qrr2BkRSRTRTo2U2Ut u J|JJ[JJ  rTc d}d} tj|}|}n#t$r|rYnwxYw|r9tj|}|r||krt dn|}|r@|s> tj|}n#t$rt dwxYw|r"tj||f|}|r"tj||f|}|||fS)Nz5different address families for source and destinationz3source_port specified but address family is unknown)r r+r.r7 ValueError any_for_afr1)wherer;rB source_portwhere_must_be_addressrArsafs r_destination_and_sourcerse BK X $ $U + +       h%%f-- byy KBT6T TX((,,FF T T TRSS S T Ph66 T7JBOO  M116;2GLL  V $$s!( 88;BB5typerBct||d} |d||||S#t$r|wxYw)aQMake 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)rg setblockingbindr7close)rArrBrs rr2r2Dsq, r4##A e   FF6NNN    s -A A! ssl_contextserver_hostnamect|||}t|tjjr|}||d|S)aMake 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)r2rvr nameNameto_text wrap_socket)rArrrrBrCs rmake_ssl_socketresb> r4 ( (D/38=114)1133  " " %' #  rcN|t|||||St|||Sr)rr2)rArrBrrs r _make_socketrs2r4ovNNN2tV,,,rr#zdns.resolver.ResolvercD|ddl}|j}|SrU)rVr#rW)r#r s r_maybe_get_resolverrs. <((** Orc.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. rrN) rLrMrNrkDEFAULTHTTP_1H1HTTP_2H2HTTP_3H3r_rrrrs= G F B F B F BBBrrFz /dns-queryqrrr;rone_rr_per_rrsetignore_trailingsessionrIpostr%verifyr& http_versionc$t||||d\}}}|}|Ttj|r5|tjkr d|d|| }n|tjkr d|d|| }i}| xtj |}|j tdtj|j r|j } |j |d<|j |j }|tjks|tjkrt s| ft#| } |j J| |j |}t'jt+|} |r.t/|tjjstd t5|| |||||||| | | St st6|r)t/|t8jstd |}d d i}|tjtjfv}|tj tjfv}|d}d}n|d}|d}|rtCj"|}n/tG|||| || | |}t9j||| |}|5}|J| rM|$d tKtM|d|'|||||}nWtQj)|*d}|+} |,|||d| i|}dddn #1swxYwY|j-dks |j-dkr!t|d|j-d|j.tj/0|j.|j1|j2||}!|j34|!_5|6|!stn|!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 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,r3AF_INETAF_INET6urllibparseurlparsehostnamerr;rrrhave_dohrr/randomchoicelistr0rvquicSyncQuicConnection_http3rohttpxClientto_wirerr contextlib nullcontextrRupdatestrlenrbase64urlsafe_b64encoderstripdecodeget status_codermessage from_wirerrelapsed total_secondsr is_responserm)"rrrr;rBrrrrrIrr%rr#r&rrAr> the_sourceurlrparsedr?wirerh1h2r<r$cmrresponsetwirers" rhttpsrsN2 tV[%RJ C ~#(--e44~   1U11T1411CC 6? " "3e33t3T33CJ &&s++ ? "122 2 8  v / / 9 & )/J~ & ; ";D{~%% +++H+  $*844H?...++FOVDDG & d73D3D3F3F.G.G H H   Y: SX0   YWXX X              Fz'5<88FDEEE 99;;D23G +.+*=> >B +.+*=> >B  "1 ]  0:0Fw0O0O"'!/    \Bv    w"""   NN$=&)#d))nn    ||% $HH+D1188>>DKKMME{{u~% #H+>c!!X%9C%?%? 3 3(2F 3 3 ( 0 3 3     M)'   A  + + - -AF ==   Hs*B+M!!M%(M%rrcF|t|D]\}}||kr|cStr)KeyError)rrheadervalues r _find_headerr s;   T>>LLL  NrpeerrcPt|d}|tdt|}|dkrtd|dks|dkrTd}t|dkr) d|z}n#t $rYnwxYwt |d ||dS) Ns:statuszno :status header in responserzstatus is negativerrz: r)r rintrrr7r)rr rr statuserrors r _check_statusrs * - -E }9::: ZZF zz./// ||v|| t99q== t{{}},    DMMfMeMMNNN$|s(B B  B rrc tjjstdtj|} | j} | J| j| j}d|_ | }| rtj d}n$tj | | d}|}|5| r| }n|||||}t|\}}||5}|||| |t'|}t)|||dddn #1swxYwYt-j}dddn #1swxYwYtj||j|j||}t7||z d|_||st:|S)Nz DNS-over-HTTP3 is not available.rT) verify_mode server_nameh3rr )r r have_quicrorrrrr;idrrrSyncQuicManagerconnectr* make_streamsend_h3receiverrrr rrrrmaxrrm)rrrrr;rBrrrrrr url_partsrrmanager the_managerthe_connectionstartrstreamfinishrs rrrss 8 86777 %%c**I!H    ~!~ AD 99;;D5?5KD5Q5Q(**H+       'NN(00tV[N-W55  ' ' 0 0 9F NN3d + + +>>*Z"8"899D &..**E4 8 8 8 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9                  M)'   A% % %AF ==   Hs81AF 6AE F E# #F &E# 'F  F F cr ||S#t$rt||YnwxYw7)zReads a datagram from the socket. A Timeout exception will be raised if the operation is not completed by the expiration time. )recvfromBlockingIOErrorr)rCmax_sizers r _udp_recvr*sT 1 1==** * 1 1 1 tZ 0 0 0 0 0 11s 55c |r|||S||S#t$rt||YnwxYwO)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. )sendtosendr(r)rCdatarrs r _udp_sendr/sn 1 1 '{{4555yy& 1 1 1 tZ 0 0 0 0 0 1 1s00A  A rCwhatrrct|tjjr|}t j}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. )rvr rMessagerr r/)rCr0rr sent_timens rsend_udpr5sP,$ +,,||~~ I$k:66A y>rrrrrraise_on_truncation ignore_errorsqueryc d} t|d|\} } t|j| ||s-tj} tj| |||||}n[#tjj$r6}| r.| ,| |sYd}~d}~wt$r| rYwxYw| r| | |s|r|| 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)rrrrr6N) r*rr&r r rr Truncatedrr7)rCrrrrrrrr6r7r8rr received_timeres r receive_udpr>sS| D(4(ujAA|# K{4E       %%'!1 /$7 &AA{$    %))!))++66&        U.u7H7H7K7K.   4}% %}l3 3s$%A**C>+B/.B//CC5c |} t||||d\} }}t|\}}| rtj| }n| Jt | t j|}|5}t|| ||t||||||j |j || | | \}}||z |_ | s| |st|cdddS#1swxYwY 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``. TN)rrr*rrr2r3 SOCK_DGRAMr5r>rmacr rrm)rrrr;rBrrrrr6rCr7rrAr begin_timerrrrr<s rudprDskp 99;;D 7 tV[$!!Rf .g66Z 80:0Ft0L0L~~~ V. 7 7 qD+z222(     I E       M+ q!1!1  ), s6A"C%%C),C)udp_socktcp_sockc  t|||||||||d| | } | dfS#tjj$rt ||||||||| } | dfcYSwxYw)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)rDr rr;tcp) rrrr;rBrrrrrErFr7rs rudp_with_fallbackrIsr               %  ;               $  s /AAc@d}|dkr ||}|dkrtd|t|z}||z }nL#ttjf$rt ||Yn$tj$rt||YnwxYw|dk|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. rrEOF) recvEOFErrorrr(rwSSLWantReadErrorrSSLWantWriteErrorr)rCcountrrr4s r _net_readrQ7s A !)) 1 %  ACxxuoo% SVVOE FAA!56 1 1 1 tZ 0 0 0 0 0$ 1 1 1 tZ 0 0 0 0 0 1 !)) HsAA &B4BBc d}t|}||krv ||||dz }nL#ttjf$rt ||Yn$tj$rt||YnwxYw||ktdSdS)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-r(rwrOrrNr)rCr.rcurrentls r _net_writerULs G D A A++ 1 tyyghh00 0GG!67 1 1 1 tZ 0 0 0 0 0# 1 1 1 tZ 0 0 0 0 0 1 A++++++s :&B"BBc$t|tjjr|d}n&t |dd|z}tj}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)prepend_lengthrbig) rvr rr2rrto_bytesr rU)rCr0rtcpmsgr3s rsend_tcpr[\s$$ +,,5T22 T##Au--4 ItVZ((( KK ##rct|d|}tjd|\}t|||}tj} tj|||||} | | 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)rQstructunpackr r rr) rCrrrrrldatarTrr<rs r receive_tcprazs}B dAz * *E =u % %DQ T1j ) )DIKKM  )'   A } rcN||}|dkrdS|tjtjtjfvr:t |||tjtj }|dkr"t|tj |dSrU) connect_exerrno EINPROGRESS EWOULDBLOCKEALREADYr getsockoptr3 SOL_SOCKETSO_ERROROSErrorosstrerror)rr@rerrs rr5r5s ,,w  C axx u %"3U^DDD1j)))ll6,fo>> axxc2;s++,,,xrc |} t|\} } |rtj|} n6t ||||d\} }}| Jt | t j|} | 5}|st||| t|| | t|| ||j |j |\}}|| z |_ ||st|cdddS#1swxYwY 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``. TN)rr*rrrr2r3r4r5r[rarrBr rrm)rrrr;rBrrrrCrrCrrrArrrr<s rrHrHsgV 99;;D-g66Z 90:0Ft0L0L$; 4d% % ![&~~~ V/ 8 8 q 1 Q Z 0 0 0D*%%%( z+QY  M+}}Q                   s6A-C00C47C4c |dS#tj$rt||Yn$tj$rt ||YnwxYw]r) do_handshakerwrNrrOrrs r_tls_handshakerrs. . NN    F# . . . q* - - - - -$ . . . q* - - - - - . .sAAAcheck_hostnamealpnsctj|\}}tj||}tjj|_||_|durtj |_ || ||S)aQMake 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_capathrwcreate_default_context TLSVersionTLSv1_2minimum_versionrs CERT_NONErset_alpn_protocols)rrsrtrvrwrs rmake_ssl_contextrs|(]FFvNNNFF,F6JJJK#&."8K!/K "%-  &&u--- rc*t||dudgS)Ndot)r)rrs r_make_dot_ssl_contextr's FO4$?% I IIrUc J|rt||||||||| S|} t|\} }t||||d\}}}|J| t | | dudg} t |t j| | |5}t|||t||t|| |t||||j |j |\}}|| z |_||st |cdddS#1swxYwY 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``. TNr)rrrB)rHrr*rrrr3r4r5rrr[rarrBr rrm)rrrr;rBrrrrCrrrrrCrrArrrr<s rtlsr-sz              99;;D-g66Z 7 tV[$!!Rf >>>&vd/JUGTT  '     K,,,q*%%%D*%%%( z+QY  M+}}Q  !$ sA;DDDrc @tjjstd| | | } d|_|} |rt jd} |}n#tj| | } | }| 5|s| ||||}t|\}}| |5}| | d| t|} dddn #1swxYwYtj}dddn #1swxYwYtj| |j|j||}t)||z 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 rrrrrrrrrrr*rr-rrr rrrrrrrm)rrrr;rBrrrrrrrrr r"r!r#rr$r%rs rrrs*n 8 75666"x'7" AD 99;;D5?5KD5Q5Q#(**H+      (00tV[N-W55  ' ' 0 0 :F KKd # # #>>*Z"8"899D : : : : : : : : : : : : : : :                  M)'   A% % %AF ==   Hs7AD19D; D1D D1D D11D58D5ceZdZdZdZdZdZdS)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" rrrN)rLrMrNrkNEVER TRY_FIRSTONLYr_rrrrs) EI DDDrr txn_managerrserialc #K|jdj}|tjjk}|}|} t|tjo|j tj k} | rt|| d|n6tj dt| | z} t|| |tj|||| 5} d} d}d}| st%|\}}||||kr|}| rt'|d|\}}n9t)|d|}tjd|\}t)|||}tj||j|jd||| |}| |} |V|j}| |jr(|&|jstjd ddddS#1swxYwYdS) z'Given a socket, does the zone transfer.rNr]Fr:rT)rrxfrorigintsig_ctxmultirz missing TSIG)questionrdtyper rdatatypeIXFRfrom_wire_originrrvr3rrAr/r^packrrUrInboundr*r*rQr_rrrrBprocess_messagerhad_tsigr FormError)rrr8rrrris_ixfrrris_udprZinbounddonerrr> mexpirationrwirer`rTs r _inbound_xfrrsY^A  %F **G  ) ) + +F ==??D 6= ) ) Iaf8I.IF *!T4,,,,T3t99--41fj))) fff = =:(, "-g66 Q "&;+C+C(  5&q%== !!Q 44}T511!!Q 44 %% !I!!z!(&  A**1--DGGGzH1 "2 = :Q]1:]-)).99 9=::::::::::::::::::s.C:G55G9<G9zonerrdclasskeyname relativizer)use_udp keyalgorithmc # KGddtjj}t|trtj|}tjj |}tj |||}|tjj krx| |j|tjjtjjd}tjddd| d}||d ||||| t+||| | d\}}} |Jt-| \}}|||}| r$|tjj krt/d | r t0jn t0j}t7||| 5}t9|||t;|||| ||Ed {Vd d d d S#1swxYwYd 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. cfeZdZdZdZdejjfdZdZ d de dej j fdZ d S) $xfr..DummyTransactionManagerc@|||rtjjn|f|_dSr)r remptyinfo)r"rrs rrz-xfr..DummyTransactionManager.__init__s!z-USX^^vVDIIIrc|jSr)rr"s rorigin_informationz7xfr..DummyTransactionManager.origin_informations 9 rrdctrrGrs r get_classz.xfr..DummyTransactionManager.get_classrarctrrGrs rreaderz+xfr..DummyTransactionManager.readerrarF replacementcjGdd}ttjj|S)NceZdZdZdZdS)Exfr..DummyTransactionManager.writer..DummyTransactioncdSrr_)r"rZkws rnopzIxfr..DummyTransactionManager.writer..DummyTransaction.nopsDrc|jSr)r)r"r>s r __getattr__zQxfr..DummyTransactionManager.writer..DummyTransaction.__getattr__s 8OrN)rLrMrNrrr_rrDummyTransactionrs2$$$$$rr)rr transaction Transaction)r"rrs rwriterz+xfr..DummyTransactionManager.writersK $ $ $ $ $ $ $ $35E5E5G5GHH HrN)F)rLrMrNrrr rdataclass RdataClassrrboolrrrr_rrDummyTransactionManagerrs W W W    &s~8 & & & & & & & I Id Is7R I I I I I IrrT)createINSOAz. . z 0 0 0 0rN) algorithmzcannot do a UDP AXFR)r rTransactionManagerrvrr from_textr RdataTypemaker make_queryr find_rrset authorityrrrrdataadduse_tsigrr*rr3rAr4r2r5r)rrrrrr;rrrr)rBrrrrrrrrsetsoarArr>rtm sock_typers rrr;s|JIIIII#/"DIII.$(x!!$'' ] $ ) )& 1 1F tVW55A ### Ks~0#-2CD  i!!$/Ff/F/F/FGG #q 7G| <<< 7 tV[$!!Rf >>>$X..OQ z 2 2B16S]////000%,D!!&2DI RF + +GqK,,,Aq&':FFFFFFFFFGGGGGGGGGGGGGGGGGGs ,HH Hudp_modec 8|#tj|\}} ntj|} t ||||d\} } }| Jt |\} } |jdjtjj kr|tj krt| tj|5}t|| |  t!|||| || D]}  ddddS#tjj$r|tjkrYnwxYw dddn #1swxYwYt| tj|5}t|| | t!|||| || D]}  ddddS#1swxYwYdS)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.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*rrrrrrr2r3rAr5rUseTCPrr4)rrr8r;rr)rBrrrrArr>rrs r inbound_xfrrs`^ }',,[9922599 7 tV[$!!Rf >>>$X..OQ  ~a3=#555(gm:S:S V. 7 7 1 Q Z 0 0 0 %E67JA        7>   w|++,+ +                R+V 4 4K,,,k1eVWjQQ  A  sBD2C::%D"D2!D""D22D69D6)FFF)TrrK) NrNrFFTTN) NNFFNrFFFN) Nr?NrFFFFNF) Nr?NrFFFNNF)NFNrF)Nr?NrFFN)TTN) NrNrFFNNNT) NrNrFFNTNN)rkrrenumrdrlrrzr3r^r urllib.parsertypingrrrrrr dns._featuresr dns._tls_util dns.exceptiondns.inet dns.messagedns.namedns.quic dns.rdatadns.rdataclass dns.rdatatypedns.transactiondns.tsigdns.xfrrw ImportError dns._no_ssl_no_sslrr _featureshave _have_httpxhttpcore._backends.syncr8rNetworkBackend_CoreNetworkBackend _backendssync SyncStreamr6r HTTPTransportrRr AddressFamilyr SocketKindrfrg__annotations__r DNSExceptionrirrmrorrr TransferErrorr*rrrrrrr2 SSLContextrrrrxrrrIntEnumrr\rrr2floatrrrHeadersbytesr rrrr*r/r5tsigKeyr>rDrIrQrUr[rar5rHrrrrrrrrrrrAXFRrrdefault_algorithmrrrrr_rrr sc$   ================JJJJ222 m  '' `&""""LLL"1(-8O4&4&4&4&4&-4&4&4&l,, & & & & & & & & *s"*  * * ] **** C!2C8&-G HHHHHs}1HHHGGGGG#-)GGGCM & CM & % $$$(((8000000 ) ) )   "=A)%)%)%)%^s"   $J ] J37 ''s"'  ''X]S(4/ ' $J '  ] ''''V - - - ./           $,    &!"!$(*.26" + 3!L L  {L L T\L   L $J L  L L L 4ZL  L  L TzL  3J 'L ./L  L !L " [#L L L L ^#(*%EO38+O3OeOOOOO*!"!*.59: :  {: :  : T\ :  : $J : : : :  3J ':  : +d2:  [: : : : z 1 1 1 1 1 1& $   +  %   3: >###"8< #! %(,g4g4 g4tg4 g4 g4  g4 #(-- . 5 g4g4g4g4g4 ;  %g4 g4g4g4g4Z!#"! %YY {Y YT\Y  Y $J Y  YYYYY *YY [YYYY~!#"!U U  {U U T\U   U $J U  U U U U DjU DjU U  3;  $%U U U U p   * 1 1 1& $$$ $ +  %$ $ 3: $$$$@ $"8< #! ,, , ,,#(-- . 5 ,  ,  , 3;  %&,,,,^---!"!CC {C CT\C  C $J C  CCC *C [CCCCL..." 3J 9t  ^ DJ4ZJ)-J^JJJJ!"!!%)-"&ii {i iT\i  i $J i  iii -$ i$&i4Zi 3Ji [iiii^!"!59"&^ ^  {^ ^ T\^   ^ $J ^  ^ ^ ^ +d2^  3J^ Dj^ 4Z^  [^ ^ ^ ^ B      dl    1:31: }s}$1: ; 1: $J 1: T\ 1:  1: 1:1:1:1:n-0M,>/2~/@ 8<*.!(+(BsGsG sG (-# sG M #c )sG^ & , sG T\ sG  sG#(-- . 5sGX]S 4 'sGsGdlsG $JsGsG sGsG(-#%sG  !sGsGsGsGr)- ! II I3I ;  %I  I T\ I dl I $JIII IIIIIIs5A:: BB