\d0dZddlmZddlmZmZmZddlmZGddZ Gddej Z d Z Gd d Z dd Zd S)z Resolver implementation for querying successive authoritative servers to lookup a record, starting from the root nameservers. @author: Jp Calderone todo:: robustify it documentation )defer)commondnserror)FailureceZdZdZdZdS)_DummyControllerz A do-nothing DNS controller. This is useful when all messages received will be responses to previously issued queries. Anything else received will be ignored. cdSN)selfargss 2lib/python3.11/site-packages/twisted/names/root.pymessageReceivedz _DummyController.messageReceiveds N)__name__ __module__ __qualname____doc__rr rrr r s-      rr c8eZdZdZd dZdZdZdZdZd Z dS) Resolverao L{Resolver} implements recursive lookup starting from a specified list of root servers. @ivar hints: See C{hints} parameter of L{__init__} @ivar _maximumQueries: See C{maximumQueries} parameter of L{__init__} @ivar _reactor: See C{reactor} parameter of L{__init__} @ivar _resolverFactory: See C{resolverFactory} parameter of L{__init__} Nctj|||_||_||_|ddlm}||_dS)a @param hints: A L{list} of L{str} giving the dotted quad representation of IP addresses of root servers at which to begin resolving names. @type hints: L{list} of L{str} @param maximumQueries: An optional L{int} giving the maximum number of queries which will be attempted to resolve a single name. @type maximumQueries: L{int} @param reactor: An optional L{IReactorTime} and L{IReactorUDP} provider to use to bind UDP ports and manage timeouts. @type reactor: L{IReactorTime} and L{IReactorUDP} provider @param resolverFactory: An optional callable which accepts C{reactor} and C{servers} arguments and returns an instance that provides a C{queryUDP} method. Defaults to L{twisted.names.client.Resolver}. @type resolverFactory: callable Nrr) r ResolverBase__init__hints_maximumQueries_reactortwisted.names.clientr_resolverFactory)r rmaximumQueriesreactorresolverFactorys rrzResolver.__init__+sW* $$T*** -  " H H H H H H /rc$d|jDS)z Return a list of two-tuples representing the addresses of the root servers, as defined by C{self.hints}. c*g|]}|tjfSr )rPORT).0ips r z#Resolver._roots..Ms4442SX444r)r)r s r_rootszResolver._rootsHs 544444rc|||j}||g|}|r||j|S)a Issue one query and return a L{Deferred} which fires with its response. @param query: The query to issue. @type query: L{dns.Query} @param servers: The servers which might have an answer for this query. @type servers: L{list} of L{tuple} of L{str} and L{int} @param timeout: A timeout on how long to wait for the response. @type timeout: L{tuple} of L{int} @param filter: A flag indicating whether to filter the results. If C{True}, the returned L{Deferred} will fire with a three-tuple of lists of L{twisted.names.dns.RRHeader} (like the return value of the I{lookup*} methods of L{IResolver}. IF C{False}, the result will be a L{Message} instance. @type filter: L{bool} @return: A L{Deferred} which fires with the response or a timeout error. @rtype: L{Deferred} )serversr#)r!rqueryUDP addCallback filterAnswers)r queryr-timeoutfilterrds r_queryzResolver._queryOsT2  ! !'4= ! I I JJw ( (  + MM!/ * * *rc|d}|tj||||||jS)z Implement name lookup by recursively discovering the authoritative server for the name and then asking it, starting at one of the servers in C{self.hints}. N) -)_discoverAuthorityrQueryr+r)r nameclstyper2s r_lookupzResolver._lookupnsJ ?%G&& IdD# & & w@T   rc|dkr!ttjdS||||d}||j|||dz |S)a# Issue a query to a server and follow a delegation if necessary. @param query: The query to issue. @type query: L{dns.Query} @param servers: The servers which might have an answer for this query. @type servers: L{list} of L{tuple} of L{str} and L{int} @param timeout: A C{tuple} of C{int} giving the timeout to use for this query. @param queriesLeft: A C{int} giving the number of queries which may yet be attempted to answer this query before the attempt will be abandoned. @return: A L{Deferred} which fires with a three-tuple of lists of L{twisted.names.dns.RRHeader} giving the response, or with a L{Failure} if there is a timeout or response error. rz"Query limit reached without resultFr8)rr ResolverErrorr6r/_discoveredAuthority)r r1r-r2 queriesLeftr5s rr<zResolver._discoverAuthority|sd. !  5./STTUU U KKw 7 7 d/qQQQrc|jtjkr0t|j|Si|jD]0}|jg|1fd}t}j}d} | || ||j j } | }|jkrnʼn tjt|j j } fd} | | | S| j j kr|j|j|jfS| jj|vrt+jd| jj}i} |jD]=} | j tjkr&| j| | jj<>g}g}|jD]i} | j tjkrR| jjj}|| vr(|| |tjfT||j|r |S|rQ|d} d}| || fd| Stt+jd S) as Interpret the response to a query, checking for error codes and following delegations if necessary. @param response: The L{Message} received in response to issuing C{query}. @type response: L{Message} @param query: The L{dns.Query} which was issued. @type query: L{dns.Query}. @param timeout: The timeout to use if another query is indicated by this response. @type timeout: L{tuple} of L{int} @param queriesLeft: A C{int} giving the number of queries which may yet be attempted to answer this query before the attempt will be abandoned. @return: A L{Failure} indicating a response error, a three-tuple of lists of L{twisted.names.dns.RRHeader} giving the response to C{query} or a L{Deferred} which will fire with one of those. cd}|gD]3}|j|kr&|j|kr|cS|jtjkr|}4|Sr )getr?r@rCNAME)r>r@r?cnamerecordrecordss rfindAnswerOrCNamez8Resolver._discoveredAuthority..findAnswerOrCNamesdE!++dB// ' ':$${d**%  11 &LrNTcF|\}}}|d|||fSNr)insert)resultsanswers authority additionalpreviouss r cbResolvedz1Resolver._discoveredAuthority..cbResolveds09@6Jq(333 'J??rzCycle in CNAME processingrcL|\}}}|djSrO)payload dottedQuad)rQrRrSrTs r getOneAddressz4Resolver._discoveredAuthority..getOneAddresss'18.Jqz)44666rcT|tjfgdz S)Nr8)r<rr')hintrEr1r r2s rz/Resolver._discoveredAuthority..s.T44T38,-w arz/Stuck at response without answers or delegation)rCoderOKrexceptionForCoderR setdefaultr>appendsetaddr@r?r<r=strr+r/rSrTrXrrCArYNSr' lookupAddress)r responser1r2rEanswerrMseenr>rKr5rV addressesrrrtrapsnsrZrUrLs` ``` @@rrDzResolver._discoveredAuthoritysQ. >SV # #@400@@JJKK K& ? ?F   v{B / / 6 6v > > > >     uuz" + HHTNNNH&&tUZCCF~5:%%// #d))UZCC # A@@@@@ MM*---H ** ((*QRR>&$..-.IJJJ~*E" +J % B BBw#%*,**?*?*A*A "','$ % %Bw#&  Z_)??LL)B-!:;;;;LL$$$  **5%+NN N  ""58W55A 7 7 7 MM- ( ( ( MM    H#$UVV r)rNN) rrrrrr+r6rAr<rDr rrrr s0000:555>    s rr]z6makePlaceholder..placeholder..s!'7wq$'7'7'D'D'Dr)r/)rrtdeferredr>s``r placeholderz$makePlaceholder..placeholders.DDDDDDEEErr )rur>rvs`` rmakePlaceholderrws* rc eZdZdZdZdZdS)DeferredResolvercHg|_||jdSr )waitingr/gotRealResolver)r resolverDeferreds rrzDeferredResolver.__init__s& $$T%9:::::rcx|j}|j|_|j|_|D]}||dSr )r{__dict__ __class__callback)r resolverwr5s rr|z DeferredResolver.gotRealResolversK L ) !+ ! !A JJx  ! !rc|ds|dvrF|jtjt |jd|St |)Nlookup) getHostByNamer1) startswithr{rbrDeferredrwAttributeError)r r>s r __getattr__zDeferredResolver.__getattr__%sd ??8 $ $ ;0J(J(J L   0 0 1 1 1"4<#3T:: :T"""rN)rrrrr|rr rrryrysA;;;!!!#####rryNcdtdD}fd|D}tj|d}fd}||t |S)a Lookup the root nameserver addresses using the given resolver Return a Resolver which will eventually become a C{root.Resolver} instance that has references to all the root servers that we were able to look up. @param resolver: The resolver instance which will be used to lookup the root nameserver addresses. @type resolver: L{twisted.internet.interfaces.IResolverSimple} @param resolverFactory: An optional callable which returns a resolver instance. It will passed as the C{resolverFactory} argument to L{Resolver.__init__}. @type resolverFactory: callable @return: A L{DeferredResolver} which will be dynamically replaced with L{Resolver} when the root nameservers have been looked up. cLg|]!}ttd|z"S)a)chrord)r(is rr*zbootstrap..@s*444Qs3s88a<  444r c@g|]}d|zS)z%s.root-servers.net)r)r(r5rs rr*zbootstrap..As-LLLq   5 9 : :LLLrT) consumeErrorsc:td|DS)Nc.g|]}|d |dS)rr8r )r(es rr*z4bootstrap..buildResolver..Fs%---A!-1Q4---r)rr$r)resr$s r buildResolverz bootstrap..buildResolverDs------    r)ranger DeferredListr/ry)rr$domainsLr5rs`` r bootstrapr,s(54%))444GLLLLGLLLA 1D111A     MM-   A  rr )rtwisted.internetr twisted.namesrrrtwisted.python.failurerr rrrwryrr rrrs  #""""",,,,,,,,,,******        nnnnnv"nnnb########&r