File: //opt/alt/python37/lib/python3.7/site-packages/dns/__pycache__/asyncquery.cpython-37.pyc
B
��f�b � @ s d Z ddlmZmZmZmZmZ ddlZddlZddl Z ddl
Z
ddl 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" e r�ddl#Z#e
j$j%Z&dd� Z'd5dd �Z(d6e
j)j*ee
j+j,e-f eee. ee/e.f d
�d d �Z0d7e
j)j*ee ee. e1e1eee
j2j3e
j4j5f ee- e1e1ed�
dd�Z6d8e
j+j,e7ee. e/ee7 e/e1e1e1e1ee
j)j* ee
j)j8 e
j+j,d�
dd�Z9d9e
j+j,e7ee. e/ee7 e/e1e1e1ee
j)j* ee
j)j: ee
j)j8 ee
j+j,e1f d�
dd�Z;d:e
j)j:ee
j+j,e-f ee. ee/e.f d�dd�Z<d d � Z=d;e
j)j:ee. e1eee
j2j3e
j4j5f ee- e1ee
j+j,e.f d �d d �Z>d<e
j+j,e7ee. e/ee7 e/e1e1ee
j)j: ee
j)j8 e
j+j,d!� d"d#�Z?d=e
j+j,e7ee. e/ee7 e/e1e1ee
j)j: ee
j)j8 ee j@ ee7 e
j+j,d%�
d&d'�ZAd>e
j+j,e7ee. e/ee7 e/e1e1ed+ e7e1ee1e7f e
j+j,d,�
d-d.�ZBdddddde jCdfe7e
jDjEee
j+j, e/ee. ee. ee7 e/e ee
j)j8 dd/� d0d1�ZFd?e
j+j,e7ee. e/ee7 e/e1e1ee
jGjH ee1e7f ee
j)j8 e
j+j,d2� d3d4�ZGdS )@zTalk to a DNS server.� )�Any�Dict�Optional�Tuple�UnionN)� NullContext) �_compute_times�_matches_destination� BadResponse�ssl�UDPMode� _have_httpx� _have_http2�NoDOH�NoDOQc C sN |s|rF|d kr>| 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)�af�address�port� r �?/opt/alt/python37/lib/python3.7/site-packages/dns/asyncquery.py�
_source_tuple; s
r c C s& | r |st � � }t| | d�S d S d S )Nr )�time�max)�
expiration�nowr r r �_timeoutK 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_udpT s
r, F� )
r r" r �ignore_unexpected�one_rr_per_rrset�keyring� request_mac�ignore_trailing�raise_on_truncationr# c
� s` d} x0| � dt|��I dH \} }
t| j|
||�rP qW t�� } tjj| |||||d�} | | |
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- i�� N)r0 r1 r/ r2 r3 )�recvfromr r �familyr r% r& � from_wire)
r r" r r. r/ r0 r1 r2 r3 �wire� from_address�
received_time�rr r r � receive_udpr s r; �5 )
�q�where�timeoutr �source� source_portr. r/ r2 r3 r �backendr# c � s� | � � } t|�\}
}tj�|�}t||f|�}|
r<t|
�}nJ| sJtj�� } t |||�}| �
� rh||f}nd}| � |t j
d||�I dH }|4 I dH �Z}t|| ||�I dH t|||||| j| j|| � I dH \}}}||
|_| �|�s�t�|S Q I dH R X 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, r; r0 �macr � is_responser
)r= r> r? r r@ rA r. r/ r2 r3 r rB r7 �
begin_timer r r" �cm�stuple�dtuple�sr: r9 �_r r r �udp� s:
rR )
r= r> r? r r@ rA r. r/ r2 �udp_sock�tcp_sockrB r# c
� sn y,t | ||||||||d| | � I dH } | dfS tjjk
rh t| ||||||||
| �
I dH } | dfS X 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)rR r% r& Z Truncated�tcp)
r= r> r? r r@ rA r. r/ r2 rS rT rB �responser r r �udp_with_fallback� s8 " rW )r r! r r# c � s` t |tjj�r|�� }n|}t|�}t�d|�| }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.
z!HN) r$ r% r& r' r( �len�struct�packr �sendallr )r r! r r7 �l�tcpmsgr* r r r �send_tcp s
r^ c � sL d}xB|dkrF| � |t|��I dH }|dkr0t�|t|� }|| }qW |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)�recvr �EOFErrorrX )r �countr rP r+ r r r �
_read_exactly5 s
rb )r r r/ r0 r1 r2 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.
� Nz!H)r0 r1 r/ r2 )rb rY �unpackr r% r& r6 ) r r r/ r0 r1 r2 �ldatar\ r7 r9 r: r r r � receive_tcpC s rf ) r= r> r? r r@ rA r/ r2 r rB r# c
� s� | � � }
t|�\} } |r0|�� I dH t|�}
nJtj�|�}t|||�}||f}| s^tj� � } | �
|t j d|||�I dH }
|
4 I dH �P}t
||
| �I dH t|| || j| j|�I dH \}}|| |_| �|�s�t�|S Q I dH R X 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 � getpeernamer r% rC rD r rF rG rH r � SOCK_STREAMr^ rf r0 rJ r rK r
)r= r> r? r r@ rA r/ r2 r rB r7 rL r rM r rN rO rP r: r9 r r r rU a s(
rU �U )
r= r> r? r r@ rA r/ r2 r rB � ssl_context�server_hostnamer# c � s� t |�\} }
|rt|�}n�|
dkrDt�� }
tjj|
_| dkrLd|
_nd}
d} tj �
|�}t |||�}||f}| sztj �
� } | �|tjd||||
| �I dH }|4 I dH �@}t|
�}t| ||||||||| �
I dH }t�� }|| |_|S Q I dH R X 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.
NFr )r r r �create_default_context�
TLSVersion�TLSv1_2�minimum_version�check_hostnamer% rC rD r rF rG rH r rh r rU r )r= r> r? r r@ rA r/ r2 r rB rj rk rL r rM r rN rO rP rV Zend_timer r r �tls� sP
rq � �
/dns-queryTzhttpx.AsyncClient)
r= r> r? r r@ rA r/ r2 �client�path�post�verifyr# c
� s� t s td��| �� } ytj�|�}
W n tk
r< d}
Y nX d}ddi}|
dk r�|
tjkrld� ||| �}q�|
tj
kr�d� ||| �}n|}|dk r�t j |d d�}|r�t
|�}nt jd t| |d
�}|4 I dH �r}|
�r|�dtt| ��d �� |j||| |d �I dH }n4t�| ��d
�} | �� }|j|||d|id�I dH }W dQ I dH R X |jdk �sd|jdk�rztd� ||j|j���tjj |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.
zhttpx is not available.N�acceptzapplication/dns-messagezhttps://{}:{}{}zhttps://[{}]:{}{}r )Z
local_addressT)Zhttp1Zhttp2rw � transport)z content-typezcontent-length)�headers�contentr? � =r% )rz r? �params�� i+ z4{} responded with status code {}
Response body: {!r})r0 r1 r/ r2 )$r
r r( r% rC rD �
ValueErrorr r �formatr �httpxZAsyncHTTPTransportr Z AsyncClientr �update�strrX rv �base64�urlsafe_b64encode�rstrip�decode�get� status_coder{ r& r6 r0 r1 �elapsed�
total_secondsr rK r
)r= r> r? r r@ rA r/ r2 rt ru rv rw r7 r ry rz �urlrM Z
the_clientrV Ztwirer: r r r �https� s\
( r� ) r> � txn_manager�queryr r? �lifetimer@ rA �udp_moderB r# c
# � s� |dkrt j�|�\}}
n t j�|�}
|jd j} | t jjk} |�� }
|� � }t j
� | �}t |||�}| |f}t
|�\}}d}�xT|�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� || |
|���v}d}d}�xB|�s�t
|�\}} | dk�s�|dk �r�| |k�r�|} |�r�t | |f|�} xjt| �}|� d|�I dH \} } t || | d��r�P �q�W n2t |d| �I dH } t�!d| �\}!t ||!| �I dH } | t jjk} t j"j#| |j$|j%d|
|| | d�}"y|�&|"�}W nD t jj'k
�r� |�sdt(�|tj)k�rr� d}d}tj}�wTY nX |"j*}�qTW |�s�|j$�r�|"j+�s�t j,�-d ��W dQ R X W dQ I dH R X q�W 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 TFz!Hi�� rc )r0 r1 �xfr�origin�tsig_ctxZmultir/ z missing TSIG).r% r� Z
make_queryZextract_serial_from_queryZquestion�rdtypeZ rdatatypeZIXFRZfrom_wire_originr( rC rD r r r �NEVERr rI rh rF rG rH r r) rY rZ rX r[ ZInboundrE r4 r rb rd r& r6 r0 rJ Zprocess_messageZUseTCP�AssertionErrorZONLYr� Zhad_tsig� exceptionZ FormError)#r> r� r� r r? r� r@ rA r� rB �serialr� Zis_ixfrr� r7 r rN rO rQ r �retryZ sock_typeZis_udprP r] Zinbound�doner� Z mexpirationr" Zrwirer8 re r\ r: r r r � inbound_xfrD s�
r� ) r= r> r? r r@ rA r/ r2 �
connectionrw rB r# c � s> t jjstd��d| _| �� } |r8t jj} t jj}
|}nt j�|
�\} }
| � 4 I dH ��}|
|| d�4 I dH �x}|s�|�||||�}t � � }|�
� I dH }|4 I dH �( |� | d�I dH |� |�I dH } W dQ I dH R X t � � }W dQ I dH R X t j
j| | j| j||d�}W dQ I dH R X 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)� verify_modeT)r0 r1 r/ r2 g )r% �quicZ have_quicr �idr( Z null_factoryZfactories_for_backend�connectr Z make_stream�sendZreceiver& r6 r0 r1 r rK r
)r= r> r? r r@ rA r/ r2 r� rw rB r7 ZcfactoryZmfactoryZthe_connection�contextZ the_manager�start�stream�finishr: r r r r� � s: r� )N)N)NNFFNr- FF)
Nr< Nr FFFFNN)
Nr< Nr FFFNNN)N)NFNr- F)Nr< Nr FFNN)
Nri Nr FFNNNN)
Nrr Nr FFNrs TT) Nri Nr FFNTN)I�__doc__�typingr r r r r r� �
contextlibr rY r Zdns.asyncbackendr% Z
dns.exceptionZdns.inetZdns.nameZ dns.messageZdns.quicZ dns.rcodeZdns.rdataclassZ
dns.rdatatypeZdns.transactionZdns._asyncbackendr Z dns.queryr r r
r r r
r r r r� rC Zlow_level_address_tuplerE r r rF ZDatagramSocketr& r' �bytes�float�intr, �bool�name�NameZtsigZKeyr; r� ZBackendrR Z StreamSocketrW r^ rb rf rU �
SSLContextrq r� r� Z transactionZTransactionManagerr� r� ZAsyncQuicConnectionr r r r �<module> s� ,
8" 63 >8 . 20 @B 2U8] <