o 2cԡ @sdZddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddlZ ddlZ ddlZ ddlZ ddlZ ddlZ ddlZ ddlZ zddlZddlmZddlmZdZWn eymdZYnwzddlZWneyGdddZYnwejZGd d d e jj Z!Gd d d e jj"Z#Gd dde jj Z$e j%j&Z&ddZ'ddZ(ddZ)e*edrej+a,nej-a,ddZ.ddZ/ddZ0ddZ1 dKddZ2dLd d!Z3    dMd$d%Z4d&d'Z5d(d)Z6dNd*d+Z7    dOd-d.Z8   dPd0d1Z9    dQd2d3Z:d4d5Z;d6d7Zdd?Z@d@dAZA   dTdCdDZBe jCjDe jEjFdd/dddddddde jGjHf dEdFZ%GdGdHdHejIZJdd/ddddeJjKfdIdJZLdS)UzTalk to a DNS server.N)SourceAddressAdapter)HostHeaderSSLAdapterTFc@sBeZdZGdddeZGdddeZGdddZddZd S) sslc@ eZdZdS)zssl.WantReadExceptionN__name__ __module__ __qualname__r r ?/var/www/html/gps/gps/lib/python3.10/site-packages/dns/query.pyWantReadException6r c@r)zssl.WantWriteExceptionNrr r r r WantWriteException9r rc@r)z ssl.SSLSocketNrr r r r SSLSocket<r rcOstd)Nzno ssl support) Exception)selfargskwargsr r r create_default_context?szssl.create_default_contextN)rrr rr rrrr r r r r4s  rc@eZdZdZdS)UnexpectedSourcez=A DNS query response came from an unexpected address or port.Nrrr __doc__r r r r rFrc@r) BadResponsez is_multicastr)rA from_address destinationignore_unexpectedr r r _matches_destinations  rKcCsd}d}z tj|}|}Wn ty|rYnw|r0tj|}|r.||kr-tdn|}|rH|sH|tjkraf_for_addressr ValueErrorsocketAF_INETAF_INET6low_level_address_tuple)whereportsource source_portwhere_must_be_addressrArIsafr r r _destination_and_sources8      rXcCs\t||}z|d|dur|||r|j|d|dWS|WSty-|w)NF)do_handshake_on_connectserver_hostname)socket_factory setblockingbind wrap_socketrclose)rAtyperT ssl_contextrZr9r r r _make_sockets    rb /dns-queryc Cstst|} t||||d\}}}d}ddi}|dur7|tjkr*d||| }n)|tjkr6d||| }n| durQtj |}|j |d<| |j | }t }n|}|dur[t|}tG}|sj|tj}|rr|||| r|dtt| d|j||| || d }nt| d } |j|||| d | id }Wdn1swY|jd ks|jdkrtd||j|j t!j"j#|j |j$|j%||d}|j&|_'|(|st)|S)aReturn the response obtained after sending a query via DNS-over-HTTPS. *q*, a ``dns.message.Message``, the query to send. *where*, a ``str``, the nameserver IP address or the full URL. If an IP address is given, the URL will be constructed using the following schema: https://:/. *timeout*, a ``float`` or ``None``, the number of seconds to wait before the query times out. If ``None``, the default, wait forever. *port*, a ``int``, the port to send the query to. The default is 443. *source*, a ``str`` containing an IPv4 or IPv6 address, specifying the source address. The default is the wildcard address. *source_port*, an ``int``, the port from which to send the message. The default is 0. *one_rr_per_rrset*, a ``bool``. If ``True``, put each RR into its own RRset. *ignore_trailing*, a ``bool``. If ``True``, ignore trailing junk at end of the received message. *session*, a ``requests.session.Session``. If provided, the session to use to send the queries. *path*, a ``str``. If *where* is an IP address, then *path* will be used to construct the URL to send the DNS query to. *post*, a ``bool``. If ``True``, the default, POST method will be used. *bootstrap_address*, a ``str``, the IP address to use to bypass the system's DNS resolver. *verify*, a ``str``, containing a path to a certificate file or directory. Returns a ``dns.message.Message``. FNacceptzapplication/dns-messagezhttps://{}:{}{}zhttps://[{}]:{}{}Host)z content-typezcontent-length)headersdatarverify=r()rgrriparamsi+z2{} responded with status code {} Response body: {}keyring request_macone_rr_per_rrsetignore_trailing)*have_dohrto_wirerXrNrOformatrPurllibparseurlsplithostnamereplacerr contextlib ExitStack enter_contextrequestssessionsSessionmountupdatestrlenpostbase64urlsafe_b64encoderstripget status_coderMcontentr(message from_wirernroelapsedr is_responser)qrRrrSrTrUrprqsessionpathrbootstrap_addressriwirerAr/transport_adapterrgurl split_urlstackresponserr r r httpssx-            rcCs. z||WStyt||Ynwq)zReads a datagram from the socket. A Timeout exception will be raised if the operation is not completed by the expiration time. )recvfromBlockingIOErrorr:)sockmax_sizer0r r r _udp_recvVs  rcCs@ z|r |||WS||WStyt||Ynwq)zSends the specified datagram to destination over the socket. A Timeout exception will be raised if the operation is not completed by the expiration time. )sendtosendrr<)rrhrIr0r r r _udp_sendbs  rcCs4t|tjjr |}t}t||||}||fS)aSend a DNS message to the specified UDP socket. *sock*, a ``socket``. *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. Returns an ``(int, float)`` tuple of bytes sent and the sent time. )r!r(rMessagersrr)rwhatrIr0 sent_timenr r r send_udpqs rc Cs`d} t|d|\} } t|j| ||rnqt} tjj| |||||d} |r+| | fS| | | fS)a~Read a DNS message from a UDP socket. *sock*, a ``socket``. *destination*, a destination tuple appropriate for the address family of the socket, specifying where the message is expected to arrive from. When receiving a response, this would be where the associated query was sent. *expiration*, a ``float`` or ``None``, the absolute time at which a timeout exception should be raised. If ``None``, no timeout will occur. *ignore_unexpected*, a ``bool``. If ``True``, ignore responses from unexpected sources. *one_rr_per_rrset*, a ``bool``. If ``True``, put each RR into its own RRset. *keyring*, a ``dict``, the keyring to use for TSIG. *request_mac*, a ``bytes``, the MAC of the request (for TSIG). *ignore_trailing*, a ``bool``. If ``True``, ignore trailing junk at end of the received message. *raise_on_truncation*, a ``bool``. If ``True``, raise an exception if the TC bit is set. Raises if the message is malformed, if network errors occur, of if there is a timeout. If *destination* is not ``None``, returns a ``(dns.message.Message, float)`` tuple of the received message and the received time. If *destination* is ``None``, returns a ``(dns.message.Message, float, tuple)`` tuple of the received message, the received time, and the address where the message arrived from. rT)rnrorprqraise_on_truncation)rrKfamilyrr(rr) rrIr0rJrprnrorqrrrH received_timerr r r receive_udps"-   r5c  Cs|} t||||\} } }t|\}}t<}| r| }n |t| tj|}t || | |t || ||||j |j || \}}|||_ ||sKt|WdS1sWwYdS)aLReturn the response obtained after sending a query via UDP. *q*, a ``dns.message.Message``, the query to send *where*, a ``str`` containing an IPv4 or IPv6 address, where to send the message. *timeout*, a ``float`` or ``None``, the number of seconds to wait before the query times out. If ``None``, the default, wait forever. *port*, an ``int``, the port send the message to. The default is 53. *source*, a ``str`` containing an IPv4 or IPv6 address, specifying the source address. The default is the wildcard address. *source_port*, an ``int``, the port from which to send the message. The default is 0. *ignore_unexpected*, a ``bool``. If ``True``, ignore responses from unexpected sources. *one_rr_per_rrset*, a ``bool``. If ``True``, put each RR into its own RRset. *ignore_trailing*, a ``bool``. If ``True``, ignore trailing junk at end of the received message. *raise_on_truncation*, a ``bool``. If ``True``, raise an exception if the TC bit is set. *sock*, a ``socket.socket``, 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 nonblocking datagram socket, and the *source* and *source_port* are ignored. Returns a ``dns.message.Message``. N)rsrXr rzr{r|rbrN SOCK_DGRAMrrrnmacrrr)rrRrrSrTrUrJrprqrrrrArI begin_timer0rr9rrr r r udps()     $rc Cs^zt|||||||||d| } | dfWStjjy.t||||||||| } | dfYSw)aReturn the response to the query, trying UDP first and falling back to TCP if UDP results in a truncated response. *q*, a ``dns.message.Message``, the query to send *where*, a ``str`` containing an IPv4 or IPv6 address, where to send the message. *timeout*, a ``float`` or ``None``, the number of seconds to wait before the query times out. If ``None``, the default, wait forever. *port*, an ``int``, the port send the message to. The default is 53. *source*, a ``str`` containing an IPv4 or IPv6 address, specifying the source address. The default is the wildcard address. *source_port*, an ``int``, the port from which to send the message. The default is 0. *ignore_unexpected*, a ``bool``. If ``True``, ignore responses from unexpected sources. *one_rr_per_rrset*, a ``bool``. If ``True``, put each RR into its own RRset. *ignore_trailing*, a ``bool``. If ``True``, ignore trailing junk at end of the received message. *udp_sock*, a ``socket.socket``, 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, it must be a nonblocking datagram socket, and the *source* and *source_port* are ignored for the UDP query. *tcp_sock*, a ``socket.socket``, 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, it must be a nonblocking connected stream socket, and *where*, *source* and *source_port* are ignored for the TCP query. Returns a (``dns.message.Message``, tcp) tuple where tcp is ``True`` if and only if TCP was used. TF)rr(r Truncatedtcp) rrRrrSrTrUrJrprqudp_socktcp_sockrr r r udp_with_fallbacks.  rc Csd}|dkrAz||}|dkrt|t|8}||7}Wnttjfy.t||Yntjy<t||Ynw|dks|S)zRead the specified number of bytes from sock. Keep trying until we either get the desired amount, or we hit EOF. A Timeout exception will be raised if the operation is not completed by the expiration time. rr) recvEOFErrorrrrSSLWantReadErrorr:SSLWantWriteErrorr<)rcountr0r9rr r r _net_read:s    rc Cs~d}t|}||kr=z ||||d7}Wnttjfy(t||Yntjy6t||Ynw||ks dSdS)zWrite the specified data to the socket. A Timeout exception will be raised if the operation is not completed by the expiration time. rN)rrrrrr<rr:)rrhr0currentlr r r _net_writeOsrcCsNt|tjjr |}t|}td||}t}t |||t||fS)a{Send a DNS message to the specified TCP socket. *sock*, a ``socket``. *what*, a ``bytes`` or ``dns.message.Message``, the message to send. *expiration*, a ``float`` or ``None``, the absolute time at which a timeout exception should be raised. If ``None``, no timeout will occur. Returns an ``(int, float)`` tuple of bytes sent and the sent time. !H) r!r(rrrsrstructpackrr)rrr0rtcpmsgrr r r send_tcp_s  rc CsLt|d|}td|\}t|||}t} tjj|||||d} | | fS)aRead a DNS message from a TCP socket. *sock*, a ``socket``. *expiration*, a ``float`` or ``None``, the absolute time at which a timeout exception should be raised. If ``None``, no timeout will occur. *one_rr_per_rrset*, a ``bool``. If ``True``, put each RR into its own RRset. *keyring*, a ``dict``, the keyring to use for TSIG. *request_mac*, a ``bytes``, the MAC of the request (for TSIG). *ignore_trailing*, a ``bool``. If ``True``, ignore trailing junk at end of the received message. Raises if the message is malformed, if network errors occur, of if there is a timeout. Returns a ``(dns.message.Message, float)`` tuple of the received message and the received time. rrm)rrunpackrr(rr) rr0rprnrorqldatarrrrr r r receive_tcpxs   rcCs`||}|dkr dS|tjtjtjfvr"t|||tjtj }|dkr.t |t |dS)Nr) connect_exerrno EINPROGRESS EWOULDBLOCKEALREADYr< getsockoptrN SOL_SOCKETSO_ERROROSErrorosstrerror)r9addressr0errr r r _connects  rc Cs|} t|\} } tH} |r|} nt||||\}}}| t|tj|} t | || t | | | t | | ||j |j |\}}|| |_||sMt|WdS1sYwYdS)aReturn the response obtained after sending a query via TCP. *q*, a ``dns.message.Message``, the query to send *where*, a ``str`` containing an IPv4 or IPv6 address, where to send the message. *timeout*, a ``float`` or ``None``, the number of seconds to wait before the query times out. If ``None``, the default, wait forever. *port*, an ``int``, the port send the message to. The default is 53. *source*, a ``str`` containing an IPv4 or IPv6 address, specifying the source address. The default is the wildcard address. *source_port*, an ``int``, the port from which to send the message. The default is 0. *one_rr_per_rrset*, a ``bool``. If ``True``, put each RR into its own RRset. *ignore_trailing*, a ``bool``. If ``True``, ignore trailing junk at end of the received message. *sock*, a ``socket.socket``, 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 nonblocking connected stream socket, and *where*, *port*, *source* and *source_port* are ignored. Returns a ``dns.message.Message``. N)rsr rzr{rXr|rbrN SOCK_STREAMrrrrnrrrr)rrRrrSrTrUrprqrrrr0rr9rArIrrr r r rs,"        $rcCsN z|WdStjyt||Yntjy%t||Ynwqr) do_handshakerrr:rr<r8r r r _tls_handshakesrUc  Cs|rt||||||||| S|} t|\} } t||||\}}}| dur3|s3t} | dur3d| _t|tj || | d4}t ||| t || t || | t || ||j|j|\}}|| |_||sht|WdS1stwYdS)a:Return the response obtained after sending a query via TLS. *q*, a ``dns.message.Message``, the query to send *where*, a ``str`` containing an IPv4 or IPv6 address, where to send the message. *timeout*, a ``float`` or ``None``, the number of seconds to wait before the query times out. If ``None``, the default, wait forever. *port*, an ``int``, the port send the message to. The default is 853. *source*, a ``str`` containing an IPv4 or IPv6 address, specifying the source address. The default is the wildcard address. *source_port*, an ``int``, the port from which to send the message. The default is 0. *one_rr_per_rrset*, a ``bool``. If ``True``, put each RR into its own RRset. *ignore_trailing*, a ``bool``. If ``True``, ignore trailing junk at end of the received message. *sock*, an ``ssl.SSLSocket``, 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 nonblocking connected SSL stream socket, and *where*, *port*, *source*, *source_port*, and *ssl_context* are ignored. *ssl_context*, an ``ssl.SSLContext``, the context to use when establishing a TLS connection. If ``None``, the default, creates one with the default configuration. *server_hostname*, a ``str`` containing the server's hostname. The default is ``None``, which means that no hostname is known, and if an SSL context is created, hostname checking will be disabled. Returns a ``dns.message.Message``. NF)rarZ)rrsr rXrrcheck_hostnamerbrNrrrrrrnrrrr)rrRrrSrTrUrprqrrarZrrr0rArIr9rrr r r tlss8-         $rc' cst|tr tj|}tjj|}tj |||}|tjj kr3tj |dddd| }|j ||dur?|j|||d|}t||| | \}}} | rY|tjj krYtd| r^tjntj}t||| q}t| \}}t|||t|}| rt||d|ntd||}t|||d }d }d }d}|r|}tjj}nd}|}d} |st|\}}!|!dus|dur|!|kr|}!| rt|d |!\}}nt|d |!}"t d|"\}t|||!}|tjj k}#tjj!||j"|j#d || d |#d }$|$$}%|%tj$j%krt&|%|$j'} d}&|durP|$j(r|$j(dj|krtj)*d|$j(d}|j+tjj,kr2tj)*dd}&|-}|tjj krPtj./|dj.| krNd }nd }|$j(|&dD][}|rbtj)*d|j+tjj,kr|j|kr|r|dj.| krtj)*dd }n |tjj kr| }||kr|tjj0ks|tjj kr|rd }qW|rtjj0}d }qW|r|j"r|$j1stj)*d|$V|rWddSWddS1swYdS)aReturn a generator for the responses to a zone transfer. *where*, a ``str`` containing an IPv4 or IPv6 address, where to send the message. *zone*, a ``dns.name.Name`` or ``str``, the name of the zone to transfer. *rdtype*, an ``int`` or ``str``, the type of zone transfer. The default is ``dns.rdatatype.AXFR``. ``dns.rdatatype.IXFR`` can be used to do an incremental transfer instead. *rdclass*, an ``int`` or ``str``, the class of the zone transfer. The default is ``dns.rdataclass.IN``. *timeout*, a ``float``, the number of seconds to wait for each response message. If None, the default, wait forever. *port*, an ``int``, the port send the message to. The default is 53. *keyring*, a ``dict``, the keyring to use for TSIG. *keyname*, a ``dns.name.Name`` or ``str``, the name of the TSIG key to use. *relativize*, a ``bool``. If ``True``, all names in the zone will be relativized to the zone origin. It is essential that the relativize setting matches the one specified to ``dns.zone.from_xfr()`` if using this generator to make a zone. *lifetime*, a ``float``, the total number of seconds to spend doing the transfer. If ``None``, the default, then there is no limit on the time the transfer may take. *source*, a ``str`` containing an IPv4 or IPv6 address, specifying the source address. The default is the wildcard address. *source_port*, an ``int``, the port from which to send the message. The default is 0. *serial*, an ``int``, the SOA serial number to use as the base for an IXFR diff sequence (only meaningful if *rdtype* is ``dns.rdatatype.IXFR``). *use_udp*, a ``bool``. If ``True``, use UDP (only meaningful for IXFR). *keyalgorithm*, a ``dns.name.Name`` or ``str``, the TSIG algorithm to use. Raises on errors, and so does the generator. Returns a generator of ``dns.message.Message`` objects. rINSOAz. . %u 0 0 0 0N) algorithmzcannot do a UDP AXFRrFTrrrnroxfrorigintsig_ctxmultirpz No answer or RRset not for qnamezfirst RRset is not an SOAr=zanswers after final SOAzIXFR base serial mismatch missing TSIG)2r!rr(name from_text rdatatype RdataTypemaker make_queryIXFRrrset authorityappenduse_tsigrsrXrMrNrrrbr rrrrrremptyrrrrrnrrcodeNOERROR TransferErrorranswerr) FormErrorrdtypercopyserialSerialAXFRhad_tsig)'rRzonerrdclassrrSrnkeyname relativizelifetimerTrUruse_udp keyalgorithmrrrrArI sock_typer9r/r0rrdone delete_mode expecting_SOA soa_rrsetronamer mexpirationris_ixfrrr answer_indexr r r r3s 8                     $rc@seZdZdZdZdZdZdS)UDPModeaHow should UDP be used in an IXFR from :py:func:`inbound_xfr()`? NEVER means "never use UDP; always use TCP" TRY_FIRST means "try to use UDP but fall back to TCP if needed" ONLY means "raise ``dns.xfr.UseTCP`` if trying UDP does not succeed" rr=rN)rrr rNEVER TRY_FIRSTONLYr r r r rs rc  Cs@|dur tj|\}} |jdj} | tjjk} |} |} t ||||\}}}t |\}}d}|rd}| rD|t j krDt j}d}nt j}d}t|||}t||||r`t|| d|ntdt| | }t|||tj|| | |}d}d}|st |\}}|dus|dur||kr|}|rt|d|\}}nt|d|}td|\}t|||}tjj||j|jd| || | d}z||}Wntjj y|sJ|t j!kr݂d}d}t j }Yq~w|j"}|r|s|jr|j#stj$%d Wdn 1swYWdn 1swY|s5dSdS) aConduct an inbound transfer and apply it via a transaction from the txn_manager. *where*, a ``str`` containing an IPv4 or IPv6 address, where to send the message. *txn_manager*, a ``dns.transaction.TransactionManager``, the txn_manager for this transfer (typically a ``dns.zone.Zone``). *query*, the query to send. If not supplied, a default query is constructed using information from the *txn_manager*. *port*, an ``int``, the port send the message to. The default is 53. *timeout*, a ``float``, the number of seconds to wait for each response message. If None, the default, wait forever. *lifetime*, a ``float``, the total number of seconds to spend doing the transfer. If ``None``, the default, then there is no limit on the time the transfer may take. *source*, a ``str`` containing an IPv4 or IPv6 address, specifying the source address. The default is the wildcard address. *source_port*, an ``int``, the port from which to send the message. The default is 0. *udp_mode*, a ``dns.query.UDPMode``, determines how UDP is used for IXFRs. The default is ``dns.UDPMode.NEVER``, i.e. only use TCP. Other possibilites are ``dns.UDPMode.TRY_FIRST``, which means "try UDP but fallback to TCP if needed", and ``dns.UDPMode.ONLY``, which means "try UDP and raise ``dns.xfr.UseTCP`` if it does not succeeed. Raises on errors. NrTFrrrrr)&r(rrquestionrrrfrom_wire_originrsrXr rrrNrrrbrrrrrrInboundrrrrrrnrprocess_messageUseTCPrrrr)r)rR txn_managerqueryrSrrrTrUudp_moderrr rrrArIr/r0retryris_udpr9rinboundrrr rwirerrrr r r inbound_xfrs'             r)T)NN) NrcNrFFNrdTNTr)NNFFNrFF) NrNrFFFFN) NrNrFFFNN)NFNrF)NrNrFFN) NrNrFFNNN)Mrrzenumrrr$rNrrr urllib.parseru dns.exceptionr(dns.inetdns.name dns.message dns.rcodedns.rdataclass dns.rdatatype dns.serialdns.xfrr}!requests_toolbelt.adapters.sourcer*requests_toolbelt.adapters.host_header_sslrrr ImportErrorrr[r) DNSExceptionrrrrrrr r3r5hasattrr6r#SelectSelectorr:r<rFrKrXrbrrrrrrrrrrrrrrrrr rdataclassrtsigdefault_algorithmIntEnumrrrr r r r s        + n  = < 8  $  7  J  (