U “j0@stdZddlmZddlmZmZmZddlmZGdddZ 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 )defer)commondnserror)Failurec@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 6/tmp/pip-unpacked-wheel-59kc99xd/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).0ipr r r Msz#Resolver._roots..)r)r r r r _rootsHszResolver._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 _queryOs  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 _lookupns 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.|s zResolver._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)getr1r2rZCNAME)r0r2r1cnamerecord)recordsr r findAnswerOrCNames   z8Resolver._discoveredAuthority..findAnswerOrCNameNcs |\}}}|d|||fSNr)insertresultsanswers 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)hint)r6r$r r%r r s  z/Resolver._discoveredAuthority..z/Stuck at response without answers or delegation)ZrCoderOKrZexceptionForCoder@ setdefaultr0appendsetaddr2r1r.r/strr!r#rArBrErr4ArFZNSrZ lookupAddress)r responser$r%r6Zanswerr;seenr0r9r(rD addressesrrrZtrapsnsrGr )rCr6r$r:r r%r r5sl               zResolver._discoveredAuthority)rNN) rrrrrr!r)r3r.r5r r r r r s rcsfdd}|S)NcsfddS)Ncst|Sr)getattr)r')r kwr0r r rIz6makePlaceholder..placeholder..)r#r rWdeferredr0rYr placeholdersz$makePlaceholder..placeholderr )r[r0r\r rZr makePlaceholdersr]c@s$eZdZddZddZddZdS)DeferredResolvercCsg|_||jdSr)waitingr#gotRealResolver)r ZresolverDeferredr r r rszDeferredResolver.__init__cCs.|j}|j|_|j|_|D]}||qdSr)r___dict__ __class__callback)r resolverwr(r r r r`s z DeferredResolver.gotRealResolvercCs>|ds|dkr2|jtt|jd|St|dS)Nlookup) getHostByNamer$) startswithr_rLrZDeferredr]AttributeError)r r0r r r __getattr__%szDeferredResolver.__getattr__N)rrrrr`rkr r r r r^sr^NcsPddtdD}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 r @szbootstrap.. csg|]}d|qS)z%s.root-servers.net)rg)rr()rdr r r AsT)Z consumeErrorscstdd|DdS)NcSsg|]}|dr|dqS)rr*r )rer r r r Fsz4bootstrap..buildResolver..)rrr)res)rr r buildResolverDs z bootstrap..buildResolver)rangerZ DeferredListr#r^)rdrdomainsLr(rsr )rdrr bootstrap,s   rw)N)rZtwisted.internetrZ twisted.namesrrrZtwisted.python.failurerrrrr]r^rwr r r r s   r