U  W[0@stdZddlmZddlmZddlmZmZmZGdddZ Gdddej Z d d Z Gd d d Z dddZd 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 )Failure)defer)dnscommonerrorc@seZdZdZddZdS)_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. cGsdSN)selfargsr r 4/usr/lib/python3/dist-packages/twisted/names/root.pymessageReceivedsz _DummyController.messageReceivedN)__name__ __module__ __qualname____doc__r r r r r rsrc@sBeZdZdZdddZddZdd Zd d Zd d ZddZ 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__} NcCs<tj|||_||_||_|dkr2ddlm}||_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_reactorZtwisted.names.clientr_resolverFactory)r rZmaximumQueriesreactorresolverFactoryr r r r+s  zResolver.__init__cCsdd|jDS)z Return a list of two-tuples representing the addresses of the root servers, as defined by C{self.hints}. cSsg|]}|tjfqSr )rPORT).0Zipr r r Osz#Resolver._roots..)r)r r r r _rootsJszResolver._rootscCs2|j||jd}||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)rrZqueryUDP addCallbackZ filterAnswers)r queryr!timeoutfilterrdr r r _queryRs  zResolver._querycCs,|dkr d}|t||||||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 nameclstyper$r r r _lookuprs zResolver._lookupcCs@|dkrttdS||||d}||j|||d|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 resultFr))rr ResolverErrorr(r"_discoveredAuthority)r r#r!r$ queriesLeftr'r r r r-szResolver._discoverAuthoritycs |jtjkr t|j|Si|jD]}|jg|q*fdd}t }j}d} | || ||j j } | dkr|jkrqn@ tt|j j } fdd} | | | Sq`| j j kr|j|j|jfS| jj|kr td| jj}q`i} |jD]&} | j tjkr | j| | jj<q g}g}|jD]H} | j tjkrV| jjj}|| kr|| |tjfn ||qV|r |S|r|d} dd }| || fd d | Sttd SdS) 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. csFd}|gD]0}|j|kr|j|kr0|S|jtjkr|}q|Sr)getr0r1rZCNAME)r/r1r0Zcnamerecord)recordsr r findAnswerOrCNames   z8Resolver._discoveredAuthority..findAnswerOrCNameNcs |\}}}|d|||fSNr)insertZresultsanswers authority additional)previousr r cbResolveds  z1Resolver._discoveredAuthority..cbResolvedzCycle in CNAME processingrcSs|\}}}|djSr:)payload dottedQuadr<r r r getOneAddresss z4Resolver._discoveredAuthority..getOneAddresscs|tjfgdS)Nr))r-rr)Zhint)r5r#r r$r r  s  z/Resolver._discoveredAuthority..z/Stuck at response without answers or delegation)ZrCoderZOKrZexceptionForCoder= setdefaultr/appendsetaddr1r0r-r.strr r"r>r?rBrr3ArCZNSrZ lookupAddress)r Zresponser#r$r5Zanswerr9seenr/r7r'rAZ addressesZrrrZtrapsnsrDr )r@r5r#r8r r$r r4s|               zResolver._discoveredAuthority)rNN) rrrrrr r(r2r-r4r r r r r!s   !rcsfdd}|S)NcsfddS)Ncst|Sr)getattr)r&)r kwr/r r rEz6makePlaceholder..placeholder..)r"r rOdeferredr/rQr placeholdersz$makePlaceholder..placeholderr )rSr/rTr rRr makePlaceholdersrUc@s$eZdZddZddZddZdS)DeferredResolvercCsg|_||jdSr)waitingr"gotRealResolver)r ZresolverDeferredr r r rszDeferredResolver.__init__cCs.|j}|j|_|j|_|D]}||qdSr)rW__dict__ __class__callback)r resolverwr'r r r rX s z DeferredResolver.gotRealResolvercCs>|ds|dkr2|jtt|jd|St|dS)Nlookup) getHostByNamer#) startswithrWrGrZDeferredrUAttributeError)r r/r r r __getattr__'szDeferredResolver.__getattr__N)rrrrrXrcr r r r rVsrVNcsPddtdD}fdd|D}tj|dd}fdd}||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. cSsg|]}ttd|qS)a)chrord)rir r r rCszbootstrap.. csg|]}d|qS)z%s.root-servers.net)r_)rr')r\r r rDsT)Z consumeErrorscstdd|DdS)NcSsg|]}|dr|dqS)rr)r )rer r r rIsz4bootstrap..buildResolver..)rrr)res)rr r buildResolverGs z bootstrap..buildResolver)rangerZ DeferredListr"rV)r\rZdomainsLr'rkr )r\rr bootstrap/s   rn)N)rZtwisted.python.failurerZtwisted.internetrZ twisted.namesrrrrrrrUrVrnr r r r s   u