Gecko [ www.corporacionhdm.com.pe ]

Name	Size	Permission	Date
__pycache__	[ DIR ]	drwxr-xr-x	2025-04-04 08:00
dnssecalgs	[ DIR ]	drwxr-xr-x	2025-04-04 08:00
quic	[ DIR ]	drwxr-xr-x	2025-04-04 08:00
rdtypes	[ DIR ]	drwxr-xr-x	2025-04-04 08:00
__init__.py	1.62 KB	-rw-r--r--	2025-04-04 08:00
_asyncbackend.py	2.34 KB	-rw-r--r--	2025-04-04 08:00
_asyncio_backend.py	8.84 KB	-rw-r--r--	2025-04-04 08:00
_ddr.py	5.12 KB	-rw-r--r--	2025-04-04 08:00
_features.py	2.43 KB	-rw-r--r--	2025-04-04 08:00
_immutable_ctx.py	2.4 KB	-rw-r--r--	2025-04-04 08:00
_trio_backend.py	8.27 KB	-rw-r--r--	2025-04-04 08:00
asyncbackend.py	2.73 KB	-rw-r--r--	2025-04-04 08:00
asyncquery.py	30.1 KB	-rw-r--r--	2025-04-04 08:00
asyncresolver.py	17.43 KB	-rw-r--r--	2025-04-04 08:00
dnssec.py	40.74 KB	-rw-r--r--	2025-04-04 08:00
dnssectypes.py	1.76 KB	-rw-r--r--	2025-04-04 08:00
e164.py	3.88 KB	-rw-r--r--	2025-04-04 08:00
edns.py	16.69 KB	-rw-r--r--	2025-04-04 08:00
entropy.py	4.14 KB	-rw-r--r--	2025-04-04 08:00
enum.py	3.6 KB	-rw-r--r--	2025-04-04 08:00
exception.py	5.81 KB	-rw-r--r--	2025-04-04 08:00
flags.py	2.69 KB	-rw-r--r--	2025-04-04 08:00
grange.py	2.09 KB	-rw-r--r--	2025-04-04 08:00
immutable.py	1.97 KB	-rw-r--r--	2025-04-04 08:00
inet.py	5.64 KB	-rw-r--r--	2025-04-04 08:00
ipv4.py	2.49 KB	-rw-r--r--	2025-04-04 08:00
ipv6.py	6.4 KB	-rw-r--r--	2025-04-04 08:00
message.py	66.59 KB	-rw-r--r--	2025-04-04 08:00
name.py	41.78 KB	-rw-r--r--	2025-04-04 08:00
namedict.py	3.91 KB	-rw-r--r--	2025-04-04 08:00
nameserver.py	9.88 KB	-rw-r--r--	2025-04-04 08:00
node.py	12.37 KB	-rw-r--r--	2025-04-04 08:00
opcode.py	2.67 KB	-rw-r--r--	2025-04-04 08:00
py.typed	0 B	-rw-r--r--	2025-04-04 08:00
query.py	54.98 KB	-rw-r--r--	2025-04-04 08:00
rcode.py	4.06 KB	-rw-r--r--	2025-04-04 08:00
rdata.py	30.29 KB	-rw-r--r--	2025-04-04 08:00
rdataclass.py	2.91 KB	-rw-r--r--	2025-04-04 08:00
rdataset.py	16.27 KB	-rw-r--r--	2025-04-04 08:00
rdatatype.py	7.27 KB	-rw-r--r--	2025-04-04 08:00
renderer.py	10.99 KB	-rw-r--r--	2025-04-04 08:00
resolver.py	72 KB	-rw-r--r--	2025-04-04 08:00
reversename.py	3.74 KB	-rw-r--r--	2025-04-04 08:00
rrset.py	8.96 KB	-rw-r--r--	2025-04-04 08:00
serial.py	3.52 KB	-rw-r--r--	2025-04-04 08:00
set.py	9 KB	-rw-r--r--	2025-04-04 08:00
tokenizer.py	23.03 KB	-rw-r--r--	2025-04-04 08:00
transaction.py	22.06 KB	-rw-r--r--	2025-04-04 08:00
tsig.py	11.15 KB	-rw-r--r--	2025-04-04 08:00
tsigkeyring.py	2.57 KB	-rw-r--r--	2025-04-04 08:00
ttl.py	2.91 KB	-rw-r--r--	2025-04-04 08:00
update.py	11.96 KB	-rw-r--r--	2025-04-04 08:00
version.py	1.88 KB	-rw-r--r--	2025-04-04 08:00
versioned.py	11.49 KB	-rw-r--r--	2025-04-04 08:00
win32util.py	8.67 KB	-rw-r--r--	2025-04-04 08:00
wire.py	2.76 KB	-rw-r--r--	2025-04-04 08:00
xfr.py	12.96 KB	-rw-r--r--	2025-04-04 08:00
zone.py	50.87 KB	-rw-r--r--	2025-04-04 08:00
zonefile.py	27.27 KB	-rw-r--r--	2025-04-04 08:00
zonetypes.py	690 B	-rw-r--r--	2025-04-04 08:00

Rename

# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license

# Copyright (C) 2001-2017 Nominum, Inc.
#
# Permission to use, copy, modify, and distribute this software and its
# documentation for any purpose with or without fee is hereby granted,
# provided that the above copyright notice and this permission notice
# appear in all copies.
#
# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

"""DNS nodes.  A node is a set of rdatasets."""

import enum
import io
from typing import Any, Dict, Optional

import dns.immutable
import dns.name
import dns.rdataclass
import dns.rdataset
import dns.rdatatype
import dns.renderer
import dns.rrset

_cname_types = {
    dns.rdatatype.CNAME,
}

# "neutral" types can coexist with a CNAME and thus are not "other data"
_neutral_types = {
    dns.rdatatype.NSEC,  # RFC 4035 section 2.5
    dns.rdatatype.NSEC3,  # This is not likely to happen, but not impossible!
    dns.rdatatype.KEY,  # RFC 4035 section 2.5, RFC 3007
}

def _matches_type_or_its_signature(rdtypes, rdtype, covers):
    return rdtype in rdtypes or (rdtype == dns.rdatatype.RRSIG and covers in rdtypes)

@enum.unique
class NodeKind(enum.Enum):
    """Rdatasets in nodes"""

REGULAR = 0  # a.k.a "other data"
    NEUTRAL = 1
    CNAME = 2

@classmethod
    def classify(
        cls, rdtype: dns.rdatatype.RdataType, covers: dns.rdatatype.RdataType
    ) -> "NodeKind":
        if _matches_type_or_its_signature(_cname_types, rdtype, covers):
            return NodeKind.CNAME
        elif _matches_type_or_its_signature(_neutral_types, rdtype, covers):
            return NodeKind.NEUTRAL
        else:
            return NodeKind.REGULAR

@classmethod
    def classify_rdataset(cls, rdataset: dns.rdataset.Rdataset) -> "NodeKind":
        return cls.classify(rdataset.rdtype, rdataset.covers)

class Node:
    """A Node is a set of rdatasets.

A node is either a CNAME node or an "other data" node.  A CNAME
    node contains only CNAME, KEY, NSEC, and NSEC3 rdatasets along with their
    covering RRSIG rdatasets.  An "other data" node contains any
    rdataset other than a CNAME or RRSIG(CNAME) rdataset.  When
    changes are made to a node, the CNAME or "other data" state is
    always consistent with the update, i.e. the most recent change
    wins.  For example, if you have a node which contains a CNAME
    rdataset, and then add an MX rdataset to it, then the CNAME
    rdataset will be deleted.  Likewise if you have a node containing
    an MX rdataset and add a CNAME rdataset, the MX rdataset will be
    deleted.
    """

__slots__ = ["rdatasets"]

def __init__(self):
        # the set of rdatasets, represented as a list.
        self.rdatasets = []

def to_text(self, name: dns.name.Name, **kw: Dict[str, Any]) -> str:
        """Convert a node to text format.

Each rdataset at the node is printed.  Any keyword arguments
        to this method are passed on to the rdataset's to_text() method.

*name*, a ``dns.name.Name``, the owner name of the
        rdatasets.

Returns a ``str``.

"""

s = io.StringIO()
        for rds in self.rdatasets:
            if len(rds) > 0:
                s.write(rds.to_text(name, **kw))  # type: ignore[arg-type]
                s.write("\n")
        return s.getvalue()[:-1]

def __repr__(self):
        return "<DNS node " + str(id(self)) + ">"

def __eq__(self, other):
        #
        # This is inefficient.  Good thing we don't need to do it much.
        #
        for rd in self.rdatasets:
            if rd not in other.rdatasets:
                return False
        for rd in other.rdatasets:
            if rd not in self.rdatasets:
                return False
        return True

def __ne__(self, other):
        return not self.__eq__(other)

def __len__(self):
        return len(self.rdatasets)

def __iter__(self):
        return iter(self.rdatasets)

def _append_rdataset(self, rdataset):
        """Append rdataset to the node with special handling for CNAME and
        other data conditions.

Specifically, if the rdataset being appended has ``NodeKind.CNAME``,
        then all rdatasets other than KEY, NSEC, NSEC3, and their covering
        RRSIGs are deleted.  If the rdataset being appended has
        ``NodeKind.REGULAR`` then CNAME and RRSIG(CNAME) are deleted.
        """
        # Make having just one rdataset at the node fast.
        if len(self.rdatasets) > 0:
            kind = NodeKind.classify_rdataset(rdataset)
            if kind == NodeKind.CNAME:
                self.rdatasets = [
                    rds
                    for rds in self.rdatasets
                    if NodeKind.classify_rdataset(rds) != NodeKind.REGULAR
                ]
            elif kind == NodeKind.REGULAR:
                self.rdatasets = [
                    rds
                    for rds in self.rdatasets
                    if NodeKind.classify_rdataset(rds) != NodeKind.CNAME
                ]
            # Otherwise the rdataset is NodeKind.NEUTRAL and we do not need to
            # edit self.rdatasets.
        self.rdatasets.append(rdataset)

def find_rdataset(
        self,
        rdclass: dns.rdataclass.RdataClass,
        rdtype: dns.rdatatype.RdataType,
        covers: dns.rdatatype.RdataType = dns.rdatatype.NONE,
        create: bool = False,
    ) -> dns.rdataset.Rdataset:
        """Find an rdataset matching the specified properties in the
        current node.

*rdclass*, a ``dns.rdataclass.RdataClass``, the class of the rdataset.

*rdtype*, a ``dns.rdatatype.RdataType``, the type of the rdataset.

*covers*, a ``dns.rdatatype.RdataType``, 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, create the rdataset if it is not found.

Raises ``KeyError`` if an rdataset of the desired type and class does
        not exist and *create* is not ``True``.

Returns a ``dns.rdataset.Rdataset``.
        """

for rds in self.rdatasets:
            if rds.match(rdclass, rdtype, covers):
                return rds
        if not create:
            raise KeyError
        rds = dns.rdataset.Rdataset(rdclass, rdtype, covers)
        self._append_rdataset(rds)
        return rds

def get_rdataset(
        self,
        rdclass: dns.rdataclass.RdataClass,
        rdtype: dns.rdatatype.RdataType,
        covers: dns.rdatatype.RdataType = dns.rdatatype.NONE,
        create: bool = False,
    ) -> Optional[dns.rdataset.Rdataset]:
        """Get an rdataset matching the specified properties in the
        current node.

None is returned if an rdataset of the specified type and
        class does not exist and *create* is not ``True``.

*rdclass*, an ``int``, the class of the rdataset.

*rdtype*, an ``int``, the type of the rdataset.

*covers*, an ``int``, 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, create the rdataset if it is not found.

Returns a ``dns.rdataset.Rdataset`` or ``None``.
        """

try:
            rds = self.find_rdataset(rdclass, rdtype, covers, create)
        except KeyError:
            rds = None
        return rds

def delete_rdataset(
        self,
        rdclass: dns.rdataclass.RdataClass,
        rdtype: dns.rdatatype.RdataType,
        covers: dns.rdatatype.RdataType = dns.rdatatype.NONE,
    ) -> None:
        """Delete the rdataset matching the specified properties in the
        current node.

If a matching rdataset does not exist, it is not an error.

*rdclass*, an ``int``, the class of the rdataset.

*rdtype*, an ``int``, the type of the rdataset.

*covers*, an ``int``, the covered type.
        """

rds = self.get_rdataset(rdclass, rdtype, covers)
        if rds is not None:
            self.rdatasets.remove(rds)

def replace_rdataset(self, replacement: dns.rdataset.Rdataset) -> None:
        """Replace an rdataset.

It is not an error if there is no rdataset matching *replacement*.

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

*replacement*, a ``dns.rdataset.Rdataset``.

Raises ``ValueError`` if *replacement* is not a
        ``dns.rdataset.Rdataset``.
        """

if not isinstance(replacement, dns.rdataset.Rdataset):
            raise ValueError("replacement is not an rdataset")
        if isinstance(replacement, dns.rrset.RRset):
            # RRsets are not good replacements as the match() method
            # is not compatible.
            replacement = replacement.to_rdataset()
        self.delete_rdataset(
            replacement.rdclass, replacement.rdtype, replacement.covers
        )
        self._append_rdataset(replacement)

def classify(self) -> NodeKind:
        """Classify a node.

A node which contains a CNAME or RRSIG(CNAME) is a
        ``NodeKind.CNAME`` node.

A node which contains only "neutral" types, i.e. types allowed to
        co-exist with a CNAME, is a ``NodeKind.NEUTRAL`` node.  The neutral
        types are NSEC, NSEC3, KEY, and their associated RRSIGS.  An empty node
        is also considered neutral.

A node which contains some rdataset which is not a CNAME, RRSIG(CNAME),
        or a neutral type is a a ``NodeKind.REGULAR`` node.  Regular nodes are
        also commonly referred to as "other data".
        """
        for rdataset in self.rdatasets:
            kind = NodeKind.classify(rdataset.rdtype, rdataset.covers)
            if kind != NodeKind.NEUTRAL:
                return kind
        return NodeKind.NEUTRAL

def is_immutable(self) -> bool:
        return False

@dns.immutable.immutable
class ImmutableNode(Node):
    def __init__(self, node):
        super().__init__()
        self.rdatasets = tuple(
            [dns.rdataset.ImmutableRdataset(rds) for rds in node.rdatasets]
        )

def find_rdataset(
        self,
        rdclass: dns.rdataclass.RdataClass,
        rdtype: dns.rdatatype.RdataType,
        covers: dns.rdatatype.RdataType = dns.rdatatype.NONE,
        create: bool = False,
    ) -> dns.rdataset.Rdataset:
        if create:
            raise TypeError("immutable")
        return super().find_rdataset(rdclass, rdtype, covers, False)

def get_rdataset(
        self,
        rdclass: dns.rdataclass.RdataClass,
        rdtype: dns.rdatatype.RdataType,
        covers: dns.rdatatype.RdataType = dns.rdatatype.NONE,
        create: bool = False,
    ) -> Optional[dns.rdataset.Rdataset]:
        if create:
            raise TypeError("immutable")
        return super().get_rdataset(rdclass, rdtype, covers, False)

def delete_rdataset(
        self,
        rdclass: dns.rdataclass.RdataClass,
        rdtype: dns.rdatatype.RdataType,
        covers: dns.rdatatype.RdataType = dns.rdatatype.NONE,
    ) -> None:
        raise TypeError("immutable")

def replace_rdataset(self, replacement: dns.rdataset.Rdataset) -> None:
        raise TypeError("immutable")

def is_immutable(self) -> bool:
        return True