403WebShell

Uname:Linux server2.hostofiraq.site 5.15.0-186-generic #196-Ubuntu SMP Sat Jun 20 16:09:34 UTC 2026 x86_64

Base Dir : /home/iscmbt-kufa-atu/public_html

User : iscmbt-kufa-atu

403WebShell403Webshell
Server IP : 89.117.53.150 / Your IP : 216.73.216.11
Web Server : Apache
System : Linux server2.hostofiraq.site 5.15.0-186-generic #196-Ubuntu SMP Sat Jun 20 16:09:34 UTC 2026 x86_64
User : iscmbt-kufa-atu ( 1014)
PHP Version : 8.2.32
Disable Function : NONE
MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : ON | Pkexec : ON
Directory : /lib/python3/dist-packages/twisted/names/__pycache__/
Upload File :
[ Back ]
Current File : /lib/python3/dist-packages/twisted/names/__pycache__/dns.cpython-310.pyc
o

pj��@s6UdZddlZddlZddlZddlZddlZddlmZddlm	Z	ddl
mZddlm
Z
mZmZddlmZmZmZddlmZmZdd	lmZdd
lmZmZmZmZddlm Z m!Z!m"Z"gd�Z#ej$Z$d
d�Z%dd�Z&dd�Z'dd�Z(dZ)e*dd�\Z+Z,Z-Z.Z/Z0Z1Z2Z3Z4Z5Z6Z7Z8Z9Z:Z;Z<dZ=dZ>dZ?dZ@dZAdZBdZCdZDd ZEd!ZFie+d"�e,d#�e-d$�e.d%�e/d&�e0d'�e1d(�e2d)�e3d*�e4d+�e5d,�e6d-�e7d.�e8d/�e9d0�e:d1�e;d2�e<d3e=d4e>d5e?d6e@d7eAd8eBd9eCd:eDd;eEd<eFd=i�ZGe*d>d?�\ZHZIZJZKZLeHd@eIdAeJdBeKdCeLdDiZMdEdF�eeG�N�eM�N��D�ZOe*ddG�\ZPZQZRZSdHZTePdIeQdJeRdKeSdLeTdMiZUdNdF�eU�N�D�ZVe*dO�\ZWZXZYdPZZdGZ[e*dQ�\Z\Z]Z^Z_Z`ZadRZbe*dRd�\ZcZdZeGdSdT�dTe�ZfddUlgmhZhmiZimjZjdVdW�ZkdXdY�ZldZd[�Zmd\d]�Znd^d_�ZoGd`da�daep�ZqGdbdc�dc�Zrejsdddde�ZtejserdBeudf<edgerfdhdi��ZvGdjdk�dke�ZwGdldm�dmewef�Zxeew�Gdndo�do��Zyeew�Gdpdq�dq��Zze!eew�Gdrds�ds���Z{eew�Gdtdu�duej|ej}��Z~eew�Gdvdw�dwej|ej}��Zeew�Gdxdy�dyej}��Z�eex�Gdzd{�d{ej|ej}��Z�Gd|d}�d}e��Z�Gd~d�de��Z�Gd�d��d�e��Z�Gd�d��d�e��Z�Gd�d��d�e��Z�Gd�d��d�e��Z�Gd�d��d�e��Z�Gd�d��d�e��Z�Gd�d��d�e��Z�eex�Gd�d��d�ej}��Z�eex�Gd�d��d�ej}ej|��Z�eex�Gd�d��d�ej|ej}��Z�eex�Gd�d��d�ej}ej|��Z�eex�Gd�d��d�ej}ej|��Z�eex�Gd�d��d�ej|ej}��Z�eex�Gd�d��d�ej}ej|��Z�eex�Gd�d��d�ej}ej|��Z�eex�Gd�d��d�ej|ej}��Z�eex�Gd�d��d�ej}ej|��Z�eex�Gd�d��d�ej|ej}��Z�eex�Gd�d��d�ej}ej|��Z�eex�Gd�d��d�ej|ej}��Z�eex�Gd�d��d�ej}ej|��Z�eex�Gd�d��d�ej}ej|��Z�eex�Gd�d��d�ej}ej|��Z�Gd�d��d�e��Z�eex�Gd�d��d�ej}ej|��Z�d�d��Z�d�d��Z�	d�d�d��Z�Gd�d��d�ej}�Z�Gd�d��d�ej}�Z�Gd�d��d��Z�Gd�d��d�e�ej��Z�Gd�d��d�e�ej��Z�dS)�zU
DNS protocol implementation.

Future Plans:
    - Get rid of some toplevels, maybe.
�N)�contextmanager)�BytesIO)�chain)�Optional�SupportsInt�Union)�	Attribute�	Interface�implementer)�defer�protocol)�CannotListenError)�failure�log�	randbytes�util)�cmp�
comparable�nativeString)e�
IEncodable�IRecord�IEncodableRecord�A�A6�AAAA�AFSDB�CNAME�DNAME�HINFO�MAILA�MAILB�MB�MD�MF�MG�MINFO�MR�MX�NAPTR�NS�NULL�OPT�PTR�RP�SOA�SPF�SRV�TXT�SSHFP�TSIG�WKS�ANY�CH�CS�HS�IN�ALL_RECORDS�AXFR�IXFR�EFORMAT�ENAME�ENOTIMP�EREFUSED�ESERVER�EBADVERSION�EBADSIG�EBADKEY�EBADTIME�Record_A�	Record_A6�Record_AAAA�Record_AFSDB�Record_CNAME�Record_DNAME�Record_HINFO�	Record_MB�	Record_MD�	Record_MF�	Record_MG�Record_MINFO�	Record_MR�	Record_MX�Record_NAPTR�	Record_NS�Record_NULL�
Record_PTR�	Record_RP�
Record_SOA�
Record_SPF�
Record_SRV�Record_SSHFP�Record_TSIG�
Record_TXT�
Record_WKS�
UnknownRecord�
QUERY_CLASSES�QUERY_TYPES�REV_CLASSES�	REV_TYPES�EXT_QUERIES�Charstr�Message�Name�Query�RRHeader�SimpleRecord�DNSDatagramProtocol�DNSMixin�DNSProtocol�OK�
OP_INVERSE�	OP_NOTIFY�OP_QUERY�	OP_STATUS�	OP_UPDATE�PORT�AuthoritativeDomainError�DNSDecodeError�DNSQueryTimeoutError�DomainErrorcCs
t|g�S)z�
    Construct a bytes object representing a single byte with the given
    ordinal value.

    @type ordinal: L{int}
    @rtype: L{bytes}
    ��bytes)�ordinal�r}�3/usr/lib/python3/dist-packages/twisted/names/dns.py�
_ord2bytes�s
rcCst|�dd�S)z�
    Represent a mostly textful bytes object in a way suitable for
    presentation to an end user.

    @param bytes: The bytes to represent.
    @rtype: L{str}
    �N)�reprrzr}r}r~�
_nicebytes�sr�cCsd�d�dd�|D���S)z�
    Represent a list of mostly textful bytes objects in a way suitable for
    presentation to an end user.

    @param list: The list of bytes to represent.
    @rtype: L{str}
    z[{}]�, cSsg|]}t|��qSr})r�)�.0�br}r}r~�
<listcomp>�sz"_nicebyteslist.<locals>.<listcomp>)�format�join)�listr}r}r~�_nicebyteslist�sr�cCst�dtjddd��dS)z�
    Wrapper around L{twisted.python.randbytes.RandomFactory.secureRandom} to
    return 2 random bytes.

    @rtype: L{bytes}
    �H�T)�fallbackr)�struct�unpackr�secureRandomr}r}r}r~�randomSource�sr��5r����!�#�&�'�)�,�c��rr)r"r#rr.r!r$r&r*r4r,rr%r'r1r-rrr0r(rrr+r2r/�TKEYr3��r<r;r rr:cC�i|]\}}||�qSr}r}�r��k�vr}r}r~�
<dictcomp>�r���r9r7r6r8r5cCr�r}r}r�r}r}r~r�r�����c@seZdZdZed�ZdS)rz0
    A single entry in a zone of authority.
    z,An indicator of what kind of record this is.N)�__name__�
__module__�__qualname__�__doc__r�TYPEr}r}r}r~rsr)rvrxrycCs2|dvrdgS|�d�}|ddkr|�d�|S)a2
    Split a domain name into its constituent labels.

    @type name: L{bytes}
    @param name: A fully qualified domain name (with or without a
        trailing dot).

    @return: A L{list} of labels ending with an empty label
        representing the DNS root zone.
    @rtype: L{list} of L{bytes}
    )��.r�r����)�split�append)�name�labelsr}r}r~�
_nameToLabels-s

r�cCs>t|t�r
|�d�}t|t�std�tjtj|t|����|S)a�
    Coerce a domain name string to bytes.

    L{twisted.names} represents domain names as L{bytes}, but many interfaces
    accept L{bytes} or a text string (L{unicode} on Python 2, L{str} on Python
    3). This function coerces text strings using IDNA encoding --- see
    L{encodings.idna}.

    Note that DNS is I{case insensitive} but I{case preserving}. This function
    doesn't normalize case, so you'll still need to do that whenever comparing
    the strings it returns.

    @param domain: A domain name.  If passed as a text string it will be
        C{idna} encoded.
    @type domain: L{bytes} or L{str}

    @returns: L{bytes} suitable for network transmission.
    @rtype: L{bytes}

    @since: Twisted 20.3.0
    �idnaz+Expected {} or {} but found {!r} of type {})�
isinstance�str�encoder{�	TypeErrorr�r��type)�domainr}r}r~�domainStringAs


��r�cCs.t|���}t|���}|t|�d�|kS)a)
    Test whether C{descendantName} is equal to or is a I{subdomain} of
    C{ancestorName}.

    The names are compared case-insensitively.

    The names are treated as byte strings containing one or more
    DNS labels separated by B{.}.

    C{descendantName} is considered equal if its sequence of labels
    exactly matches the labels of C{ancestorName}.

    C{descendantName} is considered a I{subdomain} if its sequence of
    labels ends with the labels of C{ancestorName}.

    @type descendantName: L{bytes}
    @param descendantName: The DNS subdomain name.

    @type ancestorName: L{bytes}
    @param ancestorName: The DNS parent or ancestor domain name.

    @return: C{True} if C{descendantName} is equal to or if it is a
        subdomain of C{ancestorName}. Otherwise returns C{False}.
    N)r��lower�len)�descendantName�ancestorName�descendantLabels�ancestorLabelsr}r}r~�_isSubdomainOfbsr�cCs�d}t|t�r|�d�}t|t�rF|����}|D]\}}|�|�r0tt|dd��|�Sqzt|�}W|St	yEt	d|��w|S)aE
    Parse a string description of an interval into an integer number of seconds.

    @param s: An interval definition constructed as an interval duration
        followed by an interval unit.  An interval duration is a base ten
        representation of an integer.  An interval unit is one of the following
        letters: S (seconds), M (minutes), H (hours), D (days), W (weeks), or Y
        (years).  For example: C{"3S"} indicates an interval of three seconds;
        C{"5D"} indicates an interval of five days.  Alternatively, C{s} may be
        any non-string and it will be returned unmodified.
    @type s: text string (L{bytes} or L{str}) for parsing; anything else
        for passthrough.

    @return: an L{int} giving the interval represented by the string C{s}, or
        whatever C{s} is if it is not a string.
    ))�Sr�)�M�<)r�i)�Di�Q)�Wi�:	)�Yi�3��asciiNr�z!Invalid time interval specifier: )
r�r{�decoder��upper�strip�endswith�int�float�
ValueError)�s�suffixes�suff�multr}r}r~�str2time�s 



�
��r�cCs|�|�}t|�|kr
t�|S�N)�readr��EOFError)�file�l�buffr}r}r~�
readPrecisely�s
r�c@�eZdZdZdS)rwzl
    Raised when a DNS message cannot be decoded because it violates a
    protocol-level safety limit.
    N�r�r�r�r�r}r}r}r~rw��rwc@s2eZdZdZdZddeddfdd�Zdd	d
�ZdS)
�_DecodeContexta�
    Mutable state shared between the L{IEncodable} decoders invoked while
    reading a single DNS message.

    The primary purpose is to bound the total number of compression-pointer
    jumps taken across every name in the message, defending against packets
    that fan out thousands of records pointing to deeply chained pointers.

    This class is private.  External callers must not rely on it; the
    per-message scope is installed and torn down by L{Message.decode}
    through L{_decodeContextVar}.

    @ivar jumps: The number of compression pointers followed so far.
    @ivar maxJumps: The inclusive upper bound on L{jumps}.  Exceeding it
        causes L{registerJump} to raise L{DNSDecodeError}.
    ��jumps�maxJumps��r��returnNcCsd|_||_dS)Nrr�)�selfr�r}r}r~�__init__�s
z_DecodeContext.__init__cCs0|jd7_|j|jkrtd|j�d���dS)aq
        Record that a compression pointer has been followed.

        The check is performed before any further bytes are read so the
        caller fails fast as soon as the aggregate limit is breached, even
        if additional records remain in the buffer.

        @raise DNSDecodeError: if the cumulative number of jumps exceeds
            L{maxJumps}.
        r�zCToo many compression pointers while decoding DNS message (limit is �)N)r�r�rw�r�r}r}r~�registerJump�s���z_DecodeContext.registerJump)r�)r�N)r�r�r�r��	__slots__r�r�r�r}r}r}r~r��s
r��_dnsDecodeContext)�default�_decodeContextVar�contextc	cs0�t�|�}z|VWt�|�dSt�|�w)ah
    Install C{context} on L{_decodeContextVar} for the duration of the
    C{with} block and restore the previous value on exit.

    This wraps the L{contextvars.ContextVar.set} / L{contextvars.ContextVar.reset}
    token dance so call sites can use a plain C{with} statement.

    @param context: The L{_DecodeContext} to install as the active context.
    N)r��set�reset)r��tokenr}r}r~�_installDecodeContext�s
�
r�c@s$eZdZdZddd�Zddd�ZdS)rz�
    Interface for something which can be encoded to and decoded
    to the DNS wire format.

    A binary-mode file object (such as L{io.BytesIO}) is used as a buffer when
    encoding or decoding.
    NcC�dS)a�
        Write a representation of this object to the given
        file object.

        @type strio: File-like object
        @param strio: The buffer to write to. It must have a C{tell()} method.

        @type compDict: L{dict} of L{bytes} to L{int} r L{None}
        @param compDict: A mapping of names to byte offsets that have already
        been written to the buffer, which may be used for compression (see RFC
        1035 section 4.1.4). When L{None}, encode without compression.
        Nr})�strio�compDictr}r}r~r�	�zIEncodable.encodecCr�)a�
        Reconstruct an object from data read from the given
        file object.

        @type strio: File-like object
        @param strio: A seekable buffer from which bytes may be read.

        @type length: L{int} or L{None}
        @param length: The number of bytes in this RDATA field.  Most
        implementations can ignore this value.  Only in the case of
        records similar to TXT where the total length is in no way
        encoded in the data is it necessary.
        Nr})r��lengthr}r}r~r�r�zIEncodable.decoder�)r�r�r�r�r�r�r}r}r}r~rs
rc@r�)rz`
    Interface for DNS records that can be encoded and decoded.

    @since: Twisted 21.2.0
    Nr�r}r}r}r~r'r�rc@sReZdZddd�Zddd�Zddd�Zd	ed
efdd�Zd
d�Z	d
e
fdd�ZdS)rfr�cCs"t|t�st|�d���||_dS)Nz is not a byte string)r�r{r��string)r�r�r}r}r~r�1s

zCharstr.__init__NcCs*|j}t|�}|�t|��|�|�dS)z�
        Encode this Character string into the appropriate byte format.

        @type strio: file
        @param strio: The byte representation of this Charstr will be written
            to this file.
        N)r�r��writer)r�r�r�r��indr}r}r~r�6szCharstr.encodecCs$d|_tt|d��}t||�|_dS)a 
        Decode a byte string into this Charstr.

        @type strio: file
        @param strio: Bytes will be read from this file until the full string
            is decoded.

        @raise EOFError: Raised when there are not enough bytes available from
            C{strio}.
        r�r�N)r��ordr�)r�r�r�r�r}r}r~r�CszCharstr.decode�otherr�cCst|t�r|j|jkStSr�)r�rfr��NotImplemented�r�rr}r}r~�__eq__Rs
zCharstr.__eq__cC�
t|j�Sr�)�hashr�r�r}r}r~�__hash__W�
zCharstr.__hash__cCr)zI
        Represent this L{Charstr} instance by its string value.
        )rr�r�r}r}r~�__str__Z�
zCharstr.__str__�r�r�)r�r�r�r�r�r��object�boolrr	r�rr}r}r}r~rf/s



rfc@sdeZdZUdZdZeed<ddd�Zddd	�Zdd
d�Z	de
d
efdd�Zdd�Z
d
efdd�ZdS)rhaB
    A name in the domain name system, made up of multiple labels.  For example,
    I{twistedmatrix.com}.

    @ivar name: A byte string giving the name.
    @type name: L{bytes}

    @ivar maxCompressionPointers: Per-message cap on the total number of
        compression-pointer dereferences L{decode} will follow before
        raising L{DNSDecodeError}.  Defaults to C{1000}.  Override it on
        a subclass or individual instance to tune the trade-off between
        tolerance for legitimately verbose messages and resistance to
        denial-of-service attacks.
    r��maxCompressionPointersr�cCst|�|_dS)zM
        @param name: A name.
        @type name: L{bytes} or L{str}
        N)r�r�)r�r�r}r}r~r�tsz
Name.__init__NcCs�|j}|rT|dur%||vr|�t�dd||B��dS|��tj||<|�d�}|dkr>|d|�||dd�}}n|}d}t|�}|�t	|��|�|�|s|�d�dS)a�
        Encode this Name into the appropriate byte format.

        @type strio: file
        @param strio: The byte representation of this Name will be written to
        this file.

        @type compDict: dict
        @param compDict: dictionary of Names that have already been encoded
        and whose addresses may be backreferenced by this Name (for the purpose
        of reducing the message size).
        N�!Hi�r�rr��)
r�rr��pack�tellrg�
headerSize�findr�r)r�r�r�r�r�labelr}r}r~r�{s"

 
�zName.encodec	Cs�t��}|durt|jd�}t�}d|_d}	tt|d��}|dkr-|dkr+|�|�dS|d?dkr_|d@d	>tt|d��B}|�	�||vrLt
d
��|�|�|dkrY|��}|�|�qt||�}|jdkrm||_n|jd||_q)a3
        Decode a byte string into this Name.

        When invoked from L{Message.decode}, a shared compression-pointer
        counter is picked up transparently from the private
        L{_decodeContextVar}.  Standalone callers get a fresh per-call
        counter seeded from L{maxCompressionPointers}, so existing code
        keeps working unchanged while still being protected against
        pathological inputs.

        @type strio: file
        @param strio: Bytes will be read from this file until the full Name
            is decoded.

        @type length: L{int} or L{None}
        @param length: Present for compatibility with the L{IEncodable}
            interface; ignored by this decoder.

        @raise EOFError: Raised when there are not enough bytes available
            from C{strio}.

        @raise ValueError: Raised when the name cannot be decoded because
            it contains a compression loop.

        @raise DNSDecodeError: Raised when the cumulative number of
            compression-pointer jumps exceeds the configured limit.
        N�r�r�rr�r�r��?�z Compression loop in encoded namer�)
r��getr�rr�r�rr��seekr�r��addr)	r�r�r�r��visited�offr��new_offrr}r}r~r��s6




�zName.decoderr�cCs"t|t�r|j��|j��kStSr�)r�rhr�r�rrr}r}r~r�s
zName.__eq__cCrr��rr�r�r}r}r~r	�r
z
Name.__hash__cCr)zE
        Represent this L{Name} instance by its string name.
        �rr�r�r}r}r~r�rzName.__str__r
r�)r�r�r�r�rr��__annotations__r�r�r�rrrr	r�rr}r}r}r~rhas



!8rhc@sveZdZdZdeefdeeefde	de	fdd�Z
dd	d
�Zddd�Zd
d�Z
dd�Zdefdd�Zdefdd�ZdS)riz�
    Represent a single DNS query.

    @ivar name: The name about which this query is requesting information.
    @type name: L{Name}

    @ivar type: The query type.
    @type type: L{int}

    @ivar cls: The query class.
    @type cls: L{int}
    r�r�r��clscCst|�|_||_||_dS)z�
        @type name: L{bytes} or L{str}
        @param name: See L{Query.name}

        @type type: L{int}
        @param type: The query type.

        @type cls: L{int}
        @param cls: The query class.
        N)rhr�r�r$�r�r�r�r$r}r}r~r��s

zQuery.__init__NcCs*|j�||�|�t�d|j|j��dS�N�!HH)r�r�rr�rr�r$�r�r�r�r}r}r~r�szQuery.encodecCs.|j�|�t|d�}t�d|�\|_|_dS)Nr�r')r�r�r�r�r�r�r$)r�r�r�r�r}r}r~r�s
zQuery.decodecCst|jj��|j|jf�Sr�)rr�r�r�r$r�r}r}r~r	szQuery.__hash__cCs<t|t�rt|jj��|j|jf|jj��|j|jf�StSr�)r�rirr�r�r�r$rrr}r}r~�__cmp__s
�z
Query.__cmp__r�cCsLt�|jt�|jd|j��}t�|jd|j�}d|j�d|�d|�d�S)N�UNKNOWN (%d)z<Query � �>)rbrr�rerar$r��r��t�cr}r}r~rs
�z
Query.__str__cCs d|jj�d|j�d|j�d�S)NzQuery(r�r�)r�r�r$r�r}r}r~�__repr__� zQuery.__repr__r�)r�r�r�r�rr9rr{r�r�r�r�r�r	r)rr0r}r}r}r~ri�s&

ric@szeZdZdZddd�fddddd	d
fZdZ		
	
		ddd�Zedd��Zedd��Z	ddd�Z
ddd�Zedd��Z
dS)�
_OPTHeaderaZ
    An OPT record header.

    @ivar name: The DNS name associated with this record. Since this
        is a pseudo record, the name is always an L{Name} instance
        with value b'', which represents the DNS root zone. This
        attribute is a readonly property.

    @ivar type: The DNS record type. This is a fixed value of 41
        C{dns.OPT} for OPT Record. This attribute is a readonly
        property.

    @see: L{_OPTHeader.__init__} for documentation of other public
        instance attributes.

    @see: U{https://tools.ietf.org/html/rfc6891#section-6.1.2}

    @since: 13.2
    r�cCrr�r")�nr}r}r~�<lambda>8s
z_OPTHeader.<lambda>r��udpPayloadSize�
extendedRCODE�version�dnssecOK�options)r�r�r5r6r7r8r9�rFNcCs.||_||_||_||_|durg}||_dS)a�
        @type udpPayloadSize: L{int}
        @param udpPayloadSize: The number of octets of the largest UDP
            payload that can be reassembled and delivered in the
            requestor's network stack.

        @type extendedRCODE: L{int}
        @param extendedRCODE: Forms the upper 8 bits of extended
            12-bit RCODE (together with the 4 bits defined in
            [RFC1035].  Note that EXTENDED-RCODE value 0 indicates
            that an unextended RCODE is in use (values 0 through 15).

        @type version: L{int}
        @param version: Indicates the implementation level of the
            setter.  Full conformance with this specification is
            indicated by version C{0}.

        @type dnssecOK: L{bool}
        @param dnssecOK: DNSSEC OK bit as defined by [RFC3225].

        @type options: L{list}
        @param options: A L{list} of 0 or more L{_OPTVariableOption}
            instances.
        N�r5r6r7r8r9)r�r5r6r7r8r9r}r}r~r�Ks 
z_OPTHeader.__init__cCstd�S)a/
        A readonly property for accessing the C{name} attribute of
        this record.

        @return: The DNS name associated with this record. Since this
            is a pseudo record, the name is always an L{Name} instance
            with value b'', which represents the DNS root zone.
        r�)rhr�r}r}r~r�ts
z_OPTHeader.namecCstS)z�
        A readonly property for accessing the C{type} attribute of
        this record.

        @return: The DNS record type. This is a fixed value of 41
            (C{dns.OPT} for OPT Record.
        )r+r�r}r}r~r��s	z_OPTHeader.typecCsht�}|jD]}|�|�q|��}t|jj|j|j|jd>|j	d>B|j
d>Bt|�d��||�dS)a�
        Encode this L{_OPTHeader} instance to bytes.

        @type strio: file
        @param strio: the byte representation of this L{_OPTHeader}
            will be written to this file.

        @type compDict: L{dict} or L{None}
        @param compDict: A dictionary of backreference addresses that
            have already been written to this stream and that may
            be used for DNS name compression.
        �r��)r�r�r$�ttl�payloadN)rr9r��getvaluerjr�r�r5r6r7r8r`)r�r�r�r��o�optionBytesr}r}r~r��s
�z_OPTHeader.encodecCsXt�}|�||�tt||j��|_|�|�}|jD]}|dvr)t||t	||��qdS)a
        Decode bytes into an L{_OPTHeader} instance.

        @type strio: file
        @param strio: Bytes will be read from this file until the full
            L{_OPTHeader} is decoded.

        @type length: L{int} or L{None}
        @param length: Not used.
        )r�r�N)
rjr�r`r��rdlengthr?�fromRRHeader�compareAttributes�setattr�getattr)r�r�r��h�newOptHeader�attrNamer}r}r~r��s

��z_OPTHeader.decodecCs�d}|jdur.g}t|jj�}t|jj�}|��|kr.t�}|�|�|�|�|��|ks||j|j	d?|j	d?d@|j	d@d?|d�S)ai
        A classmethod for constructing a new L{_OPTHeader} from the
        attributes and payload of an existing L{RRHeader} instance.

        @type rrHeader: L{RRHeader}
        @param rrHeader: An L{RRHeader} instance containing an
            L{UnknownRecord} payload.

        @return: An instance of L{_OPTHeader}.
        @rtype: L{_OPTHeader}
        Nr<r�r�i��r=r;)
r?r�datar�r�_OPTVariableOptionr�r�r$r>)r$�rrHeaderr9�optionsBytes�optionsBytesLengthrAr}r}r~rD�s"


��z_OPTHeader.fromRRHeader)r:rrFNr�)r�r�r�r��showAttributesrEr��propertyr�r�r�r��classmethodrDr}r}r}r~r2!s2
�

�)




r2c@sBeZdZdZddeffZdZdZddd	�Zddd�Z	dd
d�Z
d
S)rLz�
    A class to represent OPT record variable options.

    @see: L{_OPTVariableOption.__init__} for documentation of public
        instance attributes.

    @see: U{https://tools.ietf.org/html/rfc6891#section-6.1.2}

    @since: 13.2
    �coderK�rSrKr'rr�cCs||_||_dS)z�
        @type code: L{int}
        @param code: The option code

        @type data: L{bytes}
        @param data: The option data
        NrT)r�rSrKr}r}r~r��s
z_OPTVariableOption.__init__NcCs(|�t�|j|jt|j��|j�dS)a�
        Encode this L{_OPTVariableOption} to bytes.

        @type strio: file
        @param strio: the byte representation of this
            L{_OPTVariableOption} will be written to this file.

        @type compDict: L{dict} or L{None}
        @param compDict: A dictionary of backreference addresses that
            have already been written to this stream and that may
            be used for DNS name compression.
        N)rr�r�_fmtrSr�rKr(r}r}r~r��s(
z_OPTVariableOption.encodecCs:t�|j�}t||�}t�|j|�\|_}t||�|_dS)a 
        Decode bytes into an L{_OPTVariableOption} instance.

        @type strio: file
        @param strio: Bytes will be read from this file until the full
            L{_OPTVariableOption} is decoded.

        @type length: L{int} or L{None}
        @param length: Not used.
        N)r��calcsizerUr�r�rSrK)r�r�r�r�r�r}r}r~r�s
z_OPTVariableOption.decode)rr�r�)r�r�r�r�rrPrErUr�r�r�r}r}r}r~rL�s

rLc
@s�eZdZdZdZdZdZdZdee	dddfde
eefd	e
d
e
dedeed
efdd�Zddd�Zddd�Zdd�Zdefdd�ZeZdS)rjak
    A resource record header.

    @cvar fmt: L{str} specifying the byte format of an RR.

    @ivar name: The name about which this reply contains information.
    @type name: L{Name}

    @ivar type: The query type of the original request.
    @type type: L{int}

    @ivar cls: The query class of the original request.

    @ivar ttl: The time-to-live for this record.
    @type ttl: L{int}

    @ivar payload: The record described by this header.
    @type payload: L{IEncodableRecord} or L{None}

    @ivar auth: A L{bool} indicating whether this C{RRHeader} was parsed from
        an authoritative message.
    )r�r�r$r>r?�authz!HHIHNr�rFr�r�r$r>r?rWc	Cs�|durdn|j}|dur!||kr!tdt�||�t�||�f��t|�}|dkr-td��t|�|_||_||_||_	||_
||_dS)a�
        @type name: L{bytes} or L{str}
        @param name: See L{RRHeader.name}

        @type type: L{int}
        @param type: The query type.

        @type cls: L{int}
        @param cls: The query class.

        @type ttl: L{int}
        @param ttl: Time to live for this record.  This will be
            converted to an L{int}.

        @type payload: L{IEncodableRecord} or L{None}
        @param payload: An optional Query Type specific data object.

        @raises TypeError: if the ttl cannot be converted to an L{int}.
        @raises ValueError: if the ttl is negative.
        @raises ValueError: if the payload type is not equal to the C{type}
                            argument.
        Nz0Payload type (%s) does not match given type (%s)rzTTL cannot be negative)r�r�rbrr�rhr�r�r$r>r?rW)	r�r�r�r$r>r?rW�payloadType�integralTTLr}r}r~r�:s$

���

zRRHeader.__init__c	Cs�|j�||�|�t�|j|j|j|jd��|j	rD|�
�}|j	�||�|�
�}|�|dd�|�t�d||��|�|d�dSdS)Nrr�r)r�r�rr�r�fmtr�r$r>r?rr)r�r�r��prefix�aftr}r}r~r�os �zRRHeader.encodecCsH|j�|�t�|j�}t||�}t�|j|�}|\|_|_|_	|_
dSr�)r�r�r�rVrZr�r�r�r$r>rC)r�r�r�r�r��rr}r}r~r�zs

zRRHeader.decodecCs|jSr��rWr�r}r}r~�isAuthoritative�szRRHeader.isAuthoritativer�cCsRt�|jt�|jd|j��}t�|jd|j�}d|j|||j|jr%dp&dfS)Nr*z-<RR name=%s type=%s class=%s ttl=%ds auth=%s>�True�False)	rbrr�rerar$r�r>rWr-r}r}r~r�s��zRRHeader.__str__r�)r�r�r�r�rErZrC�cachedResponserr9rr{r�r�rrrrr�r�r�r_rr0r}r}r}r~rjs<�
�����
�
5

rjc@sTeZdZUdZdZdZdZeee	d<dZ
ddd�Zdd	d
�Zddd�Z
d
d�ZdS)rka
    A Resource Record which consists of a single RFC 1035 domain-name.

    @type name: L{Name}
    @ivar name: The name associated with this record.

    @type ttl: L{int}
    @ivar ttl: The maximum number of seconds which this record should be
        cached.
    )�r�r��%sr>)r�r>Nr�r�cCst|�|_t|�|_dS)z^
        @param name: See L{SimpleRecord.name}
        @type name: L{bytes} or L{str}
        N)rhr�r�r>)r�r�r>r}r}r~r��s
zSimpleRecord.__init__cCs|j�||�dSr�)r�r�r(r}r}r~r��szSimpleRecord.encodecCst�|_|j�|�dSr�)rhr�r��r�r�r�r}r}r~r��szSimpleRecord.decodecCrr�r!r�r}r}r~r	�r
zSimpleRecord.__hash__�r�Nr�)r�r�r�r�rPrEr�rr�r#r�r�r�r�r	r}r}r}r~rk�s



rkc@�eZdZdZeZdZdS)rUz&
    An authoritative nameserver.
    r)N)r�r�r�r�r)r��
fancybasenamer}r}r}r~rU��rUc@rg)rNzX
    A mail destination.

    This record type is obsolete.

    @see: L{Record_MX}
    r"N)r�r�r�r�r"r�rhr}r}r}r~rN��rNc@rg)rOzV
    A mail forwarder.

    This record type is obsolete.

    @see: L{Record_MX}
    r#N)r�r�r�r�r#r�rhr}r}r}r~rO�rjrOc@rg)rJz*
    The canonical name for an alias.
    rN)r�r�r�r�rr�rhr}r}r}r~rJ�rirJc@rg)rMzJ
    A mailbox domain name.

    This is an experimental record type.
    r!N)r�r�r�r�r!r�rhr}r}r}r~rM��rMc@rg)rPzH
    A mail group member.

    This is an experimental record type.
    r$N)r�r�r�r�r$r�rhr}r}r}r~rP�rkrPc@rg)rRzN
    A mail rename domain name.

    This is an experimental record type.
    r&N)r�r�r�r�r&r�rhr}r}r}r~rR�rkrRc@rg)rWz 
    A domain name pointer.
    r,N)r�r�r�r�r,r�rhr}r}r}r~rWrirWc@rg)rKa[
    A non-terminal DNS name redirection.

    This record type provides the capability to map an entire subtree of the
    DNS name space to another domain.  It differs from the CNAME record which
    maps a single node of the name space.

    @see: U{http://www.faqs.org/rfcs/rfc2672.html}
    @see: U{http://www.faqs.org/rfcs/rfc3363.html}
    rN)r�r�r�r�rr�rhr}r}r}r~rKsrKc@s\eZdZdZdZeZdZddd�Zddd�Z	dd	d
�Z
dd�Zd
efdd�Z
e
Zdd�ZdS)rFa 
    An IPv4 host address.

    @type address: L{bytes}
    @ivar address: The packed network-order representation of the IPv4 address
        associated with this record.

    @type ttl: L{int}
    @ivar ttl: The maximum number of seconds which this record should be
        cached.
    ��addressr>N�0.0.0.0cCs2t|t�r
|�d�}t�|�}||_t|�|_dS)��
        @type address: L{bytes} or L{str}
        @param address: The IPv4 address associated with this record, in
            quad-dotted notation.
        r�N)r�r{r��socket�	inet_atonrmr�r>�r�rmr>r}r}r~r�4s



zRecord_A.__init__cC�|�|j�dSr��rrmr(r}r}r~r�A�zRecord_A.encodecC�t|d�|_dS)Nr��r�rmrer}r}r~r�DruzRecord_A.decodecCrr��rrmr�r}r}r~r	Gr
zRecord_A.__hash__r�cCsd|���d|j�d�S)Nz<A address=z ttl=r,)�
dottedQuadr>r�r}r}r~rJ�zRecord_A.__str__cC�t�|j�Sr��rp�	inet_ntoarmr�r}r}r~ryOszRecord_A.dottedQuad)rnNr�)r�r�r�r�rErr�rmr�r�r�r	r�rr0ryr}r}r}r~rF!s


rFc@sVeZdZdZdZdZdZeZ								ddd	�Z	dd
d�Z
ddd
�Zdd�ZdS)rYaA
    Marks the start of a zone of authority.

    This record describes parameters which are shared by all records within a
    particular zone.

    @type mname: L{Name}
    @ivar mname: The domain-name of the name server that was the original or
        primary source of data for this zone.

    @type rname: L{Name}
    @ivar rname: A domain-name which specifies the mailbox of the person
        responsible for this zone.

    @type serial: L{int}
    @ivar serial: The unsigned 32 bit version number of the original copy of
        the zone.  Zone transfers preserve this value.  This value wraps and
        should be compared using sequence space arithmetic.

    @type refresh: L{int}
    @ivar refresh: A 32 bit time interval before the zone should be refreshed.

    @type minimum: L{int}
    @ivar minimum: The unsigned 32 bit minimum TTL field that should be
        exported with any RR from this zone.

    @type expire: L{int}
    @ivar expire: A 32 bit time value that specifies the upper limit on the
        time interval that can elapse before the zone is no longer
        authoritative.

    @type retry: L{int}
    @ivar retry: A 32 bit time interval that should elapse before a failed
        refresh should be retried.

    @type ttl: L{int}
    @ivar ttl: The default TTL to use for records served from this zone.
    r.)�serial�mname�rname�refresh�expire�retry�minimumr>))rrrd)r�r�rdr~r�r�r�r�r>r�rNc		CsZt|�t|�|_|_t|�t|�|_|_t|�t|�|_|_t|�|_t|�|_	dS)z�
        @param mname: See L{Record_SOA.mname}
        @type mname: L{bytes} or L{str}

        @param rname: See L{Record_SOA.rname}
        @type rname: L{bytes} or L{str}
        N)
rhrr�r�r~r�r�r�r�r>)	r�rr�r~r�r�r�r�r>r}r}r~r��s

zRecord_SOA.__init__c
CsD|j�||�|j�||�|�t�d|j|j|j|j	|j
��dS)N�!LlllL)rr�r�rr�rr~r�r�r�r�r(r}r}r~r��s��zRecord_SOA.encodecCsXt�t�|_|_|j�|�|j�|�t�dt|d��}|\|_|_|_	|_
|_dS)Nr��)rhrr�r�r�r�r�r~r�r�r�r��r�r�r�r]r}r}r~r��s
zRecord_SOA.decodecC� t|j|j|j|j|j|jf�Sr�)rr~rr�r�r�r�r�r}r}r~r	�s�zRecord_SOA.__hash__)r�r�rrrrrNr�)
r�r�r�r�rhrErPr.r�r�r�r�r	r}r}r}r~rYSs$'

�

rYc@sNeZdZdZdZdefdfZdZeZ	ddd�Z
dd	d
�Zddd�Zd
d�Z
dS)rVz�
    A null record.

    This is an experimental record type.

    @type ttl: L{int}
    @ivar ttl: The maximum number of seconds which this record should be
        cached.
    r*r?r>)r?r>NcC�||_t|�|_dSr�)r?r�r>)r�r?r>r}r}r~r���zRecord_NULL.__init__cCrsr�)rr?r(r}r}r~r��ruzRecord_NULL.encodecCst||�|_dSr�)r�r?rer}r}r~r��ruzRecord_NULL.decodecCrr�)rr?r�r}r}r~r	�r
zRecord_NULL.__hash__)NNr�)r�r�r�r�rhr�rPrEr*r�r�r�r�r	r}r}r}r~rV�s



rVc@sVeZdZdZdZdZgd�ZeZe	dd��Z
ddd�Zdd
d�Zddd�Z
dd�Zd
S)r_aX
    A well known service description.

    This record type is obsolete.  See L{Record_SRV}.

    @type address: L{bytes}
    @ivar address: The packed network-order representation of the IPv4 address
        associated with this record.

    @type protocol: L{int}
    @ivar protocol: The 8 bit IP protocol number for which this service map is
        relevant.

    @type map: L{bytes}
    @ivar map: A bitvector indicating the services available at the specified
        address.

    @type ttl: L{int}
    @ivar ttl: The maximum number of seconds which this record should be
        cached.
    r4)rmr�mapr>)��_addressrmrdrr>cCr{r�r|r�r}r}r~r�szRecord_WKS._addressrnrr�NcCs<t|t�r
|�d�}t�|�|_|||_|_t|�|_	dS)ror�N)
r�r{r�rprqrmrr�r�r>)r�rmrr�r>r}r}r~r�	s


zRecord_WKS.__init__cCs0|�|j�|�t�d|j��|�|j�dS�N�!B)rrmr�rrr�r(r}r}r~r�szRecord_WKS.encodecCs8t|d�|_t�dt|d��d|_t||d�|_dS)Nr�r�r�rr�)r�rmr�r�rr�rer}r}r~r�szRecord_WKS.decodecC�t|j|j|jf�Sr�)rrmrr�r�r}r}r~r	 �zRecord_WKS.__hash__)rnrr�Nr�)r�r�r�r�rhrErPr4r�rQr�r�r�r�r	r}r}r}r~r_�s



r_c@sReZdZdZeZdZdZdZe	dd��Z
dd	d
�Zddd�Zdd
d�Z
dd�ZdS)rHaT
    An IPv6 host address.

    @type address: L{bytes}
    @ivar address: The packed network-order representation of the IPv6 address
        associated with this record.

    @type ttl: L{int}
    @ivar ttl: The maximum number of seconds which this record should be
        cached.

    @see: U{http://www.faqs.org/rfcs/rfc1886.html}
    r)r�r>rlcC�t�t|j�Sr�)rp�	inet_ntop�AF_INET6rmr�r}r}r~r�:�zRecord_AAAA._address�::NcCs0t|t�r
|�d�}t�t|�|_t|�|_dS)z
        @type address: L{bytes} or L{str}
        @param address: The IPv6 address for this host, in RFC 2373 format.
        r�N)	r�r{r�rp�	inet_ptonr�rmr�r>rrr}r}r~r�>s

zRecord_AAAA.__init__cCrsr�rtr(r}r}r~r�IruzRecord_AAAA.encodecCrv)Nr�rwrer}r}r~r�LruzRecord_AAAA.decodecCrr�rxr�r}r}r~r	Or
zRecord_AAAA.__hash__)r�Nr�)r�r�r�r�rr�rhrPrErQr�r�r�r�r	r}r}r}r~rH$s



rHc@sreZdZdZeZdZdZdZe	dd��Z
ddd�Zdd
d�Zddd�Z
dedefdd�Zdd�Zdefdd�Zd
S)rGa�
    An IPv6 address.

    This is an experimental record type.

    @type prefixLen: L{int}
    @ivar prefixLen: The length of the suffix.

    @type suffix: L{bytes}
    @ivar suffix: An IPv6 address suffix in network order.

    @type prefix: L{Name}
    @ivar prefix: If specified, a name which will be used as a prefix for other
        A6 records.

    @type bytes: L{int}
    @ivar bytes: The length of the prefix.

    @type ttl: L{int}
    @ivar ttl: The maximum number of seconds which this record should be
        cached.

    @see: U{http://www.faqs.org/rfcs/rfc2874.html}
    @see: U{http://www.faqs.org/rfcs/rfc3363.html}
    @see: U{http://www.faqs.org/rfcs/rfc3364.html}
    r))�_suffix�suffixrd)r[r[rdr>)�	prefixLenr[r�r>cCr�r�)rpr�r�r�r�r}r}r~r�vr�zRecord_A6._suffixrr�r�NcCsTt|t�r
|�d�}||_t�t|�|_t|�|_	t
d|jd�|_t|�|_dS)z�
        @param suffix: An IPv6 address suffix in in RFC 2373 format.
        @type suffix: L{bytes} or L{str}

        @param prefix: An IPv6 address prefix for other A6 records.
        @type prefix: L{bytes} or L{str}
        r��� @N)
r�r{r�r�rpr�r�r�rhr[r�r�r>)r�r�r�r[r>r}r}r~r�zs


zRecord_A6.__init__cCsN|�t�d|j��|jr|�|j|jd��|jr%|j�|d�dSdSr�)rr�rr�r{r�r[r�r(r}r}r~r��s�zRecord_A6.encodecCsht�dt|d��d|_td|jd�|_|jr'dd|jt||j�|_|jr2|j�|�dSdS)Nr�r�rr�r�rr�)	r�r�r�r�r�r{r�r[r�rer}r}r~r��s�zRecord_A6.decoderr�cCsVt|t�r)|j|jko(|j|jd�|j|jd�ko(|j|jko(|j|jkStSr�)r�rGr�r�r{r[r>rrr}r}r~r�s
"�
�
�zRecord_A6.__eq__cCs t|j|j|jd�|jf�Sr�)rr�r�r{r[r�r}r}r~r	�r1zRecord_A6.__hash__cCs d|jt�t|j�|j|jfS)Nz<A6 %s %s (%d) ttl=%s>)r[rpr�r�r�r�r>r�r}r}r~r�s�zRecord_A6.__str__)rr�r�Nr�)r�r�r�r�rr�rhrPrErQr�r�r�r�rrrr	r�rr}r}r}r~rGSs




rGc@�FeZdZdZeZdZdZdZddd	�Z	dd
d�Z
ddd
�Zdd�ZdS)r[a:
    The location of the server(s) for a specific protocol and domain.

    This is an experimental record type.

    @type priority: L{int}
    @ivar priority: The priority of this target host.  A client MUST attempt to
        contact the target host with the lowest-numbered priority it can reach;
        target hosts with the same priority SHOULD be tried in an order defined
        by the weight field.

    @type weight: L{int}
    @ivar weight: Specifies a relative weight for entries with the same
        priority. Larger weights SHOULD be given a proportionately higher
        probability of being selected.

    @type port: L{int}
    @ivar port: The port on this target host of this service.

    @type target: L{Name}
    @ivar target: The domain name of the target host.  There MUST be one or
        more address records for this name, the name MUST NOT be an alias (in
        the sense of RFC 1034 or RFC 2181).  Implementors are urged, but not
        required, to return the address record(s) in the Additional Data
        section.  Unless and until permitted by future standards action, name
        compression is not to be used for this field.

    @type ttl: L{int}
    @ivar ttl: The maximum number of seconds which this record should be
        cached.

    @see: U{http://www.faqs.org/rfcs/rfc2782.html}
    r0)�priority�weight�target�portr>)r�r�)r�r�rdr�r>rr�NcCs6t|�|_t|�|_t|�|_t|�|_t|�|_dS)zb
        @param target: See L{Record_SRV.target}
        @type target: L{bytes} or L{str}
        N)r�r�r�r�rhr�r�r>)r�r�r�r�r�r>r}r}r~r��s




zRecord_SRV.__init__cCs.|�t�d|j|j|j��|j�|d�dS�N�!HHH)rr�rr�r�r�r�r�r(r}r}r~r��szRecord_SRV.encodecCs@t�dt|t�d���}|\|_|_|_t�|_|j�	|�dSr�)
r�r�r�rVr�r�r�rhr�r�r�r}r}r~r��szRecord_SRV.decodecC�t|j|j|j|jf�Sr�)rr�r�r�r�r�r}r}r~r	�rzzRecord_SRV.__hash__)rrrr�Nr�)
r�r�r�r�r0r�rhrErPr�r�r�r	r}r}r}r~r[�s"


r[c@sTeZdZdZeZdZdZdZ							ddd	�Z	dd
d�Z
ddd
�Zdd�ZdS)rTa
    The location of the server(s) for a specific protocol and domain.

    @type order: L{int}
    @ivar order: An integer specifying the order in which the NAPTR records
        MUST be processed to ensure the correct ordering of rules.  Low numbers
        are processed before high numbers.

    @type preference: L{int}
    @ivar preference: An integer that specifies the order in which NAPTR
        records with equal "order" values SHOULD be processed, low numbers
        being processed before high numbers.

    @type flag: L{Charstr}
    @ivar flag: A <character-string> containing flags to control aspects of the
        rewriting and interpretation of the fields in the record.  Flags
        are single characters from the set [A-Z0-9].  The case of the alphabetic
        characters is not significant.

        At this time only four flags, "S", "A", "U", and "P", are defined.

    @type service: L{Charstr}
    @ivar service: Specifies the service(s) available down this rewrite path.
        It may also specify the particular protocol that is used to talk with a
        service.  A protocol MUST be specified if the flags field states that
        the NAPTR is terminal.

    @type regexp: L{Charstr}
    @ivar regexp: A STRING containing a substitution expression that is applied
        to the original string held by the client in order to construct the
        next domain name to lookup.

    @type replacement: L{Name}
    @ivar replacement: The next NAME to query for NAPTR, SRV, or address
        records depending on the value of the flags field.  This MUST be a
        fully qualified domain-name.

    @type ttl: L{int}
    @ivar ttl: The maximum number of seconds which this record should be
        cached.

    @see: U{http://www.faqs.org/rfcs/rfc2915.html}
    )�order�
preference�flags�service�regexp�replacementr()r�r�)r�r�rd)r�r�rd)r�r�rd)r�r�rdr>rr�NcCsJt|�|_t|�|_t|�|_t|�|_t|�|_t|�|_t	|�|_
dS)zs
        @param replacement: See L{Record_NAPTR.replacement}
        @type replacement: L{bytes} or L{str}
        N)r�r�r�rfr�r�r�rhr�r�r>)r�r�r�r�r�r�r�r>r}r}r~r�9s





zRecord_NAPTR.__init__cCsT|�t�d|j|j��|j�|d�|j�|d�|j�|d�|j	�|d�dSr&)
rr�rr�r�r�r�r�r�r�r(r}r}r~r�Os
zRecord_NAPTR.encodecCsxt�dt|t�d���}|\|_|_t�|_t�|_t�|_	t
�|_|j�|�|j�|�|j	�|�|j�|�dSr&)
r�r�r�rVr�r�rfr�r�r�rhr�r�r�r}r}r~r�WszRecord_NAPTR.decodecCr�r�)rr�r�r�r�r�r�r�r}r}r~r	cs��zRecord_NAPTR.__hash__)rrr�r�r�r�Nr�)
r�r�r�r�r(r�rErhrPr�r�r�r	r}r}r}r~rT�s",
�

rTc@r�)rIa�
    Map from a domain name to the name of an AFS cell database server.

    @type subtype: L{int}
    @ivar subtype: In the case of subtype 1, the host has an AFS version 3.0
        Volume Location Server for the named AFS cell.  In the case of subtype
        2, the host has an authenticated name server holding the cell-root
        directory node for the named DCE/NCA cell.

    @type hostname: L{Name}
    @ivar hostname: The domain name of a host that has a server for the cell
        named by this record.

    @type ttl: L{int}
    @ivar ttl: The maximum number of seconds which this record should be
        cached.

    @see: U{http://www.faqs.org/rfcs/rfc1183.html}
    r)�subtype�hostnamer>)r�)r�r�rdr>rr�NcCs"t|�|_t|�|_t|�|_dS)zj
        @param hostname: See L{Record_AFSDB.hostname}
        @type hostname: L{bytes} or L{str}
        N)r�r�rhr�r�r>)r�r�r�r>r}r}r~r��s

zRecord_AFSDB.__init__cC�&|�t�d|j��|j�||�dS�Nr)rr�rr�r�r�r(r}r}r~r���zRecord_AFSDB.encodecCs0t�dt|t�d���}|\|_|j�|�dSr�)r�r�r�rVr�r�r�r�r}r}r~r���zRecord_AFSDB.decodecC�t|j|jf�Sr�)rr�r�r�r}r}r~r	�ruzRecord_AFSDB.__hash__�rr�Nr�)
r�r�r�r�rr�rhrErPr�r�r�r	r}r}r}r~rIps

	
rIc@sFeZdZdZeZdZdZdZddd�Z	dd	d
�Z
ddd�Zd
d�ZdS)rXa�
    The responsible person for a domain.

    @type mbox: L{Name}
    @ivar mbox: A domain name that specifies the mailbox for the responsible
        person.

    @type txt: L{Name}
    @ivar txt: A domain name for which TXT RR's exist (indirection through
        which allows information sharing about the contents of this RP record).

    @type ttl: L{int}
    @ivar ttl: The maximum number of seconds which this record should be
        cached.

    @see: U{http://www.faqs.org/rfcs/rfc1183.html}
    r-)�mbox�txtr>))r�r�rd)r�r�rdr>r�NcCs"t|�|_t|�|_t|�|_dS)z�
        @param mbox: See L{Record_RP.mbox}.
        @type mbox: L{bytes} or L{str}

        @param txt: See L{Record_RP.txt}
        @type txt: L{bytes} or L{str}
        N)rhr�r�r�r>)r�r�r�r>r}r}r~r��s

zRecord_RP.__init__cC� |j�||�|j�||�dSr�)r�r�r�r(r}r}r~r���zRecord_RP.encodecCs,t�|_t�|_|j�|�|j�|�dSr�)rhr�r�r�rer}r}r~r��szRecord_RP.decodecCr�r�)rr�r�r�r}r}r~r	�ruzRecord_RP.__hash__�r�r�Nr�)
r�r�r�r�r-r�rhrErPr�r�r�r	r}r}r}r~rX�s


rXc@sfeZdZdZeZdZdefdefdfZdZ	dd	d
�Z
ddd�Zdd
d�Zde
defdd�Zdd�ZdS)rLa
    Host information.

    @type cpu: L{bytes}
    @ivar cpu: Specifies the CPU type.

    @type os: L{bytes}
    @ivar os: Specifies the OS.

    @type ttl: L{int}
    @ivar ttl: The maximum number of seconds which this record should be
        cached.
    r�cpu�osr>)r�r�r>r�NcCs|||_|_t|�|_dSr�)r�r�r�r>)r�r�r�r>r}r}r~r��szRecord_HINFO.__init__cCs@|�t�dt|j��|j�|�t�dt|j��|j�dSr�)rr�rr�r�r�r(r}r}r~r��s"zRecord_HINFO.encodecCsHt�dt|d��d}t||�|_t�dt|d��d}t||�|_dS)Nr�r�r)r�r�r�r�r�)r�r�r�r�r�r}r}r~r��szRecord_HINFO.decoderr�cCsBt|t�r|j��|j��ko|j��|j��ko|j|jkStSr�)r�rLr�r�r�r>rrr}r}r~r�s
�
�zRecord_HINFO.__eq__cCst|j��|j��f�Sr�)rr�r�r�r�r}r}r~r	rzzRecord_HINFO.__hash__r�r�)r�r�r�r�rr�rhr�rPrEr�r�r�rrrr	r}r}r}r~rL�s


	rLc@sNeZdZdZeZdZdZdZdZ	dZ
ddd�Zdd	d
�Zddd�Z
d
d�ZdS)rQa�
    Mailbox or mail list information.

    This is an experimental record type.

    @type rmailbx: L{Name}
    @ivar rmailbx: A domain-name which specifies a mailbox which is responsible
        for the mailing list or mailbox.  If this domain name names the root,
        the owner of the MINFO RR is responsible for itself.

    @type emailbx: L{Name}
    @ivar emailbx: A domain-name which specifies a mailbox which is to receive
        error messages related to the mailing list or mailbox specified by the
        owner of the MINFO record.  If this domain name names the root, errors
        should be returned to the sender of the message.

    @type ttl: L{int}
    @ivar ttl: The maximum number of seconds which this record should be
        cached.
    Nr%)�rmailbx�emailbxr>))r��responsibilityrd)r��errorsrdr>r�cCs$t|�t|�|_|_t|�|_dS)z�
        @param rmailbx: See L{Record_MINFO.rmailbx}.
        @type rmailbx: L{bytes} or L{str}

        @param emailbx: See L{Record_MINFO.rmailbx}.
        @type emailbx: L{bytes} or L{str}
        N)rhr�r�r�r>)r�r�r�r>r}r}r~r�+szRecord_MINFO.__init__cCr�r�)r�r�r�r(r}r}r~r�6r�zRecord_MINFO.encodecCs.t�t�|_|_|j�|�|j�|�dSr�)rhr�r�r�rer}r}r~r�:szRecord_MINFO.decodecCr�r�)rr�r�r�r}r}r~r	?ruzRecord_MINFO.__hash__r�r�)r�r�r�r�r%r�r�r�rhrErPr�r�r�r	r}r}r}r~rQs


rQc@r�)rSa�
    Mail exchange.

    @type preference: L{int}
    @ivar preference: Specifies the preference given to this RR among others at
        the same owner.  Lower values are preferred.

    @type name: L{Name}
    @ivar name: A domain-name which specifies a host willing to act as a mail
        exchange.

    @type ttl: L{int}
    @ivar ttl: The maximum number of seconds which this record should be
        cached.
    r')r�r�r>)r�rcr>rr�NcKs*t|�|_t|�d|��|_t|�|_dS)z\
        @param name: See L{Record_MX.name}.
        @type name: L{bytes} or L{str}
        �exchangeN)r�r�rhrr�r�r>)r�r�r�r>�kwargsr}r}r~r�[s
zRecord_MX.__init__cCr�r�)rr�rr�r�r�r(r}r}r~r�dr�zRecord_MX.encodecCs0t�dt|d��d|_t�|_|j�|�dS)Nrr�r)r�r�r�r�rhr�r�rer}r}r~r�hr�zRecord_MX.decodecCr�r�)rr�r�r�r}r}r~r	mruzRecord_MX.__hash__r�r�)
r�r�r�r�r'r�rhrErPr�r�r�r	r}r}r}r~rSCs

	
rSc@s^eZdZdZdZdZdZeZdZ	dZ
dZdZdZ
dZddd�Zddd�Zddd�Zdd�Zd
S)r\ab
    A record containing the fingerprint of an SSH key.

    @type algorithm: L{int}
    @ivar algorithm: The SSH key's algorithm, such as L{ALGORITHM_RSA}.
        Note that the numbering used for SSH key algorithms is specific
        to the SSHFP record, and is not the same as the numbering
        used for KEY or SIG records.

    @type fingerprintType: L{int}
    @ivar fingerprintType: The fingerprint type,
        such as L{FINGERPRINT_TYPE_SHA256}.

    @type fingerprint: L{bytes}
    @ivar fingerprint: The key's fingerprint, e.g. a 32-byte SHA-256 digest.

    @cvar ALGORITHM_RSA: The algorithm value for C{ssh-rsa} keys.
    @cvar ALGORITHM_DSS: The algorithm value for C{ssh-dss} keys.
    @cvar ALGORITHM_ECDSA: The algorithm value for C{ecdsa-sha2-*} keys.
    @cvar ALGORITHM_Ed25519: The algorithm value for C{ed25519} keys.

    @cvar FINGERPRINT_TYPE_SHA1: The type for SHA-1 fingerprints.
    @cvar FINGERPRINT_TYPE_SHA256: The type for SHA-256 fingerprints.

    @see: U{RFC 4255 <https://tools.ietf.org/html/rfc4255>}
          and
          U{RFC 6594 <https://tools.ietf.org/html/rfc6594>}
    r2��	algorithm�fingerprintType�fingerprintr>)r�r�r�r�r�r�r�rr�cCs||_||_||_||_dSr�r�)r�r�r�r�r>r}r}r~r��s
zRecord_SSHFP.__init__NcCs(|�t�d|j|j��|�|j�dS)N�!BB)rr�rr�r�r�r(r}r}r~r��szRecord_SSHFP.encodecCs2t�dt|d��}|\|_|_t||d�|_dS)Nr�r�)r�r�r�r�r�r�r�r}r}r~r��szRecord_SSHFP.decodecCr�r�)rr�r�r�r�r}r}r~r	�r�zRecord_SSHFP.__hash__)rrr�rr�)r�r�r�r�rhrErPr2r��
ALGORITHM_RSA�
ALGORITHM_DSS�ALGORITHM_ECDSA�ALGORITHM_Ed25519�FINGERPRINT_TYPE_SHA1�FINGERPRINT_TYPE_SHA256r�r�r�r	r}r}r}r~r\qs 


r\c@sLeZdZdZeZdZdefdfZdZ	dd�Z
dd	d
�Zddd�Zd
d�Z
dS)r^z�
    Freeform text.

    @type data: L{list} of L{bytes}
    @ivar data: Freeform text which makes up this record.

    @type ttl: L{int}
    @ivar ttl: The maximum number of seconds which this record should be cached.
    r1rKr>�rKr>cOs t|�|_t|�dd��|_dS)Nr>)r�rKr�rr>)r�rK�kwr}r}r~r��s
zRecord_TXT.__init__NcCs*|jD]}|�t�dt|��|�qdSr�)rKrr�rr�)r�r�r��dr}r}r~r��s
�zRecord_TXT.encodecCstd}g|_||kr't�dt|d��d}|j�t||��||d7}||ks	||kr8t�d||j|f�dSdS)Nrr�r�z1Decoded %d bytes in %s record, but rdlength is %d)rKr�r�r�r�r�msgrh)r�r�r��soFar�Lr}r}r~r��s�
���zRecord_TXT.decodecCstt|j��Sr�)r�tuplerKr�r}r}r~r	�szRecord_TXT.__hash__r�)r�r�r�r�r1r�rhr�rPrEr�r�r�r	r}r}r}r~r^�s



r^c@sNeZdZdZdZdZdZdefdfZddd	�Z	dd
d�Z
ddd
�Zdd�ZdS)r`a>
    Encapsulate the wire data for unknown record types so that they can
    pass through the system unchanged.

    @type data: L{bytes}
    @ivar data: Wire data which makes up this record.

    @type ttl: L{int}
    @ivar ttl: The maximum number of seconds which this record should be cached.

    @since: 11.1
    N�UNKNOWNr�rKr>r�cCr�r�)rKr�r>)r�rKr>r}r}r~r��r�zUnknownRecord.__init__cCs|�|j�dS)zc
        Write the raw bytes corresponding to this record's payload to the
        stream.
        N)rrKr(r}r}r~r���zUnknownRecord.encodecCs |durtd��t||�|_dS)z~
        Load the bytes which are part of this record from the stream and store
        them unparsed and unmodified.
        Nz)must know length for unknown record types)�	Exceptionr�rKrer}r}r~r��szUnknownRecord.decodecCr�r�)rrKr>r�r}r}r~r		ruzUnknownRecord.__hash__rfr�)
r�r�r�r�r�rhrEr�rPr�r�r�r	r}r}r}r~r`�s



	r`c@rg)rZao
    Structurally, freeform text. Semantically, a policy definition, formatted
    as defined in U{rfc 4408<http://www.faqs.org/rfcs/rfc4408.html>}.

    @type data: L{list} of L{bytes}
    @ivar data: Freeform text which makes up this record.

    @type ttl: L{int}
    @ivar ttl: The maximum number of seconds
               which this record should be cached.
    r/N)r�r�r�r�r/r�rhr}r}r}r~rZ
	srZc@sZeZdZdZdZdZgd�ZeZddddde	ddfd	d
�Z
ddd�Zdd
d�Zdd�Z
dS)r]a�
    A transaction signature, encapsulated in a RR, as described
    in U{RFC 2845 <https://tools.ietf.org/html/rfc2845>}.

    @type algorithm: L{Name}
    @ivar algorithm: The name of the signature or MAC algorithm.

    @type timeSigned: L{int}
    @ivar timeSigned: Signing time, as seconds from the POSIX epoch.

    @type fudge: L{int}
    @ivar fudge: Allowable time skew, in seconds.

    @type MAC: L{bytes}
    @ivar MAC: The message digest or signature.

    @type originalID: L{int}
    @ivar originalID: A message ID.

    @type error: L{int}
    @ivar error: An error code (extended C{RCODE}) carried
          in exceptional cases.

    @type otherData: L{bytes}
    @ivar otherData: Other data carried in exceptional cases.

    r3)r��
timeSigned�fudge�MAC�
originalID�error�	otherDatar>)r�r�r�r�r�Nr�rr�c		CsH|durdnt|�|_||_t|�|_||_||_||_||_||_	dSr�)
rhr�r�r�r�r�r�r�r�r>)	r�r�r�r�r�r�r�r�r>r}r}r~r�H	s

zRecord_TSIG.__init__c	Cs�|j�||�|�t�d|j�dd��|�t�d|jt|j���|�|j�|�t�d|j	|j
t|j���|�|j�dS)Nz!Qr�r'r�)r�r�rr�rr�r�r�r�r�r�r�r(r}r}r~r�a	s�zRecord_TSIG.encodecCsvt�}|�|�||_t�ddt|d��}|\|_|_}t||�|_t�dt|d��}|\|_	|_
}t||�|_dS)Nz!QHHs�
r�r�)rhr�r�r�r�r�r�r�r�r�r�r�)r�r�r�r��fields�	macLength�otherLengthr}r}r~r�k	s
zRecord_TSIG.decodecCr�r�)rr�r�r�r�r�r}r}r~r	v	rzzRecord_TSIG.__hash__r�)r�r�r�r�rhrErPr3r�ror�r�r�r	r}r}r}r~r]	s$

�


r]cKs*|d|jdd�|��}|jdd�|_|S)a�
    Generate a L{Message} like instance suitable for use as the response to
    C{message}.

    The C{queries}, C{id} attributes will be copied from C{message} and the
    C{answer} flag will be set to L{True}.

    @param responseConstructor: A response message constructor with an
         initializer signature matching L{dns.Message.__init__}.
    @type responseConstructor: C{callable}

    @param message: A request message.
    @type message: L{Message}

    @param kwargs: Keyword arguments which will be passed to the initialiser
        of the response message.
    @type kwargs: L{dict}

    @return: A L{Message} like response instance.
    @rtype: C{responseConstructor}
    T)�id�answerNr})r��queries)�responseConstructor�messager��responser}r}r~�_responseFromMessagez	sr�cCs^g}t�|jj�}|D]!}|j|j}t|||�}||vs!||kr,|�d|�d|���q|S)a�
    Inspect the function signature of C{obj}'s constructor,
    and get a list of which arguments should be displayed.
    This is a helper function for C{_compactRepr}.

    @param obj: The instance whose repr is being generated.
    @param alwaysShow: A L{list} of field names which should always be shown.
    @param fieldNames: A L{list} of field attribute names which should be shown
        if they have non-default values.
    @return: A L{list} of displayable arguments.
    r+�=)�inspect�	signature�	__class__r��
parametersr�rGr�)�obj�
alwaysShow�
fieldNames�displayableArgsr�r��defaultValue�
fieldValuer}r}r~�_getDisplayableArguments�	s�r�c
Cs�|durg}|durg}|durg}|durg}g}|D]}||vs*t||d�dkr/|�|�qt|||�}d|jjg|}|rK|�d�d�|���|D]}t||g�}	|	rb|�d|�d|	���qM|�d	�d
�|�S)a�
    Return a L{str} representation of C{obj} which only shows fields with
    non-default values, flags which are True and sections which have been
    explicitly set.

    @param obj: The instance whose repr is being generated.
    @param alwaysShow: A L{list} of field names which should always be shown.
    @param flagNames: A L{list} of flag attribute names which should be shown if
        they are L{True}.
    @param fieldNames: A L{list} of field attribute names which should be shown
        if they have non-default values.
    @param sectionNames: A L{list} of section attribute names which should be
        shown if they have been assigned a value.

    @return: A L{str} representation of C{obj}.
    NFT�<z	 flags={}�,r+r�r,�)rGr�r�r�r�r�r�)
r�r��	flagNamesr��sectionNames�setFlagsr�r��out�sectionr}r}r~�_compactRepr�	s0
��

r�c@s�eZdZUdZdZeed<dZdZe	�
e�ZdZZ
ZZddddddeddddfd	d
�Zdefdd
�Zeefdd�Zdd�Zddd�Zdd�ZiZe�D]Ze�d�r`e�eee�ej<qN[dd�Zdd�Z dd�Z!dS)rga
    L{Message} contains all the information represented by a single
    DNS request or response.

    @ivar id: See L{__init__}
    @ivar answer: See L{__init__}
    @ivar opCode: See L{__init__}
    @ivar recDes: See L{__init__}
    @ivar recAv: See L{__init__}
    @ivar auth: See L{__init__}
    @ivar rCode: See L{__init__}
    @ivar trunc: See L{__init__}
    @ivar maxSize: See L{__init__}
    @ivar authenticData: See L{__init__}
    @ivar checkingDisabled: See L{__init__}

    @ivar queries: The queries which are being asked of or answered by
        DNS server.
    @type queries: L{list} of L{Query}

    @ivar answers: Records containing the answers to C{queries} if
        this is a response message.
    @type answers: L{list} of L{RRHeader}

    @ivar authority: Records containing information about the
        authoritative DNS servers for the names in C{queries}.
    @type authority: L{list} of L{RRHeader}

    @ivar additional: Records containing IP addresses of host names
        in C{answers} and C{authority}.
    @type additional: L{list} of L{RRHeader}

    @ivar _flagNames: The names of attributes representing the flag header
        fields.
    @ivar _fieldNames: The names of attributes representing non-flag fixed
        header fields.
    @ivar _sectionNames: The names of attributes representing the record
        sections of this message.

    @ivar maxCompressionPointers: Per-message cap on the total number of
        compression-pointer dereferences L{decode} will follow across every
        name in the message before raising L{DNSDecodeError}.  Defaults to
        C{1000}.  Override it on a subclass or individual instance to tune
        the trade-off between tolerance for legitimately verbose messages
        and resistance to denial-of-service attacks.
    r�r)r�r��opCode�recDes�recAvrW�rCode�trunc�maxSize�
authenticData�checkingDisabledr��answers�	authority�
additionalz!H2B4HNr�cCs^|	|_||_||_||_||_||_||_||_||_|
|_	||_
g|_g|_g|_
g|_dS)a�

        @param id: A 16 bit identifier assigned by the program that
            generates any kind of query.  This identifier is copied to
            the corresponding reply and can be used by the requester
            to match up replies to outstanding queries.
        @type id: L{int}

        @param answer: A one bit field that specifies whether this
            message is a query (0), or a response (1).
        @type answer: L{int}

        @param opCode: A four bit field that specifies kind of query in
            this message.  This value is set by the originator of a query
            and copied into the response.
        @type opCode: L{int}

        @param recDes: Recursion Desired - this bit may be set in a
            query and is copied into the response.  If RD is set, it
            directs the name server to pursue the query recursively.
            Recursive query support is optional.
        @type recDes: L{int}

        @param recAv: Recursion Available - this bit is set or cleared
            in a response and denotes whether recursive query support
            is available in the name server.
        @type recAv: L{int}

        @param auth: Authoritative Answer - this bit is valid in
            responses and specifies that the responding name server
            is an authority for the domain name in question section.
        @type auth: L{int}

        @ivar rCode: A response code, used to indicate success or failure in a
            message which is a response from a server to a client request.
        @type rCode: C{0 <= int < 16}

        @param trunc: A flag indicating that this message was
            truncated due to length greater than that permitted on the
            transmission channel.
        @type trunc: L{int}

        @param maxSize: The requestor's UDP payload size is the number
            of octets of the largest UDP payload that can be
            reassembled and delivered in the requestor's network
            stack.
        @type maxSize: L{int}

        @param authenticData: A flag indicating in a response that all
            the data included in the answer and authority portion of
            the response has been authenticated by the server
            according to the policies of that server.
            See U{RFC2535 section-6.1<https://tools.ietf.org/html/rfc2535#section-6.1>}.
        @type authenticData: L{int}

        @param checkingDisabled: A flag indicating in a query that
            pending (non-authenticated) data is acceptable to the
            resolver sending the query.
            See U{RFC2535 section-6.1<https://tools.ietf.org/html/rfc2535#section-6.1>}.
        @type authenticData: L{int}
        N)rr�r�r�rWr�r�r�r�rrr�rrr)r�r�r�r�r�r�rWr�r�rrrr}r}r~r�+
sJ
zMessage.__init__r�cC�t|ddddd�S)z�
        Generate a repr of this L{Message}.

        Only includes the non-default fields and sections and only includes
        flags which are set. The C{id} is always shown.

        @return: The native string repr.
        )r�rWr�r�r�rr)r�r�r�r�r�rrr�r��r�r�r�r��r�r�r}r}r~r0�
s		�zMessage.__repr__cCs|j�t|||��dS)z�
        Add another query to this Message.

        @type name: L{bytes}
        @param name: The name to query.

        @type type: L{int}
        @param type: Query type

        @type cls: L{int}
        @param cls: Query class
        N)r�r�rir%r}r}r~�addQuery�
s
zMessage.addQueryc	
Cshi}t�}|jD]}|�||�q|jD]}|�||�q|jD]}|�||�q |jD]}|�||�q,|��}t|�|j}|j	rU||j	krUd|_
|d|j	|j�}|jd@d>|jd@d>B|j
d@d>B|j
d@d>B|jd@B}|jd@d>|jd@d>B|jd@d>B|jd@B}|�t�|j|j||t|j�t|j�t|j�t|j���|�|�dS)Nr��r=r�r�r�r�)rr�r�rrrr@r�rrr�r�r�rWr�r�rrr�rr�r�	headerFmtr�)	r�r�r��body_tmp�q�body�size�byte3�byte4r}r}r~r��
s\



�����������zMessage.encodec
Cstd|_t||j�}t�|j|�}|\|_}}}}}	}
|d?d@|_|d?d@|_|d?d@|_	|d?d@|_
|d@|_|d?d@|_|d?d@|_
|d?d@|_|d@|_t|jd	�}t|��Qg|_t|�D]$}t�}
z|
�|�Wnty�YWd�dSw|j�|
�qg|j|f|j|	f|j|
ff}|D]\}}|�|||�q�Wd�dS1s�wYdS)
Nrr
r�r�r=r�r�r�r)rr�rr�r�rr�r�r�rWr�r�r�rrr�r�rr�r��rangerir�r�r�rrr�parseRecords)r�r�r��headerr]rr�nqueries�nans�nns�nadd�
decodeContext�ir�itemsr�r3r}r}r~r��
sB


���"�zMessage.decodec	Cs�t|�D]F}t|jd�}z|�|�WntyYdSw|�|j�}|s(q||jd�|_z
|j�||j	�WntyDYdSw|�
|�qdS)Nr^)r>)rrjrWr�r��lookupRecordTyper�r>r?rCr�)r�r��numr�rrr.r}r}r~rs$���zMessage.parseRecords�Record_cCs|j�|t�S)aC
        Retrieve the L{IRecord} implementation for the given record type.

        @param type: A record type, such as C{A} or L{NS}.
        @type type: L{int}

        @return: An object which implements L{IRecord} or L{None} if none
            can be found for the given type.
        @rtype: C{Type[IRecord]}
        )�_recordTypesrr`)r�r�r}r}r~rszMessage.lookupRecordTypecCst�}|�|�|��S)z�
        Encode this L{Message} into a byte string in the format described by RFC
        1035.

        @rtype: L{bytes}
        )rr�r@)r�r�r}r}r~�toStr,s
z
Message.toStrcCst|�}|�|�dS)z�
        Decode a byte string in the format described by RFC 1035 into this
        L{Message}.

        @param str: L{bytes}
        N)rr�)r�r�r�r}r}r~�fromStr7szMessage.fromStrr�)"r�r�r�r�rr�r#rErr�rVrr�rr�nsror�r�r0r:r9rr�r�rr"�globalsr��
startswithr�rr#r$r}r}r}r~rg�	sB
/

�[
,'

�
rgc@sveZdZdZdZeZddeddddddddddddddfdd�Zd	e	fd
d�Z
dd
�Zdd�Ze
dd��Zdd�ZdS)�_EDNSMessagea�
    An I{EDNS} message.

    Designed for compatibility with L{Message} but with a narrower public
    interface.

    Most importantly, L{_EDNSMessage.fromStr} will interpret and remove I{OPT}
    records that are present in the additional records section.

    The I{OPT} records are used to populate certain I{EDNS} specific attributes.

    L{_EDNSMessage.toStr} will add suitable I{OPT} records to the additional
    section to represent the extended EDNS information.

    @see: U{https://tools.ietf.org/html/rfc6891}

    @ivar id: See L{__init__}
    @ivar answer: See L{__init__}
    @ivar opCode: See L{__init__}
    @ivar auth: See L{__init__}
    @ivar trunc: See L{__init__}
    @ivar recDes: See L{__init__}
    @ivar recAv: See L{__init__}
    @ivar rCode: See L{__init__}
    @ivar ednsVersion: See L{__init__}
    @ivar dnssecOK: See L{__init__}
    @ivar authenticData: See L{__init__}
    @ivar checkingDisabled: See L{__init__}
    @ivar maxSize: See L{__init__}

    @ivar queries: See L{__init__}
    @ivar answers: See L{__init__}
    @ivar authority: See L{__init__}
    @ivar additional: See L{__init__}

    @ivar _messageFactory: A constructor of L{Message} instances. Called by
        C{_toMessage} and C{_fromMessage}.
    �r�r�r�rWr�r�r�r��ednsVersionr8rrrr�rrrrFrNcCs�||_||_||_||_||_||_||_||_|	|_|
|_	||_
||_|
|_|dur-g}||_
|dur6g}||_|dur?g}||_|durHg}||_dS)a+
        Construct a new L{_EDNSMessage}

        @see: U{RFC1035 section-4.1.1<https://tools.ietf.org/html/rfc1035#section-4.1.1>}
        @see: U{RFC2535 section-6.1<https://tools.ietf.org/html/rfc2535#section-6.1>}
        @see: U{RFC3225 section-3<https://tools.ietf.org/html/rfc3225#section-3>}
        @see: U{RFC6891 section-6.1.3<https://tools.ietf.org/html/rfc6891#section-6.1.3>}

        @param id: A 16 bit identifier assigned by the program that generates
            any kind of query.  This identifier is copied the corresponding
            reply and can be used by the requester to match up replies to
            outstanding queries.
        @type id: L{int}

        @param answer: A one bit field that specifies whether this message is a
            query (0), or a response (1).
        @type answer: L{bool}

        @param opCode: A four bit field that specifies kind of query in this
            message.  This value is set by the originator of a query and copied
            into the response.
        @type opCode: L{int}

        @param auth: Authoritative Answer - this bit is valid in responses, and
            specifies that the responding name server is an authority for the
            domain name in question section.
        @type auth: L{bool}

        @param trunc: Truncation - specifies that this message was truncated due
            to length greater than that permitted on the transmission channel.
        @type trunc: L{bool}

        @param recDes: Recursion Desired - this bit may be set in a query and is
            copied into the response.  If set, it directs the name server to
            pursue the query recursively. Recursive query support is optional.
        @type recDes: L{bool}

        @param recAv: Recursion Available - this bit is set or cleared in a
            response, and denotes whether recursive query support is available
            in the name server.
        @type recAv: L{bool}

        @param rCode: Extended 12-bit RCODE. Derived from the 4 bits defined in
            U{RFC1035 4.1.1<https://tools.ietf.org/html/rfc1035#section-4.1.1>}
            and the upper 8bits defined in U{RFC6891
            6.1.3<https://tools.ietf.org/html/rfc6891#section-6.1.3>}.
        @type rCode: L{int}

        @param ednsVersion: Indicates the EDNS implementation level. Set to
            L{None} to prevent any EDNS attributes and options being added to
            the encoded byte string.
        @type ednsVersion: L{int} or L{None}

        @param dnssecOK: DNSSEC OK bit as defined by
            U{RFC3225 3<https://tools.ietf.org/html/rfc3225#section-3>}.
        @type dnssecOK: L{bool}

        @param authenticData: A flag indicating in a response that all the data
            included in the answer and authority portion of the response has
            been authenticated by the server according to the policies of that
            server.
            See U{RFC2535 section-6.1<https://tools.ietf.org/html/rfc2535#section-6.1>}.
        @type authenticData: L{bool}

        @param checkingDisabled: A flag indicating in a query that pending
            (non-authenticated) data is acceptable to the resolver sending the
            query.
            See U{RFC2535 section-6.1<https://tools.ietf.org/html/rfc2535#section-6.1>}.
        @type authenticData: L{bool}

        @param maxSize: The requestor's UDP payload size is the number of octets
            of the largest UDP payload that can be reassembled and delivered in
            the requestor's network stack.
        @type maxSize: L{int}

        @param queries: The L{list} of L{Query} associated with this message.
        @type queries: L{list} of L{Query}

        @param answers: The L{list} of answers associated with this message.
        @type answers: L{list} of L{RRHeader}

        @param authority: The L{list} of authority records associated with this
            message.
        @type authority: L{list} of L{RRHeader}

        @param additional: The L{list} of additional records associated with
            this message.
        @type additional: L{list} of L{RRHeader}
        Nr))r�r�r�r�rWr�r�r�r�r*r8rrrr�rrrr}r}r~r��s2m
z_EDNSMessage.__init__r�cCr)N)r�rWr�r�r�rrr8)r�r�r�rr*rr	r
rr�r}r}r~r0s
�z_EDNSMessage.__repr__cCs�|j|j|j|j|j|j|j|j|jd@|j	|j
d�
}|jdd�|_|jdd�|_|j
dd�|_
|jdd�|_|jdurTt|j|j|j|jd?d�}|j�|�|S)a=
        Convert to a standard L{dns.Message}.

        If C{ednsVersion} is not None, an L{_OPTHeader} instance containing all
        the I{EDNS} specific attributes and options will be appended to the list
        of C{additional} records.

        @return: A L{dns.Message}
        @rtype: L{dns.Message}
        r=)
r�r�r�rWr�r�r�r�rrNr�)r7r8r5r6)�_messageFactoryr�r�r�rWr�r�r�r�rrr�rrrr*r2r8rr�)r��mrAr}r}r~�
_toMessages2�
�z_EDNSMessage._toMessagecCs|����S)z~
        Encode to wire format by first converting to a standard L{dns.Message}.

        @return: A L{bytes} string.
        )r-r#r�r}r}r~r#Gsz_EDNSMessage.toStrcCsg}g}|jD]}|jtkr|�t�|��q|�|�q|did|j�d|j�d|j�d|j	�d|j
�d|j�d|j�d|j
�d	|j�d
|j�dd�d
d�d|jdd��d|jdd��d|jdd��d|��}t|�dkr�|d}|j|_|j|_|j|_|jd>|j
B|_
|S)a�
        Construct and return a new L{_EDNSMessage} whose attributes and records
        are derived from the attributes and records of C{message} (a L{Message}
        instance).

        If present, an C{OPT} record will be extracted from the C{additional}
        section and its attributes and options will be used to set the EDNS
        specific attributes C{extendedRCODE}, C{ednsVersion}, C{dnssecOK},
        C{ednsOptions}.

        The C{extendedRCODE} will be combined with C{message.rCode} and assigned
        to C{self.rCode}.

        @param message: The source L{Message}.
        @type message: L{Message}

        @return: A new L{_EDNSMessage}
        @rtype: L{_EDNSMessage}
        r�r�r�rWr�r�r�r�rrr*Nr8Fr�rrrr�rr�r})rr�r+r�r2rDr�r�r�rWr�r�r�r�rrr�rrr�r7r*r8r5rr6)r$r�r�
optRecordsr]�
newMessage�optr}r}r~�_fromMessageOs\

��������	�
�
������z_EDNSMessage._fromMessagecCs>|��}|�|�|�|�}|jD]}t||t||��qdS)z�
        Decode from wire format, saving flags, values and records to this
        L{_EDNSMessage} instance in place.

        @param bytes: The full byte string to be decoded.
        @type bytes: L{bytes}
        N)r+r$r1rErFrG)r�r{r,�ednsMessagerJr}r}r~r$�s


�z_EDNSMessage.fromStr)r�r�r�r�rErgr+rrr�r�r0r-r#rRr1r$r}r}r}r~r(Bs:'
�*
<r(c@sBeZdZdZdZdZd
dd�Zdd�Zdd�Zd	d
�Z	dd�Z
dS)rmz�
    DNS protocol mixin shared by UDP and TCP implementations.

    @ivar _reactor: A L{IReactorTime} and L{IReactorUDP} provider which will
        be used to issue DNS queries and manage request timeouts.
    NcCs2||_t�dd�|_|durddlm}||_dS)Nii�r)�reactor)�
controller�random�	randranger��twisted.internetr3�_reactor)r�r4r3r}r}r~r��s

zDNSMixin.__init__cCs	t�}||jvr|Sq)z1
        Return a unique ID for queries.
        )r��liveMessages�r�r�r}r}r~�pickID�s

�zDNSMixin.pickIDcGs|jj||g|�R�S)zL
        Wrapper around reactor.callLater, mainly for test purpose.
        )r8�	callLater)r��period�func�argsr}r}r~r<�szDNSMixin.callLatercCsft|dd�}||_z||�Wn
tyt��YSwt��}|�||j||�}||f|j|<|S)a�
        Send out a message with the given queries.

        @type queries: L{list} of C{Query} instances
        @param queries: The queries to transmit

        @type timeout: L{int} or C{float}
        @param timeout: How long to wait before giving up

        @type id: L{int}
        @param id: Unique key for this request

        @type writeMessage: C{callable}
        @param writeMessage: One-parameter callback which writes the message

        @rtype: C{Deferred}
        @return: a C{Deferred} which will be fired with the result of the
            query, or errbacked with any errors that could happen (exceptions
            during writing of the query, timeout errors, ...).
        r�)r�)	rgr��
BaseExceptionr�fail�Deferredr<�_clearFailedr9)r�r��timeoutr��writeMessager,�resultDeferred�
cancelCallr}r}r~�_query�s�zDNSMixin._querycCs8z|j|=Wn	tyYnw|�t�t|���dS)z5
        Clean the Deferred after a timeout.
        N)r9�KeyError�errbackr�Failurerx)r��deferredr�r}r}r~rC�s�zDNSMixin._clearFailedr�)r�r�r�r�r�r9r�r;r<rHrCr}r}r}r~rm�s
	#rmc@sNeZdZdZdZdd�Zdd�Zdd�Zd	d
�Zdd�Z	d
d�Z
ddd�ZdS)rlz 
    DNS protocol over UDP.
    NcCsi|_i|_d|_dS)z7
        Stop protocol: reset state variables.
        N)r9�resends�	transportr�r}r}r~�stopProtocol�s
z DNSDatagramProtocol.stopProtocolcCsi|_i|_dS)z3
        Upon start, reset internal state.
        N)r9rMr�r}r}r~�
startProtocol�s
z!DNSDatagramProtocol.startProtocolcCs|j�|��|�dS)�X
        Send a message holding DNS queries.

        @type message: L{Message}
        N)rNrr#)r�r�rmr}r}r~rE
sz DNSDatagramProtocol.writeMessagecCs|jjd|dd�dS)Nrr)�
maxPacketSize)r8�	listenUDPr�r}r}r~�startListening	
sz"DNSDatagramProtocol.startListeningcCs�t�}z|�|�Wn&tyt�dt|�|f�YdSty0t�t�	�d�YdSw|j
|jvr_|j|j
\}}|j|j
=|��z|�
|�WdSty^t��YdSw|j
|jvro|j�|||�dSdS)zi
        Read a datagram, extract the message in it and trigger the associated
        Deferred.
        z#Truncated packet (%d bytes) from %sNzUnexpected decoding error)rgr$r�rr�r�r@�errrrKr�r9�cancel�callbackrMr4�messageReceived)r�rK�addrr,r��	cancellerr}r}r~�datagramReceived
s,�
��z$DNSDatagramProtocol.datagramReceivedcCs$z|j|=WdStyYdSw)zN
        Mark message ID as no longer having duplication suppression.
        N)rMrIr:r}r}r~�removeResend,
s
�z DNSDatagramProtocol.removeResendr�csh�jsz���Wn
tyt��YSw|dur ���}nd�j|<��fdd�}��||||�S)a4
        Send out a message with the given queries.

        @type address: L{tuple} of L{str} and L{int}
        @param address: The address to which to send the query

        @type queries: L{list} of C{Query} instances
        @param queries: The queries to transmit

        @rtype: C{Deferred}
        Nr�cs��|��dSr�)rE)r,�rmr�r}r~rEM
ruz/DNSDatagramProtocol.query.<locals>.writeMessage)rNrTr
rrAr;rMrH)r�rmr�rDr�rEr}r]r~�query5
s�

zDNSDatagramProtocol.query)r�N)r�r�r�r�rMrOrPrErTr[r\r^r}r}r}r~rl�s 	rlc@sBeZdZdZdZdZdd�Zdd�Zdd	�Zd
d�Z	dd
d�Z
dS)rnz 
    DNS protocol over TCP.
    Nr�cCs(|��}|j�t�dt|��|�dS)rQrN)r#rNrr�rr�)r�r�r�r}r}r~rE[
s zDNSProtocol.writeMessagecCsi|_|j�|�dS)zV
        Connection is made: reset internal state, and notify the controller.
        N)r9r4�connectionMader�r}r}r~r_d
szDNSProtocol.connectionMadecCs|j�|�dS)zZ
        Notify the controller that this protocol is no longer
        connected.
        N)r4�connectionLost)r��reasonr}r}r~r`k
r�zDNSProtocol.connectionLostcCs&|j|7_|jr�|jdur,t|j�dkr,t�d|jdd��d|_|jdd�|_t|j�|jkr�|jd|j�}t�}|�|�z
|j|j\}}Wnt	y^|j
�||�Ynw|j|j=|��z|�
|�Wn
ty|t��Ynw|j|jd�|_d|_ndS|js
dSdS)Nr�rr)�bufferr�r�r�r�rgr$r9r�rIr4rXrVrWr@rrU)r�rK�myChunkr,r�rZr}r}r~�dataReceivedr
s2
�
��zDNSProtocol.dataReceivedr�cCs|��}|�||||j�S)z�
        Send out a message with the given queries.

        @type queries: L{list} of C{Query} instances
        @param queries: The queries to transmit

        @rtype: C{Deferred}
        )r;rHrE)r�r�rDr�r}r}r~r^�
s	zDNSProtocol.query)r�)r�r�r�r�r�rbrEr_r`rdr^r}r}r}r~rnS
s	rn)NNNN)�r��contextvarsr�r5rpr��
contextlibr�ior�	itertoolsr�typingrrr�zope.interfacerr	r
r7rr�twisted.internet.errorr
�twisted.pythonrrrr�tputil�twisted.python.compatrrr�__all__r�rr�r�r�rurrr)r"r#rr.r!r$r&r*r4r,rr%r'r1r-rrr0r(rrr+r2r/r�r3rbr<r;r rr:rerrdr9r7r6r8r5rarcrrrprsrqrtror=rAr>r?r@rBrCrDrEr�twisted.names.errorrvrxryr�r�r�r�r�r�rwr��
ContextVarr�r#r�rrrfrhri�
FancyStrMixin�FancyEqMixinr2rLrjrkrUrNrOrJrMrPrRrWrKrFrYrVr_rHrGr[rTrIrXrLrQrSr\r^r`rZr]r�r�r�rgr(rm�DatagramProtocolrl�Protocolrnr}r}r}r~�<module>s�i
���������	�
���
������ �
!(4�'1<;<z&	

		1s<.]Cz130;-?+,^
�4c\Oh
Youez - 2016 - github.com/yon3zu
LinuXploit