/usr/lib/python3.9/site-packages/dns/__pycache__
Edit: /usr/lib/python3.9/site-packages/dns/__pycache__/asyncquery.cpython-39.pyc (17817B)
a
Meh @ sf d Z ddlZddlZddlZddlZddlZddlmZmZm Z m
Z
m Z ddl Z
ddlZ
ddlZ
ddlZ
ddlZ
ddlZ
ddlZ
ddlZ
ddlZ
ddlZ
ddlmZ ddlmZmZm Z m Z m Z m Z m Z m!Z!m"Z"m#Z# e"rddl$Z$e
j%j&Z'dd Z(d6dd Z)d7e
j*j+e e
j,j-e.f ee e/ e
e0e/f d
d d Z1d8e
j*j+e e e e/ e2e2e ee
j3j4e
j5j6f e e. e2e2e2e e
j,j- ed ddZ7d9e
j,j-e8e e/ e0e e8 e0e2e2e2e2e e
j*j+ e e
j*j9 e2e
j,j-dddZ:d:e
j,j-e8e e/ e0e e8 e0e2e2e2e e
j*j+ e e
j*j; e e
j*j9 e2e
e
j,j-e2f dddZ
de
j,j-e8e e/ e0e e8 e0e2e2e e
j*j; e e
j*j9 e e#jA e e8 e e2e8f e
j,j-d&d'd(ZBdd)ddd
d
dd*d%d%ddejCf
e
j,j-e8e e/ e0e e8 e0e2e2e d+ e8e2e e2e8f e e8 e d, e e0 e
j,j-d-d.d/ZDdddddde jEdfe8e
jFjGe e
j,j- e0e e/ e e/ e e8 e0e e e
j*j9 dd0 d1d2ZHd?e
j,j-e8e e/ e0e e8 e0e2e2e e
jIjJ e e2e8f e e
j*j9 e e8 e
j,j-d3
d4d5ZIdS )@zTalk to a DNS server. N)AnyDictOptionalTupleUnion) NullContext)
BadResponseNoDOHNoDOQUDPMode_compute_times_make_dot_ssl_context_matches_destination
_remaininghave_dohsslc C sN |s|rF|d u r>| t jkr d}n | t jkr0d}ntd| ||fS d S d S )Nz0.0.0.0z::zunknown address family )socketAF_INETAF_INET6NotImplementedError)afZaddressport r 2/usr/lib/python3.9/site-packages/dns/asyncquery.py
_source_tuple: s
r c C s* | d ur"|st }t| | dS d S d S )Nr )timemax)
expirationZnowr r r _timeoutJ s
r )sockwhat destinationr returnc s@ t |tjjr| }t }| ||t||I dH }||fS )a Send a DNS message to the specified UDP socket.
*sock*, a ``dns.asyncbackend.DatagramSocket``.
*what*, a ``bytes`` or ``dns.message.Message``, the message to send.
*destination*, a destination tuple appropriate for the address family
of the socket, specifying where to send the query.
*expiration*, a ``float`` or ``None``, the absolute time at which
a timeout exception should be raised. If ``None``, no timeout will
occur. The expiration value is meaningless for the asyncio backend, as
asyncio's transport sendto() never blocks.
Returns an ``(int, float)`` tuple of bytes sent and the sent time.
N)
isinstancednsmessageMessageto_wirer sendtor )r r r! r sent_timenr r r send_udpS s
r+ F ) r r! r ignore_unexpectedone_rr_per_rrsetkeyring request_macignore_trailingraise_on_truncation
ignore_errorsqueryr" c
s d} | dt|I dH \} } t| j| ||s0qt }
z tjj| |||||d}W nn tjjy } z6| r|
dur|
| sW Y d}~qn W Y d}~n&d}~0 t
y | rY qn Y n0 | r|
dur|
|sq||
| fS )aj Read a DNS message from a UDP socket.
*sock*, a ``dns.asyncbackend.DatagramSocket``.
See :py:func:`dns.query.receive_udp()` for the documentation of the other
parameters, and exceptions.
Returns a ``(dns.message.Message, float, tuple)`` tuple of the received message, the
received time, and the address where the message arrived from.
r, N)r/ r0 r. r1 r2 ) recvfromr r familyr r$ r% from_wire Truncated is_response Exception)r r! r r- r. r/ r0 r1 r2 r3 r4 wire from_address
received_timerer r r receive_udpq s@
rA 5 )qwheretimeoutr source source_portr- r. r1 r2 r backendr3 r" c
s$ | }
t|\}}tj|}t||f|}|
r _r r r udp s@
rW )rC rD rE r rF rG r- r. r1 udp_socktcp_sockrH r3 r" c
st z0t | ||||||||d| | |
I dH }
|
dfW S tjjyn t| ||||||||
|
I dH }
|
df Y S 0 dS )a Return the response to the query, trying UDP first and falling back
to TCP if UDP results in a truncated response.
*udp_sock*, a ``dns.asyncbackend.DatagramSocket``, or ``None``,
the socket to use for the UDP query. If ``None``, the default, a
socket is created. Note that if a socket is provided the *source*,
*source_port*, and *backend* are ignored for the UDP query.
*tcp_sock*, a ``dns.asyncbackend.StreamSocket``, or ``None``, the
socket to use for the TCP query. If ``None``, the default, a
socket is created. Note that if a socket is provided *where*,
*source*, *source_port*, and *backend* are ignored for the TCP query.
*backend*, a ``dns.asyncbackend.Backend``, or ``None``. If ``None``,
the default, then dnspython will use the default backend.
See :py:func:`dns.query.udp_with_fallback()` for the documentation
of the other parameters, exceptions, and return type of this
method.
TNF)rW r$ r% r9 tcp)rC rD rE r rF rG r- r. r1 rX rY rH r3 responser r r udp_with_fallback s> #
r\ )r r r r" c s\ t |tjjr |jdd}nt|dd| }t }| |t ||I dH t||fS )zSend a DNS message to the specified TCP socket.
*sock*, a ``dns.asyncbackend.StreamSocket``.
See :py:func:`dns.query.send_tcp()` for the documentation of the other
parameters, exceptions, and return type of this method.
T)Zprepend_length ZbigN)
r# r$ r% r& r' lento_bytesr sendallr )r r r tcpmsgr) r r r send_tcp4 s
rb c sH d}|dkrD| |t|I dH }|dkr.t|t| }|| }q|S )z|Read the specified number of bytes from stream. Keep trying until we
either get the desired amount, or we hit EOF.
r, r N)Zrecvr EOFErrorr^ )r countr rU r* r r r
_read_exactlyM s
re )r r r. r/ r0 r1 r" c sX t | d|I dH }td|\}t | ||I dH }t } tjj|||||d}
|
| fS )zRead a DNS message from a TCP socket.
*sock*, a ``dns.asyncbackend.StreamSocket``.
See :py:func:`dns.query.receive_tcp()` for the documentation of the other
parameters, exceptions, and return type of this method.
r] N!Hr/ r0 r. r1 )re structunpackr r$ r% r8 ) r r r. r/ r0 r1 ldatalr< r> r? r r r receive_tcp[ s rl ) rC rD rE r rF rG r. r1 r rH r" c
s | }
t|\} } |r0| I dH t|}
nJtj|}t|||}||f}| s^tj } |
|t j d|||I dH }
|
4 I dH d}t
||
| I dH t|| || j| j|I dH \}}|| |_| |st|W d I dH S 1 I dH s0 Y dS )aO Return the response obtained after sending a query via TCP.
*sock*, a ``dns.asyncbacket.StreamSocket``, or ``None``, the
socket to use for the query. If ``None``, the default, a socket
is created. Note that if a socket is provided
*where*, *port*, *source*, *source_port*, and *backend* are ignored.
*backend*, a ``dns.asyncbackend.Backend``, or ``None``. If ``None``,
the default, then dnspython will use the default backend.
See :py:func:`dns.query.tcp()` for the documentation of the other
parameters, exceptions, and return type of this method.
Nr )r' r Z getpeernamer r$ rI rJ r rL rM rN r SOCK_STREAMrb rl r/ rP r r: r )rC rD rE r rF rG r. r1 r rH r< rQ r rR r rS rT rU r? r> r r r rZ y s,
rZ U T)rC rD rE r rF rG r. r1 r rH ssl_contextserver_hostnameverifyr" c
s t |\}
}|rt|}n`|
du r,t| | }
tj|}t|||}||f}| sZtj } | |t
j d||||
| I dH }|4 I dH T}t |}t
| |||||||||
I dH }t }||
|_|W d I dH S 1 I dH s0 Y dS )a Return the response obtained after sending a query via TLS.
*sock*, an ``asyncbackend.StreamSocket``, or ``None``, the socket
to use for the query. If ``None``, the default, a socket is
created. Note that if a socket is provided, it must be a
connected SSL stream socket, and *where*, *port*,
*source*, *source_port*, *backend*, *ssl_context*, and *server_hostname*
are ignored.
*backend*, a ``dns.asyncbackend.Backend``, or ``None``. If ``None``,
the default, then dnspython will use the default backend.
See :py:func:`dns.query.tls()` for the documentation of the other
parameters, exceptions, and return type of this method.
Nr )r r r
r$ rI rJ r rL rM rN r rm r rZ r )rC rD rE r rF rG r. r1 r rH ro rp rq rQ r rR r rS rT rU r[ Zend_timer r r tls sJ
rr i z
/dns-queryzhttpx.AsyncClientzdns.asyncresolver.Resolver)rC rD rE r rF rG r. r1 clientpathpostrq bootstrap_addressresolverr7 r" c
s& t st|r t|tjs td| }ztj |}W n tyN d}Y n0 d}ddi}|durtj
|r|t j krd
||| }q|t jkrd
||| }n|}tj }|du rd}d}n|}|}| |dd| || |
|d }|rt|}ntjdd| |d
}|4 I dH }|
rT|dtt|d ||j|||d |I dH }n:t|d
}| }||j ||d|id|I dH }W d I dH q1 I dH s0 Y |j dk s|j dkrtd
||j |j tj j |j | j!| j"||d}|j#$ |_%| &|s"t'|S )a Return the response obtained after sending a query via DNS-over-HTTPS.
*client*, a ``httpx.AsyncClient``. If provided, the client to use for
the query.
Unlike the other dnspython async functions, a backend cannot be provided
in this function because httpx always auto-detects the async backend.
See :py:func:`dns.query.https()` for the documentation of the other
parameters, exceptions, and return type of this method.
z.session parameter must be an httpx.AsyncClientNZacceptzapplication/dns-messagezhttps://{}:{}{}zhttps://[{}]:{}{}r T)
local_addresshttp1http2rq
local_portrv rw r7 )ry rz rq transport)z content-typezcontent-length)headerscontent =r$ )r} params i+ z4{} responded with status code {}
Response body: {!r}rg )(r r r# httpxZ AsyncClient
ValueErrorr' r$ rI rJ Z
is_addressr r formatr rL rM Zget_transport_classr updatestrr^ wait_forru base64Zurlsafe_b64encoderstripdecodegetZ status_coder~ r% r8 r/ r0 elapsedZ
total_secondsr r: r ) rC rD rE r rF rG r. r1 rs rt ru rq rv rw r7 r< r r| r} urlrH rx r{ rR Z
the_clientr[ Ztwirer? r r r https s
8
r ) rD txn_managerr4 r rE lifetimerF rG udp_moderH r" c
# s |du rt j|\}}
n t j|}
|jd j} | t jjk} | }
| }t j
| }t |||}| |f}t
|\}}d}|rd}| r|tjkrtj}d}n
tj}d}| st j } | ||d||t|I dH }|4 I dH |r|||t|I dH n&tdt|| }|||I dH t j || |
|x}d}d}|st
|\}} | du s||dur| |kr|} |rt | |f|} t| }| d|I dH \} } t || | drqqn2t |d| I dH } t!d| \}!t ||!| I dH } | t jjk} t j"j#| |j$|j%d|
|| | d}"z|&|"}W nD t jj'y~ |sXJ |tj(krf d}d}tj}Y qLY n0 |"j)}qL|s|j$r|"j*st j+,d W d n1 s0 Y W d I dH q~1 I dH s0 Y q~dS )
am Conduct an inbound transfer and apply it via a transaction from the
txn_manager.
*backend*, a ``dns.asyncbackend.Backend``, or ``None``. If ``None``,
the default, then dnspython will use the default backend.
See :py:func:`dns.query.inbound_xfr()` for the documentation of
the other parameters, exceptions, and return type of this method.
Nr TFrf r5 r] )r/ r0 xfrorigintsig_ctxZmultir. z missing TSIG)-r$ r Z
make_queryZextract_serial_from_queryZquestionrdtypeZ rdatatypeZIXFRZfrom_wire_originr' rI rJ r r r NEVERr rO rm rL rM rN r r( rh packr^ r` ZInboundrK r6 r re ri r% r8 r/ rP Zprocess_messageZUseTCPZONLYr Zhad_tsig exceptionZ FormError)#rD r r4 r rE r rF rG r rH serialr Zis_ixfrr r< r rS rT rV r ZretryZ sock_typeZis_udprU ra ZinboundZdoner Z mexpirationr! Zrwirer= rj rk r? r r r inbound_xfrl s
r )
rC rD rE r rF rG r. r1
connectionrq rH rp r" c s t jjstdd| _| } |r8t jj}
t jj}|}nt j|
\}
}|
4 I dH }||| | d4 I dH }|s|||||}t |\}}|
|I dH }|4 I dH > | | dI dH | t
|I dH } W d I dH q1 I dH s0 Y t }W d I dH q81 I dH s.0 Y t jj| | j| j||d}W d I dH q1 I dH sv0 Y t|| d|_| |st|S )ai Return the response obtained after sending an asynchronous query via
DNS-over-QUIC.
*backend*, a ``dns.asyncbackend.Backend``, or ``None``. If ``None``,
the default, then dnspython will use the default backend.
See :py:func:`dns.query.quic()` for the documentation of the other
parameters, exceptions, and return type of this method.
z DNS-over-QUIC is not available.r N)Z verify_modeZ server_nameTrg g )r$ quicZ have_quicr
idr' Z null_factoryZfactories_for_backendZconnectr Z make_streamsendZreceiver r r% r8 r/ r0 r r: r )rC rD rE r rF rG r. r1 r rq rH rp r< ZcfactoryZmfactoryZthe_connectioncontextZ the_managerstartr streamZfinishr? r r r r sB @64 r )N)N)
NNFFNr, FFFN) NrB Nr FFFFNNF) NrB Nr FFFNNNF)N)NFNr, F)NrB Nr FFNN) Nrn Nr FFNNNNT)
Nrn Nr FFNTNN)K__doc__r
contextlibr rh r typingr r r r r Zdns.asyncbackendr$ Z
dns.exceptionZdns.inetZ dns.messageZdns.nameZdns.quicZ dns.rcodeZdns.rdataclassZ
dns.rdatatypeZdns.transactionZdns._asyncbackendr Z dns.queryr r r
r r r
r r r r r rI Zlow_level_address_tuplerK r r rL ZDatagramSocketr% r& bytesfloatintr+ boolnameNameZtsigZKeyrA r ZBackendrW Z StreamSocketr\ rb re rl rZ Z
SSLContextrr Z AF_UNSPECr r Z transactionZTransactionManagerr r ZAsyncQuicConnectionr r r r s 0
@
E
G
!
;
I
x
h