File: //lib/python3.9/site-packages/dns/__pycache__/asyncquery.cpython-39.opt-1.pyc
a
�M�e�h � @ 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"r�ddl$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� dd�Z7d9e
j,j-e8e e/ e0e e8 e0e2e2e2e2e e
j*j+ e e
j*j9 e2e
j,j-d�dd�Z: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 d�dd�Z<d;e
j*j;e e
j,j-e.f e e/ e
e0e/f d�dd�Z=d d � Z>d<e
j*j;e e/ e2e ee
j3j4e
j5j6f e e. e2e
e
j,j-e/f d �d d �Z?d=e
j,j-e8e e/ e0e e8 e0e2e2e e
j*j; e e
j*j9 e
j,j-d!� d"d#�Z@d>e
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� d1d2�ZHd?e
j,j-e8e e/ e0e e8 e0e2e2e e
jIjJ e e2e8f e e
j*j9 e e8 e
j,j-d3�
d4d5�ZIdS )@zTalk to a DNS server.� N)�Any�Dict�Optional�Tuple�Union)� NullContext)
� BadResponse�NoDOH�NoDOQ�UDPMode�_compute_times�_make_dot_ssl_context�_matches_destination�
_remaining�have_doh�sslc 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 )�socket�AF_INET�AF_INET6�NotImplementedError)�afZaddress�port� r �2/usr/lib/python3.9/site-packages/dns/asyncquery.py�
_source_tuple: s
r c C s* | d ur"|st � � }t| | d�S d S d S )Nr )�time�max)�
expirationZnowr r r �_timeoutJ s
r )�sock�what� destinationr �returnc � s@ t |tjj�r|�� }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)�
isinstance�dns�message�Message�to_wirer �sendtor )r r r! r � sent_time�nr r r �send_udpS s
r+ F� ) r r! r �ignore_unexpected�one_rr_per_rrset�keyring� request_mac�ignore_trailing�raise_on_truncation�
ignore_errors�queryr" c
� s� d} | � dt|��I dH \} } t| j| ||�s0qt�� }
z tjj| |||||d�}W nn tjjy� } z6| r�|
dur�|
� |�� �s�W Y d}~qn� W Y d}~n&d}~0 t
y� | r�Y qn� Y n0 | r�|
dur�|
� |�s�q||
| 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_time�r�er r r � receive_udpq s@
��
�� � rA �5 )�q�where�timeoutr �source� source_portr- r. r1 r2 r �backendr3 r" c
� s$ | � � }
t|�\}}tj�|�}t||f|�}|
r<t|
�}nJ| sJtj�� } t |||�}| �
� rh||f}nd}| � |t j
d||�I dH }|4 I dH �v}t||
||�I dH t|||||| j| j|| | | � I dH \}}}|| |_| s�| �|�s�t�|W d �I dH S 1 I dH �s0 Y dS )aF Return the response obtained after sending a query via UDP.
*sock*, a ``dns.asyncbackend.DatagramSocket``, or ``None``,
the socket to use for the query. If ``None``, the default, a
socket is created. Note that if a socket is provided, the
*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.udp()` for the documentation of the other
parameters, exceptions, and return type of this method.
Nr )r' r r$ �inet�af_for_address�_lltupler � asyncbackend�get_default_backendr Z datagram_connection_required� make_socketr �
SOCK_DGRAMr+ rA r/ �macr r: r )rC rD rE r rF rG r- r. r1 r2 r rH r3 r< �
begin_timer r r! �cm�stuple�dtuple�sr? r> �_r r r �udp� s@
�
rW )rC rD rE r rF rG r- r. r1 �udp_sock�tcp_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 |tjj�r |jdd�}nt|��dd�| }t�� }| �|t ||��I dH t|�|fS )z�Send 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' �len�to_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 }t�d|�\}t | ||�I dH }t�� } tjj|||||d�}
|
| fS )z�Read 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�!H�r/ r0 r. r1 )re �struct�unpackr r$ r% r8 ) r r r. r/ r0 r1 �ldata�lr< 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 \}}|| |_| �|�s�t�|W d �I dH S 1 I dH � s�0 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_context�server_hostname�verifyr" 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 s�0 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 �client�path�postrq �bootstrap_address�resolverr7 r" c
� s& t st�|r t|tj�s td��| �� }ztj� |�}W n tyN d}Y n0 d}ddi}|dur�tj�
|�r�|t j kr�d�
||| �}q�|t jkr�d�
||| �}n|}tj�� }|du r�d}d}n|}|}|�� |dd| || |
|d �}|r�t|�}ntjdd| |d
�}|4 I dH ��}|
�rT|�dtt|��d �� |�|j|||d �|�I dH }n:t�|��d
�}|�� }|�|j ||d|id�|�I dH }W d �I dH �q�1 I dH �s�0 Y |j dk �s�|j dk�r�td�
||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_address�http1�http2rq �
local_portrv rw r7 )ry rz rq � transport)z content-typezcontent-length)�headers�content� =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 �update�strr^ �wait_forru �base64Zurlsafe_b64encode�rstrip�decode�getZ 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}|�r�d}| r�|tjkr�tj}d}n
tj}d}| s�t j�� } | �||d||t|��I dH }|4 I dH ��� |�r|�||t|��I dH n&t�dt|��| }|�||�I dH t j� || |
|���n}d}d}|�s�t
|�\}} | du �s||du�r�| |k�r�|} |�r�t | |f|�} t| �}|� d|�I dH \} } t || | d��r��q��q�n2t |d| �I dH } t�!d| �\}!t ||!| �I dH } | t jjk} t j"j#| |j$|j%d|
|| | d�}"z|�&|"�}W n: t jj'�yt |tj(k�r\� d}d}tj}Y �qLY n0 |"j)}�qL|�s�|j$�r�|"j*�s�t j+�,d ��W d � n1 �s�0 Y W d �I dH q~1 I dH �s�0 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 �xfr�origin�tsig_ctxZmultir. z missing TSIG)-r$ r� Z
make_queryZextract_serial_from_queryZquestion�rdtypeZ 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 jjstd��d| _| �� } |r8t jj}
t jj}|}nt j�|
�\}
}|
� 4 I dH ��}||| | d�4 I dH ��}|s�|�||||�}t |�\}}|�
|�I dH }|4 I dH �> |� | d�I dH |� t
|��I dH } W d �I dH �q1 I dH s�0 Y t�� }W d �I dH �q81 I dH �s.0 Y t jj| | j| j||d�}W d �I dH �q�1 I dH �sv0 Y t|| d�|_| �|��s�t�|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_stream�sendZreceiver r r% r8 r/ r0 r r: r )rC rD rE r rF rG r. r1 r� rq rH rp r< ZcfactoryZmfactoryZthe_connection�contextZ the_manager�startr �streamZfinishr? r r r r� � sB � @6�4 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& �bytes�float�intr+ �bool�name�NameZtsigZKeyrA r� ZBackendrW Z StreamSocketr\ rb re rl rZ Z
SSLContextrr Z AF_UNSPECr� r� Z transactionZTransactionManagerr� r� ZAsyncQuicConnectionr r r r �<module> s 0
�
� �
� @ �
� E �
� G �
� �� ! �
� ; �
� I�
� x�
� h �
�