/usr/lib/python3.9/site-packages/dns/__pycache__
Edit: /usr/lib/python3.9/site-packages/dns/__pycache__/asyncresolver.cpython-39.pyc (13002B)
a
MeE @ s d Z ddlZddlZddlmZmZmZmZmZ ddl Z
ddl Z
ddl Z
ddl
Z
ddlZ
ddlZ
ddlZ
ddlZ
ddlZ
ddlmZmZmZmZ e
jjZe
jjZG dd de
j j Z da e ddd Z ddd
d Z!e
j"j#e
j$j%d dd
ddddf ee
j&j'e(f ee
j"j)e(f ee
j$j*e(f e+ee( e+e,ee- ee+ ee
j.j/ e
j j0d ddZ1e(eee
j j0dddZ2ej3fee
j&j'e(f e,ee
j j4dddZ5ee
j&j'e(f e
j&j'dddZ6d(e-ddd d Z7e
j$j%d ddfee
j&j'e(f e
j$j*e+ee ee
j.j/ e
j&j'd d d Z8d!ej3dfee
j&j'e(f e,e,ee e d"d#d$Z9e
j"j#e
j$j%d dd
ddddd!ej3df ee
j&j'e(f ee
j&j'e(f ee
j"j)e(f ee
j$j*e(f e+ee( e+e,ee- ee+ ee
j.j/ e,e,ee e
j j0d%d&d'Z:dS )) Asynchronous DNS stub resolver. N)AnyDictListOptionalUnion)NXDOMAINNoAnswer NoRootSOA NotAbsolutec
@ s e Zd ZdZejjejjdddddddf e ej
j e f e ejj
e f e ejje f eee eeee ee eejj ejjd ddZe eeejjd d
d Zejfe ej
j e f eeejj d d
dZ e ej
j e f ej
j dddZ deddddZ dS )Resolverr FNTr qnamerdtyperdclasstcpsourceraise_on_no_answer source_portlifetimesearchbackendreturnc
s t j| |||||| } |
s&t j }
t } | \}
}|durF|S |
dusRJ d}|s.| \}}}|r||
|I dH | | || j
}z |j |
|||||
dI dH }W n@ t y } z(|
d|\}}W Y d}~qVW Y d}~n
d}~0 0 |
|d\}}|durV|S qVq.dS )a Query nameservers asynchronously to find the answer to the question.
*backend*, a ``dns.asyncbackend.Backend``, or ``None``. If ``None``,
the default, then dnspython will use the default backend.
See :py:func:`dns.resolver.Resolver.resolve()` for the
documentation of the other parameters, exceptions, and return
type of this method.
NF)timeoutr r Zmax_sizer )dnsresolverZ _Resolution asyncbackendZget_default_backendtimeZ next_requestZnext_nameserversleep_compute_timeouterrorsZ async_query ExceptionZ query_result)selfr r r r r r r r r r Z
resolutionstartZrequestanswerZdone
nameserverZbackoffr responseex_ r) 5/usr/lib/python3.9/site-packages/dns/asyncresolver.pyresolve- s>
"zResolver.resolveipaddrargskwargsr c sL i }| | tjj|d< tjj|d< | jtj|g|R i |I dH S )a Use an asynchronous resolver to run a reverse query for PTR
records.
This utilizes the resolve() method to perform a PTR lookup on the
specified IP address.
*ipaddr*, a ``str``, the IPv4 or IPv6 address you want to get
the PTR record for.
All other arguments that can be passed to the resolve() function
except for rdtype and rdclass are also supported by this
function.
r r N) updater rdatatypeZPTR
rdataclassINr+ Z reversenameZ from_address)r" r- r. r/ modified_kwargsr) r) r* resolve_addressn s
zResolver.resolve_addressnamefamilyr/ r c sX i }| | |dd tjj|d< |tjkr^| j|tjj fi |I dH }tj
j j |dS |tj
kr| j|tjjfi |I dH }tj
j j |dS |tjkrtd| |dd}|d d}t } | j|tjjfd
| | |d |I dH }|j}| j|tjj fd
| | |d |I dH }tj
j j ||| d }
|
sTt|jd
|
S )a Use an asynchronous resolver to query for address records.
This utilizes the resolve() method to perform A and/or AAAA lookups on
the specified name.
*qname*, a ``dns.name.Name`` or ``str``, the name to resolve.
*family*, an ``int``, the address family. If socket.AF_UNSPEC
(the default), both A and AAAA records will be retrieved.
All other arguments that can be passed to the resolve() function
except for rdtype and rdclass are also supported by this
function.
r Nr )v4)v6zunknown address family r Tr F)r r )r: r9 Z add_empty)r& )r0 popr r2 r3 socketZAF_INETr+ r1 Ar HostAnswersZmakeZAF_INET6ZAAAA AF_UNSPECNotImplementedErrorr r r r r& ) r" r7 r8 r/ r4 r9 r: r r r# answersr) r) r* resolve_name sP
zResolver.resolve_namer7 r c
sR z | j |ddI dH }|j}W n. tjjyL } z|j}W Y d}~n
d}~0 0 |S )a Determine the canonical name of *name*.
The canonical name is the name the resolver uses for queries
after all CNAME and DNAME renamings have been applied.
*name*, a ``dns.name.Name`` or ``str``, the query name.
This method can raise any exception that ``resolve()`` can
raise, other than ``dns.resolver.NoAnswer`` and
``dns.resolver.NXDOMAIN``.
Returns a ``dns.name.Name``.
F)r N)r+ canonical_namer r r )r" r7 r$ rD er) r) r* rD s
zResolver.canonical_name @)r r c st z\t | }| jtjjd|dI dH }tj|}tj||I dH }t|dkrZ|| _ W n t
yn Y n0 dS )a Try to update the resolver's nameservers using Discovery of Designated
Resolvers (DDR). If successful, the resolver will subsequently use
DNS-over-HTTPS or DNS-over-TLS for future queries.
*lifetime*, a float, is the maximum time to spend attempting DDR. The default
is 5 seconds.
If the SVCB query is successful and results in a non-empty list of nameservers,
then the resolver's nameservers are set to the returned servers in priority
order.
The current implementation does not use any address hints from the SVCB record,
nor does it resolve addresses for the SCVB target name, rather it assumes that
the bootstrap nameserver will always be one of the addresses and uses it.
A future revision to the code may offer fuller support. The code verifies that
the bootstrap nameserver is in the Subject Alternative Name field of the
TLS certficate.
Zsvcb)r Nr ) r r+ r Z_ddrZ_local_resolver_namequeryZ
_remainingZ_get_nameservers_asynclen nameserversr! )r" r Z
expirationr$ r rI r) r) r* try_ddr s
zResolver.try_ddr)rF ) __name__
__module__ __qualname____doc__r r1 r= r2 r3 r r7 Namestr RdataType
RdataClassboolr intfloatr Backendr Answerr+ r r5 r< r? r> rB rD rJ r) r) r) r* r * sF
B E r )r c C s t du rt t dusJ t S )zDGet the default asynchronous resolver, initializing it if necessary.N)default_resolverreset_default_resolverr) r) r) r* get_default_resolver s rZ c C s
t adS )zRe-initialize default asynchronous resolver.
Note that the resolver configuration (i.e. /etc/resolv.conf on UNIX
systems) will be re-read immediately.
N)r rX r) r) r) r* rY s rY FTr
c
s$ t | |||||||||
I dH S )a
Query nameservers asynchronously to find the answer to the question.
This is a convenience function that uses the default resolver
object to make the query.
See :py:func:`dns.asyncresolver.Resolver.resolve` for more
information on the parameters.
N)rZ r+ )
r r r r r r r r r r r) r) r* r+ s r+ r, c s t j| g|R i |I dH S )zUse a resolver to run a reverse query for PTR records.
See :py:func:`dns.asyncresolver.Resolver.resolve_address` for more
information on the parameters.
N)rZ r5 )r- r. r/ r) r) r* r5 = s r5 r6 c s t j| |fi |I dH S )zUse a resolver to asynchronously query for address records.
See :py:func:`dns.asyncresolver.Resolver.resolve_name` for more
information on the parameters.
N)rZ rB )r7 r8 r/ r) r) r* rB I s rB rC c s t | I dH S )zDetermine the canonical name of *name*.
See :py:func:`dns.resolver.Resolver.canonical_name` for more
information on the parameters and possible exceptions.
N)rZ rD )r7 r) r) r* rD U s rD rF )r r c s t | I dH S )a Try to update the default resolver's nameservers using Discovery of Designated
Resolvers (DDR). If successful, the resolver will subsequently use
DNS-over-HTTPS or DNS-over-TLS for future queries.
See :py:func:`dns.resolver.Resolver.try_ddr` for more information.
N)rZ rJ )r r) r) r* rJ _ s rJ )r7 r r r r r c s t | tr tj| tjj} |du r*t }| s:t| zB|j | tj
j |||dI dH }|j dushJ |j j| krz| W S W n t
tfy Y n0 z | } W q: tjjy tY q:0 q:dS )zFind the name of the zone which contains the specified name.
See :py:func:`dns.resolver.Resolver.zone_for_name` for more
information on the parameters and possible exceptions.
N)r )
isinstancerP r r7 Z from_textrootrZ is_absoluter r+ r1 ZSOAZrrsetr r parentZNoParentr
)r7 r r r r r$ r) r) r*
zone_for_namei s&
r_ 5 )whereportr8 r r c s |du rt }g }t| tr>tj| r>|tj| | n4| | |I dH }|
D ]}|tj|| qXtj j dd}||_
|S )a Make a stub resolver using the specified destination as the full resolver.
*where*, a ``dns.name.Name`` or ``str`` the domain name or IP address of the
full resolver.
*port*, an ``int``, the port to use. If not specified, the default is 53.
*family*, an ``int``, the address family to use. This parameter is used if
*where* is not an address. The default is ``socket.AF_UNSPEC`` in which case
the first address returned by ``resolve_name()`` will be used, otherwise the
first address of the specified family will be used.
*resolver*, a ``dns.asyncresolver.Resolver`` or ``None``, the resolver to use for
resolution of hostnames. If not specified, the default resolver will be used.
Returns a ``dns.resolver.Resolver`` or raises an exception.
NF)Z configure)rZ r[ rP r ZinetZ
is_addressappendr% ZDo53NameserverrB Z addressesZ
asyncresolverr rI )ra rb r8 r rI rA Zaddressresr) r) r* make_resolver_at s re )ra r r r r r r r r r r rb r8 r r c s6 t | | | |
I dH }|||||||||| |
I dH S )a Query nameservers to find the answer to the question.
This is a convenience function that calls ``dns.asyncresolver.make_resolver_at()``
to make a resolver, and then uses it to resolve the query.
See ``dns.asyncresolver.Resolver.resolve`` for more information on the resolution
parameters, and ``dns.asyncresolver.make_resolver_at`` for information about the
resolver parameters *where*, *port*, *family*, and *resolver*.
If making more than one query, it is more efficient to call
``dns.asyncresolver.make_resolver_at()`` and then use that resolver for the queries
instead of calling ``resolve_at()`` multiple times.
N)re r+ )ra r r r r r r r r r r rb r8 r rd r) r) r*
resolve_at s rf )rF );rN r< r typingr r r r r Zdns._ddrr Zdns.asyncbackendZdns.asyncqueryZ
dns.exceptionZdns.nameZ dns.queryZdns.rdataclassZ
dns.rdatatypeZ dns.resolverr r r
r Z
asyncqueryZudpZ_udpr Z_tcpr Z BaseResolverr rX rZ rY r1 r= r2 r3 r7 rO rP rQ rR rS rT rU r rV rW r+ r5 r? r> rB rD rJ r_ re rf r) r) r) r*
s [
$
& (