/usr/lib/python3/dist-packages/twisted/names/__pycache__
Edit: /usr/lib/python3/dist-packages/twisted/names/__pycache__/root.cpython-310.pyc (11920B)
o
b0 @ st d Z ddlmZ ddlmZmZmZ ddlmZ G dd dZ G dd dej
Z d d
Z G d 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 @ s e Zd ZdZdd ZdS )_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.
c G s d S N )selfargsr r 4/usr/lib/python3/dist-packages/twisted/names/root.pymessageReceived s z _DummyController.messageReceivedN)__name__
__module__ __qualname____doc__r
r r r r r s r c @ sB e Zd ZdZdddZdd Zdd Zd
d Zd d
Zdd 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__}
Nc C s< t j| || _|| _|| _|du rddlm} || _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
Nr r ) r ResolverBase__init__hints_maximumQueries_reactortwisted.names.clientr _resolverFactory)r
r maximumQueriesreactorresolverFactoryr r r r + s
zResolver.__init__c C s dd | j D S )z
Return a list of two-tuples representing the addresses of the root
servers, as defined by C{self.hints}.
c S s g | ]}|t jfqS r )r PORT).0ipr r r
M s z#Resolver._roots..)r )r
r r r _rootsH s zResolver._rootsc C s2 | 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 )r r queryUDP addCallback
filterAnswers)r
queryr$ timeoutfilterrdr r r _queryO s
zResolver._queryc C s, |du rd}| 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) - )_discoverAuthorityr Queryr# r )r
nameclstyper) r r r _lookupn s
zResolver._lookupc C s@ |dkr t tdS | |||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.
r z"Query limit reached without resultFr. )r r
ResolverErrorr- r& _discoveredAuthority)r
r( r$ r) queriesLeftr, r r r r2 | s
zResolver._discoverAuthorityc s |j tjkrt|j |S i |jD ] }|jg | qfdd}t }j}d} |
| | ||j j } | du rj|jkrJn>
tt|j j }
fdd} |
| |
S | j j krx|j|j|jfS | jj|v rtd| jj}q1i } |jD ]}
|
j tjkr|
j | |
jj< qg }g }|jD ]!}
|
j tjkr|
jjj}|| v r|| | tjf q|| q|r҈
|S |r|d }
d d
}|
| |
fd d |
S ttd
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.
c sF d } | g D ]}|j|kr |j|kr| S |jtjkr |}q|S r )getr5 r6 r CNAME)r4 r6 r5 cnamerecord)recordsr r findAnswerOrCName s
z8Resolver._discoveredAuthority..findAnswerOrCNameNTc s | \}}}| d |||fS Nr )insertresultsanswers authority
additional)previousr r
cbResolved s
z1Resolver._discoveredAuthority..cbResolvedzCycle in CNAME processingr c S s | \}}}|d j S rA )payload
dottedQuadrC r r r
getOneAddress s
z4Resolver._discoveredAuthority..getOneAddressc s | tjfg d S )Nr. )r2 r r )hint)r: r( r
r) r r s z/Resolver._discoveredAuthority..z/Stuck at response without answers or delegation) rCoder OKr exceptionForCoderE
setdefaultr4 appendsetaddr6 r5 r2 r3 strr# r& rF rG rJ r r8 ArK NSr
lookupAddress)r
responser( r) r: answerr@ seenr4 r> r, rI addressesrrr trapsnsrL r )rH r: r( r? r
r) r r9 st
%
z Resolver._discoveredAuthority)r NN)
r r r r r r# r- r7 r2 r9 r r r r r s
r c s fdd}|S )Nc s fdd S )Nc s t | i S r )getattr)r+ )r kwr4 r r rN s z6makePlaceholder..placeholder..)r& r rb deferredr4 rc r placeholder s z$makePlaceholder..placeholderr )re r4 rf r rd r makePlaceholder s rg c @ s$ e Zd Zdd Zdd Zdd ZdS )DeferredResolverc C s g | _ || j d S r )waitingr& gotRealResolver)r
resolverDeferredr r r r s zDeferredResolver.__init__c C s. | j }|j| _|j| _|D ]}|| q
d S r )ri __dict__ __class__callback)r
resolverwr, r r r rj s z DeferredResolver.gotRealResolverc C s: | ds |dv r| jt t| jd |S t|)Nlookup)
getHostByNamer( )
startswithri rS r Deferredrg AttributeError)r
r4 r r r __getattr__% s z DeferredResolver.__getattr__N)r r r r rj rw r r r r rh s rh Nc sP dd t dD } 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.
c S s g | ]
}t td | qS )a)chrord)r ir r r r" @ z bootstrap..
c s g | ] } d | qS )z%s.root-servers.net)rr )r r, )ro r r r" A s T)
consumeErrorsc s t dd | D dS )Nc S s g | ]
}|d r|d qS )r r. r )r er r r r" F r| z4bootstrap..buildResolver..)r r r )res)r r r
buildResolverD s z bootstrap..buildResolver)ranger DeferredListr& rh )ro r domainsLr, r r )ro r r bootstrap, s
r r )r twisted.internetr
twisted.namesr r r twisted.python.failurer r r r rg rh r r r r r s r