a
MeP @ s U d Z ddlZddlZddlZddlZddlZddlZddlZddlm Z m
Z
m Z m Z m
Z
mZmZmZ ddlmZ ddlZddlZddlZddlZddlZddlZddlZddlZddl Zddl Zddl Zddl Zddl Zddl!Zddl"Zddl#Zddl$Zej%dkrddl&ZG dd dej'j(Z)G dd d ej'j(Z*ee
e+ e,e-ee.e+f e
ej/j0 f Z1e e1 e e+ d
d d Z2G d
d dej'j3Z4e4Z3G dd dej'j(Z5G dd dej'j(Z6G dd dej'j(Z7G dd dej'j(Z8G dd dej'j(Z9G dd dej'j(Z:G dd d Z;G d d d e<Z=G d d d e=Z>G d!d" d"Z?G d#d$ d$Z@eejAjBejCjDejEjFf ZGG d%d& d&e@ZHG d'd( d(ZIG d)d* d*e@ZJG d+d, d,ZKG d-d. d.ZLG d/d0 d0eLZMdaNe
eM eOd1< eMd2d3d4ZPdd2d5d6ZQejCjRejEjSd7dd8dddfeejAjBe+f eejCjDe+f eejEjFe+f e,e
e+ e,e-e
eT e
e, e;d9
d:d;ZUejCjRejEjSd7dd8ddfeejAjBe+f eejCjDe+f eejEjFe+f e,e
e+ e,e-e
eT e;d< d=d>ZVe+e e e;d?d@dAZWejXfeejAjBe+f e-e e>dBdCdDZYeejAjBe+f ejAjBdEdFdGZZdgeTddIdJdKZ[ejEjSd7ddfeejAjBe+f ejEjFe,e
eM e
eT ejAjBdLdMdNZ\dOejXdfeejAjBe+f e-e-e
eM eMdPdQdRZ]ejCjRejEjSd7dd8ddddOejXdf eejAjBe+f eejAjBe+f eejCjDe+f eejEjFe+f e,e
e+ e,e-e
eT e
e, e-e-e
eM e;dSdTdUZ^ej_ej`gejaejbgiZcdadejeZfejgZhejiZjejkZlejmZnejoZpddejXdddfdVdWZqdhdXdYZrdidZd[Zsd\d] Ztd^d_ Zud`da Zvdje
eM ddbdcddZwdd2dedfZxdS )kDNS stub resolver. N)AnyDictIteratorListOptionalSequenceTupleUnion)urlparsewin32c st e Zd ZdZddhZdZ fddZdddZed fd
d Z e
d d
Z dd Z dd Z
dd Zdd Z ZS )NXDOMAINz"The DNS query name does not exist.qnames responsesNc s t j|i | d S Nsuper__init__selfargskwargs __class__ 0/usr/lib/python3.9/site-packages/dns/resolver.pyr > s zNXDOMAIN.__init__c C s\ t |tttfstdt|dkr,td|d u r:i }nt |tsLtdt||d}|S )Nz#qnames must be a list, tuple or setr z(qnames must contain at least one elementz(responses must be a dict(qname=response)r r )
isinstancelisttuplesetAttributeErrorlendict)r r r r r r r
_check_kwargsA s
zNXDOMAIN._check_kwargsreturnc sP d| j vrt S | j d }t|dkr0d}nd}dtt|}d||S )Nr z None of DNS query names existz!The DNS query name does not existz, z{}: {})r r __str__r" joinmapstrformat)r r msgr r r r( M s
zNXDOMAIN.__str__c C sp d| j vrtd| j d D ]D}| j d | }z | }||krJ|W S W q ty^ Y q 0 q | j d d S )z%Return the unresolved canonical name.r z parametrized exception requiredr r )r TypeErrorcanonical_name Exception)r qnameresponsecnamer r r r/ X s
zNXDOMAIN.canonical_namec C sx t | jdg }t| jdi }|jdi }|jdg D ]*}||vrV|| ||v r@|| ||< q@t||dS )z3Augment by results from another NXDOMAIN exception.r r r )r r getr# appendr
)r Ze_nxZqnames0Z
responses0Z
responses1Zqname1r r r __add__i s
zNXDOMAIN.__add__c C s
| j d S )zXAll of the names that were tried.
Returns a list of ``dns.name.Name``.
r r r r r r r u s zNXDOMAIN.qnamesc C s
| j d S )zA map from queried names to their NXDOMAIN responses.
Returns a dict mapping a ``dns.name.Name`` to a
``dns.message.Message``.
r r7 r8 r r r r | s zNXDOMAIN.responsesc C s | j d | S )zTThe response for query *qname*.
Returns a ``dns.message.Message``.
r r7 )r r1 r r r r2 s zNXDOMAIN.response)N)__name__
__module__ __qualname____doc__ supp_kwargsfmtr r$ r+ r( propertyr/ r6 r r r2
__classcell__r r r r r
4 s
r
c @ s e Zd ZdZdS )YXDOMAINz8The DNS query name is too long after DNAME substitution.Nr9 r: r; r< r r r r rA s rA )errorsr& c C s, g }| D ] }| d|d |d q|S )z3Turn a resolution errors trace into a list of text.zServer {} answered {}r )r5 r, )rC Ztextserrr r r _errors_to_text s rF c sH e Zd ZdZdZdedd ZddhZ fddZ fd d
Z Z S ) LifetimeTimeoutz The resolution lifetime expired.z(%s after {timeout:.3f} seconds: {errors}NtimeoutrC c s t j|i | d S r r r r r r r s zLifetimeTimeout.__init__c s& t |d }t j|d d|dS )NrC rI ; rI rC )rF r _fmt_kwargsr) r r Zsrv_msgsr r r rL s zLifetimeTimeout._fmt_kwargs
r9 r: r; r< r- r> r= r rL r@ r r r r rG s rG c s> e Zd ZdZdZdhZ fddZ fddZdd Z Z S )
NoAnswerz r= r rL r2 r@ r r r r rO s rO c sH e Zd ZdZdZdedd ZddhZ fdd Z fd
d Z Z S )
NoNameserverszAll nameservers failed to answer the query.
errors: list of servers and respective errors
The type of errors is
[(server IP address, any object convertible to string)].
Non-empty errors list will add explanatory message ()
z+All nameservers failed to answer the query.z%s {query}: {errors}NrH requestrC c s t j|i | d S r r r r r r r s zNoNameservers.__init__c s( t |d }t j|d jd|dS )NrC rS rJ )rP rC )rF r rL rQ r) rM r r r rL s zNoNameservers._fmt_kwargsrN r r r r rR s rR c @ s e Zd ZdZdS ) NotAbsolutezEAn absolute domain name is required but a relative name was provided.NrB r r r r rT s rT c @ s e Zd ZdZdS ) NoRootSOAzBThere is no SOA RR at the DNS root name. This should never happen!NrB r r r r rU s rU c @ s e Zd ZdZdS )
NoMetaqueriesz DNS metaqueries are not allowed.NrB r r r r rV s rV c @ s e Zd ZdZdS )NoResolverConfigurationzEResolver configuration could not be read or specified no nameservers.NrB r r r r rW s rW c @ sr e Zd ZdZdejjejjej j
ej j e
e e
e ddddZdd Zedd d
Zd d Zd
d Zdd ZdS )Answera& DNS stub resolver answer.
Instances of this class bundle up the result of a successful DNS
resolution.
For convenience, the answer object implements much of the sequence
protocol, forwarding to its ``rrset`` attribute. E.g.
``for a in answer`` is equivalent to ``for a in answer.rrset``.
``answer[i]`` is equivalent to ``answer.rrset[i]``, and
``answer[i:j]`` is equivalent to ``answer.rrset[i:j]``.
Note that CNAMEs or DNAMEs in the response may mean that answer
RRset's name might not be the query name.
N)r1 rdtyperdclassr2
nameserverportr& c C sX || _ || _|| _|| _|| _|| _| | _| jj| _| jj | _
t | jj | _
d S r )r1 rY rZ r2 r[ r\ Zresolve_chainingZchaining_resultr/ answerrrsettimeZ minimum_ttl
expiration)r r1 rY rZ r2 r[ r\ r r r r s
zAnswer.__init__c C s\ |dkr| j jS |dkr | j jS |dkr0| j jS |dkr@| j jS |dkrP| j jS t|d S )NnamettlcoversrZ rY )r^ ra rb rc rZ rY r! )r attrr r r __getattr__ s zAnswer.__getattr__r% c C s | j rt| j pdS Nr )r^ r" r8 r r r __len__) s zAnswer.__len__c C s | j rt| j ptt S r )r^ iterr r8 r r r __iter__, s zAnswer.__iter__c C s | j d u rt| j | S r r^
IndexErrorr ir r r __getitem__/ s
zAnswer.__getitem__c C s | j d u rt| j |= d S r rj rl r r r __delitem__4 s
zAnswer.__delitem__)NN)r9 r: r; r< dnsra Name rdatatype RdataType
rdataclass
RdataClassmessage QueryMessager r+ intr re rg ri rn ro r r r r rX s" rX c @ s e Zd ZdZdS )Answersz5A dict of DNS stub resolver answers, indexed by type.NrB r r r r ry : s ry c @ s e Zd ZdZedee ee ed dddZe j
fe e e
ee f ddd Ze j
fe e e dd
d Zejjd d
dZdS ) HostAnswerszTA dict of DNS stub resolver answers to a host name lookup, indexed by
type.
NT)v6v4 add_emptyr& c C sF t }|d ur$|s|jr$||tjj< |d urB|s6|jrB||tjj< |S r )rz r^ rp rr AAAAA)clsr{ r| r} answersr r r makeC s zHostAnswers.make)familyr& c c s |t jkr2| t jE d H | t jE d H d S |t jkrL| tjj}n(|t jkrf| tjj }nt
d| |r|D ]}|j |fV q|d S )Nunknown address family ) socket AF_UNSPECaddresses_and_familiesAF_INET6AF_INETr4 rp rr r~ r NotImplementedErroraddress)r r r] Zrdatar r r r S s
z"HostAnswers.addresses_and_familiesc C s dd | |D S )Nc s s | ]}|d V qdS )r Nr ).0Zpairr r r g z(HostAnswers.addresses..)r )r r r r r addressesf s zHostAnswers.addressesr% c C s | tjj| tjj}|jS r )r4 rp rr r~ r r/ )r r] r r r r/ j s zHostAnswers.canonical_name)NNT)r9 r: r; r< classmethodr rX boolr r r rx r r r+ r r rp ra rq r/ r r r r rz > s$ rz c @ s@ e Zd ZdZd eeddddZdddd Zd dd
d ZdS )
CacheStatisticszCache Statisticsr N)hitsmissesr& c C s || _ || _d S r r r )r r r r r r r r s zCacheStatistics.__init__r% c C s d| _ d| _d S rf r r8 r r r resetv s zCacheStatistics.resetc C s t | j| jS r )r r r r8 r r r clonez s zCacheStatistics.clone)r r )r9 r: r; r< rx r r r r r r r r o s r c @ sR e Zd ZddddZddddZedddZedd d
Zedd d Z dS )
CacheBaseNr% c C s t | _t | _d S r ) threadingLocklockr
statisticsr8 r r r r s
zCacheBase.__init__c C s4 | j | j W d n1 s&0 Y dS )z Reset all statistics to zero.N)r r r r8 r r r reset_statistics s zCacheBase.reset_statisticsc C s2 | j | jjW d S 1 s$0 Y dS )z How many hits has the cache had?N)r r r r8 r r r r s zCacheBase.hitsc C s2 | j | jjW d S 1 s$0 Y dS )z"How many misses has the cache had?N)r r r r8 r r r r s zCacheBase.missesc C s4 | j | j W d S 1 s&0 Y dS )zReturn a consistent snapshot of all the statistics.
If running with multiple threads, it's better to take a
snapshot than to call statistics methods such as hits() and
misses() individually.
N)r r r r8 r r r get_statistics_snapshot s z!CacheBase.get_statistics_snapshot)
r9 r: r; r r rx r r r r r r r r r ~ s
r c st e Zd ZdZdedd fdd
Zdddd Zeee d
d d Z
ee dd
ddZ dee dd
ddZ Z
S )Cachez$Simple thread-safe DNS answer cache. r@N)cleaning_intervalr& c s* t i | _|| _t | j | _dS )zf*cleaning_interval*, a ``float`` is the number of seconds between
periodic cleanings.
N)r r datar r_
next_cleaning)r r r r r r s
zCache.__init__r% c C sh t }| j|krdg }| j D ] \}}|j|kr || q |D ] }| j|= qBt }|| j | _dS )z&Clean the cache if it's time to do so.N)r_ r r itemsr` r5 r )r nowZkeys_to_deletekvr r r _maybe_clean s
zCache._maybe_cleankeyr& c C s | j n | | j|}|du s2|jt krR| j jd7 _W d dS | j jd7 _|W d S 1 sz0 Y dS aK Get the answer associated with *key*.
Returns None if no answer is cached for the key.
*key*, a ``(dns.name.Name, dns.rdatatype.RdataType, dns.rdataclass.RdataClass)``
tuple whose values are the query name, rdtype, and rdclass respectively.
Returns a ``dns.resolver.Answer`` or ``None``.
Nr' ) r r r r4 r` r_ r r r )r r r r r r r4 s z Cache.getr valuer& c C s< | j " | || j|< W d n1 s.0 Y dS a Associate key and value in the cache.
*key*, a ``(dns.name.Name, dns.rdatatype.RdataType, dns.rdataclass.RdataClass)``
tuple whose values are the query name, rdtype, and rdclass respectively.
*value*, a ``dns.resolver.Answer``, the answer.
N)r r r r r r r r r put s z Cache.putc C s\ | j B |dur$|| jv r:| j|= ni | _t | j | _W d n1 sN0 Y dS a2 Flush the cache.
If *key* is not ``None``, only that item is flushed. Otherwise the entire cache
is flushed.
*key*, a ``(dns.name.Name, dns.rdatatype.RdataType, dns.rdataclass.RdataClass)``
tuple whose values are the query name, rdtype, and rdclass respectively.
N)r r r_ r r )r r r r r flush s
z Cache.flush)r )N)r9 r: r; r< floatr r CacheKeyr rX r4 r r r@ r r r r r s
r c @ s6 e Zd ZdZdd Zd ddddZddd d
ZdS ) LRUCacheNodezLRUCache node.c C s" || _ || _d| _| | _| | _d S rf )r r r prevnextr r r r r s
zLRUCacheNode.__init__N)noder& c C s || _ |j| _| |j_ | |_d S r r r )r r r r r
link_after s zLRUCacheNode.link_afterr% c C s | j | j_ | j| j _d S r r r8 r r r unlink s
zLRUCacheNode.unlink)r9 r: r; r< r r r r r r r r s r c s e Zd ZdZdedd fdd
ZeddddZeee d d
d Z
eed d d
Z ee ddddZ dee dd ddZ
ZS )LRUCachea` Thread-safe, bounded, least-recently-used DNS answer cache.
This cache is better than the simple cache (above) if you're
running a web crawler or other process that does a lot of
resolutions. The LRUCache has a maximum number of nodes, and when
it is full, the least-recently used node is removed to make space
for a new one.
順 N)max_sizer& c s> t i | _| | tdd| _| j| j_| j| j_dS )zl*max_size*, an ``int``, is the maximum number of nodes to cache;
it must be greater than 0.
N)r r r set_max_sizer sentinelr r r r r r r r s
zLRUCache.__init__c C s |dk r d}|| _ d S )Nr' )r r r r r r s zLRUCache.set_max_sizer c C s | j | j|}|du r<| j jd7 _W d dS | |jjt kr~| j|j = | j jd7 _W d dS |
| j | j j d7 _ | j d7 _ |jW d S 1 s0 Y dS r )
r r r4 r r r r r` r_ r r r r r r r r r r r4 s
z LRUCache.getc C sr | j X | j|}|du s,|jjt krz t|}W qH ty: td| Y qH0 n
t|}|}|D ]~}t|dksT|d dksT|d dkrqT| }t|dk rqT|d dkr| |d qT|d dkrt
j |d | _
g | _qT|d d krg | _|dd
D ]}| j t
j | qqT|d d krT|dd
D ]}|d krBd
| _n|dkrV| nzd|v rzt|dd | _W n ttfy Y n0 n |du s|du rd}n |du r"d}|| _ || _|| _|| _dS )a Configure EDNS behavior.
*edns*, an ``int``, is the EDNS level to use. Specifying
``None``, ``False``, or ``-1`` means "do not use EDNS", and in this case
the other parameters are ignored. Specifying ``True`` is
equivalent to specifying 0, i.e. "use EDNS0".
*ednsflags*, an ``int``, the EDNS flag values.
*payload*, an ``int``, is the EDNS sender's payload field, which is the
maximum size of UDP datagram the sender can handle. I.e. how big
a response to this message can be.
*options*, a list of ``dns.edns.Option`` objects or ``None``, the EDNS
options.
NFrH Tr )r r r r )r r r r r r r r r o s zBaseResolver.use_edns)r r& c C s
|| _ dS )zkOverrides the default flags with your own.
*flags*, an ``int``, the message flags to use.
N)r )r r r r r set_flags s zBaseResolver.set_flags)r r default_portr& c C s g }t |tr|D ]}t |tjjr*|}nntj|rR|||}tj||}nFzt |j
dkrft W n" t y t
d| dY n0 tj|}|| qnt
dt||S )Nhttpsz nameserver z\ is not a dns.nameserver.Nameserver instance or text form, IP address, nor a valid https URLz.nameservers must be a list or tuple (not a {}))r r rp r[ r inet
is_addressr4 Do53Nameserverr schemer r0 r Z
DoHNameserverr5 r, type)r r r r! Zenriched_nameserversr[ Zenriched_nameserverr\ r r r r s2
z BaseResolver._enrich_nameserversc C s | j S r )r r8 r r r r s zBaseResolver.nameservers)r r& c C s | || j| j || _dS )a
*nameservers*, a ``list`` of nameservers, where a nameserver is either
a string interpretable as a nameserver, or a ``dns.nameserver.Nameserver``
instance.
Raises ``ValueError`` if *nameservers* is not a list of nameservers.
N)r r r\ r )r r r r r r s )r T)NN))r9 r: r; r< rp ra rq __annotations__r r+ rx r r r r r r
r ZOptionr r[ r r r r r
ErrorTupler r r r r rv ZDEFAULT_EDNS_PAYLOADr r r r r? r setterr r r r r s
G
, !
%r c @ sH e Zd ZdZejjejjddddddfe ej
j e f e ejj
e f e ejje f eee eeee ee ed
ddZejjejjdddddfe ej
j e f e ejj
e f e ejje f eee eeee ed d
d Ze eeed d
dZejfe ej
j e f eeedddZe ej
j e f ej
j dddZ deddddZ dS )Resolverr FNTr
r1 rY rZ r sourcer source_portr r r& c
C s t | |||||| }
t } |
\} }
|
dur4|
S d}|s |
\}}}|rXt| | | ||
j}z|j| ||||d}W n@ ty } z(|
d|\}}W Y d}~q8W Y d}~n
d}~0 0 |
|d\}
}|
dur8|
S q8q dS )a Query nameservers to find the answer to the question.
The *qname*, *rdtype*, and *rdclass* parameters may be objects
of the appropriate type, or strings that can be converted into objects
of the appropriate type.
*qname*, a ``dns.name.Name`` or ``str``, the query name.
*rdtype*, an ``int`` or ``str``, the query type.
*rdclass*, an ``int`` or ``str``, the query class.
*tcp*, a ``bool``. If ``True``, use TCP to make the query.
*source*, a ``str`` or ``None``. If not ``None``, bind to this IP
address when making queries.
*raise_on_no_answer*, a ``bool``. If ``True``, raise
``dns.resolver.NoAnswer`` if there's no answer to the question.
*source_port*, an ``int``, the port from which to send the message.
*lifetime*, a ``float``, how many seconds a query should run
before timing out.
*search*, a ``bool`` or ``None``, determines whether the
search list configured in the system's resolver configuration
are used for relative names, and whether the resolver's domain
may be added to relative names. The default is ``None``,
which causes the value of the resolver's
``use_search_by_default`` attribute to be used.
Raises ``dns.resolver.LifetimeTimeout`` if no answers could be found
in the specified lifetime.
Raises ``dns.resolver.NXDOMAIN`` if the query name does not exist.
Raises ``dns.resolver.YXDOMAIN`` if the query name is too long after
DNAME substitution.
Raises ``dns.resolver.NoAnswer`` if *raise_on_no_answer* is
``True`` and the query name exists but has no RRset of the
desired type and class.
Raises ``dns.resolver.NoNameservers`` if no non-broken
nameservers are available to answer the question.
Returns a ``dns.resolver.Answer`` instance.
NF)rI r- r. r )
r r_ r r sleepr rC rP r0 r )r r1 rY rZ r r- r r. r r Z
resolutionr rS r] Zdoner[ r rI r2 r _r r r resolve s6 ?
"zResolver.resolve r1 rY rZ r r- r r. r r& c C s* t jdtdd | ||||||||d S )a$ Query nameservers to find the answer to the question.
This method calls resolve() with ``search=True``, and is
provided for backwards compatibility with prior versions of
dnspython. See the documentation for the resolve() method for
further details.
z2please use dns.resolver.Resolver.resolve() insteadr
stacklevelTwarningswarnDeprecationWarningr1 ) r r1 rY rZ r r- r r. r r r r rP = s zResolver.queryipaddrr r r& c O sF i }| | tjj|d< tjj|d< | jtj|g|R i |S )a Use a 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.
rY rZ ) updaterp rr PTRrt r r1 reversename from_address)r r: r r modified_kwargsr r r resolve_address` s
zResolver.resolve_addressra r r r& c K s4 i }| | |dd tjj|d< |tjkrT| j|tjj fi |}t
j |dS |tj kr| j|tjj
fi |}t
j |dS |tjkrtd| |dd}|d d}t } | j|tjj
fd
| | |d |}|j}| j|tjj fd
| | |d |}t
j ||| d }
|
s0t|jd
|
S )a Use a 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.
rY NrZ )r| )r{ r r Tr F)r r )r{ r| r} r )r; r rp rt r r r r1 rr r rz r r r~ r r r_ r r1 rO r2 ) r ra r r r? r| r{ r r r r r r r resolve_namex sL
zResolver.resolve_namera r& c
C sL z| j |dd}|j}W n. tjjyF } 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)r1 r/ rp r r
)r ra r] r/ r r r r r/ s
zResolver.canonical_namer r r& c C sh zPt | }| jtjjd|d}tj|}tj||}t|dkrN|| _ W n t
yb 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.
ZSVCBr r N) r_ r1 rp Z_ddrZ_local_resolver_namerP Z
_remainingZ_get_nameservers_syncr" r r0 )r r r` r] rI r r r r try_ddr s
zResolver.try_ddr)r ) r9 r: r; r< rp rr r rt r r
ra rq r+ rs ru r r rx r rX r1 rP r r@ r r rz rB r/ rF r r r r r+ sb i # C r+ default_resolverr% c C s t du rt t S )z7Get the default resolver, initializing it if necessary.N)rG reset_default_resolverr r r r get_default_resolver s rI c C s
t adS )zRe-initialize default resolver.
Note that the resolver configuration (i.e. /etc/resolv.conf on UNIX
systems) will be re-read immediately.
N)r+ rG r r r r rH s rH FTr, c C s t | |||||||| S )zQuery nameservers to find the answer to the question.
This is a convenience function that uses the default resolver
object to make the query.
See ``dns.resolver.Resolver.resolve`` for more information on the
parameters.
)rI r1 ) r1 rY rZ r r- r r. r r r r r r1 s r1 r2 c
C s( t jdtdd t| |||||||d S )a Query nameservers to find the answer to the question.
This method calls resolve() with ``search=True``, and is
provided for backwards compatibility with prior versions of
dnspython. See the documentation for the resolve() method for
further details.
z)please use dns.resolver.resolve() insteadr r3 Tr5 )r1 rY rZ r r- r r. r r r r rP * s rP r9 c O s t j| g|R i |S )zUse a resolver to run a reverse query for PTR records.
See ``dns.resolver.Resolver.resolve_address`` for more information on the
parameters.
)rI r@ )r: r r r r r r@ K s r@ rA c K s t j| |fi |S )zUse a resolver to query for address records.
See ``dns.resolver.Resolver.resolve_name`` for more information on the
parameters.
)rI rB )ra r r r r r rB U s rB rC c C s t | S )zDetermine the canonical name of *name*.
See ``dns.resolver.Resolver.canonical_name`` for more information on the
parameters and possible exceptions.
)rI r/ ra r r r r/ a s r/ r rD c C s t | 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.
)rI rF rE r r r rF k s rF )ra rZ r r r r& c
C s t | tr tj| tjj} |du r*t }| s:t| t }|durT|| }nd}zT|dur||t }|dkrd}nd}|j
| tj j |||d}|j
j| kr| W S W n tjjtjjfyb } zt | tjjr| | }
n| }
|
rN|
jD ]P} | jtj j kr| j|kr| j| \} }
}
| tjjkr| j W Y d} ~ S qW Y d} ~ n
d} ~ 0 0 z | } W qX tjjy tY qX0 qXdS )a Find the name of the zone which contains the specified name.
*name*, an absolute ``dns.name.Name`` or ``str``, the query name.
*rdclass*, an ``int``, the query class.
*tcp*, a ``bool``. If ``True``, use TCP to make the query.
*resolver*, a ``dns.resolver.Resolver`` or ``None``, the resolver to use.
If ``None``, the default, then the default resolver is used.
*lifetime*, a ``float``, the total time to allow for the queries needed
to determine the zone. If ``None``, the default, then only the individual
query limits of the resolver apply.
Raises ``dns.resolver.NoRootSOA`` if there is no SOA RR at the DNS
root. (This is only likely to happen if you're using non-default
root servers in your network and they are misconfigured.)
Raises ``dns.resolver.LifetimeTimeout`` if the answer could not be
found in the allotted lifetime.
Returns a ``dns.name.Name``.
Nr rE ) r r+ rp ra r r
rI r rT r_ r1 rr ZSOAr^ r r
rO r r4 r2 Z authorityrY rZ Z fullcompareZNAMERELN_SUPERDOMAINparentZNoParentrU )ra rZ r r r r r` Z rlifetimer] r r2 Zrrsnrr0 r r r
zone_for_nameu sF
. rM r )wherer\ r r r& c C s |du rt }g }t| tr>tj| r>|tj| | n*| | |
D ]}|tj|| qNtj 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.resolver.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)r )rI r r+ rp r# r$ r5 r[ r% rB r r r+ r )rN r\ r r r r resr r r make_resolver_at s rP )rN r1 rY rZ r r- r r. r r r\ r r r& c
C s$ t | |
| | ||||||||| S )a} Query nameservers to find the answer to the question.
This is a convenience function that calls ``dns.resolver.make_resolver_at()`` to
make a resolver, and then uses it to resolve the query.
See ``dns.resolver.Resolver.resolve`` for more information on the resolution
parameters, and ``dns.resolver.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.resolver.make_resolver_at()`` and then use that resolver for the queries
instead of calling ``resolve_at()`` multiple times.
)rP r1 )
rN r1 rY rZ r r- r r. r r r\ r r r r r
resolve_at s rQ c C sT |t j@ dkr t| |||||S |t jt jB @ dkrBt t jd| d u r`|d u r`t t jdg }d }| d u rt| |||||S z tj
| t| |||||W S t y Y n0 z&t
| |}| }| d}W nF tjjy t t jdY n" t y" t t jdY n0 d } z |d u r:d} nt|} W nH t y |t j@ dkrzt |} W n t y Y n0 Y n0 | d u rt t jdg }
|dkrt jt jg} n|g} |t j@ dkr|} nd} |D ]L\}
}| D ]<}t| D ],}tj |
| f|}|
|||| |f qqqt |
dkrPt t jd|
S )Nr z*Non-recoverable failure in name resolutionName or service not knownTz$Temporary failure in name resolution ) r ZAI_NUMERICHOST_original_getaddrinfoZ
AI_ADDRCONFIGZ AI_V4MAPPEDgaierrorZEAI_FAIL
EAI_NONAMErp r# Zaf_for_addressr0 _resolverrB r r/ r r r
Z EAI_AGAINrx ZAI_NUMERICSERVZ
getservbyname
SOCK_DGRAM SOCK_STREAM AI_CANONNAME_protocols_for_socktypeZlow_level_address_tupler5 r" )hostservicer Zsocktypeprotor Zaddrsr/ r r\ tuplesZ socktypesr3 addrafZ
addr_tupler r r _getaddrinfo* sj
rb c
C sf | d }| d }t | dkr,| d }tj}n
d }tj}t|||tjtjd}t |dkrbtd|d d d }|tj@ rd}nd}t j
|} |tj @ dkr z"t
| d}
|
jd jd } W nV t jjt jjfy |tj@ rttjd
|} |d ur| d t| 7 } Y n0 n |} |d ur<| d t| 7 } |tj@ rRt|} n t||} | | fS ) Nr r' rD z'sockaddr resolved to multiple addressesZudpr r< TrR %)r" r r r rb rY SOL_TCPerrorZNI_DGRAMrp r= r> ZNI_NUMERICHOSTrW r1 r^ targetr r r
rO NI_NAMEREQDrU rV r+ ZNI_NUMERICSERVZ
getservbyport)
sockaddrr r\ r\ Zscoper r_ r` Zpnamer1 r] hostnamer] r r r _getnameinfo~ s@
rk c C s: | d u rt } zt| \} }}W n ty4 Y n0 | S r )r r _gethostbyaddrr0 )ra r0 r r r _getfqdn s rm c C s t | d d S )Nr r )_gethostbyname_exrJ r r r _gethostbyname s ro c C sT g }g }t | dtjtjtjtj}|d d }|D ]}||d d q2|||fS )Nr rD rc )rb r r rY re rZ r5 )ra aliasesr r_ canonicalitemr r r rn s rn c
C s z"t j| | dddf}tj}W nR tyt zt j| W n ty` ttjdY n0 | df}tj }Y n0 t
|tj \}}g }g }t |d|tj
tjtj}|d d }t j|| } |D ]0}
|
d d } t j|| } | | kr|| q|||fS )NP r rR rD rc )rp Zipv6Z inet_atonr r r0 Zipv4rU rV r rk rh rb rY re rZ r# Z inet_ptonr5 )
Zipri r ra r0 rp r r_ rq Zbin_iprr r` Zbin_addrr r r rl s2
rl )r r& c C s: | du rt } | att_tt_tt_t t_
t t_ t
t_dS )a Override the system resolver routines in the socket module with
versions which use dnspython's resolver.
This can be useful in testing situations where you want to control
the resolution behavior of python code without having to change
the system's resolver settings (e.g. /etc/resolv.conf).
The resolver to use may be specified; if it's not, the default
resolver will be used.
resolver, a ``dns.resolver.Resolver`` or ``None``, the resolver to use.
N)rI rW rb r getaddrinfork getnameinform getfqdnro
gethostbynamern gethostbyname_exrl
gethostbyaddr)r r r r override_system_resolver s rz c C s, da tt_tt_tt_tt_ t
t_ t t_
dS )z5Undo the effects of prior override_system_resolver().N)rW rT r rt _original_getnameinforu _original_getfqdnrv _original_gethostbynamerw _original_gethostbyname_exrx _original_gethostbyaddrry r r r r restore_system_resolver s r )r )r )N)N)yr< r r r r r r_ r6 typingr r r r r r r r
urllib.parser Zdns._ddrrp Zdns.ednsZ
dns.exceptionZ dns.flagsZdns.inetZdns.ipv4Zdns.ipv6Z dns.messageZdns.nameZdns.nameserverZ dns.queryZ dns.rcodeZdns.rdataclassZ
dns.rdatatypeZdns.rdtypes.svcbbaseZdns.reversenameZdns.tsigr Z
dns.win32utilr Z DNSExceptionr
rA r+ r rx r0 rv r r) rF ZTimeoutrG rO rR rT rU rV rW rX r# ry rz r r ra rq rr rs rt ru r r r r r r r+ rG r( rI rH r r r r1 rP r@ r rB r/ rF rM rP rQ rX ZSOL_UDPrY re r[ rW rt rT ru r{ rv r| rw r} rx r~ ry r rb rk rm ro rn rl rz r r r r r sl ( X
E1 Oo U !
# !
W ' /
T
'