Update dnspython-2.2.0

lib/dns/__init__.py

@@ -1,3 +1,5 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
 # Copyright (C) 2003-2007, 2009, 2011 Nominum, Inc.
 #
 # Permission to use, copy, modify, and distribute this software and its
@@ -16,13 +18,15 @@
 """dnspython DNS toolkit"""
 
 __all__ = [
+    'asyncbackend',
+    'asyncquery',
+    'asyncresolver',
     'dnssec',
     'e164',
     'edns',
     'entropy',
     'exception',
     'flags',
-    'hash',
     'inet',
     'ipv4',
     'ipv6',
@@ -41,6 +45,7 @@ __all__ = [
     'resolver',
     'reversename',
     'rrset',
+    'serial',
     'set',
     'tokenizer',
     'tsig',
@@ -49,6 +54,8 @@ __all__ = [
     'rdtypes',
     'update',
     'version',
-    'wiredata',
+    'wire',
     'zone',
 ]
+
+from dns.version import version as __version__  # noqa

lib/dns/_asyncbackend.py

@@ -0,0 +1,60 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
+# This is a nullcontext for both sync and async.  3.7 has a nullcontext,
+# but it is only for sync use.
+
+class NullContext:
+    def __init__(self, enter_result=None):
+        self.enter_result = enter_result
+
+    def __enter__(self):
+        return self.enter_result
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        pass
+
+    async def __aenter__(self):
+        return self.enter_result
+
+    async def __aexit__(self, exc_type, exc_value, traceback):
+        pass
+
+
+# These are declared here so backends can import them without creating
+# circular dependencies with dns.asyncbackend.
+
+class Socket:  # pragma: no cover
+    async def close(self):
+        pass
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_value, traceback):
+        await self.close()
+
+
+class DatagramSocket(Socket):  # pragma: no cover
+    async def sendto(self, what, destination, timeout):
+        pass
+
+    async def recvfrom(self, size, timeout):
+        pass
+
+
+class StreamSocket(Socket):  # pragma: no cover
+    async def sendall(self, what, destination, timeout):
+        pass
+
+    async def recv(self, size, timeout):
+        pass
+
+
+class Backend:    # pragma: no cover
+    def name(self):
+        return 'unknown'
+
+    async def make_socket(self, af, socktype, proto=0,
+                          source=None, destination=None, timeout=None,
+                          ssl_context=None, server_hostname=None):
+        raise NotImplementedError

lib/dns/_asyncio_backend.py

@@ -0,0 +1,140 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
+"""asyncio library query support"""
+
+import socket
+import asyncio
+
+import dns._asyncbackend
+import dns.exception
+
+
+def _get_running_loop():
+    try:
+        return asyncio.get_running_loop()
+    except AttributeError:  # pragma: no cover
+        return asyncio.get_event_loop()
+
+
+class _DatagramProtocol:
+    def __init__(self):
+        self.transport = None
+        self.recvfrom = None
+
+    def connection_made(self, transport):
+        self.transport = transport
+
+    def datagram_received(self, data, addr):
+        if self.recvfrom:
+            self.recvfrom.set_result((data, addr))
+            self.recvfrom = None
+
+    def error_received(self, exc):  # pragma: no cover
+        if self.recvfrom:
+            self.recvfrom.set_exception(exc)
+
+    def connection_lost(self, exc):
+        if self.recvfrom:
+            self.recvfrom.set_exception(exc)
+
+    def close(self):
+        self.transport.close()
+
+
+async def _maybe_wait_for(awaitable, timeout):
+    if timeout:
+        try:
+            return await asyncio.wait_for(awaitable, timeout)
+        except asyncio.TimeoutError:
+            raise dns.exception.Timeout(timeout=timeout)
+    else:
+        return await awaitable
+
+
+class DatagramSocket(dns._asyncbackend.DatagramSocket):
+    def __init__(self, family, transport, protocol):
+        self.family = family
+        self.transport = transport
+        self.protocol = protocol
+
+    async def sendto(self, what, destination, timeout):  # pragma: no cover
+        # no timeout for asyncio sendto
+        self.transport.sendto(what, destination)
+
+    async def recvfrom(self, size, timeout):
+        # ignore size as there's no way I know to tell protocol about it
+        done = _get_running_loop().create_future()
+        assert self.protocol.recvfrom is None
+        self.protocol.recvfrom = done
+        await _maybe_wait_for(done, timeout)
+        return done.result()
+
+    async def close(self):
+        self.protocol.close()
+
+    async def getpeername(self):
+        return self.transport.get_extra_info('peername')
+
+    async def getsockname(self):
+        return self.transport.get_extra_info('sockname')
+
+
+class StreamSocket(dns._asyncbackend.DatagramSocket):
+    def __init__(self, af, reader, writer):
+        self.family = af
+        self.reader = reader
+        self.writer = writer
+
+    async def sendall(self, what, timeout):
+        self.writer.write(what),
+        return await _maybe_wait_for(self.writer.drain(), timeout)
+        raise dns.exception.Timeout(timeout=timeout)
+
+    async def recv(self, count, timeout):
+        return await _maybe_wait_for(self.reader.read(count),
+                                     timeout)
+        raise dns.exception.Timeout(timeout=timeout)
+
+    async def close(self):
+        self.writer.close()
+        try:
+            await self.writer.wait_closed()
+        except AttributeError:  # pragma: no cover
+            pass
+
+    async def getpeername(self):
+        return self.writer.get_extra_info('peername')
+
+    async def getsockname(self):
+        return self.writer.get_extra_info('sockname')
+
+
+class Backend(dns._asyncbackend.Backend):
+    def name(self):
+        return 'asyncio'
+
+    async def make_socket(self, af, socktype, proto=0,
+                          source=None, destination=None, timeout=None,
+                          ssl_context=None, server_hostname=None):
+        loop = _get_running_loop()
+        if socktype == socket.SOCK_DGRAM:
+            transport, protocol = await loop.create_datagram_endpoint(
+                _DatagramProtocol, source, family=af,
+                proto=proto)
+            return DatagramSocket(af, transport, protocol)
+        elif socktype == socket.SOCK_STREAM:
+            (r, w) = await _maybe_wait_for(
+                asyncio.open_connection(destination[0],
+                                        destination[1],
+                                        ssl=ssl_context,
+                                        family=af,
+                                        proto=proto,
+                                        local_addr=source,
+                                        server_hostname=server_hostname),
+                timeout)
+            return StreamSocket(af, r, w)
+        raise NotImplementedError('unsupported socket ' +
+                                  f'type {socktype}')  # pragma: no cover
+
+    async def sleep(self, interval):
+        await asyncio.sleep(interval)

lib/dns/_compat.py

@@ -1,21 +0,0 @@
-import sys
-
-
-if sys.version_info > (3,):
-    long = int
-    xrange = range
-else:
-    long = long
-    xrange = xrange
-
-# unicode / binary types
-if sys.version_info > (3,):
-    text_type = str
-    binary_type = bytes
-    string_types = (str,)
-    unichr = chr
-else:
-    text_type = unicode
-    binary_type = str
-    string_types = (basestring,)
-    unichr = unichr

lib/dns/_curio_backend.py

@@ -0,0 +1,106 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
+"""curio async I/O library query support"""
+
+import socket
+import curio
+import curio.socket  # type: ignore
+
+import dns._asyncbackend
+import dns.exception
+import dns.inet
+
+
+def _maybe_timeout(timeout):
+    if timeout:
+        return curio.ignore_after(timeout)
+    else:
+        return dns._asyncbackend.NullContext()
+
+
+# for brevity
+_lltuple = dns.inet.low_level_address_tuple
+
+
+class DatagramSocket(dns._asyncbackend.DatagramSocket):
+    def __init__(self, socket):
+        self.socket = socket
+        self.family = socket.family
+
+    async def sendto(self, what, destination, timeout):
+        async with _maybe_timeout(timeout):
+            return await self.socket.sendto(what, destination)
+        raise dns.exception.Timeout(timeout=timeout)  # pragma: no cover
+
+    async def recvfrom(self, size, timeout):
+        async with _maybe_timeout(timeout):
+            return await self.socket.recvfrom(size)
+        raise dns.exception.Timeout(timeout=timeout)
+
+    async def close(self):
+        await self.socket.close()
+
+    async def getpeername(self):
+        return self.socket.getpeername()
+
+    async def getsockname(self):
+        return self.socket.getsockname()
+
+
+class StreamSocket(dns._asyncbackend.DatagramSocket):
+    def __init__(self, socket):
+        self.socket = socket
+        self.family = socket.family
+
+    async def sendall(self, what, timeout):
+        async with _maybe_timeout(timeout):
+            return await self.socket.sendall(what)
+        raise dns.exception.Timeout(timeout=timeout)
+
+    async def recv(self, size, timeout):
+        async with _maybe_timeout(timeout):
+            return await self.socket.recv(size)
+        raise dns.exception.Timeout(timeout=timeout)
+
+    async def close(self):
+        await self.socket.close()
+
+    async def getpeername(self):
+        return self.socket.getpeername()
+
+    async def getsockname(self):
+        return self.socket.getsockname()
+
+
+class Backend(dns._asyncbackend.Backend):
+    def name(self):
+        return 'curio'
+
+    async def make_socket(self, af, socktype, proto=0,
+                          source=None, destination=None, timeout=None,
+                          ssl_context=None, server_hostname=None):
+        if socktype == socket.SOCK_DGRAM:
+            s = curio.socket.socket(af, socktype, proto)
+            try:
+                if source:
+                    s.bind(_lltuple(source, af))
+            except Exception:  # pragma: no cover
+                await s.close()
+                raise
+            return DatagramSocket(s)
+        elif socktype == socket.SOCK_STREAM:
+            if source:
+                source_addr = _lltuple(source, af)
+            else:
+                source_addr = None
+            async with _maybe_timeout(timeout):
+                s = await curio.open_connection(destination[0], destination[1],
+                                                ssl=ssl_context,
+                                                source_addr=source_addr,
+                                                server_hostname=server_hostname)
+            return StreamSocket(s)
+        raise NotImplementedError('unsupported socket ' +
+                                  f'type {socktype}')  # pragma: no cover
+
+    async def sleep(self, interval):
+        await curio.sleep(interval)

lib/dns/_trio_backend.py

@@ -0,0 +1,119 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
+"""trio async I/O library query support"""
+
+import socket
+import trio
+import trio.socket  # type: ignore
+
+import dns._asyncbackend
+import dns.exception
+import dns.inet
+
+
+def _maybe_timeout(timeout):
+    if timeout:
+        return trio.move_on_after(timeout)
+    else:
+        return dns._asyncbackend.NullContext()
+
+
+# for brevity
+_lltuple = dns.inet.low_level_address_tuple
+
+
+class DatagramSocket(dns._asyncbackend.DatagramSocket):
+    def __init__(self, socket):
+        self.socket = socket
+        self.family = socket.family
+
+    async def sendto(self, what, destination, timeout):
+        with _maybe_timeout(timeout):
+            return await self.socket.sendto(what, destination)
+        raise dns.exception.Timeout(timeout=timeout)  # pragma: no cover
+
+    async def recvfrom(self, size, timeout):
+        with _maybe_timeout(timeout):
+            return await self.socket.recvfrom(size)
+        raise dns.exception.Timeout(timeout=timeout)
+
+    async def close(self):
+        self.socket.close()
+
+    async def getpeername(self):
+        return self.socket.getpeername()
+
+    async def getsockname(self):
+        return self.socket.getsockname()
+
+
+class StreamSocket(dns._asyncbackend.DatagramSocket):
+    def __init__(self, family, stream, tls=False):
+        self.family = family
+        self.stream = stream
+        self.tls = tls
+
+    async def sendall(self, what, timeout):
+        with _maybe_timeout(timeout):
+            return await self.stream.send_all(what)
+        raise dns.exception.Timeout(timeout=timeout)
+
+    async def recv(self, size, timeout):
+        with _maybe_timeout(timeout):
+            return await self.stream.receive_some(size)
+        raise dns.exception.Timeout(timeout=timeout)
+
+    async def close(self):
+        await self.stream.aclose()
+
+    async def getpeername(self):
+        if self.tls:
+            return self.stream.transport_stream.socket.getpeername()
+        else:
+            return self.stream.socket.getpeername()
+
+    async def getsockname(self):
+        if self.tls:
+            return self.stream.transport_stream.socket.getsockname()
+        else:
+            return self.stream.socket.getsockname()
+
+
+class Backend(dns._asyncbackend.Backend):
+    def name(self):
+        return 'trio'
+
+    async def make_socket(self, af, socktype, proto=0, source=None,
+                          destination=None, timeout=None,
+                          ssl_context=None, server_hostname=None):
+        s = trio.socket.socket(af, socktype, proto)
+        stream = None
+        try:
+            if source:
+                await s.bind(_lltuple(source, af))
+            if socktype == socket.SOCK_STREAM:
+                with _maybe_timeout(timeout):
+                    await s.connect(_lltuple(destination, af))
+        except Exception:  # pragma: no cover
+            s.close()
+            raise
+        if socktype == socket.SOCK_DGRAM:
+            return DatagramSocket(s)
+        elif socktype == socket.SOCK_STREAM:
+            stream = trio.SocketStream(s)
+            s = None
+            tls = False
+            if ssl_context:
+                tls = True
+                try:
+                    stream = trio.SSLStream(stream, ssl_context,
+                                            server_hostname=server_hostname)
+                except Exception:  # pragma: no cover
+                    await stream.aclose()
+                    raise
+            return StreamSocket(af, stream, tls)
+        raise NotImplementedError('unsupported socket ' +
+                                  f'type {socktype}')    # pragma: no cover
+
+    async def sleep(self, interval):
+        await trio.sleep(interval)

lib/dns/asyncbackend.py

@@ -0,0 +1,96 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
+import dns.exception
+
+from dns._asyncbackend import Socket, DatagramSocket, \
+    StreamSocket, Backend  # noqa:
+
+
+_default_backend = None
+
+_backends = {}
+
+# Allow sniffio import to be disabled for testing purposes
+_no_sniffio = False
+
+class AsyncLibraryNotFoundError(dns.exception.DNSException):
+    pass
+
+
+def get_backend(name):
+    """Get the specified asychronous backend.
+
+    *name*, a ``str``, the name of the backend.  Currently the "trio",
+    "curio", and "asyncio" backends are available.
+
+    Raises NotImplementError if an unknown backend name is specified.
+    """
+    backend = _backends.get(name)
+    if backend:
+        return backend
+    if name == 'trio':
+        import dns._trio_backend
+        backend = dns._trio_backend.Backend()
+    elif name == 'curio':
+        import dns._curio_backend
+        backend = dns._curio_backend.Backend()
+    elif name == 'asyncio':
+        import dns._asyncio_backend
+        backend = dns._asyncio_backend.Backend()
+    else:
+        raise NotImplementedError(f'unimplemented async backend {name}')
+    _backends[name] = backend
+    return backend
+
+
+def sniff():
+    """Attempt to determine the in-use asynchronous I/O library by using
+    the ``sniffio`` module if it is available.
+
+    Returns the name of the library, or raises AsyncLibraryNotFoundError
+    if the library cannot be determined.
+    """
+    try:
+        if _no_sniffio:
+            raise ImportError
+        import sniffio
+        try:
+            return sniffio.current_async_library()
+        except sniffio.AsyncLibraryNotFoundError:
+            raise AsyncLibraryNotFoundError('sniffio cannot determine ' +
+                                            'async library')
+    except ImportError:
+        import asyncio
+        try:
+            asyncio.get_running_loop()
+            return 'asyncio'
+        except RuntimeError:
+            raise AsyncLibraryNotFoundError('no async library detected')
+        except AttributeError:  # pragma: no cover
+            # we have to check current_task on 3.6
+            if not asyncio.Task.current_task():
+                raise AsyncLibraryNotFoundError('no async library detected')
+            return 'asyncio'
+
+
+def get_default_backend():
+    """Get the default backend, initializing it if necessary.
+    """
+    if _default_backend:
+        return _default_backend
+
+    return set_default_backend(sniff())
+
+
+def set_default_backend(name):
+    """Set the default backend.
+
+    It's not normally necessary to call this method, as
+    ``get_default_backend()`` will initialize the backend
+    appropriately in many cases.  If ``sniffio`` is not installed, or
+    in testing situations, this function allows the backend to be set
+    explicitly.
+    """
+    global _default_backend
+    _default_backend = get_backend(name)
+    return _default_backend

lib/dns/asyncquery.py

@@ -0,0 +1,500 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
+# Copyright (C) 2003-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.
+
+"""Talk to a DNS server."""
+
+import socket
+import struct
+import time
+
+import dns.asyncbackend
+import dns.exception
+import dns.inet
+import dns.name
+import dns.message
+import dns.rcode
+import dns.rdataclass
+import dns.rdatatype
+
+from dns.query import _compute_times, _matches_destination, BadResponse, ssl
+
+
+# for brevity
+_lltuple = dns.inet.low_level_address_tuple
+
+
+def _source_tuple(af, address, port):
+    # Make a high level source tuple, or return None if address and port
+    # are both None
+    if address or port:
+        if address is None:
+            if af == socket.AF_INET:
+                address = '0.0.0.0'
+            elif af == socket.AF_INET6:
+                address = '::'
+            else:
+                raise NotImplementedError(f'unknown address family {af}')
+        return (address, port)
+    else:
+        return None
+
+
+def _timeout(expiration, now=None):
+    if expiration:
+        if not now:
+            now = time.time()
+        return max(expiration - now, 0)
+    else:
+        return None
+
+
+async def send_udp(sock, what, destination, expiration=None):
+    """Send a DNS message to the specified UDP socket.
+
+    *sock*, a ``dns.asyncbackend.DatagramSocket``.
+
+    *what*, a ``bytes`` or ``dns.message.Message``, the message to send.
+
+    *destination*, a destination tuple appropriate for the address family
+    of the socket, specifying where to send the query.
+
+    *expiration*, a ``float`` or ``None``, the absolute time at which
+    a timeout exception should be raised.  If ``None``, no timeout will
+    occur.
+
+    Returns an ``(int, float)`` tuple of bytes sent and the sent time.
+    """
+
+    if isinstance(what, dns.message.Message):
+        what = what.to_wire()
+    sent_time = time.time()
+    n = await sock.sendto(what, destination, _timeout(expiration, sent_time))
+    return (n, sent_time)
+
+
+async def receive_udp(sock, destination=None, expiration=None,
+                      ignore_unexpected=False, one_rr_per_rrset=False,
+                      keyring=None, request_mac=b'', ignore_trailing=False,
+                      raise_on_truncation=False):
+    """Read a DNS message from a UDP socket.
+
+    *sock*, a ``dns.asyncbackend.DatagramSocket``.
+
+    *destination*, a destination tuple appropriate for the address family
+    of the socket, specifying where the message is expected to arrive from.
+    When receiving a response, this would be where the associated query was
+    sent.
+
+    *expiration*, a ``float`` or ``None``, the absolute time at which
+    a timeout exception should be raised.  If ``None``, no timeout will
+    occur.
+
+    *ignore_unexpected*, a ``bool``.  If ``True``, ignore responses from
+    unexpected sources.
+
+    *one_rr_per_rrset*, a ``bool``.  If ``True``, put each RR into its own
+    RRset.
+
+    *keyring*, a ``dict``, the keyring to use for TSIG.
+
+    *request_mac*, a ``bytes``, the MAC of the request (for TSIG).
+
+    *ignore_trailing*, a ``bool``.  If ``True``, ignore trailing
+    junk at end of the received message.
+
+    *raise_on_truncation*, a ``bool``.  If ``True``, raise an exception if
+    the TC bit is set.
+
+    Raises if the message is malformed, if network errors occur, of if
+    there is a timeout.
+
+    Returns a ``(dns.message.Message, float, tuple)`` tuple of the received
+    message, the received time, and the address where the message arrived from.
+    """
+
+    wire = b''
+    while 1:
+        (wire, from_address) = await sock.recvfrom(65535, _timeout(expiration))
+        if _matches_destination(sock.family, from_address, destination,
+                                ignore_unexpected):
+            break
+    received_time = time.time()
+    r = dns.message.from_wire(wire, keyring=keyring, request_mac=request_mac,
+                              one_rr_per_rrset=one_rr_per_rrset,
+                              ignore_trailing=ignore_trailing,
+                              raise_on_truncation=raise_on_truncation)
+    return (r, received_time, from_address)
+
+async def udp(q, where, timeout=None, port=53, source=None, source_port=0,
+              ignore_unexpected=False, one_rr_per_rrset=False,
+              ignore_trailing=False, raise_on_truncation=False, sock=None,
+              backend=None):
+    """Return the response obtained after sending a query via UDP.
+
+    *q*, a ``dns.message.Message``, the query to send
+
+    *where*, a ``str`` containing an IPv4 or IPv6 address,  where
+    to send the message.
+
+    *timeout*, a ``float`` or ``None``, the number of seconds to wait before the
+    query times out.  If ``None``, the default, wait forever.
+
+    *port*, an ``int``, the port send the message to.  The default is 53.
+
+    *source*, a ``str`` containing an IPv4 or IPv6 address, specifying
+    the source address.  The default is the wildcard address.
+
+    *source_port*, an ``int``, the port from which to send the message.
+    The default is 0.
+
+    *ignore_unexpected*, a ``bool``.  If ``True``, ignore responses from
+    unexpected sources.
+
+    *one_rr_per_rrset*, a ``bool``.  If ``True``, put each RR into its own
+    RRset.
+
+    *ignore_trailing*, a ``bool``.  If ``True``, ignore trailing
+    junk at end of the received message.
+
+    *raise_on_truncation*, a ``bool``.  If ``True``, raise an exception if
+    the TC bit is set.
+
+    *sock*, a ``dns.asyncbackend.DatagramSocket``, or ``None``,
+    the socket to use for the query.  If ``None``, the default, a
+    socket is created.  Note that if a socket is provided, the
+    *source*, *source_port*, and *backend* are ignored.
+
+    *backend*, a ``dns.asyncbackend.Backend``, or ``None``.  If ``None``,
+    the default, then dnspython will use the default backend.
+
+    Returns a ``dns.message.Message``.
+    """
+    wire = q.to_wire()
+    (begin_time, expiration) = _compute_times(timeout)
+    s = None
+    # After 3.6 is no longer supported, this can use an AsyncExitStack.
+    try:
+        af = dns.inet.af_for_address(where)
+        destination = _lltuple((where, port), af)
+        if sock:
+            s = sock
+        else:
+            if not backend:
+                backend = dns.asyncbackend.get_default_backend()
+            stuple = _source_tuple(af, source, source_port)
+            s = await backend.make_socket(af, socket.SOCK_DGRAM, 0, stuple)
+        await send_udp(s, wire, destination, expiration)
+        (r, received_time, _) = await receive_udp(s, destination, expiration,
+                                                  ignore_unexpected,
+                                                  one_rr_per_rrset,
+                                                  q.keyring, q.mac,
+                                                  ignore_trailing,
+                                                  raise_on_truncation)
+        r.time = received_time - begin_time
+        if not q.is_response(r):
+            raise BadResponse
+        return r
+    finally:
+        if not sock and s:
+            await s.close()
+
+async def udp_with_fallback(q, where, timeout=None, port=53, source=None,
+                            source_port=0, ignore_unexpected=False,
+                            one_rr_per_rrset=False, ignore_trailing=False,
+                            udp_sock=None, tcp_sock=None, backend=None):
+    """Return the response to the query, trying UDP first and falling back
+    to TCP if UDP results in a truncated response.
+
+    *q*, a ``dns.message.Message``, the query to send
+
+    *where*, a ``str`` containing an IPv4 or IPv6 address,  where
+    to send the message.
+
+    *timeout*, a ``float`` or ``None``, the number of seconds to wait before the
+    query times out.  If ``None``, the default, wait forever.
+
+    *port*, an ``int``, the port send the message to.  The default is 53.
+
+    *source*, a ``str`` containing an IPv4 or IPv6 address, specifying
+    the source address.  The default is the wildcard address.
+
+    *source_port*, an ``int``, the port from which to send the message.
+    The default is 0.
+
+    *ignore_unexpected*, a ``bool``.  If ``True``, ignore responses from
+    unexpected sources.
+
+    *one_rr_per_rrset*, a ``bool``.  If ``True``, put each RR into its own
+    RRset.
+
+    *ignore_trailing*, a ``bool``.  If ``True``, ignore trailing
+    junk at end of the received message.
+
+    *udp_sock*, a ``dns.asyncbackend.DatagramSocket``, or ``None``,
+    the socket to use for the UDP query.  If ``None``, the default, a
+    socket is created.  Note that if a socket is provided the *source*,
+    *source_port*, and *backend* are ignored for the UDP query.
+
+    *tcp_sock*, a ``dns.asyncbackend.StreamSocket``, or ``None``, the
+    socket to use for the TCP query.  If ``None``, the default, a
+    socket is created.  Note that if a socket is provided *where*,
+    *source*, *source_port*, and *backend*  are ignored for the TCP query.
+
+    *backend*, a ``dns.asyncbackend.Backend``, or ``None``.  If ``None``,
+    the default, then dnspython will use the default backend.
+
+    Returns a (``dns.message.Message``, tcp) tuple where tcp is ``True``
+    if and only if TCP was used.
+    """
+    try:
+        response = await udp(q, where, timeout, port, source, source_port,
+                             ignore_unexpected, one_rr_per_rrset,
+                             ignore_trailing, True, udp_sock, backend)
+        return (response, False)
+    except dns.message.Truncated:
+        response = await tcp(q, where, timeout, port, source, source_port,
+                             one_rr_per_rrset, ignore_trailing, tcp_sock,
+                             backend)
+        return (response, True)
+
+
+async def send_tcp(sock, what, expiration=None):
+    """Send a DNS message to the specified TCP socket.
+
+    *sock*, a ``socket``.
+
+    *what*, a ``bytes`` or ``dns.message.Message``, the message to send.
+
+    *expiration*, a ``float`` or ``None``, the absolute time at which
+    a timeout exception should be raised.  If ``None``, no timeout will
+    occur.
+
+    Returns an ``(int, float)`` tuple of bytes sent and the sent time.
+    """
+
+    if isinstance(what, dns.message.Message):
+        what = what.to_wire()
+    l = len(what)
+    # copying the wire into tcpmsg is inefficient, but lets us
+    # avoid writev() or doing a short write that would get pushed
+    # onto the net
+    tcpmsg = struct.pack("!H", l) + what
+    sent_time = time.time()
+    await sock.sendall(tcpmsg, expiration)
+    return (len(tcpmsg), sent_time)
+
+
+async def _read_exactly(sock, count, expiration):
+    """Read the specified number of bytes from stream.  Keep trying until we
+    either get the desired amount, or we hit EOF.
+    """
+    s = b''
+    while count > 0:
+        n = await sock.recv(count, _timeout(expiration))
+        if n == b'':
+            raise EOFError
+        count = count - len(n)
+        s = s + n
+    return s
+
+
+async def receive_tcp(sock, expiration=None, one_rr_per_rrset=False,
+                      keyring=None, request_mac=b'', ignore_trailing=False):
+    """Read a DNS message from a TCP socket.
+
+    *sock*, a ``socket``.
+
+    *expiration*, a ``float`` or ``None``, the absolute time at which
+    a timeout exception should be raised.  If ``None``, no timeout will
+    occur.
+
+    *one_rr_per_rrset*, a ``bool``.  If ``True``, put each RR into its own
+    RRset.
+
+    *keyring*, a ``dict``, the keyring to use for TSIG.
+
+    *request_mac*, a ``bytes``, the MAC of the request (for TSIG).
+
+    *ignore_trailing*, a ``bool``.  If ``True``, ignore trailing
+    junk at end of the received message.
+
+    Raises if the message is malformed, if network errors occur, of if
+    there is a timeout.
+
+    Returns a ``(dns.message.Message, float)`` tuple of the received message
+    and the received time.
+    """
+
+    ldata = await _read_exactly(sock, 2, expiration)
+    (l,) = struct.unpack("!H", ldata)
+    wire = await _read_exactly(sock, l, expiration)
+    received_time = time.time()
+    r = dns.message.from_wire(wire, keyring=keyring, request_mac=request_mac,
+                              one_rr_per_rrset=one_rr_per_rrset,
+                              ignore_trailing=ignore_trailing)
+    return (r, received_time)
+
+
+async def tcp(q, where, timeout=None, port=53, source=None, source_port=0,
+              one_rr_per_rrset=False, ignore_trailing=False, sock=None,
+              backend=None):
+    """Return the response obtained after sending a query via TCP.
+
+    *q*, a ``dns.message.Message``, the query to send
+
+    *where*, a ``str`` containing an IPv4 or IPv6 address, where
+    to send the message.
+
+    *timeout*, a ``float`` or ``None``, the number of seconds to wait before the
+    query times out.  If ``None``, the default, wait forever.
+
+    *port*, an ``int``, the port send the message to.  The default is 53.
+
+    *source*, a ``str`` containing an IPv4 or IPv6 address, specifying
+    the source address.  The default is the wildcard address.
+
+    *source_port*, an ``int``, the port from which to send the message.
+    The default is 0.
+
+    *one_rr_per_rrset*, a ``bool``.  If ``True``, put each RR into its own
+    RRset.
+
+    *ignore_trailing*, a ``bool``.  If ``True``, ignore trailing
+    junk at end of the received message.
+
+    *sock*, a ``dns.asyncbacket.StreamSocket``, or ``None``, the
+    socket to use for the query.  If ``None``, the default, a socket
+    is created.  Note that if a socket is provided
+    *where*, *port*, *source*, *source_port*, and *backend* are ignored.
+
+    *backend*, a ``dns.asyncbackend.Backend``, or ``None``.  If ``None``,
+    the default, then dnspython will use the default backend.
+
+    Returns a ``dns.message.Message``.
+    """
+
+    wire = q.to_wire()
+    (begin_time, expiration) = _compute_times(timeout)
+    s = None
+    # After 3.6 is no longer supported, this can use an AsyncExitStack.
+    try:
+        if sock:
+            # Verify that the socket is connected, as if it's not connected,
+            # it's not writable, and the polling in send_tcp() will time out or
+            # hang forever.
+            await sock.getpeername()
+            s = sock
+        else:
+            # These are simple (address, port) pairs, not
+            # family-dependent tuples you pass to lowlevel socket
+            # code.
+            af = dns.inet.af_for_address(where)
+            stuple = _source_tuple(af, source, source_port)
+            dtuple = (where, port)
+            if not backend:
+                backend = dns.asyncbackend.get_default_backend()
+            s = await backend.make_socket(af, socket.SOCK_STREAM, 0, stuple,
+                                          dtuple, timeout)
+        await send_tcp(s, wire, expiration)
+        (r, received_time) = await receive_tcp(s, expiration, one_rr_per_rrset,
+                                               q.keyring, q.mac,
+                                               ignore_trailing)
+        r.time = received_time - begin_time
+        if not q.is_response(r):
+            raise BadResponse
+        return r
+    finally:
+        if not sock and s:
+            await s.close()
+
+async def tls(q, where, timeout=None, port=853, source=None, source_port=0,
+              one_rr_per_rrset=False, ignore_trailing=False, sock=None,
+              backend=None, ssl_context=None, server_hostname=None):
+    """Return the response obtained after sending a query via TLS.
+
+    *q*, a ``dns.message.Message``, the query to send
+
+    *where*, a ``str`` containing an IPv4 or IPv6 address,  where
+    to send the message.
+
+    *timeout*, a ``float`` or ``None``, the number of seconds to wait before the
+    query times out.  If ``None``, the default, wait forever.
+
+    *port*, an ``int``, the port send the message to.  The default is 853.
+
+    *source*, a ``str`` containing an IPv4 or IPv6 address, specifying
+    the source address.  The default is the wildcard address.
+
+    *source_port*, an ``int``, the port from which to send the message.
+    The default is 0.
+
+    *one_rr_per_rrset*, a ``bool``.  If ``True``, put each RR into its own
+    RRset.
+
+    *ignore_trailing*, a ``bool``.  If ``True``, ignore trailing
+    junk at end of the received message.
+
+    *sock*, an ``asyncbackend.StreamSocket``, or ``None``, the socket
+    to use for the query.  If ``None``, the default, a socket is
+    created.  Note that if a socket is provided, it must be a
+    connected SSL stream socket, and *where*, *port*,
+    *source*, *source_port*, *backend*, *ssl_context*, and *server_hostname*
+    are ignored.
+
+    *backend*, a ``dns.asyncbackend.Backend``, or ``None``.  If ``None``,
+    the default, then dnspython will use the default backend.
+
+    *ssl_context*, an ``ssl.SSLContext``, the context to use when establishing
+    a TLS connection. If ``None``, the default, creates one with the default
+    configuration.
+
+    *server_hostname*, a ``str`` containing the server's hostname.  The
+    default is ``None``, which means that no hostname is known, and if an
+    SSL context is created, hostname checking will be disabled.
+
+    Returns a ``dns.message.Message``.
+    """
+    # After 3.6 is no longer supported, this can use an AsyncExitStack.
+    (begin_time, expiration) = _compute_times(timeout)
+    if not sock:
+        if ssl_context is None:
+            ssl_context = ssl.create_default_context()
+            if server_hostname is None:
+                ssl_context.check_hostname = False
+        else:
+            ssl_context = None
+            server_hostname = None
+        af = dns.inet.af_for_address(where)
+        stuple = _source_tuple(af, source, source_port)
+        dtuple = (where, port)
+        if not backend:
+            backend = dns.asyncbackend.get_default_backend()
+        s = await backend.make_socket(af, socket.SOCK_STREAM, 0, stuple,
+                                      dtuple, timeout, ssl_context,
+                                      server_hostname)
+    else:
+        s = sock
+    try:
+        timeout = _timeout(expiration)
+        response = await tcp(q, where, timeout, port, source, source_port,
+                             one_rr_per_rrset, ignore_trailing, s, backend)
+        end_time = time.time()
+        response.time = end_time - begin_time
+        return response
+    finally:
+        if not sock and s:
+            await s.close()

lib/dns/asyncresolver.py

@@ -0,0 +1,257 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
+# Copyright (C) 2003-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.
+
+"""Asynchronous DNS stub resolver."""
+
+import time
+
+import dns.asyncbackend
+import dns.asyncquery
+import dns.exception
+import dns.query
+import dns.resolver
+
+# import some resolver symbols for brevity
+from dns.resolver import NXDOMAIN, NoAnswer, NotAbsolute, NoRootSOA
+
+
+# for indentation purposes below
+_udp = dns.asyncquery.udp
+_tcp = dns.asyncquery.tcp
+
+
+class Resolver(dns.resolver.Resolver):
+
+    async def resolve(self, qname, rdtype=dns.rdatatype.A,
+                      rdclass=dns.rdataclass.IN,
+                      tcp=False, source=None, raise_on_no_answer=True,
+                      source_port=0, lifetime=None, search=None,
+                      backend=None):
+        """Query nameservers asynchronously to find the answer to the question.
+
+        The *qname*, *rdtype*, and *rdclass* parameters may be objects
+        of the appropriate type, or strings that can be converted into objects
+        of the appropriate type.
+
+        *qname*, a ``dns.name.Name`` or ``str``, the query name.
+
+        *rdtype*, an ``int`` or ``str``,  the query type.
+
+        *rdclass*, an ``int`` or ``str``,  the query class.
+
+        *tcp*, a ``bool``.  If ``True``, use TCP to make the query.
+
+        *source*, a ``str`` or ``None``.  If not ``None``, bind to this IP
+        address when making queries.
+
+        *raise_on_no_answer*, a ``bool``.  If ``True``, raise
+        ``dns.resolver.NoAnswer`` if there's no answer to the question.
+
+        *source_port*, an ``int``, the port from which to send the message.
+
+        *lifetime*, a ``float``, how many seconds a query should run
+         before timing out.
+
+        *search*, a ``bool`` or ``None``, determines whether the
+        search list configured in the system's resolver configuration
+        are used for relative names, and whether the resolver's domain
+        may be added to relative names.  The default is ``None``,
+        which causes the value of the resolver's
+        ``use_search_by_default`` attribute to be used.
+
+        *backend*, a ``dns.asyncbackend.Backend``, or ``None``.  If ``None``,
+        the default, then dnspython will use the default backend.
+
+        Raises ``dns.resolver.NXDOMAIN`` if the query name does not exist.
+
+        Raises ``dns.resolver.YXDOMAIN`` if the query name is too long after
+        DNAME substitution.
+
+        Raises ``dns.resolver.NoAnswer`` if *raise_on_no_answer* is
+        ``True`` and the query name exists but has no RRset of the
+        desired type and class.
+
+        Raises ``dns.resolver.NoNameservers`` if no non-broken
+        nameservers are available to answer the question.
+
+        Returns a ``dns.resolver.Answer`` instance.
+
+        """
+
+        resolution = dns.resolver._Resolution(self, qname, rdtype, rdclass, tcp,
+                                              raise_on_no_answer, search)
+        if not backend:
+            backend = dns.asyncbackend.get_default_backend()
+        start = time.time()
+        while True:
+            (request, answer) = resolution.next_request()
+            # Note we need to say "if answer is not None" and not just
+            # "if answer" because answer implements __len__, and python
+            # will call that.  We want to return if we have an answer
+            # object, including in cases where its length is 0.
+            if answer is not None:
+                # cache hit!
+                return answer
+            done = False
+            while not done:
+                (nameserver, port, tcp, backoff) = resolution.next_nameserver()
+                if backoff:
+                    await backend.sleep(backoff)
+                timeout = self._compute_timeout(start, lifetime)
+                try:
+                    if dns.inet.is_address(nameserver):
+                        if tcp:
+                            response = await _tcp(request, nameserver,
+                                                  timeout, port,
+                                                  source, source_port,
+                                                  backend=backend)
+                        else:
+                            response = await _udp(request, nameserver,
+                                                  timeout, port,
+                                                  source, source_port,
+                                                  raise_on_truncation=True,
+                                                  backend=backend)
+                    else:
+                        # We don't do DoH yet.
+                        raise NotImplementedError
+                except Exception as ex:
+                    (_, done) = resolution.query_result(None, ex)
+                    continue
+                (answer, done) = resolution.query_result(response, None)
+                # Note we need to say "if answer is not None" and not just
+                # "if answer" because answer implements __len__, and python
+                # will call that.  We want to return if we have an answer
+                # object, including in cases where its length is 0.
+                if answer is not None:
+                    return answer
+
+    async def query(self, *args, **kwargs):
+        # We have to define something here as we don't want to inherit the
+        # parent's query().
+        raise NotImplementedError
+
+    async def resolve_address(self, ipaddr, *args, **kwargs):
+        """Use an asynchronous resolver to run a reverse query for PTR
+        records.
+
+        This utilizes the resolve() method to perform a PTR lookup on the
+        specified IP address.
+
+        *ipaddr*, a ``str``, the IPv4 or IPv6 address you want to get
+        the PTR record for.
+
+        All other arguments that can be passed to the resolve() function
+        except for rdtype and rdclass are also supported by this
+        function.
+
+        """
+
+        return await self.resolve(dns.reversename.from_address(ipaddr),
+                                  rdtype=dns.rdatatype.PTR,
+                                  rdclass=dns.rdataclass.IN,
+                                  *args, **kwargs)
+
+default_resolver = None
+
+
+def get_default_resolver():
+    """Get the default asynchronous resolver, initializing it if necessary."""
+    if default_resolver is None:
+        reset_default_resolver()
+    return default_resolver
+
+
+def reset_default_resolver():
+    """Re-initialize default asynchronous resolver.
+
+    Note that the resolver configuration (i.e. /etc/resolv.conf on UNIX
+    systems) will be re-read immediately.
+    """
+
+    global default_resolver
+    default_resolver = Resolver()
+
+
+async def resolve(qname, rdtype=dns.rdatatype.A, rdclass=dns.rdataclass.IN,
+                  tcp=False, source=None, raise_on_no_answer=True,
+                  source_port=0, search=None, backend=None):
+    """Query nameservers asynchronously to find the answer to the question.
+
+    This is a convenience function that uses the default resolver
+    object to make the query.
+
+    See ``dns.asyncresolver.Resolver.resolve`` for more information on the
+    parameters.
+    """
+
+    return await get_default_resolver().resolve(qname, rdtype, rdclass, tcp,
+                                                source, raise_on_no_answer,
+                                                source_port, search, backend)
+
+
+async def resolve_address(ipaddr, *args, **kwargs):
+    """Use a resolver to run a reverse query for PTR records.
+
+    See ``dns.asyncresolver.Resolver.resolve_address`` for more
+    information on the parameters.
+    """
+
+    return await get_default_resolver().resolve_address(ipaddr, *args, **kwargs)
+
+
+async def zone_for_name(name, rdclass=dns.rdataclass.IN, tcp=False,
+                        resolver=None, backend=None):
+    """Find the name of the zone which contains the specified name.
+
+    *name*, an absolute ``dns.name.Name`` or ``str``, the query name.
+
+    *rdclass*, an ``int``, the query class.
+
+    *tcp*, a ``bool``.  If ``True``, use TCP to make the query.
+
+    *resolver*, a ``dns.asyncresolver.Resolver`` or ``None``, the
+    resolver to use.  If ``None``, the default resolver is used.
+
+    *backend*, a ``dns.asyncbackend.Backend``, or ``None``.  If ``None``,
+    the default, then dnspython will use the default backend.
+
+    Raises ``dns.resolver.NoRootSOA`` if there is no SOA RR at the DNS
+    root.  (This is only likely to happen if you're using non-default
+    root servers in your network and they are misconfigured.)
+
+    Returns a ``dns.name.Name``.
+    """
+
+    if isinstance(name, str):
+        name = dns.name.from_text(name, dns.name.root)
+    if resolver is None:
+        resolver = get_default_resolver()
+    if not name.is_absolute():
+        raise NotAbsolute(name)
+    while True:
+        try:
+            answer = await resolver.resolve(name, dns.rdatatype.SOA, rdclass,
+                                            tcp, backend=backend)
+            if answer.rrset.name == name:
+                return name
+            # otherwise we were CNAMEd or DNAMEd and need to look higher
+        except (NXDOMAIN, NoAnswer):
+            pass
+        try:
+            name = name.parent()
+        except dns.name.NoParent:  # pragma: no cover
+            raise NoRootSOA

lib/dns/dnssec.py

@@ -1,4 +1,6 @@
-# Copyright (C) 2003-2007, 2009, 2011 Nominum, Inc.
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
+# Copyright (C) 2003-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,
@@ -15,30 +17,30 @@
 
 """Common DNSSEC-related functions and constants."""
 
-from io import BytesIO
+import hashlib
 import struct
 import time
+import base64
 
+import dns.enum
 import dns.exception
-import dns.hash
 import dns.name
 import dns.node
 import dns.rdataset
 import dns.rdata
 import dns.rdatatype
 import dns.rdataclass
-from ._compat import string_types
 
 
 class UnsupportedAlgorithm(dns.exception.DNSException):
-
     """The DNSSEC algorithm is not supported."""
 
 
 class ValidationFailure(dns.exception.DNSException):
-
     """The DNSSEC signature is invalid."""
 
+
+class Algorithm(dns.enum.IntEnum):
     RSAMD5 = 1
     DH = 2
     DSA = 3
@@ -48,66 +50,55 @@ DSANSEC3SHA1 = 6
     RSASHA1NSEC3SHA1 = 7
     RSASHA256 = 8
     RSASHA512 = 10
+    ECCGOST = 12
     ECDSAP256SHA256 = 13
     ECDSAP384SHA384 = 14
+    ED25519 = 15
+    ED448 = 16
     INDIRECT = 252
     PRIVATEDNS = 253
     PRIVATEOID = 254
 
-_algorithm_by_text = {
-    'RSAMD5': RSAMD5,
-    'DH': DH,
-    'DSA': DSA,
-    'ECC': ECC,
-    'RSASHA1': RSASHA1,
-    'DSANSEC3SHA1': DSANSEC3SHA1,
-    'RSASHA1NSEC3SHA1': RSASHA1NSEC3SHA1,
-    'RSASHA256': RSASHA256,
-    'RSASHA512': RSASHA512,
-    'INDIRECT': INDIRECT,
-    'ECDSAP256SHA256': ECDSAP256SHA256,
-    'ECDSAP384SHA384': ECDSAP384SHA384,
-    'PRIVATEDNS': PRIVATEDNS,
-    'PRIVATEOID': PRIVATEOID,
-}
+    @classmethod
+    def _maximum(cls):
+        return 255
 
-# We construct the inverse mapping programmatically to ensure that we
-# cannot make any mistakes (e.g. omissions, cut-and-paste errors) that
-# would cause the mapping not to be true inverse.
 
-_algorithm_by_value = dict((y, x) for x, y in _algorithm_by_text.items())
+globals().update(Algorithm.__members__)
 
 
 def algorithm_from_text(text):
-    """Convert text into a DNSSEC algorithm value
-    @rtype: int"""
+    """Convert text into a DNSSEC algorithm value.
 
-    value = _algorithm_by_text.get(text.upper())
-    if value is None:
-        value = int(text)
-    return value
+    *text*, a ``str``, the text to convert to into an algorithm value.
+
+    Returns an ``int``.
+    """
+
+    return Algorithm.from_text(text)
 
 
 def algorithm_to_text(value):
     """Convert a DNSSEC algorithm value to text
-    @rtype: string"""
 
-    text = _algorithm_by_value.get(value)
-    if text is None:
-        text = str(value)
-    return text
+    *value*, an ``int`` a DNSSEC algorithm.
+
+    Returns a ``str``, the name of a DNSSEC algorithm.
+    """
+
+    return Algorithm.to_text(value)
 
 
-def _to_rdata(record, origin):
-    s = BytesIO()
-    record.to_wire(s, origin=origin)
-    return s.getvalue()
+def key_id(key):
+    """Return the key id (a 16-bit number) for the specified key.
 
+    *key*, a ``dns.rdtypes.ANY.DNSKEY.DNSKEY``
 
-def key_id(key, origin=None):
-    rdata = _to_rdata(key, origin)
-    rdata = bytearray(rdata)
-    if key.algorithm == RSAMD5:
+    Returns an ``int`` between 0 and 65535
+    """
+
+    rdata = key.to_wire()
+    if key.algorithm == Algorithm.RSAMD5:
         return (rdata[-3] << 8) + rdata[-2]
     else:
         total = 0
@@ -119,24 +110,60 @@ def key_id(key, origin=None):
         total += ((total >> 16) & 0xffff)
         return total & 0xffff
 
+class DSDigest(dns.enum.IntEnum):
+    """DNSSEC Delgation Signer Digest Algorithm"""
+
+    SHA1 = 1
+    SHA256 = 2
+    SHA384 = 4
+
+    @classmethod
+    def _maximum(cls):
+        return 255
+
 
 def make_ds(name, key, algorithm, origin=None):
-    if algorithm.upper() == 'SHA1':
-        dsalg = 1
-        hash = dns.hash.hashes['SHA1']()
-    elif algorithm.upper() == 'SHA256':
-        dsalg = 2
-        hash = dns.hash.hashes['SHA256']()
+    """Create a DS record for a DNSSEC key.
+
+    *name*, a ``dns.name.Name`` or ``str``, the owner name of the DS record.
+
+    *key*, a ``dns.rdtypes.ANY.DNSKEY.DNSKEY``, the key the DS is about.
+
+    *algorithm*, a ``str`` or ``int`` specifying the hash algorithm.
+    The currently supported hashes are "SHA1", "SHA256", and "SHA384". Case
+    does not matter for these strings.
+
+    *origin*, a ``dns.name.Name`` or ``None``.  If `key` is a relative name,
+    then it will be made absolute using the specified origin.
+
+    Raises ``UnsupportedAlgorithm`` if the algorithm is unknown.
+
+    Returns a ``dns.rdtypes.ANY.DS.DS``
+    """
+
+    try:
+        if isinstance(algorithm, str):
+            algorithm = DSDigest[algorithm.upper()]
+    except Exception:
+        raise UnsupportedAlgorithm('unsupported algorithm "%s"' % algorithm)
+
+    if algorithm == DSDigest.SHA1:
+        dshash = hashlib.sha1()
+    elif algorithm == DSDigest.SHA256:
+        dshash = hashlib.sha256()
+    elif algorithm == DSDigest.SHA384:
+        dshash = hashlib.sha384()
     else:
         raise UnsupportedAlgorithm('unsupported algorithm "%s"' % algorithm)
 
-    if isinstance(name, string_types):
+    if isinstance(name, str):
         name = dns.name.from_text(name, origin)
-    hash.update(name.canonicalize().to_wire())
-    hash.update(_to_rdata(key, origin))
-    digest = hash.digest()
+    dshash.update(name.canonicalize().to_wire())
+    dshash.update(key.to_wire(origin=origin))
+    digest = dshash.digest()
 
-    dsrdata = struct.pack("!HBB", key_id(key), key.algorithm, dsalg) + digest
+    dsrdata = struct.pack("!HBB", key_id(key), key.algorithm, algorithm) + \
+        digest
     return dns.rdata.from_wire(dns.rdataclass.IN, dns.rdatatype.DS, dsrdata, 0,
                                len(dsrdata))
 
@@ -162,101 +189,109 @@ def _find_candidate_keys(keys, rrsig):
 
 
 def _is_rsa(algorithm):
-    return algorithm in (RSAMD5, RSASHA1,
-                         RSASHA1NSEC3SHA1, RSASHA256,
-                         RSASHA512)
+    return algorithm in (Algorithm.RSAMD5, Algorithm.RSASHA1,
+                         Algorithm.RSASHA1NSEC3SHA1, Algorithm.RSASHA256,
+                         Algorithm.RSASHA512)
 
 
 def _is_dsa(algorithm):
-    return algorithm in (DSA, DSANSEC3SHA1)
+    return algorithm in (Algorithm.DSA, Algorithm.DSANSEC3SHA1)
 
 
 def _is_ecdsa(algorithm):
-    return _have_ecdsa and (algorithm in (ECDSAP256SHA256, ECDSAP384SHA384))
+    return algorithm in (Algorithm.ECDSAP256SHA256, Algorithm.ECDSAP384SHA384)
+
+
+def _is_eddsa(algorithm):
+    return algorithm in (Algorithm.ED25519, Algorithm.ED448)
+
+
+def _is_gost(algorithm):
+    return algorithm == Algorithm.ECCGOST
 
 
 def _is_md5(algorithm):
-    return algorithm == RSAMD5
+    return algorithm == Algorithm.RSAMD5
 
 
 def _is_sha1(algorithm):
-    return algorithm in (DSA, RSASHA1,
-                         DSANSEC3SHA1, RSASHA1NSEC3SHA1)
+    return algorithm in (Algorithm.DSA, Algorithm.RSASHA1,
+                         Algorithm.DSANSEC3SHA1, Algorithm.RSASHA1NSEC3SHA1)
 
 
 def _is_sha256(algorithm):
-    return algorithm in (RSASHA256, ECDSAP256SHA256)
+    return algorithm in (Algorithm.RSASHA256, Algorithm.ECDSAP256SHA256)
 
 
 def _is_sha384(algorithm):
-    return algorithm == ECDSAP384SHA384
+    return algorithm == Algorithm.ECDSAP384SHA384
 
 
 def _is_sha512(algorithm):
-    return algorithm == RSASHA512
+    return algorithm == Algorithm.RSASHA512
 
 
 def _make_hash(algorithm):
     if _is_md5(algorithm):
-        return dns.hash.hashes['MD5']()
+        return hashes.MD5()
     if _is_sha1(algorithm):
-        return dns.hash.hashes['SHA1']()
+        return hashes.SHA1()
     if _is_sha256(algorithm):
-        return dns.hash.hashes['SHA256']()
+        return hashes.SHA256()
     if _is_sha384(algorithm):
-        return dns.hash.hashes['SHA384']()
+        return hashes.SHA384()
     if _is_sha512(algorithm):
-        return dns.hash.hashes['SHA512']()
+        return hashes.SHA512()
+    if algorithm == Algorithm.ED25519:
+        return hashes.SHA512()
+    if algorithm == Algorithm.ED448:
+        return hashes.SHAKE256(114)
+
     raise ValidationFailure('unknown hash for algorithm %u' % algorithm)
 
 
-def _make_algorithm_id(algorithm):
-    if _is_md5(algorithm):
-        oid = [0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x02, 0x05]
-    elif _is_sha1(algorithm):
-        oid = [0x2b, 0x0e, 0x03, 0x02, 0x1a]
-    elif _is_sha256(algorithm):
-        oid = [0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01]
-    elif _is_sha512(algorithm):
-        oid = [0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x03]
-    else:
-        raise ValidationFailure('unknown algorithm %u' % algorithm)
-    olen = len(oid)
-    dlen = _make_hash(algorithm).digest_size
-    idbytes = [0x30] + [8 + olen + dlen] + \
-              [0x30, olen + 4] + [0x06, olen] + oid + \
-              [0x05, 0x00] + [0x04, dlen]
-    return struct.pack('!%dB' % len(idbytes), *idbytes)
+def _bytes_to_long(b):
+    return int.from_bytes(b, 'big')
 
 
 def _validate_rrsig(rrset, rrsig, keys, origin=None, now=None):
-    """Validate an RRset against a single signature rdata
+    """Validate an RRset against a single signature rdata, throwing an
+    exception if validation is not successful.
 
-    The owner name of the rrsig is assumed to be the same as the owner name
-    of the rrset.
+    *rrset*, the RRset to validate.  This can be a
+    ``dns.rrset.RRset`` or a (``dns.name.Name``, ``dns.rdataset.Rdataset``)
+    tuple.
 
-    @param rrset: The RRset to validate
-    @type rrset: dns.rrset.RRset or (dns.name.Name, dns.rdataset.Rdataset)
-    tuple
-    @param rrsig: The signature rdata
-    @type rrsig: dns.rrset.Rdata
-    @param keys: The key dictionary.
-    @type keys: a dictionary keyed by dns.name.Name with node or rdataset
-    values
-    @param origin: The origin to use for relative names
-    @type origin: dns.name.Name or None
-    @param now: The time to use when validating the signatures.  The default
-    is the current time.
-    @type now: int
+    *rrsig*, a ``dns.rdata.Rdata``, the signature to validate.
+
+    *keys*, the key dictionary, used to find the DNSKEY associated
+    with a given name.  The dictionary is keyed by a
+    ``dns.name.Name``, and has ``dns.node.Node`` or
+    ``dns.rdataset.Rdataset`` values.
+
+    *origin*, a ``dns.name.Name`` or ``None``, the origin to use for relative
+    names.
+
+    *now*, an ``int`` or ``None``, the time, in seconds since the epoch, to
+    use as the current time when validating.  If ``None``, the actual current
+    time is used.
+
+    Raises ``ValidationFailure`` if the signature is expired, not yet valid,
+    the public key is invalid, the algorithm is unknown, the verification
+    fails, etc.
+
+    Raises ``UnsupportedAlgorithm`` if the algorithm is recognized by
+    dnspython but not implemented.
     """
 
-    if isinstance(origin, string_types):
+    if isinstance(origin, str):
         origin = dns.name.from_text(origin, dns.name.root)
 
-    for candidate_key in _find_candidate_keys(keys, rrsig):
-        if not candidate_key:
+    candidate_keys = _find_candidate_keys(keys, rrsig)
+    if candidate_keys is None:
         raise ValidationFailure('unknown key')
 
+    for candidate_key in candidate_keys:
         # For convenience, allow the rrset to be specified as a (name,
         # rdataset) tuple as well as a proper rrset
         if isinstance(rrset, tuple):
@@ -273,8 +308,6 @@ def _validate_rrsig(rrset, rrsig, keys, origin=None, now=None):
         if rrsig.inception > now:
             raise ValidationFailure('not yet valid')
 
-        hash = _make_hash(rrsig.algorithm)
-
         if _is_rsa(rrsig.algorithm):
             keyptr = candidate_key.key
             (bytes_,) = struct.unpack('!B', keyptr[0:1])
@@ -284,11 +317,13 @@ def _validate_rrsig(rrset, rrsig, keys, origin=None, now=None):
                 keyptr = keyptr[2:]
             rsa_e = keyptr[0:bytes_]
             rsa_n = keyptr[bytes_:]
-            keylen = len(rsa_n) * 8
-            pubkey = Crypto.PublicKey.RSA.construct(
-                (Crypto.Util.number.bytes_to_long(rsa_n),
-                 Crypto.Util.number.bytes_to_long(rsa_e)))
-            sig = (Crypto.Util.number.bytes_to_long(rrsig.signature),)
+            try:
+                public_key = rsa.RSAPublicNumbers(
+                    _bytes_to_long(rsa_e),
+                    _bytes_to_long(rsa_n)).public_key(default_backend())
+            except ValueError:
+                raise ValidationFailure('invalid public key')
+            sig = rrsig.signature
         elif _is_dsa(rrsig.algorithm):
             keyptr = candidate_key.key
             (t,) = struct.unpack('!B', keyptr[0:1])
@@ -301,41 +336,62 @@ def _validate_rrsig(rrset, rrsig, keys, origin=None, now=None):
             dsa_g = keyptr[0:octets]
             keyptr = keyptr[octets:]
             dsa_y = keyptr[0:octets]
-            pubkey = Crypto.PublicKey.DSA.construct(
-                (Crypto.Util.number.bytes_to_long(dsa_y),
-                 Crypto.Util.number.bytes_to_long(dsa_g),
-                 Crypto.Util.number.bytes_to_long(dsa_p),
-                 Crypto.Util.number.bytes_to_long(dsa_q)))
-            (dsa_r, dsa_s) = struct.unpack('!20s20s', rrsig.signature[1:])
-            sig = (Crypto.Util.number.bytes_to_long(dsa_r),
-                   Crypto.Util.number.bytes_to_long(dsa_s))
+            try:
+                public_key = dsa.DSAPublicNumbers(
+                    _bytes_to_long(dsa_y),
+                    dsa.DSAParameterNumbers(
+                        _bytes_to_long(dsa_p),
+                        _bytes_to_long(dsa_q),
+                        _bytes_to_long(dsa_g))).public_key(default_backend())
+            except ValueError:
+                raise ValidationFailure('invalid public key')
+            sig_r = rrsig.signature[1:21]
+            sig_s = rrsig.signature[21:]
+            sig = utils.encode_dss_signature(_bytes_to_long(sig_r),
+                                             _bytes_to_long(sig_s))
         elif _is_ecdsa(rrsig.algorithm):
-            if rrsig.algorithm == ECDSAP256SHA256:
-                curve = ecdsa.curves.NIST256p
-                key_len = 32
-            elif rrsig.algorithm == ECDSAP384SHA384:
-                curve = ecdsa.curves.NIST384p
-                key_len = 48
-            else:
-                # shouldn't happen
-                raise ValidationFailure('unknown ECDSA curve')
             keyptr = candidate_key.key
-            x = Crypto.Util.number.bytes_to_long(keyptr[0:key_len])
-            y = Crypto.Util.number.bytes_to_long(keyptr[key_len:key_len * 2])
-            assert ecdsa.ecdsa.point_is_valid(curve.generator, x, y)
-            point = ecdsa.ellipticcurve.Point(curve.curve, x, y, curve.order)
-            verifying_key = ecdsa.keys.VerifyingKey.from_public_point(point,
-                                                                      curve)
-            pubkey = ECKeyWrapper(verifying_key, key_len)
-            r = rrsig.signature[:key_len]
-            s = rrsig.signature[key_len:]
-            sig = ecdsa.ecdsa.Signature(Crypto.Util.number.bytes_to_long(r),
-                                        Crypto.Util.number.bytes_to_long(s))
+            if rrsig.algorithm == Algorithm.ECDSAP256SHA256:
+                curve = ec.SECP256R1()
+                octets = 32
+            else:
+                curve = ec.SECP384R1()
+                octets = 48
+            ecdsa_x = keyptr[0:octets]
+            ecdsa_y = keyptr[octets:octets * 2]
+            try:
+                public_key = ec.EllipticCurvePublicNumbers(
+                    curve=curve,
+                    x=_bytes_to_long(ecdsa_x),
+                    y=_bytes_to_long(ecdsa_y)).public_key(default_backend())
+            except ValueError:
+                raise ValidationFailure('invalid public key')
+            sig_r = rrsig.signature[0:octets]
+            sig_s = rrsig.signature[octets:]
+            sig = utils.encode_dss_signature(_bytes_to_long(sig_r),
+                                             _bytes_to_long(sig_s))
+
+        elif _is_eddsa(rrsig.algorithm):
+            keyptr = candidate_key.key
+            if rrsig.algorithm == Algorithm.ED25519:
+                loader = ed25519.Ed25519PublicKey
+            else:
+                loader = ed448.Ed448PublicKey
+            try:
+                public_key = loader.from_public_bytes(keyptr)
+            except ValueError:
+                raise ValidationFailure('invalid public key')
+            sig = rrsig.signature
+        elif _is_gost(rrsig.algorithm):
+            raise UnsupportedAlgorithm(
+                'algorithm "%s" not supported by dnspython' %
+                algorithm_to_text(rrsig.algorithm))
         else:
             raise ValidationFailure('unknown algorithm %u' % rrsig.algorithm)
 
-        hash.update(_to_rdata(rrsig, origin)[:18])
-        hash.update(rrsig.signer.to_digestable(origin))
+        data = b''
+        data += rrsig.to_wire(origin=origin)[:18]
+        data += rrsig.signer.to_digestable(origin)
 
         if rrsig.labels < len(rrname) - 1:
             suffix = rrname.split(rrsig.labels + 1)[1]
@@ -345,54 +401,69 @@ def _validate_rrsig(rrset, rrsig, keys, origin=None, now=None):
                               rrsig.original_ttl)
         rrlist = sorted(rdataset)
         for rr in rrlist:
-            hash.update(rrnamebuf)
-            hash.update(rrfixed)
+            data += rrnamebuf
+            data += rrfixed
             rrdata = rr.to_digestable(origin)
             rrlen = struct.pack('!H', len(rrdata))
-            hash.update(rrlen)
-            hash.update(rrdata)
-
-        digest = hash.digest()
+            data += rrlen
+            data += rrdata
 
+        chosen_hash = _make_hash(rrsig.algorithm)
+        try:
             if _is_rsa(rrsig.algorithm):
-            # PKCS1 algorithm identifier goop
-            digest = _make_algorithm_id(rrsig.algorithm) + digest
-            padlen = keylen // 8 - len(digest) - 3
-            digest = struct.pack('!%dB' % (2 + padlen + 1),
-                                 *([0, 1] + [0xFF] * padlen + [0])) + digest
-        elif _is_dsa(rrsig.algorithm) or _is_ecdsa(rrsig.algorithm):
-            pass
+                public_key.verify(sig, data, padding.PKCS1v15(), chosen_hash)
+            elif _is_dsa(rrsig.algorithm):
+                public_key.verify(sig, data, chosen_hash)
+            elif _is_ecdsa(rrsig.algorithm):
+                public_key.verify(sig, data, ec.ECDSA(chosen_hash))
+            elif _is_eddsa(rrsig.algorithm):
+                public_key.verify(sig, data)
             else:
                 # Raise here for code clarity; this won't actually ever happen
                 # since if the algorithm is really unknown we'd already have
                 # raised an exception above
-            raise ValidationFailure('unknown algorithm %u' % rrsig.algorithm)
-
-        if pubkey.verify(digest, sig):
+                raise ValidationFailure('unknown algorithm %u' %
+                                        rrsig.algorithm)  # pragma: no cover
+            # If we got here, we successfully verified so we can return
+            # without error
             return
+        except InvalidSignature:
+            # this happens on an individual validation failure
+            continue
+    # nothing verified -- raise failure:
     raise ValidationFailure('verify failure')
 
 
 def _validate(rrset, rrsigset, keys, origin=None, now=None):
-    """Validate an RRset
+    """Validate an RRset against a signature RRset, throwing an exception
+    if none of the signatures validate.
 
-    @param rrset: The RRset to validate
-    @type rrset: dns.rrset.RRset or (dns.name.Name, dns.rdataset.Rdataset)
-    tuple
-    @param rrsigset: The signature RRset
-    @type rrsigset: dns.rrset.RRset or (dns.name.Name, dns.rdataset.Rdataset)
-    tuple
-    @param keys: The key dictionary.
-    @type keys: a dictionary keyed by dns.name.Name with node or rdataset
-    values
-    @param origin: The origin to use for relative names
-    @type origin: dns.name.Name or None
-    @param now: The time to use when validating the signatures.  The default
-    is the current time.
-    @type now: int
+    *rrset*, the RRset to validate.  This can be a
+    ``dns.rrset.RRset`` or a (``dns.name.Name``, ``dns.rdataset.Rdataset``)
+    tuple.
+
+    *rrsigset*, the signature RRset.  This can be a
+    ``dns.rrset.RRset`` or a (``dns.name.Name``, ``dns.rdataset.Rdataset``)
+    tuple.
+
+    *keys*, the key dictionary, used to find the DNSKEY associated
+    with a given name.  The dictionary is keyed by a
+    ``dns.name.Name``, and has ``dns.node.Node`` or
+    ``dns.rdataset.Rdataset`` values.
+
+    *origin*, a ``dns.name.Name``, the origin to use for relative names;
+    defaults to None.
+
+    *now*, an ``int`` or ``None``, the time, in seconds since the epoch, to
+    use as the current time when validating.  If ``None``, the actual current
+    time is used.
+
+    Raises ``ValidationFailure`` if the signature is expired, not yet valid,
+    the public key is invalid, the algorithm is unknown, the verification
+    fails, etc.
     """
 
-    if isinstance(origin, string_types):
+    if isinstance(origin, str):
         origin = dns.name.from_text(origin, dns.name.root)
 
     if isinstance(rrset, tuple):
@@ -408,7 +479,7 @@ def _validate(rrset, rrsigset, keys, origin=None, now=None):
         rrsigrdataset = rrsigset
 
     rrname = rrname.choose_relativity(origin)
-    rrsigname = rrname.choose_relativity(origin)
+    rrsigname = rrsigname.choose_relativity(origin)
     if rrname != rrsigname:
         raise ValidationFailure("owner names do not match")
 
@@ -416,42 +487,95 @@ def _validate(rrset, rrsigset, keys, origin=None, now=None):
         try:
             _validate_rrsig(rrset, rrsig, keys, origin, now)
             return
-        except ValidationFailure:
+        except (ValidationFailure, UnsupportedAlgorithm):
             pass
     raise ValidationFailure("no RRSIGs validated")
 
 
-def _need_pycrypto(*args, **kwargs):
-    raise NotImplementedError("DNSSEC validation requires pycrypto")
+class NSEC3Hash(dns.enum.IntEnum):
+    """NSEC3 hash algorithm"""
+
+    SHA1 = 1
+
+    @classmethod
+    def _maximum(cls):
+        return 255
+
+def nsec3_hash(domain, salt, iterations, algorithm):
+    """
+    Calculate the NSEC3 hash, according to
+    https://tools.ietf.org/html/rfc5155#section-5
+
+    *domain*, a ``dns.name.Name`` or ``str``, the name to hash.
+
+    *salt*, a ``str``, ``bytes``, or ``None``, the hash salt.  If a
+    string, it is decoded as a hex string.
+
+    *iterations*, an ``int``, the number of iterations.
+
+    *algorithm*, a ``str`` or ``int``, the hash algorithm.
+    The only defined algorithm is SHA1.
+
+    Returns a ``str``, the encoded NSEC3 hash.
+    """
+
+    b32_conversion = str.maketrans(
+        "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567", "0123456789ABCDEFGHIJKLMNOPQRSTUV"
+    )
 
     try:
-    import Crypto.PublicKey.RSA
-    import Crypto.PublicKey.DSA
-    import Crypto.Util.number
-    validate = _validate
-    validate_rrsig = _validate_rrsig
-    _have_pycrypto = True
-except ImportError:
-    validate = _need_pycrypto
-    validate_rrsig = _need_pycrypto
-    _have_pycrypto = False
+        if isinstance(algorithm, str):
+            algorithm = NSEC3Hash[algorithm.upper()]
+    except Exception:
+        raise ValueError("Wrong hash algorithm (only SHA1 is supported)")
+
+    if algorithm != NSEC3Hash.SHA1:
+        raise ValueError("Wrong hash algorithm (only SHA1 is supported)")
+
+    salt_encoded = salt
+    if salt is None:
+        salt_encoded = b''
+    elif isinstance(salt, str):
+        if len(salt) % 2 == 0:
+            salt_encoded = bytes.fromhex(salt)
+        else:
+            raise ValueError("Invalid salt length")
+
+    if not isinstance(domain, dns.name.Name):
+        domain = dns.name.from_text(domain)
+    domain_encoded = domain.canonicalize().to_wire()
+
+    digest = hashlib.sha1(domain_encoded + salt_encoded).digest()
+    for i in range(iterations):
+        digest = hashlib.sha1(digest + salt_encoded).digest()
+
+    output = base64.b32encode(digest).decode("utf-8")
+    output = output.translate(b32_conversion)
+
+    return output
+
+
+def _need_pyca(*args, **kwargs):
+    raise ImportError("DNSSEC validation requires " +
+                      "python cryptography")  # pragma: no cover
+
 
 try:
-    import ecdsa
-    import ecdsa.ecdsa
-    import ecdsa.ellipticcurve
-    import ecdsa.keys
-    _have_ecdsa = True
-
-    class ECKeyWrapper(object):
-
-        def __init__(self, key, key_len):
-            self.key = key
-            self.key_len = key_len
-
-        def verify(self, digest, sig):
-            diglong = Crypto.Util.number.bytes_to_long(digest)
-            return self.key.pubkey.verifies(diglong, sig)
-
-except ImportError:
-    _have_ecdsa = False
+    from cryptography.exceptions import InvalidSignature
+    from cryptography.hazmat.backends import default_backend
+    from cryptography.hazmat.primitives import hashes
+    from cryptography.hazmat.primitives.asymmetric import padding
+    from cryptography.hazmat.primitives.asymmetric import utils
+    from cryptography.hazmat.primitives.asymmetric import dsa
+    from cryptography.hazmat.primitives.asymmetric import ec
+    from cryptography.hazmat.primitives.asymmetric import ed25519
+    from cryptography.hazmat.primitives.asymmetric import ed448
+    from cryptography.hazmat.primitives.asymmetric import rsa
+except ImportError:  # pragma: no cover
+    validate = _need_pyca
+    validate_rrsig = _need_pyca
+    _have_pyca = False
+else:
+    validate = _validate                # type: ignore
+    validate_rrsig = _validate_rrsig    # type: ignore
+    _have_pyca = True

lib/dns/e164.py

@@ -1,4 +1,6 @@
-# Copyright (C) 2006, 2007, 2009, 2011 Nominum, Inc.
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
+# Copyright (C) 2006-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,
@@ -13,31 +15,31 @@
 # ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
 # OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
-"""DNS E.164 helpers
-
-@var public_enum_domain: The DNS public ENUM domain, e164.arpa.
-@type public_enum_domain: dns.name.Name object
-"""
-
+"""DNS E.164 helpers."""
 
 import dns.exception
 import dns.name
 import dns.resolver
-from ._compat import string_types
 
+#: The public E.164 domain.
 public_enum_domain = dns.name.from_text('e164.arpa.')
 
 
 def from_e164(text, origin=public_enum_domain):
     """Convert an E.164 number in textual form into a Name object whose
     value is the ENUM domain name for that number.
-    @param text: an E.164 number in textual form.
-    @type text: str
-    @param origin: The domain in which the number should be constructed.
-    The default is e164.arpa.
-    @type origin: dns.name.Name object or None
-    @rtype: dns.name.Name object
+
+    Non-digits in the text are ignored, i.e. "16505551212",
+    "+1.650.555.1212" and "1 (650) 555-1212" are all the same.
+
+    *text*, a ``str``, is an E.164 number in textual form.
+
+    *origin*, a ``dns.name.Name``, the domain in which the number
+    should be constructed.  The default is ``e164.arpa.``.
+
+    Returns a ``dns.name.Name``.
     """
+
     parts = [d for d in text if d.isdigit()]
     parts.reverse()
     return dns.name.from_text('.'.join(parts), origin=origin)
@@ -45,40 +47,58 @@ def from_e164(text, origin=public_enum_domain):
 
 def to_e164(name, origin=public_enum_domain, want_plus_prefix=True):
     """Convert an ENUM domain name into an E.164 number.
-    @param name: the ENUM domain name.
-    @type name: dns.name.Name object.
-    @param origin: A domain containing the ENUM domain name.  The
-    name is relativized to this domain before being converted to text.
-    @type origin: dns.name.Name object or None
-    @param want_plus_prefix: if True, add a '+' to the beginning of the
-    returned number.
-    @rtype: str
+
+    Note that dnspython does not have any information about preferred
+    number formats within national numbering plans, so all numbers are
+    emitted as a simple string of digits, prefixed by a '+' (unless
+    *want_plus_prefix* is ``False``).
+
+    *name* is a ``dns.name.Name``, the ENUM domain name.
+
+    *origin* is a ``dns.name.Name``, a domain containing the ENUM
+    domain name.  The name is relativized to this domain before being
+    converted to text.  If ``None``, no relativization is done.
+
+    *want_plus_prefix* is a ``bool``.  If True, add a '+' to the beginning of
+    the returned number.
+
+    Returns a ``str``.
+
     """
     if origin is not None:
         name = name.relativize(origin)
-    dlabels = [d for d in name.labels if (d.isdigit() and len(d) == 1)]
+    dlabels = [d for d in name.labels if d.isdigit() and len(d) == 1]
     if len(dlabels) != len(name.labels):
         raise dns.exception.SyntaxError('non-digit labels in ENUM domain name')
     dlabels.reverse()
     text = b''.join(dlabels)
     if want_plus_prefix:
         text = b'+' + text
-    return text
+    return text.decode()
 
 
 def query(number, domains, resolver=None):
     """Look for NAPTR RRs for the specified number in the specified domains.
 
     e.g. lookup('16505551212', ['e164.dnspython.org.', 'e164.arpa.'])
+
+    *number*, a ``str`` is the number to look for.
+
+    *domains* is an iterable containing ``dns.name.Name`` values.
+
+    *resolver*, a ``dns.resolver.Resolver``, is the resolver to use.  If
+    ``None``, the default resolver is used.
     """
+
     if resolver is None:
         resolver = dns.resolver.get_default_resolver()
+    e_nx = dns.resolver.NXDOMAIN()
     for domain in domains:
-        if isinstance(domain, string_types):
+        if isinstance(domain, str):
             domain = dns.name.from_text(domain)
         qname = dns.e164.from_e164(number, domain)
         try:
-            return resolver.query(qname, 'NAPTR')
-        except dns.resolver.NXDOMAIN:
-            pass
-    raise dns.resolver.NXDOMAIN
+            return resolver.resolve(qname, 'NAPTR')
+        except dns.resolver.NXDOMAIN as e:
+            e_nx += e
+    raise e_nx

lib/dns/edns.py

@@ -1,4 +1,6 @@
-# Copyright (C) 2009, 2011 Nominum, Inc.
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
+# Copyright (C) 2009-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,
@@ -15,47 +17,85 @@
 
 """EDNS Options"""
 
+import math
+import socket
+import struct
+
+import dns.enum
+import dns.inet
+
+class OptionType(dns.enum.IntEnum):
+    #: NSID
     NSID = 3
+    #: DAU
+    DAU = 5
+    #: DHU
+    DHU = 6
+    #: N3U
+    N3U = 7
+    #: ECS (client-subnet)
+    ECS = 8
+    #: EXPIRE
+    EXPIRE = 9
+    #: COOKIE
+    COOKIE = 10
+    #: KEEPALIVE
+    KEEPALIVE = 11
+    #: PADDING
+    PADDING = 12
+    #: CHAIN
+    CHAIN = 13
 
+    @classmethod
+    def _maximum(cls):
+        return 65535
 
-class Option(object):
+globals().update(OptionType.__members__)
 
-    """Base class for all EDNS option types.
-    """
+class Option:
+
+    """Base class for all EDNS option types."""
 
     def __init__(self, otype):
         """Initialize an option.
-        @param otype: The rdata type
-        @type otype: int
+
+        *otype*, an ``int``, is the option type.
         """
         self.otype = otype
 
-    def to_wire(self, file):
+    def to_wire(self, file=None):
         """Convert an option to wire format.
+
+        Returns a ``bytes`` or ``None``.
+
         """
-        raise NotImplementedError
+        raise NotImplementedError  # pragma: no cover
 
     @classmethod
-    def from_wire(cls, otype, wire, current, olen):
-        """Build an EDNS option object from wire format
+    def from_wire_parser(cls, otype, parser):
+        """Build an EDNS option object from wire format.
 
-        @param otype: The option type
-        @type otype: int
-        @param wire: The wire-format message
-        @type wire: string
-        @param current: The offset in wire of the beginning of the rdata.
-        @type current: int
-        @param olen: The length of the wire-format option data
-        @type olen: int
-        @rtype: dns.edns.Option instance"""
-        raise NotImplementedError
+        *otype*, an ``int``, is the option type.
+
+        *parser*, a ``dns.wire.Parser``, the parser, which should be
+        restructed to the option length.
+
+        Returns a ``dns.edns.Option``.
+        """
+        raise NotImplementedError  # pragma: no cover
 
     def _cmp(self, other):
         """Compare an EDNS option with another option of the same type.
-        Return < 0 if self < other, 0 if self == other,
-        and > 0 if self > other.
+
+        Returns < 0 if < *other*, 0 if == *other*, and > 0 if > *other*.
         """
-        raise NotImplementedError
+        wire = self.to_wire()
+        owire = other.to_wire()
+        if wire == owire:
+            return 0
+        if wire > owire:
+            return 1
+        return -1
 
     def __eq__(self, other):
         if not isinstance(other, Option):
@@ -66,9 +106,9 @@ class Option(object):
 
     def __ne__(self, other):
         if not isinstance(other, Option):
-            return False
+            return True
         if self.otype != other.otype:
-            return False
+            return True
         return self._cmp(other) != 0
 
     def __lt__(self, other):
@@ -95,56 +135,210 @@ class Option(object):
             return NotImplemented
         return self._cmp(other) > 0
 
+    def __str__(self):
+        return self.to_text()
+
 
 class GenericOption(Option):
 
-    """Generate Rdata Class
+    """Generic Option Class
 
     This class is used for EDNS option types for which we have no better
     implementation.
     """
 
     def __init__(self, otype, data):
-        super(GenericOption, self).__init__(otype)
+        super().__init__(otype)
         self.data = data
 
-    def to_wire(self, file):
+    def to_wire(self, file=None):
+        if file:
             file.write(self.data)
+        else:
+            return self.data
+
+    def to_text(self):
+        return "Generic %d" % self.otype
 
     @classmethod
-    def from_wire(cls, otype, wire, current, olen):
-        return cls(otype, wire[current: current + olen])
+    def from_wire_parser(cls, otype, parser):
+        return cls(otype, parser.get_remaining())
+
+
+class ECSOption(Option):
+    """EDNS Client Subnet (ECS, RFC7871)"""
+
+    def __init__(self, address, srclen=None, scopelen=0):
+        """*address*, a ``str``, is the client address information.
+
+        *srclen*, an ``int``, the source prefix length, which is the
+        leftmost number of bits of the address to be used for the
+        lookup.  The default is 24 for IPv4 and 56 for IPv6.
+
+        *scopelen*, an ``int``, the scope prefix length.  This value
+        must be 0 in queries, and should be set in responses.
+        """
+
+        super().__init__(OptionType.ECS)
+        af = dns.inet.af_for_address(address)
+
+        if af == socket.AF_INET6:
+            self.family = 2
+            if srclen is None:
+                srclen = 56
+        elif af == socket.AF_INET:
+            self.family = 1
+            if srclen is None:
+                srclen = 24
+        else:
+            raise ValueError('Bad ip family')
+
+        self.address = address
+        self.srclen = srclen
+        self.scopelen = scopelen
+
+        addrdata = dns.inet.inet_pton(af, address)
+        nbytes = int(math.ceil(srclen / 8.0))
+
+        # Truncate to srclen and pad to the end of the last octet needed
+        # See RFC section 6
+        self.addrdata = addrdata[:nbytes]
+        nbits = srclen % 8
+        if nbits != 0:
+            last = struct.pack('B',
+                               ord(self.addrdata[-1:]) & (0xff << (8 - nbits)))
+            self.addrdata = self.addrdata[:-1] + last
+
+    def to_text(self):
+        return "ECS {}/{} scope/{}".format(self.address, self.srclen,
+                                           self.scopelen)
+
+    @staticmethod
+    def from_text(text):
+        """Convert a string into a `dns.edns.ECSOption`
+
+        *text*, a `str`, the text form of the option.
+
+        Returns a `dns.edns.ECSOption`.
+
+        Examples:
+
+        >>> import dns.edns
+        >>>
+        >>> # basic example
+        >>> dns.edns.ECSOption.from_text('1.2.3.4/24')
+        >>>
+        >>> # also understands scope
+        >>> dns.edns.ECSOption.from_text('1.2.3.4/24/32')
+        >>>
+        >>> # IPv6
+        >>> dns.edns.ECSOption.from_text('2001:4b98::1/64/64')
+        >>>
+        >>> # it understands results from `dns.edns.ECSOption.to_text()`
+        >>> dns.edns.ECSOption.from_text('ECS 1.2.3.4/24/32')
+        """
+        optional_prefix = 'ECS'
+        tokens = text.split()
+        ecs_text = None
+        if len(tokens) == 1:
+            ecs_text = tokens[0]
+        elif len(tokens) == 2:
+            if tokens[0] != optional_prefix:
+                raise ValueError('could not parse ECS from "{}"'.format(text))
+            ecs_text = tokens[1]
+        else:
+            raise ValueError('could not parse ECS from "{}"'.format(text))
+        n_slashes = ecs_text.count('/')
+        if n_slashes == 1:
+            address, srclen = ecs_text.split('/')
+            scope = 0
+        elif n_slashes == 2:
+            address, srclen, scope = ecs_text.split('/')
+        else:
+            raise ValueError('could not parse ECS from "{}"'.format(text))
+        try:
+            scope = int(scope)
+        except ValueError:
+            raise ValueError('invalid scope ' +
+                             '"{}": scope must be an integer'.format(scope))
+        try:
+            srclen = int(srclen)
+        except ValueError:
+            raise ValueError('invalid srclen ' +
+                             '"{}": srclen must be an integer'.format(srclen))
+        return ECSOption(address, srclen, scope)
+
+    def to_wire(self, file=None):
+        value = (struct.pack('!HBB', self.family, self.srclen, self.scopelen) +
+                 self.addrdata)
+        if file:
+            file.write(value)
+        else:
+            return value
+
+    @classmethod
+    def from_wire_parser(cls, otype, parser):
+        family, src, scope = parser.get_struct('!HBB')
+        addrlen = int(math.ceil(src / 8.0))
+        prefix = parser.get_bytes(addrlen)
+        if family == 1:
+            pad = 4 - addrlen
+            addr = dns.ipv4.inet_ntoa(prefix + b'\x00' * pad)
+        elif family == 2:
+            pad = 16 - addrlen
+            addr = dns.ipv6.inet_ntoa(prefix + b'\x00' * pad)
+        else:
+            raise ValueError('unsupported family')
+
+        return cls(addr, src, scope)
 
-    def _cmp(self, other):
-        if self.data == other.data:
-            return 0
-        if self.data > other.data:
-            return 1
-        return -1
 
 _type_to_class = {
+    OptionType.ECS: ECSOption
 }
 
-
 def get_option_class(otype):
+    """Return the class for the specified option type.
+
+    The GenericOption class is used if a more specific class is not
+    known.
+    """
+
     cls = _type_to_class.get(otype)
     if cls is None:
         cls = GenericOption
     return cls
 
 
-def option_from_wire(otype, wire, current, olen):
-    """Build an EDNS option object from wire format
+def option_from_wire_parser(otype, parser):
+    """Build an EDNS option object from wire format.
 
-    @param otype: The option type
-    @type otype: int
-    @param wire: The wire-format message
-    @type wire: string
-    @param current: The offset in wire of the beginning of the rdata.
-    @type current: int
-    @param olen: The length of the wire-format option data
-    @type olen: int
-    @rtype: dns.edns.Option instance"""
+    *otype*, an ``int``, is the option type.
 
+    *parser*, a ``dns.wire.Parser``, the parser, which should be
+    restricted to the option length.
+
+    Returns an instance of a subclass of ``dns.edns.Option``.
+    """
     cls = get_option_class(otype)
-    return cls.from_wire(otype, wire, current, olen)
+    otype = OptionType.make(otype)
+    return cls.from_wire_parser(otype, parser)
+
+
+def option_from_wire(otype, wire, current, olen):
+    """Build an EDNS option object from wire format.
+
+    *otype*, an ``int``, is the option type.
+
+    *wire*, a ``bytes``, is the wire-format message.
+
+    *current*, an ``int``, is the offset in *wire* of the beginning
+    of the rdata.
+
+    *olen*, an ``int``, is the length of the wire-format option data
+
+    Returns an instance of a subclass of ``dns.edns.Option``.
+    """
+    parser = dns.wire.Parser(wire, current)
+    with parser.restrict_to(olen):
+        return option_from_wire_parser(otype, parser)

lib/dns/entropy.py

@@ -1,4 +1,6 @@
-# Copyright (C) 2009, 2011 Nominum, Inc.
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
+# Copyright (C) 2009-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,
@@ -14,85 +16,76 @@
 # OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
 import os
+import hashlib
+import random
 import time
-from ._compat import long, binary_type
 try:
     import threading as _threading
-except ImportError:
-    import dummy_threading as _threading
+except ImportError:  # pragma: no cover
+    import dummy_threading as _threading    # type: ignore
 
 
-class EntropyPool(object):
+class EntropyPool:
+
+    # This is an entropy pool for Python implementations that do not
+    # have a working SystemRandom.  I'm not sure there are any, but
+    # leaving this code doesn't hurt anything as the library code
+    # is used if present.
 
     def __init__(self, seed=None):
         self.pool_index = 0
         self.digest = None
         self.next_byte = 0
         self.lock = _threading.Lock()
-        try:
-            import hashlib
         self.hash = hashlib.sha1()
         self.hash_len = 20
-        except:
-            try:
-                import sha
-                self.hash = sha.new()
-                self.hash_len = 20
-            except:
-                import md5
-                self.hash = md5.new()
-                self.hash_len = 16
         self.pool = bytearray(b'\0' * self.hash_len)
         if seed is not None:
-            self.stir(bytearray(seed))
+            self._stir(bytearray(seed))
             self.seeded = True
+            self.seed_pid = os.getpid()
         else:
             self.seeded = False
+            self.seed_pid = 0
 
-    def stir(self, entropy, already_locked=False):
-        if not already_locked:
-            self.lock.acquire()
-        try:
+    def _stir(self, entropy):
         for c in entropy:
             if self.pool_index == self.hash_len:
                 self.pool_index = 0
             b = c & 0xff
             self.pool[self.pool_index] ^= b
             self.pool_index += 1
-        finally:
-            if not already_locked:
-                self.lock.release()
+
+    def stir(self, entropy):
+        with self.lock:
+            self._stir(entropy)
 
     def _maybe_seed(self):
-        if not self.seeded:
+        if not self.seeded or self.seed_pid != os.getpid():
             try:
                 seed = os.urandom(16)
-            except:
-                try:
-                    r = open('/dev/urandom', 'rb', 0)
+            except Exception:  # pragma: no cover
                 try:
+                    with open('/dev/urandom', 'rb', 0) as r:
                         seed = r.read(16)
-                    finally:
-                        r.close()
-                except:
+                except Exception:
                     seed = str(time.time())
             self.seeded = True
+            self.seed_pid = os.getpid()
+            self.digest = None
             seed = bytearray(seed)
-            self.stir(seed, True)
+            self._stir(seed)
 
     def random_8(self):
-        self.lock.acquire()
-        try:
+        with self.lock:
             self._maybe_seed()
             if self.digest is None or self.next_byte == self.hash_len:
-                self.hash.update(binary_type(self.pool))
+                self.hash.update(bytes(self.pool))
                 self.digest = bytearray(self.hash.digest())
-                self.stir(self.digest, True)
+                self._stir(self.digest)
                 self.next_byte = 0
             value = self.digest[self.next_byte]
             self.next_byte += 1
-        finally:
-            self.lock.release()
         return value
 
     def random_16(self):
@@ -103,25 +96,34 @@ class EntropyPool(object):
 
     def random_between(self, first, last):
         size = last - first + 1
-        if size > long(4294967296):
+        if size > 4294967296:
             raise ValueError('too big')
         if size > 65536:
             rand = self.random_32
-            max = long(4294967295)
+            max = 4294967295
         elif size > 256:
             rand = self.random_16
             max = 65535
         else:
             rand = self.random_8
             max = 255
-        return (first + size * rand() // (max + 1))
+        return first + size * rand() // (max + 1)
 
 pool = EntropyPool()
 
+try:
+    system_random = random.SystemRandom()
+except Exception:  # pragma: no cover
+    system_random = None
 
 def random_16():
+    if system_random is not None:
+        return system_random.randrange(0, 65536)
+    else:
         return pool.random_16()
 
-
 def between(first, last):
+    if system_random is not None:
+        return system_random.randrange(first, last + 1)
+    else:
         return pool.random_between(first, last)

lib/dns/enum.py

@@ -0,0 +1,90 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
+# Copyright (C) 2003-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.
+
+import enum
+
+class IntEnum(enum.IntEnum):
+    @classmethod
+    def _check_value(cls, value):
+        max = cls._maximum()
+        if value < 0 or value > max:
+            name = cls._short_name()
+            raise ValueError(f"{name} must be between >= 0 and <= {max}")
+
+    @classmethod
+    def from_text(cls, text):
+        text = text.upper()
+        try:
+            return cls[text]
+        except KeyError:
+            pass
+        prefix = cls._prefix()
+        if text.startswith(prefix) and text[len(prefix):].isdigit():
+            value = int(text[len(prefix):])
+            cls._check_value(value)
+            try:
+                return cls(value)
+            except ValueError:
+                return value
+        raise cls._unknown_exception_class()
+
+    @classmethod
+    def to_text(cls, value):
+        cls._check_value(value)
+        try:
+            return cls(value).name
+        except ValueError:
+            return f"{cls._prefix()}{value}"
+
+    @classmethod
+    def make(cls, value):
+        """Convert text or a value into an enumerated type, if possible.
+
+        *value*, the ``int`` or ``str`` to convert.
+
+        Raises a class-specific exception if a ``str`` is provided that
+        cannot be converted.
+
+        Raises ``ValueError`` if the value is out of range.
+
+        Returns an enumeration from the calling class corresponding to the
+        value, if one is defined, or an ``int`` otherwise.
+        """
+
+        if isinstance(value, str):
+            return cls.from_text(value)
+        cls._check_value(value)
+        try:
+            return cls(value)
+        except ValueError:
+            return value
+
+    @classmethod
+    def _maximum(cls):
+        raise NotImplementedError
+
+    @classmethod
+    def _short_name(cls):
+        return cls.__name__.lower()
+
+    @classmethod
+    def _prefix(cls):
+        return ''
+
+    @classmethod
+    def _unknown_exception_class(cls):
+        return ValueError

lib/dns/exception.py

@@ -1,4 +1,6 @@
-# Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
+# Copyright (C) 2003-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,
@@ -13,47 +15,53 @@
 # ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
 # OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
-"""Common DNS Exceptions."""
+"""Common DNS Exceptions.
 
+Dnspython modules may also define their own exceptions, which will
+always be subclasses of ``DNSException``.
+"""
 
 class DNSException(Exception):
-
     """Abstract base class shared by all dnspython exceptions.
 
     It supports two basic modes of operation:
 
-    a) Old/compatible mode is used if __init__ was called with
-       empty **kwargs.
-    In compatible mode all *args are passed to standard Python Exception class
-    as before and all *args are printed by standard __str__ implementation.
-    Class variable msg (or doc string if msg is None) is returned from str()
-    if *args is empty.
+    a) Old/compatible mode is used if ``__init__`` was called with
+    empty *kwargs*.  In compatible mode all *args* are passed
+    to the standard Python Exception class as before and all *args* are
+    printed by the standard ``__str__`` implementation.  Class variable
+    ``msg`` (or doc string if ``msg`` is ``None``) is returned from ``str()``
+    if *args* is empty.
 
-    b) New/parametrized mode is used if __init__ was called with
-       non-empty **kwargs.
-    In the new mode *args has to be empty and all kwargs has to exactly match
-    set in class variable self.supp_kwargs. All kwargs are stored inside
-    self.kwargs and used in new __str__ implementation to construct
-    formatted message based on self.fmt string.
+    b) New/parametrized mode is used if ``__init__`` was called with
+    non-empty *kwargs*.
+    In the new mode *args* must be empty and all kwargs must match
+    those set in class variable ``supp_kwargs``. All kwargs are stored inside
+    ``self.kwargs`` and used in a new ``__str__`` implementation to construct
+    a formatted message based on the ``fmt`` class variable, a ``string``.
 
-    In the simplest case it is enough to override supp_kwargs and fmt
-    class variables to get nice parametrized messages.
+    In the simplest case it is enough to override the ``supp_kwargs``
+    and ``fmt`` class variables to get nice parametrized messages.
     """
+
     msg = None  # non-parametrized message
     supp_kwargs = set()  # accepted parameters for _fmt_kwargs (sanity check)
     fmt = None  # message parametrized with results from _fmt_kwargs
 
     def __init__(self, *args, **kwargs):
         self._check_params(*args, **kwargs)
-        self._check_kwargs(**kwargs)
-        self.kwargs = kwargs
+        if kwargs:
+            self.kwargs = self._check_kwargs(**kwargs)
+            self.msg = str(self)
+        else:
+            self.kwargs = dict()  # defined but empty for old mode exceptions
         if self.msg is None:
             # doc string is better implicit message than empty string
             self.msg = self.__doc__
         if args:
-            super(DNSException, self).__init__(*args)
+            super().__init__(*args)
         else:
-            super(DNSException, self).__init__(self.msg)
+            super().__init__(self.msg)
 
     def _check_params(self, *args, **kwargs):
         """Old exceptions supported only args and not kwargs.
@@ -68,6 +76,7 @@ class DNSException(Exception):
             assert set(kwargs.keys()) == self.supp_kwargs, \
                 'following set of keyword args is required: %s' % (
                     self.supp_kwargs)
+        return kwargs
 
     def _fmt_kwargs(self, **kwargs):
         """Format kwargs before printing them.
@@ -94,31 +103,26 @@ class DNSException(Exception):
             return self.fmt.format(**fmtargs)
         else:
             # print *args directly in the same way as old DNSException
-            return super(DNSException, self).__str__()
+            return super().__str__()
 
 
 class FormError(DNSException):
-
     """DNS message is malformed."""
 
 
 class SyntaxError(DNSException):
-
     """Text input is malformed."""
 
 
 class UnexpectedEnd(SyntaxError):
-
     """Text input ended unexpectedly."""
 
 
 class TooBig(DNSException):
-
     """The DNS message is too big."""
 
 
 class Timeout(DNSException):
-
     """The DNS operation timed out."""
-    supp_kwargs = set(['timeout'])
+    supp_kwargs = {'timeout'}
     fmt = "The DNS operation timed out after {timeout} seconds"

lib/dns/flags.py

@@ -1,4 +1,6 @@
-# Copyright (C) 2001-2007, 2009-2011 Nominum, Inc.
+# 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,
@@ -15,98 +17,90 @@
 
 """DNS Message Flags."""
 
+import enum
+
 # Standard DNS flags
 
+class Flag(enum.IntFlag):
+    #: Query Response
     QR = 0x8000
+    #: Authoritative Answer
     AA = 0x0400
+    #: Truncated Response
     TC = 0x0200
+    #: Recursion Desired
     RD = 0x0100
+    #: Recursion Available
     RA = 0x0080
+    #: Authentic Data
     AD = 0x0020
+    #: Checking Disabled
     CD = 0x0010
 
+globals().update(Flag.__members__)
+
+
 # EDNS flags
 
+class EDNSFlag(enum.IntFlag):
+    #: DNSSEC answer OK
     DO = 0x8000
 
-_by_text = {
-    'QR': QR,
-    'AA': AA,
-    'TC': TC,
-    'RD': RD,
-    'RA': RA,
-    'AD': AD,
-    'CD': CD
-}
 
-_edns_by_text = {
-    'DO': DO
-}
+globals().update(EDNSFlag.__members__)
 
 
-# We construct the inverse mappings programmatically to ensure that we
-# cannot make any mistakes (e.g. omissions, cut-and-paste errors) that
-# would cause the mappings not to be true inverses.
-
-_by_value = dict((y, x) for x, y in _by_text.items())
-
-_edns_by_value = dict((y, x) for x, y in _edns_by_text.items())
-
-
-def _order_flags(table):
-    order = list(table.items())
-    order.sort()
-    order.reverse()
-    return order
-
-_flags_order = _order_flags(_by_value)
-
-_edns_flags_order = _order_flags(_edns_by_value)
-
-
-def _from_text(text, table):
+def _from_text(text, enum_class):
     flags = 0
     tokens = text.split()
     for t in tokens:
-        flags = flags | table[t.upper()]
+        flags |= enum_class[t.upper()]
     return flags
 
 
-def _to_text(flags, table, order):
+def _to_text(flags, enum_class):
     text_flags = []
-    for k, v in order:
-        if flags & k != 0:
-            text_flags.append(v)
+    for k, v in enum_class.__members__.items():
+        if flags & v != 0:
+            text_flags.append(k)
     return ' '.join(text_flags)
 
 
 def from_text(text):
     """Convert a space-separated list of flag text values into a flags
     value.
-    @rtype: int"""
 
-    return _from_text(text, _by_text)
+    Returns an ``int``
+    """
+
+    return _from_text(text, Flag)
 
 
 def to_text(flags):
     """Convert a flags value into a space-separated list of flag text
     values.
-    @rtype: string"""
 
-    return _to_text(flags, _by_value, _flags_order)
+    Returns a ``str``.
+    """
+
+    return _to_text(flags, Flag)
 
 
 def edns_from_text(text):
     """Convert a space-separated list of EDNS flag text values into a EDNS
     flags value.
-    @rtype: int"""
 
-    return _from_text(text, _edns_by_text)
+    Returns an ``int``
+    """
+
+    return _from_text(text, EDNSFlag)
 
 
 def edns_to_text(flags):
     """Convert an EDNS flags value into a space-separated list of EDNS flag
     text values.
-    @rtype: string"""
 
-    return _to_text(flags, _edns_by_value, _edns_flags_order)
+    Returns a ``str``.
+    """
+
+    return _to_text(flags, EDNSFlag)

lib/dns/grange.py

@@ -1,4 +1,6 @@
-# Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
+# Copyright (C) 2012-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,
@@ -17,23 +19,25 @@
 
 import dns
 
-
 def from_text(text):
-    """Convert the text form of a range in a GENERATE statement to an
+    """Convert the text form of a range in a ``$GENERATE`` statement to an
     integer.
 
-    @param text: the textual range
-    @type text: string
-    @return: The start, stop and step values.
-    @rtype: tuple
-    """
-    # TODO, figure out the bounds on start, stop and step.
+    *text*, a ``str``, the textual range in ``$GENERATE`` form.
 
+    Returns a tuple of three ``int`` values ``(start, stop, step)``.
+    """
+
+    # TODO, figure out the bounds on start, stop and step.
     step = 1
     cur = ''
     state = 0
     # state   0 1 2 3 4
     #         x - y / z
+
+    if text and text[0] == '-':
+        raise dns.exception.SyntaxError("Start cannot be a negative number")
+
     for c in text:
         if c == '-' and state == 0:
             start = int(cur)
@@ -49,7 +53,7 @@ def from_text(text):
             raise dns.exception.SyntaxError("Could not parse %s" % (c))
 
     if state in (1, 3):
-        raise dns.exception.SyntaxError
+        raise dns.exception.SyntaxError()
 
     if state == 2:
         stop = int(cur)

lib/dns/inet.py

@@ -1,4 +1,6 @@
-# Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
+# Copyright (C) 2003-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,
@@ -21,36 +23,30 @@ import dns.ipv4
 import dns.ipv6
 
 
-# We assume that AF_INET is always defined.
-
+# We assume that AF_INET and AF_INET6 are always defined.  We keep
+# these here for the benefit of any old code (unlikely though that
+# is!).
 AF_INET = socket.AF_INET
-
-# AF_INET6 might not be defined in the socket module, but we need it.
-# We'll try to use the socket module's value, and if it doesn't work,
-# we'll use our own value.
-
-try:
 AF_INET6 = socket.AF_INET6
-except AttributeError:
-    AF_INET6 = 9999
 
 
 def inet_pton(family, text):
     """Convert the textual form of a network address into its binary form.
 
-    @param family: the address family
-    @type family: int
-    @param text: the textual address
-    @type text: string
-    @raises NotImplementedError: the address family specified is not
+    *family* is an ``int``, the address family.
+
+    *text* is a ``str``, the textual address.
+
+    Raises ``NotImplementedError`` if the address family specified is not
     implemented.
-    @rtype: string
+
+    Returns a ``bytes``.
     """
 
     if family == AF_INET:
         return dns.ipv4.inet_aton(text)
     elif family == AF_INET6:
-        return dns.ipv6.inet_aton(text)
+        return dns.ipv6.inet_aton(text, True)
     else:
         raise NotImplementedError
 
@@ -58,14 +54,16 @@ def inet_pton(family, text):
 def inet_ntop(family, address):
     """Convert the binary form of a network address into its textual form.
 
-    @param family: the address family
-    @type family: int
-    @param address: the binary address
-    @type address: string
-    @raises NotImplementedError: the address family specified is not
+    *family* is an ``int``, the address family.
+
+    *address* is a ``bytes``, the network address in binary form.
+
+    Raises ``NotImplementedError`` if the address family specified is not
     implemented.
-    @rtype: string
+
+    Returns a ``str``.
     """
+
     if family == AF_INET:
         return dns.ipv4.inet_ntoa(address)
     elif family == AF_INET6:
@@ -77,35 +75,96 @@ def inet_ntop(family, address):
 def af_for_address(text):
     """Determine the address family of a textual-form network address.
 
-    @param text: the textual address
-    @type text: string
-    @raises ValueError: the address family cannot be determined from the input.
-    @rtype: int
+    *text*, a ``str``, the textual address.
+
+    Raises ``ValueError`` if the address family cannot be determined
+    from the input.
+
+    Returns an ``int``.
     """
+
     try:
         dns.ipv4.inet_aton(text)
         return AF_INET
-    except:
+    except Exception:
         try:
-            dns.ipv6.inet_aton(text)
+            dns.ipv6.inet_aton(text, True)
             return AF_INET6
-        except:
+        except Exception:
             raise ValueError
 
 
 def is_multicast(text):
     """Is the textual-form network address a multicast address?
 
-    @param text: the textual address
-    @raises ValueError: the address family cannot be determined from the input.
-    @rtype: bool
+    *text*, a ``str``, the textual address.
+
+    Raises ``ValueError`` if the address family cannot be determined
+    from the input.
+
+    Returns a ``bool``.
     """
+
     try:
-        first = ord(dns.ipv4.inet_aton(text)[0])
-        return (first >= 224 and first <= 239)
-    except:
+        first = dns.ipv4.inet_aton(text)[0]
+        return first >= 224 and first <= 239
+    except Exception:
         try:
-            first = ord(dns.ipv6.inet_aton(text)[0])
-            return (first == 255)
-        except:
+            first = dns.ipv6.inet_aton(text, True)[0]
+            return first == 255
+        except Exception:
             raise ValueError
+
+
+def is_address(text):
+    """Is the specified string an IPv4 or IPv6 address?
+
+    *text*, a ``str``, the textual address.
+
+    Returns a ``bool``.
+    """
+
+    try:
+        dns.ipv4.inet_aton(text)
+        return True
+    except Exception:
+        try:
+            dns.ipv6.inet_aton(text, True)
+            return True
+        except Exception:
+            return False
+
+
+def low_level_address_tuple(high_tuple, af=None):
+    """Given a "high-level" address tuple, i.e.
+    an (address, port) return the appropriate "low-level" address tuple
+    suitable for use in socket calls.
+
+    If an *af* other than ``None`` is provided, it is assumed the
+    address in the high-level tuple is valid and has that af.  If af
+    is ``None``, then af_for_address will be called.
+
+    """
+    address, port = high_tuple
+    if af is None:
+        af = af_for_address(address)
+    if af == AF_INET:
+        return (address, port)
+    elif af == AF_INET6:
+        i = address.find('%')
+        if i < 0:
+            # no scope, shortcut!
+            return (address, port, 0, 0)
+        # try to avoid getaddrinfo()
+        addrpart = address[:i]
+        scope = address[i + 1:]
+        if scope.isdigit():
+            return (addrpart, port, 0, int(scope))
+        try:
+            return (addrpart, port, 0, socket.if_nametoindex(scope))
+        except AttributeError:
+            ai_flags = socket.AI_NUMERICHOST
+            ((*_, tup), *_) = socket.getaddrinfo(address, port, flags=ai_flags)
+            return tup
+    else:
+        raise NotImplementedError(f'unknown address family {af}')

lib/dns/ipv4.py

@@ -1,4 +1,6 @@
-# Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
+# Copyright (C) 2003-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,
@@ -18,30 +20,29 @@
 import struct
 
 import dns.exception
-from ._compat import binary_type
 
 def inet_ntoa(address):
-    """Convert an IPv4 address in network form to text form.
+    """Convert an IPv4 address in binary form to text form.
 
-    @param address: The IPv4 address
-    @type address: string
-    @returns: string
+    *address*, a ``bytes``, the IPv4 address in binary form.
+
+    Returns a ``str``.
     """
+
     if len(address) != 4:
         raise dns.exception.SyntaxError
-    if not isinstance(address, bytearray):
-        address = bytearray(address)
-    return (u'%u.%u.%u.%u' % (address[0], address[1],
-                              address[2], address[3])).encode()
+    return ('%u.%u.%u.%u' % (address[0], address[1],
+                             address[2], address[3]))
 
 def inet_aton(text):
-    """Convert an IPv4 address in text form to network form.
+    """Convert an IPv4 address in text form to binary form.
 
-    @param text: The IPv4 address
-    @type text: string
-    @returns: string
+    *text*, a ``str``, the IPv4 address in textual form.
+
+    Returns a ``bytes``.
     """
-    if not isinstance(text, binary_type):
+
+    if not isinstance(text, bytes):
         text = text.encode()
     parts = text.split(b'.')
     if len(parts) != 4:
@@ -49,11 +50,11 @@ def inet_aton(text):
     for part in parts:
         if not part.isdigit():
             raise dns.exception.SyntaxError
-        if len(part) > 1 and part[0] == '0':
+        if len(part) > 1 and part[0] == ord('0'):
             # No leading zeros
             raise dns.exception.SyntaxError
     try:
-        bytes = [int(part) for part in parts]
-        return struct.pack('BBBB', *bytes)
-    except:
+        b = [int(part) for part in parts]
+        return struct.pack('BBBB', *b)
+    except Exception:
         raise dns.exception.SyntaxError

lib/dns/ipv6.py

@@ -1,4 +1,6 @@
-# Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
+# Copyright (C) 2003-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,
@@ -20,17 +22,16 @@ import binascii
 
 import dns.exception
 import dns.ipv4
-from ._compat import xrange, binary_type
 
-_leading_zero = re.compile(b'0+([0-9a-f]+)')
+_leading_zero = re.compile(r'0+([0-9a-f]+)')
 
 def inet_ntoa(address):
-    """Convert a network format IPv6 address into text.
+    """Convert an IPv6 address in binary form to text form.
 
-    @param address: the binary address
-    @type address: string
-    @rtype: string
-    @raises ValueError: the address isn't 16 bytes long
+    *address*, a ``bytes``, the IPv6 address in binary form.
+
+    Raises ``ValueError`` if the address isn't 16 bytes long.
+    Returns a ``str``.
     """
 
     if len(address) != 16:
@@ -40,12 +41,12 @@ def inet_ntoa(address):
     i = 0
     l = len(hex)
     while i < l:
-        chunk = hex[i : i + 4]
+        chunk = hex[i:i + 4].decode()
         # strip leading zeros.  we do this with an re instead of
         # with lstrip() because lstrip() didn't support chars until
         # python 2.2.2
         m = _leading_zero.match(chunk)
-        if not m is None:
+        if m is not None:
             chunk = m.group(1)
         chunks.append(chunk)
         i += 4
@@ -56,8 +57,8 @@ def inet_ntoa(address):
     best_len = 0
     start = -1
     last_was_zero = False
-    for i in xrange(8):
-        if chunks[i] != b'0':
+    for i in range(8):
+        if chunks[i] != '0':
             if last_was_zero:
                 end = i
                 current_len = end - start
@@ -77,59 +78,70 @@ def inet_ntoa(address):
     if best_len > 1:
         if best_start == 0 and \
            (best_len == 6 or
-            best_len == 5 and chunks[5] == b'ffff'):
+            best_len == 5 and chunks[5] == 'ffff'):
             # We have an embedded IPv4 address
             if best_len == 6:
-                prefix = b'::'
+                prefix = '::'
             else:
-                prefix = b'::ffff:'
+                prefix = '::ffff:'
             hex = prefix + dns.ipv4.inet_ntoa(address[12:])
         else:
-            hex = b':'.join(chunks[:best_start]) + b'::' + \
-                  b':'.join(chunks[best_start + best_len:])
+            hex = ':'.join(chunks[:best_start]) + '::' + \
+                  ':'.join(chunks[best_start + best_len:])
     else:
-        hex = b':'.join(chunks)
+        hex = ':'.join(chunks)
     return hex
 
-_v4_ending = re.compile(b'(.*):(\d+\.\d+\.\d+\.\d+)$')
-_colon_colon_start = re.compile(b'::.*')
-_colon_colon_end = re.compile(b'.*::$')
+_v4_ending = re.compile(br'(.*):(\d+\.\d+\.\d+\.\d+)$')
+_colon_colon_start = re.compile(br'::.*')
+_colon_colon_end = re.compile(br'.*::$')
 
-def inet_aton(text):
-    """Convert a text format IPv6 address into network format.
+def inet_aton(text, ignore_scope=False):
+    """Convert an IPv6 address in text form to binary form.
 
-    @param text: the textual address
-    @type text: string
-    @rtype: string
-    @raises dns.exception.SyntaxError: the text was not properly formatted
+    *text*, a ``str``, the IPv6 address in textual form.
+
+    *ignore_scope*, a ``bool``.  If ``True``, a scope will be ignored.
+    If ``False``, the default, it is an error for a scope to be present.
+
+    Returns a ``bytes``.
     """
 
     #
     # Our aim here is not something fast; we just want something that works.
     #
-    if not isinstance(text, binary_type):
+    if not isinstance(text, bytes):
         text = text.encode()
 
+    if ignore_scope:
+        parts = text.split(b'%')
+        l = len(parts)
+        if l == 2:
+            text = parts[0]
+        elif l > 2:
+            raise dns.exception.SyntaxError
+
     if text == b'::':
         text = b'0::'
     #
     # Get rid of the icky dot-quad syntax if we have it.
     #
     m = _v4_ending.match(text)
-    if not m is None:
-        b = bytearray(dns.ipv4.inet_aton(m.group(2)))
-        text = (u"%s:%02x%02x:%02x%02x" % (m.group(1).decode(), b[0], b[1],
-                                           b[2], b[3])).encode()
+    if m is not None:
+        b = dns.ipv4.inet_aton(m.group(2))
+        text = (u"{}:{:02x}{:02x}:{:02x}{:02x}".format(m.group(1).decode(),
+                                                       b[0], b[1], b[2],
+                                                       b[3])).encode()
     #
     # Try to turn '::<whatever>' into ':<whatever>'; if no match try to
     # turn '<whatever>::' into '<whatever>:'
     #
     m = _colon_colon_start.match(text)
-    if not m is None:
+    if m is not None:
         text = text[1:]
     else:
         m = _colon_colon_end.match(text)
-        if not m is None:
+        if m is not None:
             text = text[:-1]
     #
     # Now canonicalize into 8 chunks of 4 hex digits each
@@ -145,7 +157,7 @@ def inet_aton(text):
             if seen_empty:
                 raise dns.exception.SyntaxError
             seen_empty = True
-            for i in xrange(0, 8 - l + 1):
+            for i in range(0, 8 - l + 1):
                 canonical.append(b'0000')
         else:
             lc = len(c)
@@ -169,4 +181,11 @@ def inet_aton(text):
 _mapped_prefix = b'\x00' * 10 + b'\xff\xff'
 
 def is_mapped(address):
+    """Is the specified address a mapped IPv4 address?
+
+    *address*, a ``bytes`` is an IPv6 address in binary form.
+
+    Returns a ``bool``.
+    """
+
     return address.startswith(_mapped_prefix)

lib/dns/namedict.py

@@ -1,4 +1,6 @@
-# Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
+# Copyright (C) 2003-2017 Nominum, Inc.
 # Copyright (C) 2016 Coresec Systems AB
 #
 # Permission to use, copy, modify, and distribute this software and its
@@ -25,26 +27,26 @@
 
 """DNS name dictionary"""
 
-import collections
+from collections.abc import MutableMapping
+
 import dns.name
-from ._compat import xrange
 
 
-class NameDict(collections.MutableMapping):
-
+class NameDict(MutableMapping):
     """A dictionary whose keys are dns.name.Name objects.
-    @ivar max_depth: the maximum depth of the keys that have ever been
-    added to the dictionary.
-    @type max_depth: int
-    @ivar max_depth_items: the number of items of maximum depth
-    @type max_depth_items: int
+
+    In addition to being like a regular Python dictionary, this
+    dictionary can also get the deepest match for a given key.
     """
 
     __slots__ = ["max_depth", "max_depth_items", "__store"]
 
     def __init__(self, *args, **kwargs):
+        super().__init__()
         self.__store = dict()
+        #: the maximum depth of the keys that have ever been added
         self.max_depth = 0
+        #: the number of items of maximum depth
         self.max_depth_items = 0
         self.update(dict(*args, **kwargs))
 
@@ -65,8 +67,8 @@ class NameDict(collections.MutableMapping):
         self.__update_max_depth(key)
 
     def __delitem__(self, key):
-        value = self.__store.pop(key)
-        if len(value) == self.max_depth:
+        self.__store.pop(key)
+        if len(key) == self.max_depth:
             self.max_depth_items = self.max_depth_items - 1
         if self.max_depth_items == 0:
             self.max_depth = 0
@@ -83,20 +85,22 @@ class NameDict(collections.MutableMapping):
         return key in self.__store
 
     def get_deepest_match(self, name):
-        """Find the deepest match to I{name} in the dictionary.
+        """Find the deepest match to *fname* in the dictionary.
 
         The deepest match is the longest name in the dictionary which is
-        a superdomain of I{name}.
+        a superdomain of *name*.  Note that *superdomain* includes matching
+        *name* itself.
 
-        @param name: the name
-        @type name: dns.name.Name object
-        @rtype: (key, value) tuple
+        *name*, a ``dns.name.Name``, the name to find.
+
+        Returns a ``(key, value)`` where *key* is the deepest
+        ``dns.name.Name``, and *value* is the value associated with *key*.
         """
 
         depth = len(name)
         if depth > self.max_depth:
             depth = self.max_depth
-        for i in xrange(-depth, 0):
+        for i in range(-depth, 0):
             n = dns.name.Name(name[i:])
             if n in self:
                 return (n, self[n])

lib/dns/node.py

@@ -1,4 +1,6 @@
-# Copyright (C) 2001-2007, 2009-2011 Nominum, Inc.
+# 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,
@@ -15,28 +17,21 @@
 
 """DNS nodes.  A node is a set of rdatasets."""
 
-from io import StringIO
+import io
 
 import dns.rdataset
 import dns.rdatatype
 import dns.renderer
 
 
-class Node(object):
+class Node:
 
-    """A DNS node.
-
-    A node is a set of rdatasets
-
-    @ivar rdatasets: the node's rdatasets
-    @type rdatasets: list of dns.rdataset.Rdataset objects"""
+    """A Node is a set of rdatasets."""
 
     __slots__ = ['rdatasets']
 
     def __init__(self):
-        """Initialize a DNS node.
-        """
-
+        # the set of rdatasets, represented as a list.
         self.rdatasets = []
 
     def to_text(self, name, **kw):
@@ -44,26 +39,25 @@ class Node(object):
 
         Each rdataset at the node is printed.  Any keyword arguments
         to this method are passed on to the rdataset's to_text() method.
-        @param name: the owner name of the rdatasets
-        @type name: dns.name.Name object
-        @rtype: string
+
+        *name*, a ``dns.name.Name`` or ``str``, the owner name of the
+        rdatasets.
+
+        Returns a ``str``.
+
         """
 
-        s = StringIO()
+        s = io.StringIO()
         for rds in self.rdatasets:
             if len(rds) > 0:
                 s.write(rds.to_text(name, **kw))
-                s.write(u'\n')
+                s.write('\n')
         return s.getvalue()[:-1]
 
     def __repr__(self):
         return '<DNS node ' + str(id(self)) + '>'
 
     def __eq__(self, other):
-        """Two nodes are equal if they have the same rdatasets.
-
-        @rtype: bool
-        """
         #
         # This is inefficient.  Good thing we don't need to do it much.
         #
@@ -89,24 +83,26 @@ class Node(object):
         """Find an rdataset matching the specified properties in the
         current node.
 
-        @param rdclass: The class of the rdataset
-        @type rdclass: int
-        @param rdtype: The type of the rdataset
-        @type rdtype: int
-        @param covers: 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.
-        @type covers: int
-        @param create: If True, create the rdataset if it is not found.
-        @type create: bool
-        @raises KeyError: An rdataset of the desired type and class does
-        not exist and I{create} is not True.
-        @rtype: dns.rdataset.Rdataset object
+        *rdclass*, an ``int``, the class of the rdataset.
+
+        *rdtype*, an ``int``, the type of the rdataset.
+
+        *covers*, an ``int`` 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.
+
+        *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:
@@ -124,17 +120,24 @@ class Node(object):
         current node.
 
         None is returned if an rdataset of the specified type and
-        class does not exist and I{create} is not True.
+        class does not exist and *create* is not ``True``.
 
-        @param rdclass: The class of the rdataset
-        @type rdclass: int
-        @param rdtype: The type of the rdataset
-        @type rdtype: int
-        @param covers: The covered type.
-        @type covers: int
-        @param create: If True, create the rdataset if it is not found.
-        @type create: bool
-        @rtype: dns.rdataset.Rdataset object or None
+        *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:
@@ -149,12 +152,11 @@ class Node(object):
 
         If a matching rdataset does not exist, it is not an error.
 
-        @param rdclass: The class of the rdataset
-        @type rdclass: int
-        @param rdtype: The type of the rdataset
-        @type rdtype: int
-        @param covers: The covered type.
-        @type covers: int
+        *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)
@@ -164,11 +166,16 @@ class Node(object):
     def replace_rdataset(self, replacement):
         """Replace an rdataset.
 
-        It is not an error if there is no rdataset matching I{replacement}.
+        It is not an error if there is no rdataset matching *replacement*.
 
-        Ownership of the I{replacement} object is transferred to the node;
-        in other words, this method does not store a copy of I{replacement}
-        at the node, it stores I{replacement} itself.
+        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):

lib/dns/opcode.py

@@ -1,4 +1,6 @@
-# Copyright (C) 2001-2007, 2009-2011 Nominum, Inc.
+# 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,
@@ -15,58 +17,55 @@
 
 """DNS Opcodes."""
 
+import dns.enum
 import dns.exception
 
+class Opcode(dns.enum.IntEnum):
+    #: Query
     QUERY = 0
+    #: Inverse Query (historical)
     IQUERY = 1
+    #: Server Status (unspecified and unimplemented anywhere)
     STATUS = 2
+    #: Notify
     NOTIFY = 4
+    #: Dynamic Update
     UPDATE = 5
 
-_by_text = {
-    'QUERY': QUERY,
-    'IQUERY': IQUERY,
-    'STATUS': STATUS,
-    'NOTIFY': NOTIFY,
-    'UPDATE': UPDATE
-}
+    @classmethod
+    def _maximum(cls):
+        return 15
 
-# We construct the inverse mapping programmatically to ensure that we
-# cannot make any mistakes (e.g. omissions, cut-and-paste errors) that
-# would cause the mapping not to be true inverse.
+    @classmethod
+    def _unknown_exception_class(cls):
+        return UnknownOpcode
 
-_by_value = dict((y, x) for x, y in _by_text.items())
+globals().update(Opcode.__members__)
 
 
 class UnknownOpcode(dns.exception.DNSException):
-
     """An DNS opcode is unknown."""
 
 
 def from_text(text):
     """Convert text into an opcode.
 
-    @param text: the textual opcode
-    @type text: string
-    @raises UnknownOpcode: the opcode is unknown
-    @rtype: int
+    *text*, a ``str``, the textual opcode
+
+    Raises ``dns.opcode.UnknownOpcode`` if the opcode is unknown.
+
+    Returns an ``int``.
     """
 
-    if text.isdigit():
-        value = int(text)
-        if value >= 0 and value <= 15:
-            return value
-    value = _by_text.get(text.upper())
-    if value is None:
-        raise UnknownOpcode
-    return value
+    return Opcode.from_text(text)
 
 
 def from_flags(flags):
     """Extract an opcode from DNS message flags.
 
-    @param flags: int
-    @rtype: int
+    *flags*, an ``int``, the DNS flags.
+
+    Returns an ``int``.
     """
 
     return (flags & 0x7800) >> 11
@@ -75,7 +74,10 @@ def from_flags(flags):
 def to_flags(value):
     """Convert an opcode to a value suitable for ORing into DNS message
     flags.
-    @rtype: int
+
+    *value*, an ``int``, the DNS opcode value.
+
+    Returns an ``int``.
     """
 
     return (value << 11) & 0x7800
@@ -84,26 +86,22 @@ def to_flags(value):
 def to_text(value):
     """Convert an opcode to text.
 
-    @param value: the opcdoe
-    @type value: int
-    @raises UnknownOpcode: the opcode is unknown
-    @rtype: string
+    *value*, an ``int`` the opcode value,
+
+    Raises ``dns.opcode.UnknownOpcode`` if the opcode is unknown.
+
+    Returns a ``str``.
     """
 
-    text = _by_value.get(value)
-    if text is None:
-        text = str(value)
-    return text
+    return Opcode.to_text(value)
 
 
 def is_update(flags):
-    """True if the opcode in flags is UPDATE.
+    """Is the opcode in flags UPDATE?
 
-    @param flags: DNS flags
-    @type flags: int
-    @rtype: bool
+    *flags*, an ``int``, the DNS message flags.
+
+    Returns a ``bool``.
     """
 
-    if (from_flags(flags) == UPDATE):
-        return True
-    return False
+    return from_flags(flags) == Opcode.UPDATE

lib/dns/rcode.py

@@ -1,4 +1,6 @@
-# Copyright (C) 2001-2007, 2009-2011 Nominum, Inc.
+# 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,
@@ -15,78 +17,90 @@
 
 """DNS Result Codes."""
 
+import dns.enum
 import dns.exception
-from ._compat import long
-
 
+class Rcode(dns.enum.IntEnum):
+    #: No error
     NOERROR = 0
+    #: Format error
     FORMERR = 1
+    #: Server failure
     SERVFAIL = 2
+    #: Name does not exist ("Name Error" in RFC 1025 terminology).
     NXDOMAIN = 3
+    #: Not implemented
     NOTIMP = 4
+    #: Refused
     REFUSED = 5
+    #: Name exists.
     YXDOMAIN = 6
+    #: RRset exists.
     YXRRSET = 7
+    #: RRset does not exist.
     NXRRSET = 8
+    #: Not authoritative.
     NOTAUTH = 9
+    #: Name not in zone.
     NOTZONE = 10
+    #: DSO-TYPE Not Implemented
+    DSOTYPENI = 11
+    #: Bad EDNS version.
     BADVERS = 16
+    #: TSIG Signature Failure
+    BADSIG = 16
+    #: Key not recognized.
+    BADKEY = 17
+    #: Signature out of time window.
+    BADTIME = 18
+    #: Bad TKEY Mode.
+    BADMODE = 19
+    #: Duplicate key name.
+    BADNAME = 20
+    #: Algorithm not supported.
+    BADALG = 21
+    #: Bad Truncation
+    BADTRUNC = 22
+    #: Bad/missing Server Cookie
+    BADCOOKIE = 23
 
-_by_text = {
-    'NOERROR': NOERROR,
-    'FORMERR': FORMERR,
-    'SERVFAIL': SERVFAIL,
-    'NXDOMAIN': NXDOMAIN,
-    'NOTIMP': NOTIMP,
-    'REFUSED': REFUSED,
-    'YXDOMAIN': YXDOMAIN,
-    'YXRRSET': YXRRSET,
-    'NXRRSET': NXRRSET,
-    'NOTAUTH': NOTAUTH,
-    'NOTZONE': NOTZONE,
-    'BADVERS': BADVERS
-}
+    @classmethod
+    def _maximum(cls):
+        return 4095
 
-# We construct the inverse mapping programmatically to ensure that we
-# cannot make any mistakes (e.g. omissions, cut-and-paste errors) that
-# would cause the mapping not to be a true inverse.
-
-_by_value = dict((y, x) for x, y in _by_text.items())
+    @classmethod
+    def _unknown_exception_class(cls):
+        return UnknownRcode
 
+globals().update(Rcode.__members__)
 
 class UnknownRcode(dns.exception.DNSException):
-
     """A DNS rcode is unknown."""
 
 
 def from_text(text):
     """Convert text into an rcode.
 
-    @param text: the textual rcode
-    @type text: string
-    @raises UnknownRcode: the rcode is unknown
-    @rtype: int
+    *text*, a ``str``, the textual rcode or an integer in textual form.
+
+    Raises ``dns.rcode.UnknownRcode`` if the rcode mnemonic is unknown.
+
+    Returns an ``int``.
     """
 
-    if text.isdigit():
-        v = int(text)
-        if v >= 0 and v <= 4095:
-            return v
-    v = _by_text.get(text.upper())
-    if v is None:
-        raise UnknownRcode
-    return v
+    return Rcode.from_text(text)
 
 
 def from_flags(flags, ednsflags):
     """Return the rcode value encoded by flags and ednsflags.
 
-    @param flags: the DNS flags
-    @type flags: int
-    @param ednsflags: the EDNS flags
-    @type ednsflags: int
-    @raises ValueError: rcode is < 0 or > 4095
-    @rtype: int
+    *flags*, an ``int``, the DNS flags field.
+
+    *ednsflags*, an ``int``, the EDNS flags field.
+
+    Raises ``ValueError`` if rcode is < 0 or > 4095
+
+    Returns an ``int``.
     """
 
     value = (flags & 0x000f) | ((ednsflags >> 20) & 0xff0)
@@ -98,28 +112,30 @@ def from_flags(flags, ednsflags):
 def to_flags(value):
     """Return a (flags, ednsflags) tuple which encodes the rcode.
 
-    @param value: the rcode
-    @type value: int
-    @raises ValueError: rcode is < 0 or > 4095
-    @rtype: (int, int) tuple
+    *value*, an ``int``, the rcode.
+
+    Raises ``ValueError`` if rcode is < 0 or > 4095.
+
+    Returns an ``(int, int)`` tuple.
     """
 
     if value < 0 or value > 4095:
         raise ValueError('rcode must be >= 0 and <= 4095')
     v = value & 0xf
-    ev = long(value & 0xff0) << 20
+    ev = (value & 0xff0) << 20
     return (v, ev)
 
 
-def to_text(value):
+def to_text(value, tsig=False):
     """Convert rcode into text.
 
-    @param value: the rcode
-    @type value: int
-    @rtype: string
+    *value*, an ``int``, the rcode.
+
+    Raises ``ValueError`` if rcode is < 0 or > 4095.
+
+    Returns a ``str``.
     """
 
-    text = _by_value.get(value)
-    if text is None:
-        text = str(value)
-    return text
+    if tsig and value == Rcode.BADVERS:
+        return 'BADSIG'
+    return Rcode.to_text(value)

lib/dns/rdata.py

@@ -1,4 +1,6 @@
-# Copyright (C) 2001-2007, 2009-2011 Nominum, Inc.
+# 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,
@@ -13,95 +15,68 @@
 # ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
 # OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
-"""DNS rdata.
+"""DNS rdata."""
 
-@var _rdata_modules: A dictionary mapping a (rdclass, rdtype) tuple to
-the module which implements that type.
-@type _rdata_modules: dict
-@var _module_prefix: The prefix to use when forming modules names.  The
-default is 'dns.rdtypes'.  Changing this value will break the library.
-@type _module_prefix: string
-@var _hex_chunk: At most this many octets that will be represented in each
-chunk of hexstring that _hexify() produces before whitespace occurs.
-@type _hex_chunk: int"""
-
-from io import BytesIO
+from importlib import import_module
 import base64
 import binascii
-import struct
+import io
+import inspect
+import itertools
 
+import dns.wire
 import dns.exception
 import dns.name
 import dns.rdataclass
 import dns.rdatatype
 import dns.tokenizer
-import dns.wiredata
-from ._compat import xrange, string_types, text_type
 
-_hex_chunksize = 32
+_chunksize = 32
 
 
-def _hexify(data, chunksize=_hex_chunksize):
+def _wordbreak(data, chunksize=_chunksize):
+    """Break a binary string into chunks of chunksize characters separated by
+    a space.
+    """
+
+    if not chunksize:
+        return data.decode()
+    return b' '.join([data[i:i + chunksize]
+                      for i
+                      in range(0, len(data), chunksize)]).decode()
+
+
+def _hexify(data, chunksize=_chunksize):
     """Convert a binary string into its hex encoding, broken up into chunks
-    of I{chunksize} characters separated by a space.
-
-    @param data: the binary string
-    @type data: string
-    @param chunksize: the chunk size.  Default is L{dns.rdata._hex_chunksize}
-    @rtype: string
+    of chunksize characters separated by a space.
     """
 
-    line = binascii.hexlify(data)
-    return b' '.join([line[i:i + chunksize]
-                      for i
-                      in range(0, len(line), chunksize)]).decode()
-
-_base64_chunksize = 32
+    return _wordbreak(binascii.hexlify(data), chunksize)
 
 
-def _base64ify(data, chunksize=_base64_chunksize):
+def _base64ify(data, chunksize=_chunksize):
     """Convert a binary string into its base64 encoding, broken up into chunks
-    of I{chunksize} characters separated by a space.
-
-    @param data: the binary string
-    @type data: string
-    @param chunksize: the chunk size.  Default is
-    L{dns.rdata._base64_chunksize}
-    @rtype: string
+    of chunksize characters separated by a space.
     """
 
-    line = base64.b64encode(data)
-    return b' '.join([line[i:i + chunksize]
-                      for i
-                      in range(0, len(line), chunksize)]).decode()
-
-__escaped = {
-    '"': True,
-    '\\': True,
-}
+    return _wordbreak(base64.b64encode(data), chunksize)
 
+__escaped = b'"\\'
 
 def _escapify(qstring):
-    """Escape the characters in a quoted string which need it.
+    """Escape the characters in a quoted string which need it."""
 
-    @param qstring: the string
-    @type qstring: string
-    @returns: the escaped string
-    @rtype: string
-    """
-
-    if isinstance(qstring, text_type):
+    if isinstance(qstring, str):
         qstring = qstring.encode()
     if not isinstance(qstring, bytearray):
         qstring = bytearray(qstring)
 
     text = ''
     for c in qstring:
-        packed = struct.pack('!B', c).decode()
-        if packed in __escaped:
-            text += '\\' + packed
+        if c in __escaped:
+            text += '\\' + chr(c)
         elif c >= 0x20 and c < 0x7F:
-            text += packed
+            text += chr(c)
         else:
             text += '\\%03d' % c
     return text
@@ -110,43 +85,85 @@ def _escapify(qstring):
 def _truncate_bitmap(what):
     """Determine the index of greatest byte that isn't all zeros, and
     return the bitmap that contains all the bytes less than that index.
-
-    @param what: a string of octets representing a bitmap.
-    @type what: string
-    @rtype: string
     """
 
-    for i in xrange(len(what) - 1, -1, -1):
+    for i in range(len(what) - 1, -1, -1):
         if what[i] != 0:
-            break
             return what[0: i + 1]
+    return what[0:1]
 
-
-class Rdata(object):
-
-    """Base class for all DNS rdata types.
+def _constify(o):
     """
+    Convert mutable types to immutable types.
+    """
+    if isinstance(o, bytearray):
+        return bytes(o)
+    if isinstance(o, tuple):
+        try:
+            hash(o)
+            return o
+        except Exception:
+            return tuple(_constify(elt) for elt in o)
+    if isinstance(o, list):
+        return tuple(_constify(elt) for elt in o)
+    return o
+
+class Rdata:
+    """Base class for all DNS rdata types."""
 
     __slots__ = ['rdclass', 'rdtype']
 
     def __init__(self, rdclass, rdtype):
         """Initialize an rdata.
-        @param rdclass: The rdata class
-        @type rdclass: int
-        @param rdtype: The rdata type
-        @type rdtype: int
+
+        *rdclass*, an ``int`` is the rdataclass of the Rdata.
+
+        *rdtype*, an ``int`` is the rdatatype of the Rdata.
         """
 
-        self.rdclass = rdclass
-        self.rdtype = rdtype
+        object.__setattr__(self, 'rdclass', rdclass)
+        object.__setattr__(self, 'rdtype', rdtype)
+
+    def __setattr__(self, name, value):
+        # Rdatas are immutable
+        raise TypeError("object doesn't support attribute assignment")
+
+    def __delattr__(self, name):
+        # Rdatas are immutable
+        raise TypeError("object doesn't support attribute deletion")
+
+    def _get_all_slots(self):
+        return itertools.chain.from_iterable(getattr(cls, '__slots__', [])
+                                             for cls in self.__class__.__mro__)
+
+    def __getstate__(self):
+        # We used to try to do a tuple of all slots here, but it
+        # doesn't work as self._all_slots isn't available at
+        # __setstate__() time.  Before that we tried to store a tuple
+        # of __slots__, but that didn't work as it didn't store the
+        # slots defined by ancestors.  This older way didn't fail
+        # outright, but ended up with partially broken objects, e.g.
+        # if you unpickled an A RR it wouldn't have rdclass and rdtype
+        # attributes, and would compare badly.
+        state = {}
+        for slot in self._get_all_slots():
+            state[slot] = getattr(self, slot)
+        return state
+
+    def __setstate__(self, state):
+        for slot, val in state.items():
+            object.__setattr__(self, slot, val)
 
     def covers(self):
-        """DNS SIG/RRSIG rdatas apply to a specific type; this type is
+        """Return the type a Rdata covers.
+
+        DNS SIG/RRSIG rdatas apply to a specific type; this type is
         returned by the covers() function.  If the rdata type is not
         SIG or RRSIG, dns.rdatatype.NONE is returned.  This is useful when
         creating rdatasets, allowing the rdataset to contain only RRSIGs
         of a particular type, e.g. RRSIG(NS).
-        @rtype: int
+
+        Returns an ``int``.
         """
 
         return dns.rdatatype.NONE
@@ -155,38 +172,53 @@ class Rdata(object):
         """Return a 32-bit type value, the least significant 16 bits of
         which are the ordinary DNS type, and the upper 16 bits of which are
         the "covered" type, if any.
-        @rtype: int
+
+        Returns an ``int``.
         """
 
         return self.covers() << 16 | self.rdtype
 
     def to_text(self, origin=None, relativize=True, **kw):
         """Convert an rdata to text format.
-        @rtype: string
+
+        Returns a ``str``.
         """
+
         raise NotImplementedError
 
-    def to_wire(self, file, compress=None, origin=None):
+    def _to_wire(self, file, compress=None, origin=None, canonicalize=False):
+        raise NotImplementedError
+
+    def to_wire(self, file=None, compress=None, origin=None,
+                canonicalize=False):
         """Convert an rdata to wire format.
-        @rtype: string
+
+        Returns a ``bytes`` or ``None``.
         """
 
-        raise NotImplementedError
+        if file:
+            return self._to_wire(file, compress, origin, canonicalize)
+        else:
+            f = io.BytesIO()
+            self._to_wire(f, compress, origin, canonicalize)
+            return f.getvalue()
+
+    def to_generic(self, origin=None):
+        """Creates a dns.rdata.GenericRdata equivalent of this rdata.
+
+        Returns a ``dns.rdata.GenericRdata``.
+        """
+        return dns.rdata.GenericRdata(self.rdclass, self.rdtype,
+                                      self.to_wire(origin=origin))
 
     def to_digestable(self, origin=None):
         """Convert rdata to a format suitable for digesting in hashes.  This
-        is also the DNSSEC canonical form."""
-        f = BytesIO()
-        self.to_wire(f, None, origin)
-        return f.getvalue()
+        is also the DNSSEC canonical form.
 
-    def validate(self):
-        """Check that the current contents of the rdata's fields are
-        valid.  If you change an rdata by assigning to its fields,
-        it is a good idea to call validate() when you are done making
-        changes.
+        Returns a ``bytes``.
         """
-        dns.rdata.from_text(self.rdclass, self.rdtype, self.to_text())
+
+        return self.to_wire(origin=origin, canonicalize=True)
 
     def __repr__(self):
         covers = self.covers()
@@ -203,16 +235,19 @@ class Rdata(object):
 
     def _cmp(self, other):
         """Compare an rdata with another rdata of the same rdtype and
-        rdclass.  Return < 0 if self < other in the DNSSEC ordering,
-        0 if self == other, and > 0 if self > other.
+        rdclass.
+
+        Return < 0 if self < other in the DNSSEC ordering, 0 if self
+        == other, and > 0 if self > other.
+
         """
         our = self.to_digestable(dns.name.root)
         their = other.to_digestable(dns.name.root)
         if our == their:
             return 0
-        if our > their:
+        elif our > their:
             return 1
-
+        else:
             return -1
 
     def __eq__(self, other):
@@ -258,56 +293,55 @@ class Rdata(object):
         return hash(self.to_digestable(dns.name.root))
 
     @classmethod
-    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
-        """Build an rdata object from text format.
-
-        @param rdclass: The rdata class
-        @type rdclass: int
-        @param rdtype: The rdata type
-        @type rdtype: int
-        @param tok: The tokenizer
-        @type tok: dns.tokenizer.Tokenizer
-        @param origin: The origin to use for relative names
-        @type origin: dns.name.Name
-        @param relativize: should names be relativized?
-        @type relativize: bool
-        @rtype: dns.rdata.Rdata instance
-        """
-
+    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+                  relativize_to=None):
         raise NotImplementedError
 
     @classmethod
     def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin=None):
-        """Build an rdata object from wire format
-
-        @param rdclass: The rdata class
-        @type rdclass: int
-        @param rdtype: The rdata type
-        @type rdtype: int
-        @param wire: The wire-format message
-        @type wire: string
-        @param current: The offset in wire of the beginning of the rdata.
-        @type current: int
-        @param rdlen: The length of the wire-format rdata
-        @type rdlen: int
-        @param origin: The origin to use for relative names
-        @type origin: dns.name.Name
-        @rtype: dns.rdata.Rdata instance
-        """
-
         raise NotImplementedError
 
-    def choose_relativity(self, origin=None, relativize=True):
-        """Convert any domain names in the rdata to the specified
-        relativization.
+    def replace(self, **kwargs):
+        """
+        Create a new Rdata instance based on the instance replace was
+        invoked on. It is possible to pass different parameters to
+        override the corresponding properties of the base Rdata.
+
+        Any field specific to the Rdata type can be replaced, but the
+        *rdtype* and *rdclass* fields cannot.
+
+        Returns an instance of the same Rdata subclass as *self*.
         """
 
-        pass
+        # Get the constructor parameters.
+        parameters = inspect.signature(self.__init__).parameters
+
+        # Ensure that all of the arguments correspond to valid fields.
+        # Don't allow rdclass or rdtype to be changed, though.
+        for key in kwargs:
+            if key not in parameters:
+                raise AttributeError("'{}' object has no attribute '{}'"
+                                     .format(self.__class__.__name__, key))
+            if key in ('rdclass', 'rdtype'):
+                raise AttributeError("Cannot overwrite '{}' attribute '{}'"
+                                     .format(self.__class__.__name__, key))
+
+        # Construct the parameter list.  For each field, use the value in
+        # kwargs if present, and the current value otherwise.
+        args = (kwargs.get(key, getattr(self, key)) for key in parameters)
+
+        # Create, validate, and return the new object.
+        #
+        # Note that if we make constructors do validation in the future,
+        # this validation can go away.
+        rd = self.__class__(*args)
+        dns.rdata.from_text(rd.rdclass, rd.rdtype, rd.to_text())
+        return rd
 
 
 class GenericRdata(Rdata):
 
-    """Generate Rdata Class
+    """Generic Rdata Class
 
     This class is used for rdata types for which we have no better
     implementation.  It implements the DNS "unknown RRs" scheme.
@@ -316,16 +350,17 @@ class GenericRdata(Rdata):
     __slots__ = ['data']
 
     def __init__(self, rdclass, rdtype, data):
-        super(GenericRdata, self).__init__(rdclass, rdtype)
-        self.data = data
+        super().__init__(rdclass, rdtype)
+        object.__setattr__(self, 'data', data)
 
     def to_text(self, origin=None, relativize=True, **kw):
         return r'\# %d ' % len(self.data) + _hexify(self.data)
 
     @classmethod
-    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+                  relativize_to=None):
         token = tok.get()
-        if not token.is_identifier() or token.value != '\#':
+        if not token.is_identifier() or token.value != r'\#':
             raise dns.exception.SyntaxError(
                 r'generic rdata does not start with \#')
         length = tok.get_int()
@@ -342,52 +377,46 @@ class GenericRdata(Rdata):
                 'generic rdata hex data has wrong length')
         return cls(rdclass, rdtype, data)
 
-    def to_wire(self, file, compress=None, origin=None):
+    def _to_wire(self, file, compress=None, origin=None, canonicalize=False):
         file.write(self.data)
 
     @classmethod
-    def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin=None):
-        return cls(rdclass, rdtype, wire[current: current + rdlen])
+    def from_wire_parser(cls, rdclass, rdtype, parser, origin=None):
+        return cls(rdclass, rdtype, parser.get_remaining())
 
-_rdata_modules = {}
+_rdata_classes = {}
 _module_prefix = 'dns.rdtypes'
 
-
 def get_rdata_class(rdclass, rdtype):
-
-    def import_module(name):
-        mod = __import__(name)
-        components = name.split('.')
-        for comp in components[1:]:
-            mod = getattr(mod, comp)
-        return mod
-
-    mod = _rdata_modules.get((rdclass, rdtype))
+    cls = _rdata_classes.get((rdclass, rdtype))
+    if not cls:
+        cls = _rdata_classes.get((dns.rdatatype.ANY, rdtype))
+        if not cls:
             rdclass_text = dns.rdataclass.to_text(rdclass)
             rdtype_text = dns.rdatatype.to_text(rdtype)
             rdtype_text = rdtype_text.replace('-', '_')
-    if not mod:
-        mod = _rdata_modules.get((dns.rdatatype.ANY, rdtype))
-        if not mod:
             try:
                 mod = import_module('.'.join([_module_prefix,
                                               rdclass_text, rdtype_text]))
-                _rdata_modules[(rdclass, rdtype)] = mod
+                cls = getattr(mod, rdtype_text)
+                _rdata_classes[(rdclass, rdtype)] = cls
             except ImportError:
                 try:
                     mod = import_module('.'.join([_module_prefix,
                                                   'ANY', rdtype_text]))
-                    _rdata_modules[(dns.rdataclass.ANY, rdtype)] = mod
-                except ImportError:
-                    mod = None
-    if mod:
                     cls = getattr(mod, rdtype_text)
-    else:
+                    _rdata_classes[(dns.rdataclass.ANY, rdtype)] = cls
+                    _rdata_classes[(rdclass, rdtype)] = cls
+                except ImportError:
+                    pass
+    if not cls:
         cls = GenericRdata
+        _rdata_classes[(rdclass, rdtype)] = cls
     return cls
 
 
-def from_text(rdclass, rdtype, tok, origin=None, relativize=True):
+def from_text(rdclass, rdtype, tok, origin=None, relativize=True,
+              relativize_to=None, idna_codec=None):
     """Build an rdata object from text format.
 
     This function attempts to dynamically load a class which
@@ -398,23 +427,37 @@ def from_text(rdclass, rdtype, tok, origin=None, relativize=True):
     Once a class is chosen, its from_text() class method is called
     with the parameters to this function.
 
-    If I{tok} is a string, then a tokenizer is created and the string
+    If *tok* is a ``str``, then a tokenizer is created and the string
     is used as its input.
 
-    @param rdclass: The rdata class
-    @type rdclass: int
-    @param rdtype: The rdata type
-    @type rdtype: int
-    @param tok: The tokenizer or input text
-    @type tok: dns.tokenizer.Tokenizer or string
-    @param origin: The origin to use for relative names
-    @type origin: dns.name.Name
-    @param relativize: Should names be relativized?
-    @type relativize: bool
-    @rtype: dns.rdata.Rdata instance"""
+    *rdclass*, an ``int``, the rdataclass.
 
-    if isinstance(tok, string_types):
-        tok = dns.tokenizer.Tokenizer(tok)
+    *rdtype*, an ``int``, the rdatatype.
+
+    *tok*, a ``dns.tokenizer.Tokenizer`` or a ``str``.
+
+    *origin*, a ``dns.name.Name`` (or ``None``), the
+    origin to use for relative names.
+
+    *relativize*, a ``bool``.  If true, name will be relativized.
+
+    *relativize_to*, a ``dns.name.Name`` (or ``None``), the origin to use
+    when relativizing names.  If not set, the *origin* value will be used.
+
+    *idna_codec*, a ``dns.name.IDNACodec``, specifies the IDNA
+    encoder/decoder to use if a tokenizer needs to be created.  If
+    ``None``, the default IDNA 2003 encoder/decoder is used.  If a
+    tokenizer is not created, then the codec associated with the tokenizer
+    is the one that is used.
+
+    Returns an instance of the chosen Rdata subclass.
+
+    """
+
+    if isinstance(tok, str):
+        tok = dns.tokenizer.Tokenizer(tok, idna_codec=idna_codec)
+    rdclass = dns.rdataclass.RdataClass.make(rdclass)
+    rdtype = dns.rdatatype.RdataType.make(rdtype)
     cls = get_rdata_class(rdclass, rdtype)
     if cls != GenericRdata:
         # peek at first token
@@ -428,10 +471,41 @@ def from_text(rdclass, rdtype, tok, origin=None, relativize=True):
             # from_wire on it.
             #
             rdata = GenericRdata.from_text(rdclass, rdtype, tok, origin,
-                                           relativize)
+                                           relativize, relativize_to)
             return from_wire(rdclass, rdtype, rdata.data, 0, len(rdata.data),
                              origin)
-    return cls.from_text(rdclass, rdtype, tok, origin, relativize)
+    return cls.from_text(rdclass, rdtype, tok, origin, relativize,
+                         relativize_to)
+
+
+def from_wire_parser(rdclass, rdtype, parser, origin=None):
+    """Build an rdata object from wire format
+
+    This function attempts to dynamically load a class which
+    implements the specified rdata class and type.  If there is no
+    class-and-type-specific implementation, the GenericRdata class
+    is used.
+
+    Once a class is chosen, its from_wire() class method is called
+    with the parameters to this function.
+
+    *rdclass*, an ``int``, the rdataclass.
+
+    *rdtype*, an ``int``, the rdatatype.
+
+    *parser*, a ``dns.wire.Parser``, the parser, which should be
+    restricted to the rdata length.
+
+    *origin*, a ``dns.name.Name`` (or ``None``).  If not ``None``,
+    then names will be relativized to this origin.
+
+    Returns an instance of the chosen Rdata subclass.
+    """
+
+    rdclass = dns.rdataclass.RdataClass.make(rdclass)
+    rdtype = dns.rdatatype.RdataType.make(rdtype)
+    cls = get_rdata_class(rdclass, rdtype)
+    return cls.from_wire_parser(rdclass, rdtype, parser, origin)
 
 
 def from_wire(rdclass, rdtype, wire, current, rdlen, origin=None):
@@ -445,20 +519,60 @@ def from_wire(rdclass, rdtype, wire, current, rdlen, origin=None):
     Once a class is chosen, its from_wire() class method is called
     with the parameters to this function.
 
-    @param rdclass: The rdata class
-    @type rdclass: int
-    @param rdtype: The rdata type
-    @type rdtype: int
-    @param wire: The wire-format message
-    @type wire: string
-    @param current: The offset in wire of the beginning of the rdata.
-    @type current: int
-    @param rdlen: The length of the wire-format rdata
-    @type rdlen: int
-    @param origin: The origin to use for relative names
-    @type origin: dns.name.Name
-    @rtype: dns.rdata.Rdata instance"""
+    *rdclass*, an ``int``, the rdataclass.
 
-    wire = dns.wiredata.maybe_wrap(wire)
-    cls = get_rdata_class(rdclass, rdtype)
-    return cls.from_wire(rdclass, rdtype, wire, current, rdlen, origin)
+    *rdtype*, an ``int``, the rdatatype.
+
+    *wire*, a ``bytes``, the wire-format message.
+
+    *current*, an ``int``, the offset in wire of the beginning of
+    the rdata.
+
+    *rdlen*, an ``int``, the length of the wire-format rdata
+
+    *origin*, a ``dns.name.Name`` (or ``None``).  If not ``None``,
+    then names will be relativized to this origin.
+
+    Returns an instance of the chosen Rdata subclass.
+    """
+    parser = dns.wire.Parser(wire, current)
+    with parser.restrict_to(rdlen):
+        return from_wire_parser(rdclass, rdtype, parser, origin)
+
+
+class RdatatypeExists(dns.exception.DNSException):
+    """DNS rdatatype already exists."""
+    supp_kwargs = {'rdclass', 'rdtype'}
+    fmt = "The rdata type with class {rdclass} and rdtype {rdtype} " + \
+        "already exists."
+
+
+def register_type(implementation, rdtype, rdtype_text, is_singleton=False,
+                  rdclass=dns.rdataclass.IN):
+    """Dynamically register a module to handle an rdatatype.
+
+    *implementation*, a module implementing the type in the usual dnspython
+    way.
+
+    *rdtype*, an ``int``, the rdatatype to register.
+
+    *rdtype_text*, a ``str``, the textual form of the rdatatype.
+
+    *is_singleton*, a ``bool``, indicating if the type is a singleton (i.e.
+    RRsets of the type can have only one member.)
+
+    *rdclass*, the rdataclass of the type, or ``dns.rdataclass.ANY`` if
+    it applies to all classes.
+    """
+
+    existing_cls = get_rdata_class(rdclass, rdtype)
+    if existing_cls != GenericRdata or dns.rdatatype.is_metatype(rdtype):
+        raise RdatatypeExists(rdclass=rdclass, rdtype=rdtype)
+    try:
+        if dns.rdatatype.RdataType(rdtype).name != rdtype_text:
+            raise RdatatypeExists(rdclass=rdclass, rdtype=rdtype)
+    except ValueError:
+        pass
+    _rdata_classes[(rdclass, rdtype)] = getattr(implementation,
+                                                rdtype_text.replace('-', '_'))
+    dns.rdatatype.register_type(rdtype, rdtype_text, is_singleton)

lib/dns/rdataclass.py

@@ -1,4 +1,6 @@
-# Copyright (C) 2001-2007, 2009-2011 Nominum, Inc.
+# 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,
@@ -13,105 +15,87 @@
 # ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
 # OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
-"""DNS Rdata Classes.
-
-@var _by_text: The rdata class textual name to value mapping
-@type _by_text: dict
-@var _by_value: The rdata class value to textual name mapping
-@type _by_value: dict
-@var _metaclasses: If an rdataclass is a metaclass, there will be a mapping
-whose key is the rdatatype value and whose value is True in this dictionary.
-@type _metaclasses: dict"""
-
-import re
+"""DNS Rdata Classes."""
 
+import dns.enum
 import dns.exception
 
+class RdataClass(dns.enum.IntEnum):
+    """DNS Rdata Class"""
     RESERVED0 = 0
     IN = 1
+    INTERNET = IN
     CH = 3
+    CHAOS = CH
     HS = 4
+    HESIOD = HS
     NONE = 254
     ANY = 255
 
-_by_text = {
-    'RESERVED0': RESERVED0,
-    'IN': IN,
-    'CH': CH,
-    'HS': HS,
-    'NONE': NONE,
-    'ANY': ANY
-}
+    @classmethod
+    def _maximum(cls):
+        return 65535
 
-# We construct the inverse mapping programmatically to ensure that we
-# cannot make any mistakes (e.g. omissions, cut-and-paste errors) that
-# would cause the mapping not to be true inverse.
+    @classmethod
+    def _short_name(cls):
+        return "class"
 
-_by_value = dict((y, x) for x, y in _by_text.items())
+    @classmethod
+    def _prefix(cls):
+        return "CLASS"
 
-# Now that we've built the inverse map, we can add class aliases to
-# the _by_text mapping.
+    @classmethod
+    def _unknown_exception_class(cls):
+        return UnknownRdataclass
 
-_by_text.update({
-    'INTERNET': IN,
-    'CHAOS': CH,
-    'HESIOD': HS
-})
+globals().update(RdataClass.__members__)
 
-_metaclasses = {
-    NONE: True,
-    ANY: True
-}
-
-_unknown_class_pattern = re.compile('CLASS([0-9]+)$', re.I)
+_metaclasses = {RdataClass.NONE, RdataClass.ANY}
 
 
 class UnknownRdataclass(dns.exception.DNSException):
-
     """A DNS class is unknown."""
 
 
 def from_text(text):
     """Convert text into a DNS rdata class value.
-    @param text: the text
-    @type text: string
-    @rtype: int
-    @raises dns.rdataclass.UnknownRdataclass: the class is unknown
-    @raises ValueError: the rdata class value is not >= 0 and <= 65535
+
+    The input text can be a defined DNS RR class mnemonic or
+    instance of the DNS generic class syntax.
+
+    For example, "IN" and "CLASS1" will both result in a value of 1.
+
+    Raises ``dns.rdatatype.UnknownRdataclass`` if the class is unknown.
+
+    Raises ``ValueError`` if the rdata class value is not >= 0 and <= 65535.
+
+    Returns an ``int``.
     """
 
-    value = _by_text.get(text.upper())
-    if value is None:
-        match = _unknown_class_pattern.match(text)
-        if match is None:
-            raise UnknownRdataclass
-        value = int(match.group(1))
-        if value < 0 or value > 65535:
-            raise ValueError("class must be between >= 0 and <= 65535")
-    return value
+    return RdataClass.from_text(text)
 
 
 def to_text(value):
-    """Convert a DNS rdata class to text.
-    @param value: the rdata class value
-    @type value: int
-    @rtype: string
-    @raises ValueError: the rdata class value is not >= 0 and <= 65535
+    """Convert a DNS rdata class value to text.
+
+    If the value has a known mnemonic, it will be used, otherwise the
+    DNS generic class syntax will be used.
+
+    Raises ``ValueError`` if the rdata class value is not >= 0 and <= 65535.
+
+    Returns a ``str``.
     """
 
-    if value < 0 or value > 65535:
-        raise ValueError("class must be between >= 0 and <= 65535")
-    text = _by_value.get(value)
-    if text is None:
-        text = 'CLASS' + repr(value)
-    return text
+    return RdataClass.to_text(value)
 
 
 def is_metaclass(rdclass):
-    """True if the class is a metaclass.
-    @param rdclass: the rdata class
-    @type rdclass: int
-    @rtype: bool"""
+    """True if the specified class is a metaclass.
+
+    The currently defined metaclasses are ANY and NONE.
+
+    *rdclass* is an ``int``.
+    """
 
     if rdclass in _metaclasses:
         return True

lib/dns/rdataset.py

@@ -1,4 +1,6 @@
-# Copyright (C) 2001-2007, 2009-2011 Nominum, Inc.
+# 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,
@@ -15,8 +17,8 @@
 
 """DNS rdatasets (an rdataset is a set of rdatas of a given type and class)"""
 
+import io
 import random
-from io import StringIO
 import struct
 
 import dns.exception
@@ -24,60 +26,46 @@ import dns.rdatatype
 import dns.rdataclass
 import dns.rdata
 import dns.set
-from ._compat import string_types
 
 # define SimpleSet here for backwards compatibility
 SimpleSet = dns.set.Set
 
 
 class DifferingCovers(dns.exception.DNSException):
-
     """An attempt was made to add a DNS SIG/RRSIG whose covered type
     is not the same as that of the other rdatas in the rdataset."""
 
 
 class IncompatibleTypes(dns.exception.DNSException):
-
     """An attempt was made to add DNS RR data of an incompatible type."""
 
 
 class Rdataset(dns.set.Set):
 
-    """A DNS rdataset.
-
-    @ivar rdclass: The class of the rdataset
-    @type rdclass: int
-    @ivar rdtype: The type of the rdataset
-    @type rdtype: int
-    @ivar covers: 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.
-    @type covers: int
-    @ivar ttl: The DNS TTL (Time To Live) value
-    @type ttl: int
-    """
+    """A DNS rdataset."""
 
     __slots__ = ['rdclass', 'rdtype', 'covers', 'ttl']
 
-    def __init__(self, rdclass, rdtype, covers=dns.rdatatype.NONE):
+    def __init__(self, rdclass, rdtype, covers=dns.rdatatype.NONE, ttl=0):
         """Create a new rdataset of the specified class and type.
 
-        @see: the description of the class instance variables for the
-        meaning of I{rdclass} and I{rdtype}"""
+        *rdclass*, an ``int``, the rdataclass.
 
-        super(Rdataset, self).__init__()
+        *rdtype*, an ``int``, the rdatatype.
+
+        *covers*, an ``int``, the covered rdatatype.
+
+        *ttl*, an ``int``, the TTL.
+        """
+
+        super().__init__()
         self.rdclass = rdclass
         self.rdtype = rdtype
         self.covers = covers
-        self.ttl = 0
+        self.ttl = ttl
 
     def _clone(self):
-        obj = super(Rdataset, self)._clone()
+        obj = super()._clone()
         obj.rdclass = self.rdclass
         obj.rdtype = self.rdtype
         obj.covers = self.covers
@@ -85,11 +73,14 @@ class Rdataset(dns.set.Set):
         return obj
 
     def update_ttl(self, ttl):
-        """Set the TTL of the rdataset to be the lesser of the set's current
+        """Perform TTL minimization.
+
+        Set the TTL of the rdataset to be the lesser of the set's current
         TTL or the specified TTL.  If the set contains no rdatas, set the TTL
         to the specified TTL.
-        @param ttl: The TTL
-        @type ttl: int"""
+
+        *ttl*, an ``int``.
+        """
 
         if len(self) == 0:
             self.ttl = ttl
@@ -99,13 +90,19 @@ class Rdataset(dns.set.Set):
     def add(self, rd, ttl=None):
         """Add the specified rdata to the rdataset.
 
-        If the optional I{ttl} parameter is supplied, then
-        self.update_ttl(ttl) will be called prior to adding the rdata.
+        If the optional *ttl* parameter is supplied, then
+        ``self.update_ttl(ttl)`` will be called prior to adding the rdata.
 
-        @param rd: The rdata
-        @type rd: dns.rdata.Rdata object
-        @param ttl: The TTL
-        @type ttl: int"""
+        *rd*, a ``dns.rdata.Rdata``, the rdata
+
+        *ttl*, an ``int``, the TTL.
+
+        Raises ``dns.rdataset.IncompatibleTypes`` if the type and class
+        do not match the type and class of the rdataset.
+
+        Raises ``dns.rdataset.DifferingCovers`` if the type is a signature
+        type and the covered type does not match that of the rdataset.
+        """
 
         #
         # If we're adding a signature, do some special handling to
@@ -126,24 +123,33 @@ class Rdataset(dns.set.Set):
                 raise DifferingCovers
         if dns.rdatatype.is_singleton(rd.rdtype) and len(self) > 0:
             self.clear()
-        super(Rdataset, self).add(rd)
+        super().add(rd)
 
     def union_update(self, other):
         self.update_ttl(other.ttl)
-        super(Rdataset, self).union_update(other)
+        super().union_update(other)
 
     def intersection_update(self, other):
         self.update_ttl(other.ttl)
-        super(Rdataset, self).intersection_update(other)
+        super().intersection_update(other)
 
     def update(self, other):
         """Add all rdatas in other to self.
 
-        @param other: The rdataset from which to update
-        @type other: dns.rdataset.Rdataset object"""
+        *other*, a ``dns.rdataset.Rdataset``, the rdataset from which
+        to update.
+        """
 
         self.update_ttl(other.ttl)
-        super(Rdataset, self).update(other)
+        super().update(other)
+
+    def _rdata_repr(self):
+        def maybe_truncate(s):
+            if len(s) > 100:
+                return s[:100] + '...'
+            return s
+        return '[%s]' % ', '.join('<%s>' % maybe_truncate(str(rr))
+                                  for rr in self)
 
     def __repr__(self):
         if self.covers == 0:
@@ -151,23 +157,20 @@ class Rdataset(dns.set.Set):
         else:
             ctext = '(' + dns.rdatatype.to_text(self.covers) + ')'
         return '<DNS ' + dns.rdataclass.to_text(self.rdclass) + ' ' + \
-               dns.rdatatype.to_text(self.rdtype) + ctext + ' rdataset>'
+               dns.rdatatype.to_text(self.rdtype) + ctext + \
+               ' rdataset: ' + self._rdata_repr() + '>'
 
     def __str__(self):
         return self.to_text()
 
     def __eq__(self, other):
-        """Two rdatasets are equal if they have the same class, type, and
-        covers, and contain the same rdata.
-        @rtype: bool"""
-
         if not isinstance(other, Rdataset):
             return False
         if self.rdclass != other.rdclass or \
            self.rdtype != other.rdtype or \
            self.covers != other.covers:
             return False
-        return super(Rdataset, self).__eq__(other)
+        return super().__eq__(other)
 
     def __ne__(self, other):
         return not self.__eq__(other)
@@ -176,20 +179,23 @@ class Rdataset(dns.set.Set):
                 override_rdclass=None, **kw):
         """Convert the rdataset into DNS master file format.
 
-        @see: L{dns.name.Name.choose_relativity} for more information
-        on how I{origin} and I{relativize} determine the way names
+        See ``dns.name.Name.choose_relativity`` for more information
+        on how *origin* and *relativize* determine the way names
         are emitted.
 
         Any additional keyword arguments are passed on to the rdata
-        to_text() method.
+        ``to_text()`` method.
+
+        *name*, a ``dns.name.Name``.  If name is not ``None``, emit RRs with
+        *name* as the owner name.
+
+        *origin*, a ``dns.name.Name`` or ``None``, the origin for relative
+        names.
+
+        *relativize*, a ``bool``.  If ``True``, names will be relativized
+        to *origin*.
+        """
 
-        @param name: If name is not None, emit a RRs with I{name} as
-        the owner name.
-        @type name: dns.name.Name object
-        @param origin: The origin for relative names, or None.
-        @type origin: dns.name.Name object
-        @param relativize: True if names should names be relativized
-        @type relativize: bool"""
         if name is not None:
             name = name.choose_relativity(origin, relativize)
             ntext = str(name)
@@ -197,7 +203,7 @@ class Rdataset(dns.set.Set):
         else:
             ntext = ''
             pad = ''
-        s = StringIO()
+        s = io.StringIO()
         if override_rdclass is not None:
             rdclass = override_rdclass
         else:
@@ -208,12 +214,12 @@ class Rdataset(dns.set.Set):
             # some dynamic updates, so we don't need to print out the TTL
             # (which is meaningless anyway).
             #
-            s.write(u'%s%s%s %s\n' % (ntext, pad,
+            s.write('{}{}{} {}\n'.format(ntext, pad,
                                          dns.rdataclass.to_text(rdclass),
                                          dns.rdatatype.to_text(self.rdtype)))
         else:
             for rd in self:
-                s.write(u'%s%s%d %s %s %s\n' %
+                s.write('%s%s%d %s %s %s\n' %
                         (ntext, pad, self.ttl, dns.rdataclass.to_text(rdclass),
                          dns.rdatatype.to_text(self.rdtype),
                          rd.to_text(origin=origin, relativize=relativize,
@@ -227,16 +233,26 @@ class Rdataset(dns.set.Set):
                 override_rdclass=None, want_shuffle=True):
         """Convert the rdataset to wire format.
 
-        @param name: The owner name of the RRset that will be emitted
-        @type name: dns.name.Name object
-        @param file: The file to which the wire format data will be appended
-        @type file: file
-        @param compress: The compression table to use; the default is None.
-        @type compress: dict
-        @param origin: The origin to be appended to any relative names when
-        they are emitted.  The default is None.
-        @returns: the number of records emitted
-        @rtype: int
+        *name*, a ``dns.name.Name`` is the owner name to use.
+
+        *file* is the file where the name is emitted (typically a
+        BytesIO file).
+
+        *compress*, a ``dict``, is the compression table to use.  If
+        ``None`` (the default), names will not be compressed.
+
+        *origin* is a ``dns.name.Name`` or ``None``.  If the name is
+        relative and origin is not ``None``, then *origin* will be appended
+        to it.
+
+        *override_rdclass*, an ``int``, is used as the class instead of the
+        class of the rdataset.  This is useful when rendering rdatasets
+        associated with dynamic updates.
+
+        *want_shuffle*, a ``bool``.  If ``True``, then the order of the
+        Rdatas within the Rdataset will be shuffled before rendering.
+
+        Returns an ``int``, the number of records emitted.
         """
 
         if override_rdclass is not None:
@@ -272,8 +288,9 @@ class Rdataset(dns.set.Set):
             return len(self)
 
     def match(self, rdclass, rdtype, covers):
-        """Returns True if this rdataset matches the specified class, type,
-        and covers"""
+        """Returns ``True`` if this rdataset matches the specified class,
+        type, and covers.
+        """
         if self.rdclass == rdclass and \
            self.rdtype == rdtype and \
            self.covers == covers:
@@ -281,21 +298,23 @@ class Rdataset(dns.set.Set):
         return False
 
 
-def from_text_list(rdclass, rdtype, ttl, text_rdatas):
+def from_text_list(rdclass, rdtype, ttl, text_rdatas, idna_codec=None):
     """Create an rdataset with the specified class, type, and TTL, and with
     the specified list of rdatas in text format.
 
-    @rtype: dns.rdataset.Rdataset object
+    *idna_codec*, a ``dns.name.IDNACodec``, specifies the IDNA
+    encoder/decoder to use; if ``None``, the default IDNA 2003
+    encoder/decoder is used.
+
+    Returns a ``dns.rdataset.Rdataset`` object.
     """
 
-    if isinstance(rdclass, string_types):
-        rdclass = dns.rdataclass.from_text(rdclass)
-    if isinstance(rdtype, string_types):
-        rdtype = dns.rdatatype.from_text(rdtype)
+    rdclass = dns.rdataclass.RdataClass.make(rdclass)
+    rdtype = dns.rdatatype.RdataType.make(rdtype)
     r = Rdataset(rdclass, rdtype)
     r.update_ttl(ttl)
     for t in text_rdatas:
-        rd = dns.rdata.from_text(r.rdclass, r.rdtype, t)
+        rd = dns.rdata.from_text(r.rdclass, r.rdtype, t, idna_codec=idna_codec)
         r.add(rd)
     return r
 
@@ -304,7 +323,7 @@ def from_text(rdclass, rdtype, ttl, *text_rdatas):
     """Create an rdataset with the specified class, type, and TTL, and with
     the specified rdatas in text format.
 
-    @rtype: dns.rdataset.Rdataset object
+    Returns a ``dns.rdataset.Rdataset`` object.
     """
 
     return from_text_list(rdclass, rdtype, ttl, text_rdatas)
@@ -314,7 +333,7 @@ def from_rdata_list(ttl, rdatas):
     """Create an rdataset with the specified TTL, and with
     the specified list of rdata objects.
 
-    @rtype: dns.rdataset.Rdataset object
+    Returns a ``dns.rdataset.Rdataset`` object.
     """
 
     if len(rdatas) == 0:
@@ -332,7 +351,7 @@ def from_rdata(ttl, *rdatas):
     """Create an rdataset with the specified TTL, and with
     the specified rdata objects.
 
-    @rtype: dns.rdataset.Rdataset object
+    Returns a ``dns.rdataset.Rdataset`` object.
     """
 
     return from_rdata_list(ttl, rdatas)

lib/dns/rdatatype.py

@@ -1,4 +1,6 @@
-# Copyright (C) 2001-2007, 2009-2011 Nominum, Inc.
+# 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,
@@ -13,23 +15,14 @@
 # ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
 # OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
-"""DNS Rdata Types.
-
-@var _by_text: The rdata type textual name to value mapping
-@type _by_text: dict
-@var _by_value: The rdata type value to textual name mapping
-@type _by_value: dict
-@var _metatypes: If an rdatatype is a metatype, there will be a mapping
-whose key is the rdatatype value and whose value is True in this dictionary.
-@type _metatypes: dict
-@var _singletons: If an rdatatype is a singleton, there will be a mapping
-whose key is the rdatatype value and whose value is True in this dictionary.
-@type _singletons: dict"""
-
-import re
+"""DNS Rdata Types."""
 
+import dns.enum
 import dns.exception
 
+class RdataType(dns.enum.IntEnum):
+    """DNS Rdata Type"""
+    TYPE0 = 0
     NONE = 0
     A = 1
     NS = 2
@@ -80,8 +73,10 @@ NSEC3 = 50
     NSEC3PARAM = 51
     TLSA = 52
     HIP = 55
+    NINFO = 56
     CDS = 59
     CDNSKEY = 60
+    OPENPGPKEY = 61
     CSYNC = 62
     SPF = 99
     UNSPEC = 103
@@ -96,158 +91,131 @@ MAILA = 254
     ANY = 255
     URI = 256
     CAA = 257
+    AVC = 258
+    AMTRELAY = 259
     TA = 32768
     DLV = 32769
 
-_by_text = {
-    'NONE': NONE,
-    'A': A,
-    'NS': NS,
-    'MD': MD,
-    'MF': MF,
-    'CNAME': CNAME,
-    'SOA': SOA,
-    'MB': MB,
-    'MG': MG,
-    'MR': MR,
-    'NULL': NULL,
-    'WKS': WKS,
-    'PTR': PTR,
-    'HINFO': HINFO,
-    'MINFO': MINFO,
-    'MX': MX,
-    'TXT': TXT,
-    'RP': RP,
-    'AFSDB': AFSDB,
-    'X25': X25,
-    'ISDN': ISDN,
-    'RT': RT,
-    'NSAP': NSAP,
-    'NSAP-PTR': NSAP_PTR,
-    'SIG': SIG,
-    'KEY': KEY,
-    'PX': PX,
-    'GPOS': GPOS,
-    'AAAA': AAAA,
-    'LOC': LOC,
-    'NXT': NXT,
-    'SRV': SRV,
-    'NAPTR': NAPTR,
-    'KX': KX,
-    'CERT': CERT,
-    'A6': A6,
-    'DNAME': DNAME,
-    'OPT': OPT,
-    'APL': APL,
-    'DS': DS,
-    'SSHFP': SSHFP,
-    'IPSECKEY': IPSECKEY,
-    'RRSIG': RRSIG,
-    'NSEC': NSEC,
-    'DNSKEY': DNSKEY,
-    'DHCID': DHCID,
-    'NSEC3': NSEC3,
-    'NSEC3PARAM': NSEC3PARAM,
-    'TLSA': TLSA,
-    'HIP': HIP,
-    'CDS': CDS,
-    'CDNSKEY': CDNSKEY,
-    'CSYNC': CSYNC,
-    'SPF': SPF,
-    'UNSPEC': UNSPEC,
-    'EUI48': EUI48,
-    'EUI64': EUI64,
-    'TKEY': TKEY,
-    'TSIG': TSIG,
-    'IXFR': IXFR,
-    'AXFR': AXFR,
-    'MAILB': MAILB,
-    'MAILA': MAILA,
-    'ANY': ANY,
-    'URI': URI,
-    'CAA': CAA,
-    'TA': TA,
-    'DLV': DLV,
-}
+    @classmethod
+    def _maximum(cls):
+        return 65535
 
-# We construct the inverse mapping programmatically to ensure that we
-# cannot make any mistakes (e.g. omissions, cut-and-paste errors) that
-# would cause the mapping not to be true inverse.
+    @classmethod
+    def _short_name(cls):
+        return "type"
 
-_by_value = dict((y, x) for x, y in _by_text.items())
+    @classmethod
+    def _prefix(cls):
+        return "TYPE"
 
+    @classmethod
+    def _unknown_exception_class(cls):
+        return UnknownRdatatype
 
-_metatypes = {
-    OPT: True
-}
+_registered_by_text = {}
+_registered_by_value = {}
 
-_singletons = {
-    SOA: True,
-    NXT: True,
-    DNAME: True,
-    NSEC: True,
-    # CNAME is technically a singleton, but we allow multiple CNAMEs.
-}
+globals().update(RdataType.__members__)
 
-_unknown_type_pattern = re.compile('TYPE([0-9]+)$', re.I)
+_metatypes = {RdataType.OPT}
+
+_singletons = {RdataType.SOA, RdataType.NXT, RdataType.DNAME,
+               RdataType.NSEC, RdataType.CNAME}
 
 
 class UnknownRdatatype(dns.exception.DNSException):
-
     """DNS resource record type is unknown."""
 
 
 def from_text(text):
     """Convert text into a DNS rdata type value.
-    @param text: the text
-    @type text: string
-    @raises dns.rdatatype.UnknownRdatatype: the type is unknown
-    @raises ValueError: the rdata type value is not >= 0 and <= 65535
-    @rtype: int"""
 
-    value = _by_text.get(text.upper())
-    if value is None:
-        match = _unknown_type_pattern.match(text)
-        if match is None:
-            raise UnknownRdatatype
-        value = int(match.group(1))
-        if value < 0 or value > 65535:
-            raise ValueError("type must be between >= 0 and <= 65535")
-    return value
+    The input text can be a defined DNS RR type mnemonic or
+    instance of the DNS generic type syntax.
+
+    For example, "NS" and "TYPE2" will both result in a value of 2.
+
+    Raises ``dns.rdatatype.UnknownRdatatype`` if the type is unknown.
+
+    Raises ``ValueError`` if the rdata type value is not >= 0 and <= 65535.
+
+    Returns an ``int``.
+    """
+
+    text = text.upper().replace('-', '_')
+    try:
+        return RdataType.from_text(text)
+    except UnknownRdatatype:
+        registered_type = _registered_by_text.get(text)
+        if registered_type:
+            return registered_type
+        raise
 
 
 def to_text(value):
-    """Convert a DNS rdata type to text.
-    @param value: the rdata type value
-    @type value: int
-    @raises ValueError: the rdata type value is not >= 0 and <= 65535
-    @rtype: string"""
+    """Convert a DNS rdata type value to text.
 
-    if value < 0 or value > 65535:
-        raise ValueError("type must be between >= 0 and <= 65535")
-    text = _by_value.get(value)
-    if text is None:
-        text = 'TYPE' + repr(value)
-    return text
+    If the value has a known mnemonic, it will be used, otherwise the
+    DNS generic type syntax will be used.
+
+    Raises ``ValueError`` if the rdata type value is not >= 0 and <= 65535.
+
+    Returns a ``str``.
+    """
+
+    text = RdataType.to_text(value)
+    if text.startswith("TYPE"):
+        registered_text = _registered_by_value.get(value)
+        if registered_text:
+            text = registered_text
+    return text.replace('_', '-')
 
 
 def is_metatype(rdtype):
-    """True if the type is a metatype.
-    @param rdtype: the type
-    @type rdtype: int
-    @rtype: bool"""
+    """True if the specified type is a metatype.
 
-    if rdtype >= TKEY and rdtype <= ANY or rdtype in _metatypes:
-        return True
-    return False
+    *rdtype* is an ``int``.
+
+    The currently defined metatypes are TKEY, TSIG, IXFR, AXFR, MAILA,
+    MAILB, ANY, and OPT.
+
+    Returns a ``bool``.
+    """
+
+    return (256 > rdtype >= 128) or rdtype in _metatypes
 
 
 def is_singleton(rdtype):
-    """True if the type is a singleton.
-    @param rdtype: the type
-    @type rdtype: int
-    @rtype: bool"""
+    """Is the specified type a singleton type?
+
+    Singleton types can only have a single rdata in an rdataset, or a single
+    RR in an RRset.
+
+    The currently defined singleton types are CNAME, DNAME, NSEC, NXT, and
+    SOA.
+
+    *rdtype* is an ``int``.
+
+    Returns a ``bool``.
+    """
 
     if rdtype in _singletons:
         return True
     return False
+
+# pylint: disable=redefined-outer-name
+def register_type(rdtype, rdtype_text, is_singleton=False):
+    """Dynamically register an rdatatype.
+
+    *rdtype*, an ``int``, the rdatatype to register.
+
+    *rdtype_text*, a ``str``, the textual form of the rdatatype.
+
+    *is_singleton*, a ``bool``, indicating if the type is a singleton (i.e.
+    RRsets of the type can have only one member.)
+    """
+
+    _registered_by_text[rdtype_text] = rdtype
+    _registered_by_value[rdtype] = rdtype_text
+    if is_singleton:
+        _singletons.add(rdtype)

lib/dns/rdtypes/ANY/AFSDB.py

@@ -1,3 +1,5 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
 # Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
 #
 # Permission to use, copy, modify, and distribute this software and its
@@ -18,12 +20,7 @@ import dns.rdtypes.mxbase
 
 class AFSDB(dns.rdtypes.mxbase.UncompressedDowncasingMX):
 
-    """AFSDB record
-
-    @ivar subtype: the subtype value
-    @type subtype: int
-    @ivar hostname: the hostname name
-    @type hostname: dns.name.Name object"""
+    """AFSDB record"""
 
     # Use the property mechanism to make "subtype" an alias for the
     # "preference" attribute, and "hostname" an alias for the "exchange"
@@ -36,18 +33,12 @@ class AFSDB(dns.rdtypes.mxbase.UncompressedDowncasingMX):
     # implementation, but this way we don't copy code, and that's
     # good.
 
-    def get_subtype(self):
+    @property
+    def subtype(self):
+        "the AFSDB subtype"
         return self.preference
 
-    def set_subtype(self, subtype):
-        self.preference = subtype
-
-    subtype = property(get_subtype, set_subtype)
-
-    def get_hostname(self):
+    @property
+    def hostname(self):
+        "the AFSDB hostname"
         return self.exchange
-
-    def set_hostname(self, hostname):
-        self.exchange = hostname
-
-    hostname = property(get_hostname, set_hostname)

lib/dns/rdtypes/ANY/AMTRELAY.py

@@ -0,0 +1,79 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
+# Copyright (C) 2006, 2007, 2009-2011 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.
+
+import struct
+
+import dns.exception
+import dns.rdtypes.util
+
+
+class Relay(dns.rdtypes.util.Gateway):
+    name = 'AMTRELAY relay'
+
+class AMTRELAY(dns.rdata.Rdata):
+
+    """AMTRELAY record"""
+
+    # see: RFC 8777
+
+    __slots__ = ['precedence', 'discovery_optional', 'relay_type', 'relay']
+
+    def __init__(self, rdclass, rdtype, precedence, discovery_optional,
+                 relay_type, relay):
+        super().__init__(rdclass, rdtype)
+        Relay(relay_type, relay).check()
+        object.__setattr__(self, 'precedence', precedence)
+        object.__setattr__(self, 'discovery_optional', discovery_optional)
+        object.__setattr__(self, 'relay_type', relay_type)
+        object.__setattr__(self, 'relay', relay)
+
+    def to_text(self, origin=None, relativize=True, **kw):
+        relay = Relay(self.relay_type, self.relay).to_text(origin, relativize)
+        return '%d %d %d %s' % (self.precedence, self.discovery_optional,
+                                self.relay_type, relay)
+
+    @classmethod
+    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+                  relativize_to=None):
+        precedence = tok.get_uint8()
+        discovery_optional = tok.get_uint8()
+        if discovery_optional > 1:
+            raise dns.exception.SyntaxError('expecting 0 or 1')
+        discovery_optional = bool(discovery_optional)
+        relay_type = tok.get_uint8()
+        if relay_type > 0x7f:
+            raise dns.exception.SyntaxError('expecting an integer <= 127')
+        relay = Relay(relay_type).from_text(tok, origin, relativize,
+                                            relativize_to)
+        return cls(rdclass, rdtype, precedence, discovery_optional, relay_type,
+                   relay)
+
+    def _to_wire(self, file, compress=None, origin=None, canonicalize=False):
+        relay_type = self.relay_type | (self.discovery_optional << 7)
+        header = struct.pack("!BB", self.precedence, relay_type)
+        file.write(header)
+        Relay(self.relay_type, self.relay).to_wire(file, compress, origin,
+                                                   canonicalize)
+
+    @classmethod
+    def from_wire_parser(cls, rdclass, rdtype, parser, origin=None):
+        (precedence, relay_type) = parser.get_struct('!BB')
+        discovery_optional = bool(relay_type >> 7)
+        relay_type &= 0x7f
+        relay = Relay(relay_type).from_wire_parser(parser, origin)
+        return cls(rdclass, rdtype, precedence, discovery_optional, relay_type,
+                   relay)

lib/dns/rdtypes/ANY/AVC.py

@@ -1,4 +1,6 @@
-# Copyright (C) 2011 Nominum, Inc.
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
+# Copyright (C) 2016 Nominum, Inc.
 #
 # Permission to use, copy, modify, and distribute this software and its
 # documentation for any purpose with or without fee is hereby granted,
@@ -13,20 +15,11 @@
 # ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
 # OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
-"""Hashing backwards compatibility wrapper"""
-
-import sys
-import hashlib
+import dns.rdtypes.txtbase
 
 
-hashes = {}
-hashes['MD5'] = hashlib.md5
-hashes['SHA1'] = hashlib.sha1
-hashes['SHA224'] = hashlib.sha224
-hashes['SHA256'] = hashlib.sha256
-hashes['SHA384'] = hashlib.sha384
-hashes['SHA512'] = hashlib.sha512
+class AVC(dns.rdtypes.txtbase.TXTBase):
 
+    """AVC record"""
 
-def get(algorithm):
-    return hashes[algorithm.upper()]
+    # See: IANA dns parameters for AVC

lib/dns/rdtypes/ANY/CAA.py

@@ -1,3 +1,5 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
 # Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
 #
 # Permission to use, copy, modify, and distribute this software and its
@@ -22,23 +24,17 @@ import dns.tokenizer
 
 class CAA(dns.rdata.Rdata):
 
-    """CAA (Certification Authority Authorization) record
+    """CAA (Certification Authority Authorization) record"""
 
-    @ivar flags: the flags
-    @type flags: int
-    @ivar tag: the tag
-    @type tag: string
-    @ivar value: the value
-    @type value: string
-    @see: RFC 6844"""
+    # see: RFC 6844
 
     __slots__ = ['flags', 'tag', 'value']
 
     def __init__(self, rdclass, rdtype, flags, tag, value):
-        super(CAA, self).__init__(rdclass, rdtype)
-        self.flags = flags
-        self.tag = tag
-        self.value = value
+        super().__init__(rdclass, rdtype)
+        object.__setattr__(self, 'flags', flags)
+        object.__setattr__(self, 'tag', tag)
+        object.__setattr__(self, 'value', value)
 
     def to_text(self, origin=None, relativize=True, **kw):
         return '%u %s "%s"' % (self.flags,
@@ -46,7 +42,8 @@ class CAA(dns.rdata.Rdata):
                                dns.rdata._escapify(self.value))
 
     @classmethod
-    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+                  relativize_to=None):
         flags = tok.get_uint8()
         tag = tok.get_string().encode()
         if len(tag) > 255:
@@ -56,7 +53,7 @@ class CAA(dns.rdata.Rdata):
         value = tok.get_string().encode()
         return cls(rdclass, rdtype, flags, tag, value)
 
-    def to_wire(self, file, compress=None, origin=None):
+    def _to_wire(self, file, compress=None, origin=None, canonicalize=False):
         file.write(struct.pack('!B', self.flags))
         l = len(self.tag)
         assert l < 256
@@ -65,10 +62,8 @@ class CAA(dns.rdata.Rdata):
         file.write(self.value)
 
     @classmethod
-    def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin=None):
-        (flags, l) = struct.unpack('!BB', wire[current: current + 2])
-        current += 2
-        tag = wire[current: current + l]
-        value = wire[current + l:current + rdlen - 2]
+    def from_wire_parser(cls, rdclass, rdtype, parser, origin=None):
+        flags = parser.get_uint8()
+        tag = parser.get_counted_bytes()
+        value = parser.get_remaining()
         return cls(rdclass, rdtype, flags, tag, value)
-

lib/dns/rdtypes/ANY/CDNSKEY.py

@@ -1,3 +1,5 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
 # Copyright (C) 2004-2007, 2009-2011 Nominum, Inc.
 #
 # Permission to use, copy, modify, and distribute this software and its
@@ -14,10 +16,7 @@
 # OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
 import dns.rdtypes.dnskeybase
-from dns.rdtypes.dnskeybase import flags_to_text_set, flags_from_text_set
-
-
-__all__ = ['flags_to_text_set', 'flags_from_text_set']
+from dns.rdtypes.dnskeybase import SEP, REVOKE, ZONE  # noqa: F401
 
 
 class CDNSKEY(dns.rdtypes.dnskeybase.DNSKEYBase):

lib/dns/rdtypes/ANY/CDS.py

@@ -1,3 +1,5 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
 # Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
 #
 # Permission to use, copy, modify, and distribute this software and its

lib/dns/rdtypes/ANY/CERT.py

@@ -1,3 +1,5 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
 # Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
 #
 # Permission to use, copy, modify, and distribute this software and its
@@ -54,27 +56,19 @@ def _ctype_to_text(what):
 
 class CERT(dns.rdata.Rdata):
 
-    """CERT record
+    """CERT record"""
 
-    @ivar certificate_type: certificate type
-    @type certificate_type: int
-    @ivar key_tag: key tag
-    @type key_tag: int
-    @ivar algorithm: algorithm
-    @type algorithm: int
-    @ivar certificate: the certificate or CRL
-    @type certificate: string
-    @see: RFC 2538"""
+    # see RFC 2538
 
     __slots__ = ['certificate_type', 'key_tag', 'algorithm', 'certificate']
 
     def __init__(self, rdclass, rdtype, certificate_type, key_tag, algorithm,
                  certificate):
-        super(CERT, self).__init__(rdclass, rdtype)
-        self.certificate_type = certificate_type
-        self.key_tag = key_tag
-        self.algorithm = algorithm
-        self.certificate = certificate
+        super().__init__(rdclass, rdtype)
+        object.__setattr__(self, 'certificate_type', certificate_type)
+        object.__setattr__(self, 'key_tag', key_tag)
+        object.__setattr__(self, 'algorithm', algorithm)
+        object.__setattr__(self, 'certificate', certificate)
 
     def to_text(self, origin=None, relativize=True, **kw):
         certificate_type = _ctype_to_text(self.certificate_type)
@@ -83,40 +77,27 @@ class CERT(dns.rdata.Rdata):
                                 dns.rdata._base64ify(self.certificate))
 
     @classmethod
-    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+                  relativize_to=None):
         certificate_type = _ctype_from_text(tok.get_string())
         key_tag = tok.get_uint16()
         algorithm = dns.dnssec.algorithm_from_text(tok.get_string())
         if algorithm < 0 or algorithm > 255:
             raise dns.exception.SyntaxError("bad algorithm type")
-        chunks = []
-        while 1:
-            t = tok.get().unescape()
-            if t.is_eol_or_eof():
-                break
-            if not t.is_identifier():
-                raise dns.exception.SyntaxError
-            chunks.append(t.value.encode())
-        b64 = b''.join(chunks)
+        b64 = tok.concatenate_remaining_identifiers().encode()
         certificate = base64.b64decode(b64)
         return cls(rdclass, rdtype, certificate_type, key_tag,
                    algorithm, certificate)
 
-    def to_wire(self, file, compress=None, origin=None):
+    def _to_wire(self, file, compress=None, origin=None, canonicalize=False):
         prefix = struct.pack("!HHB", self.certificate_type, self.key_tag,
                              self.algorithm)
         file.write(prefix)
         file.write(self.certificate)
 
     @classmethod
-    def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin=None):
-        prefix = wire[current: current + 5].unwrap()
-        current += 5
-        rdlen -= 5
-        if rdlen < 0:
-            raise dns.exception.FormError
-        (certificate_type, key_tag, algorithm) = struct.unpack("!HHB", prefix)
-        certificate = wire[current: current + rdlen].unwrap()
+    def from_wire_parser(cls, rdclass, rdtype, parser, origin=None):
+        (certificate_type, key_tag, algorithm) = parser.get_struct("!HHB")
+        certificate = parser.get_remaining()
         return cls(rdclass, rdtype, certificate_type, key_tag, algorithm,
                    certificate)
-

lib/dns/rdtypes/ANY/CNAME.py

@@ -1,3 +1,5 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
 # Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
 #
 # Permission to use, copy, modify, and distribute this software and its

lib/dns/rdtypes/ANY/CSYNC.py

@@ -1,3 +1,5 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
 # Copyright (C) 2004-2007, 2009-2011, 2016 Nominum, Inc.
 #
 # Permission to use, copy, modify, and distribute this software and its
@@ -19,106 +21,43 @@ import dns.exception
 import dns.rdata
 import dns.rdatatype
 import dns.name
-from dns._compat import xrange
+import dns.rdtypes.util
+
+
+class Bitmap(dns.rdtypes.util.Bitmap):
+    type_name = 'CSYNC'
+
 
 class CSYNC(dns.rdata.Rdata):
 
-    """CSYNC record
-
-    @ivar serial: the SOA serial number
-    @type serial: int
-    @ivar flags: the CSYNC flags
-    @type flags: int
-    @ivar windows: the windowed bitmap list
-    @type windows: list of (window number, string) tuples"""
+    """CSYNC record"""
 
     __slots__ = ['serial', 'flags', 'windows']
 
     def __init__(self, rdclass, rdtype, serial, flags, windows):
-        super(CSYNC, self).__init__(rdclass, rdtype)
-        self.serial = serial
-        self.flags = flags
-        self.windows = windows
+        super().__init__(rdclass, rdtype)
+        object.__setattr__(self, 'serial', serial)
+        object.__setattr__(self, 'flags', flags)
+        object.__setattr__(self, 'windows', dns.rdata._constify(windows))
 
     def to_text(self, origin=None, relativize=True, **kw):
-        text = ''
-        for (window, bitmap) in self.windows:
-            bits = []
-            for i in xrange(0, len(bitmap)):
-                byte = bitmap[i]
-                for j in xrange(0, 8):
-                    if byte & (0x80 >> j):
-                        bits.append(dns.rdatatype.to_text(window * 256 +
-                                                          i * 8 + j))
-            text += (' ' + ' '.join(bits))
+        text = Bitmap(self.windows).to_text()
         return '%d %d%s' % (self.serial, self.flags, text)
 
     @classmethod
-    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+                  relativize_to=None):
         serial = tok.get_uint32()
         flags = tok.get_uint16()
-        rdtypes = []
-        while 1:
-            token = tok.get().unescape()
-            if token.is_eol_or_eof():
-                break
-            nrdtype = dns.rdatatype.from_text(token.value)
-            if nrdtype == 0:
-                raise dns.exception.SyntaxError("CSYNC with bit 0")
-            if nrdtype > 65535:
-                raise dns.exception.SyntaxError("CSYNC with bit > 65535")
-            rdtypes.append(nrdtype)
-        rdtypes.sort()
-        window = 0
-        octets = 0
-        prior_rdtype = 0
-        bitmap = bytearray(b'\0' * 32)
-        windows = []
-        for nrdtype in rdtypes:
-            if nrdtype == prior_rdtype:
-                continue
-            prior_rdtype = nrdtype
-            new_window = nrdtype // 256
-            if new_window != window:
-                windows.append((window, bitmap[0:octets]))
-                bitmap = bytearray(b'\0' * 32)
-                window = new_window
-            offset = nrdtype % 256
-            byte = offset // 8
-            bit = offset % 8
-            octets = byte + 1
-            bitmap[byte] = bitmap[byte] | (0x80 >> bit)
-
-        windows.append((window, bitmap[0:octets]))
+        windows = Bitmap().from_text(tok)
         return cls(rdclass, rdtype, serial, flags, windows)
 
-    def to_wire(self, file, compress=None, origin=None):
+    def _to_wire(self, file, compress=None, origin=None, canonicalize=False):
         file.write(struct.pack('!IH', self.serial, self.flags))
-        for (window, bitmap) in self.windows:
-            file.write(struct.pack('!BB', window, len(bitmap)))
-            file.write(bitmap)
+        Bitmap(self.windows).to_wire(file)
 
     @classmethod
-    def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin=None):
-        if rdlen < 6:
-            raise dns.exception.FormError("CSYNC too short")
-        (serial, flags) = struct.unpack("!IH", wire[current: current + 6])
-        current += 6
-        rdlen -= 6
-        windows = []
-        while rdlen > 0:
-            if rdlen < 3:
-                raise dns.exception.FormError("CSYNC too short")
-            window = wire[current]
-            octets = wire[current + 1]
-            if octets == 0 or octets > 32:
-                raise dns.exception.FormError("bad CSYNC octets")
-            current += 2
-            rdlen -= 2
-            if rdlen < octets:
-                raise dns.exception.FormError("bad CSYNC bitmap length")
-            bitmap = bytearray(wire[current: current + octets].unwrap())
-            current += octets
-            rdlen -= octets
-            windows.append((window, bitmap))
+    def from_wire_parser(cls, rdclass, rdtype, parser, origin=None):
+        (serial, flags) = parser.get_struct("!IH")
+        windows = Bitmap().from_wire_parser(parser)
         return cls(rdclass, rdtype, serial, flags, windows)

lib/dns/rdtypes/ANY/DLV.py

@@ -1,3 +1,5 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
 # Copyright (C) 2009-2011 Nominum, Inc.
 #
 # Permission to use, copy, modify, and distribute this software and its

lib/dns/rdtypes/ANY/DNAME.py

@@ -1,3 +1,5 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
 # Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
 #
 # Permission to use, copy, modify, and distribute this software and its
@@ -20,5 +22,5 @@ class DNAME(dns.rdtypes.nsbase.UncompressedNS):
 
     """DNAME record"""
 
-    def to_digestable(self, origin=None):
-        return self.target.to_digestable(origin)
+    def _to_wire(self, file, compress=None, origin=None, canonicalize=False):
+        self.target.to_wire(file, None, origin, canonicalize)

lib/dns/rdtypes/ANY/DNSKEY.py

@@ -1,3 +1,5 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
 # Copyright (C) 2004-2007, 2009-2011 Nominum, Inc.
 #
 # Permission to use, copy, modify, and distribute this software and its
@@ -14,10 +16,7 @@
 # OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
 import dns.rdtypes.dnskeybase
-from dns.rdtypes.dnskeybase import flags_to_text_set, flags_from_text_set
-
-
-__all__ = ['flags_to_text_set', 'flags_from_text_set']
+from dns.rdtypes.dnskeybase import SEP, REVOKE, ZONE  # noqa: F401
 
 
 class DNSKEY(dns.rdtypes.dnskeybase.DNSKEYBase):

lib/dns/rdtypes/ANY/DS.py

@@ -1,3 +1,5 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
 # Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
 #
 # Permission to use, copy, modify, and distribute this software and its

lib/dns/rdtypes/ANY/EUI48.py

@@ -1,3 +1,5 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
 # Copyright (C) 2015 Red Hat, Inc.
 # Author: Petr Spacek <pspacek@redhat.com>
 #
@@ -19,11 +21,9 @@ import dns.rdtypes.euibase
 
 class EUI48(dns.rdtypes.euibase.EUIBase):
 
-    """EUI48 record
+    """EUI48 record"""
 
-    @ivar fingerprint: 48-bit Extended Unique Identifier (EUI-48)
-    @type fingerprint: string
-    @see: rfc7043.txt"""
+    # see: rfc7043.txt
 
     byte_len = 6  # 0123456789ab (in hex)
     text_len = byte_len * 3 - 1  # 01-23-45-67-89-ab

lib/dns/rdtypes/ANY/EUI64.py

@@ -1,3 +1,5 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
 # Copyright (C) 2015 Red Hat, Inc.
 # Author: Petr Spacek <pspacek@redhat.com>
 #
@@ -19,11 +21,9 @@ import dns.rdtypes.euibase
 
 class EUI64(dns.rdtypes.euibase.EUIBase):
 
-    """EUI64 record
+    """EUI64 record"""
 
-    @ivar fingerprint: 64-bit Extended Unique Identifier (EUI-64)
-    @type fingerprint: string
-    @see: rfc7043.txt"""
+    # see: rfc7043.txt
 
     byte_len = 8  # 0123456789abcdef (in hex)
     text_len = byte_len * 3 - 1  # 01-23-45-67-89-ab-cd-ef

lib/dns/rdtypes/ANY/GPOS.py

@@ -1,3 +1,5 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
 # Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
 #
 # Permission to use, copy, modify, and distribute this software and its
@@ -18,15 +20,19 @@ import struct
 import dns.exception
 import dns.rdata
 import dns.tokenizer
-from dns._compat import long, text_type
 
 
 def _validate_float_string(what):
+    if len(what) == 0:
+        raise dns.exception.FormError
     if what[0] == b'-'[0] or what[0] == b'+'[0]:
         what = what[1:]
     if what.isdigit():
         return
+    try:
         (left, right) = what.split(b'.')
+    except ValueError:
+        raise dns.exception.FormError
     if left == b'' and right == b'':
         raise dns.exception.FormError
     if not left == b'' and not left.decode().isdigit():
@@ -36,38 +42,29 @@ def _validate_float_string(what):
 
 
 def _sanitize(value):
-    if isinstance(value, text_type):
+    if isinstance(value, str):
         return value.encode()
     return value
 
 
 class GPOS(dns.rdata.Rdata):
 
-    """GPOS record
+    """GPOS record"""
 
-    @ivar latitude: latitude
-    @type latitude: string
-    @ivar longitude: longitude
-    @type longitude: string
-    @ivar altitude: altitude
-    @type altitude: string
-    @see: RFC 1712"""
+    # see: RFC 1712
 
     __slots__ = ['latitude', 'longitude', 'altitude']
 
     def __init__(self, rdclass, rdtype, latitude, longitude, altitude):
-        super(GPOS, self).__init__(rdclass, rdtype)
+        super().__init__(rdclass, rdtype)
         if isinstance(latitude, float) or \
-           isinstance(latitude, int) or \
-           isinstance(latitude, long):
+           isinstance(latitude, int):
             latitude = str(latitude)
         if isinstance(longitude, float) or \
-           isinstance(longitude, int) or \
-           isinstance(longitude, long):
+           isinstance(longitude, int):
             longitude = str(longitude)
         if isinstance(altitude, float) or \
-           isinstance(altitude, int) or \
-           isinstance(altitude, long):
+           isinstance(altitude, int):
             altitude = str(altitude)
         latitude = _sanitize(latitude)
         longitude = _sanitize(longitude)
@@ -75,24 +72,31 @@ class GPOS(dns.rdata.Rdata):
         _validate_float_string(latitude)
         _validate_float_string(longitude)
         _validate_float_string(altitude)
-        self.latitude = latitude
-        self.longitude = longitude
-        self.altitude = altitude
+        object.__setattr__(self, 'latitude', latitude)
+        object.__setattr__(self, 'longitude', longitude)
+        object.__setattr__(self, 'altitude', altitude)
+        flat = self.float_latitude
+        if flat < -90.0 or flat > 90.0:
+            raise dns.exception.FormError('bad latitude')
+        flong = self.float_longitude
+        if flong < -180.0 or flong > 180.0:
+            raise dns.exception.FormError('bad longitude')
 
     def to_text(self, origin=None, relativize=True, **kw):
-        return '%s %s %s' % (self.latitude.decode(),
+        return '{} {} {}'.format(self.latitude.decode(),
                                  self.longitude.decode(),
                                  self.altitude.decode())
 
     @classmethod
-    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+                  relativize_to=None):
         latitude = tok.get_string()
         longitude = tok.get_string()
         altitude = tok.get_string()
         tok.get_eol()
         return cls(rdclass, rdtype, latitude, longitude, altitude)
 
-    def to_wire(self, file, compress=None, origin=None):
+    def _to_wire(self, file, compress=None, origin=None, canonicalize=False):
         l = len(self.latitude)
         assert l < 256
         file.write(struct.pack('!B', l))
@@ -107,54 +111,23 @@ class GPOS(dns.rdata.Rdata):
         file.write(self.altitude)
 
     @classmethod
-    def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin=None):
-        l = wire[current]
-        current += 1
-        rdlen -= 1
-        if l > rdlen:
-            raise dns.exception.FormError
-        latitude = wire[current: current + l].unwrap()
-        current += l
-        rdlen -= l
-        l = wire[current]
-        current += 1
-        rdlen -= 1
-        if l > rdlen:
-            raise dns.exception.FormError
-        longitude = wire[current: current + l].unwrap()
-        current += l
-        rdlen -= l
-        l = wire[current]
-        current += 1
-        rdlen -= 1
-        if l != rdlen:
-            raise dns.exception.FormError
-        altitude = wire[current: current + l].unwrap()
+    def from_wire_parser(cls, rdclass, rdtype, parser, origin=None):
+        latitude = parser.get_counted_bytes()
+        longitude = parser.get_counted_bytes()
+        altitude = parser.get_counted_bytes()
         return cls(rdclass, rdtype, latitude, longitude, altitude)
 
-    def _get_float_latitude(self):
+    @property
+    def float_latitude(self):
+        "latitude as a floating point value"
         return float(self.latitude)
 
-    def _set_float_latitude(self, value):
-        self.latitude = str(value)
-
-    float_latitude = property(_get_float_latitude, _set_float_latitude,
-                              doc="latitude as a floating point value")
-
-    def _get_float_longitude(self):
+    @property
+    def float_longitude(self):
+        "longitude as a floating point value"
         return float(self.longitude)
 
-    def _set_float_longitude(self, value):
-        self.longitude = str(value)
-
-    float_longitude = property(_get_float_longitude, _set_float_longitude,
-                               doc="longitude as a floating point value")
-
-    def _get_float_altitude(self):
+    @property
+    def float_altitude(self):
+        "altitude as a floating point value"
         return float(self.altitude)
-
-    def _set_float_altitude(self, value):
-        self.altitude = str(value)
-
-    float_altitude = property(_get_float_altitude, _set_float_altitude,
-                              doc="altitude as a floating point value")

lib/dns/rdtypes/ANY/HINFO.py

@@ -1,3 +1,5 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
 # Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
 #
 # Permission to use, copy, modify, and distribute this software and its
@@ -18,44 +20,40 @@ import struct
 import dns.exception
 import dns.rdata
 import dns.tokenizer
-from dns._compat import text_type
 
 
 class HINFO(dns.rdata.Rdata):
 
-    """HINFO record
+    """HINFO record"""
 
-    @ivar cpu: the CPU type
-    @type cpu: string
-    @ivar os: the OS type
-    @type os: string
-    @see: RFC 1035"""
+    # see: RFC 1035
 
     __slots__ = ['cpu', 'os']
 
     def __init__(self, rdclass, rdtype, cpu, os):
-        super(HINFO, self).__init__(rdclass, rdtype)
-        if isinstance(cpu, text_type):
-            self.cpu = cpu.encode()
+        super().__init__(rdclass, rdtype)
+        if isinstance(cpu, str):
+            object.__setattr__(self, 'cpu', cpu.encode())
         else:
-            self.cpu = cpu
-        if isinstance(os, text_type):
-            self.os = os.encode()
+            object.__setattr__(self, 'cpu', cpu)
+        if isinstance(os, str):
+            object.__setattr__(self, 'os', os.encode())
         else:
-            self.os = os
+            object.__setattr__(self, 'os', os)
 
     def to_text(self, origin=None, relativize=True, **kw):
-        return '"%s" "%s"' % (dns.rdata._escapify(self.cpu),
+        return '"{}" "{}"'.format(dns.rdata._escapify(self.cpu),
                                   dns.rdata._escapify(self.os))
 
     @classmethod
-    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
-        cpu = tok.get_string()
-        os = tok.get_string()
+    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+                  relativize_to=None):
+        cpu = tok.get_string(max_length=255)
+        os = tok.get_string(max_length=255)
         tok.get_eol()
         return cls(rdclass, rdtype, cpu, os)
 
-    def to_wire(self, file, compress=None, origin=None):
+    def _to_wire(self, file, compress=None, origin=None, canonicalize=False):
         l = len(self.cpu)
         assert l < 256
         file.write(struct.pack('!B', l))
@@ -66,20 +64,7 @@ class HINFO(dns.rdata.Rdata):
         file.write(self.os)
 
     @classmethod
-    def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin=None):
-        l = wire[current]
-        current += 1
-        rdlen -= 1
-        if l > rdlen:
-            raise dns.exception.FormError
-        cpu = wire[current:current + l].unwrap()
-        current += l
-        rdlen -= l
-        l = wire[current]
-        current += 1
-        rdlen -= 1
-        if l != rdlen:
-            raise dns.exception.FormError
-        os = wire[current: current + l].unwrap()
+    def from_wire_parser(cls, rdclass, rdtype, parser, origin=None):
+        cpu = parser.get_counted_bytes()
+        os = parser.get_counted_bytes()
         return cls(rdclass, rdtype, cpu, os)
-

lib/dns/rdtypes/ANY/HIP.py

@@ -1,3 +1,5 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
 # Copyright (C) 2010, 2011 Nominum, Inc.
 #
 # Permission to use, copy, modify, and distribute this software and its
@@ -24,40 +26,33 @@ import dns.rdatatype
 
 class HIP(dns.rdata.Rdata):
 
-    """HIP record
+    """HIP record"""
 
-    @ivar hit: the host identity tag
-    @type hit: string
-    @ivar algorithm: the public key cryptographic algorithm
-    @type algorithm: int
-    @ivar key: the public key
-    @type key: string
-    @ivar servers: the rendezvous servers
-    @type servers: list of dns.name.Name objects
-    @see: RFC 5205"""
+    # see: RFC 5205
 
     __slots__ = ['hit', 'algorithm', 'key', 'servers']
 
     def __init__(self, rdclass, rdtype, hit, algorithm, key, servers):
-        super(HIP, self).__init__(rdclass, rdtype)
-        self.hit = hit
-        self.algorithm = algorithm
-        self.key = key
-        self.servers = servers
+        super().__init__(rdclass, rdtype)
+        object.__setattr__(self, 'hit', hit)
+        object.__setattr__(self, 'algorithm', algorithm)
+        object.__setattr__(self, 'key', key)
+        object.__setattr__(self, 'servers', dns.rdata._constify(servers))
 
     def to_text(self, origin=None, relativize=True, **kw):
         hit = binascii.hexlify(self.hit).decode()
         key = base64.b64encode(self.key).replace(b'\n', b'').decode()
-        text = u''
+        text = ''
         servers = []
         for server in self.servers:
             servers.append(server.choose_relativity(origin, relativize))
         if len(servers) > 0:
-            text += (u' ' + u' '.join(map(lambda x: x.to_unicode(), servers)))
-        return u'%u %s %s%s' % (self.algorithm, hit, key, text)
+            text += (' ' + ' '.join((x.to_unicode() for x in servers)))
+        return '%u %s %s%s' % (self.algorithm, hit, key, text)
 
     @classmethod
-    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+                  relativize_to=None):
         algorithm = tok.get_uint8()
         hit = binascii.unhexlify(tok.get_string().encode())
         if len(hit) > 255:
@@ -68,46 +63,26 @@ class HIP(dns.rdata.Rdata):
             token = tok.get()
             if token.is_eol_or_eof():
                 break
-            server = dns.name.from_text(token.value, origin)
-            server.choose_relativity(origin, relativize)
+            server = tok.as_name(token, origin, relativize, relativize_to)
             servers.append(server)
         return cls(rdclass, rdtype, hit, algorithm, key, servers)
 
-    def to_wire(self, file, compress=None, origin=None):
+    def _to_wire(self, file, compress=None, origin=None, canonicalize=False):
         lh = len(self.hit)
         lk = len(self.key)
         file.write(struct.pack("!BBH", lh, self.algorithm, lk))
         file.write(self.hit)
         file.write(self.key)
         for server in self.servers:
-            server.to_wire(file, None, origin)
+            server.to_wire(file, None, origin, False)
 
     @classmethod
-    def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin=None):
-        (lh, algorithm, lk) = struct.unpack('!BBH',
-                                            wire[current: current + 4])
-        current += 4
-        rdlen -= 4
-        hit = wire[current: current + lh].unwrap()
-        current += lh
-        rdlen -= lh
-        key = wire[current: current + lk].unwrap()
-        current += lk
-        rdlen -= lk
+    def from_wire_parser(cls, rdclass, rdtype, parser, origin=None):
+        (lh, algorithm, lk) = parser.get_struct('!BBH')
+        hit = parser.get_bytes(lh)
+        key = parser.get_bytes(lk)
         servers = []
-        while rdlen > 0:
-            (server, cused) = dns.name.from_wire(wire[: current + rdlen],
-                                                 current)
-            current += cused
-            rdlen -= cused
-            if origin is not None:
-                server = server.relativize(origin)
+        while parser.remaining() > 0:
+            server = parser.get_name(origin)
             servers.append(server)
         return cls(rdclass, rdtype, hit, algorithm, key, servers)
-
-    def choose_relativity(self, origin=None, relativize=True):
-        servers = []
-        for server in self.servers:
-            server = server.choose_relativity(origin, relativize)
-            servers.append(server)
-        self.servers = servers

lib/dns/rdtypes/ANY/ISDN.py

@@ -1,3 +1,5 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
 # Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
 #
 # Permission to use, copy, modify, and distribute this software and its
@@ -18,41 +20,37 @@ import struct
 import dns.exception
 import dns.rdata
 import dns.tokenizer
-from dns._compat import text_type
 
 
 class ISDN(dns.rdata.Rdata):
 
-    """ISDN record
+    """ISDN record"""
 
-    @ivar address: the ISDN address
-    @type address: string
-    @ivar subaddress: the ISDN subaddress (or '' if not present)
-    @type subaddress: string
-    @see: RFC 1183"""
+    # see: RFC 1183
 
     __slots__ = ['address', 'subaddress']
 
     def __init__(self, rdclass, rdtype, address, subaddress):
-        super(ISDN, self).__init__(rdclass, rdtype)
-        if isinstance(address, text_type):
-            self.address = address.encode()
+        super().__init__(rdclass, rdtype)
+        if isinstance(address, str):
+            object.__setattr__(self, 'address', address.encode())
         else:
-            self.address = address
-        if isinstance(address, text_type):
-            self.subaddress = subaddress.encode()
+            object.__setattr__(self, 'address', address)
+        if isinstance(address, str):
+            object.__setattr__(self, 'subaddress', subaddress.encode())
         else:
-            self.subaddress = subaddress
+            object.__setattr__(self, 'subaddress', subaddress)
 
     def to_text(self, origin=None, relativize=True, **kw):
         if self.subaddress:
-            return '"%s" "%s"' % (dns.rdata._escapify(self.address),
+            return '"{}" "{}"'.format(dns.rdata._escapify(self.address),
                                       dns.rdata._escapify(self.subaddress))
         else:
             return '"%s"' % dns.rdata._escapify(self.address)
 
     @classmethod
-    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+                  relativize_to=None):
         address = tok.get_string()
         t = tok.get()
         if not t.is_eol_or_eof():
@@ -64,7 +62,7 @@ class ISDN(dns.rdata.Rdata):
         tok.get_eol()
         return cls(rdclass, rdtype, address, subaddress)
 
-    def to_wire(self, file, compress=None, origin=None):
+    def _to_wire(self, file, compress=None, origin=None, canonicalize=False):
         l = len(self.address)
         assert l < 256
         file.write(struct.pack('!B', l))
@@ -76,23 +74,10 @@ class ISDN(dns.rdata.Rdata):
             file.write(self.subaddress)
 
     @classmethod
-    def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin=None):
-        l = wire[current]
-        current += 1
-        rdlen -= 1
-        if l > rdlen:
-            raise dns.exception.FormError
-        address = wire[current: current + l].unwrap()
-        current += l
-        rdlen -= l
-        if rdlen > 0:
-            l = wire[current]
-            current += 1
-            rdlen -= 1
-            if l != rdlen:
-                raise dns.exception.FormError
-            subaddress = wire[current: current + l].unwrap()
+    def from_wire_parser(cls, rdclass, rdtype, parser, origin=None):
+        address = parser.get_counted_bytes()
+        if parser.remaining() > 0:
+            subaddress = parser.get_counted_bytes()
         else:
-            subaddress = ''
+            subaddress = b''
         return cls(rdclass, rdtype, address, subaddress)
-

lib/dns/rdtypes/ANY/LOC.py

@@ -1,3 +1,5 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
 # Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
 #
 # Permission to use, copy, modify, and distribute this software and its
@@ -17,23 +19,32 @@ import struct
 
 import dns.exception
 import dns.rdata
-from dns._compat import long, xrange
 
 
-_pows = tuple(long(10**i) for i in range(0, 11))
+_pows = tuple(10**i for i in range(0, 11))
 
 # default values are in centimeters
 _default_size = 100.0
 _default_hprec = 1000000.0
 _default_vprec = 1000.0
 
+# for use by from_wire()
+_MAX_LATITUDE = 0x80000000 + 90 * 3600000
+_MIN_LATITUDE = 0x80000000 - 90 * 3600000
+_MAX_LONGITUDE = 0x80000000 + 180 * 3600000
+_MIN_LONGITUDE = 0x80000000 - 180 * 3600000
+
+# pylint complains about division since we don't have a from __future__ for
+# it, but we don't care about python 2 warnings, so turn them off.
+#
+# pylint: disable=old-division
 
 def _exponent_of(what, desc):
     if what == 0:
         return 0
     exp = None
-    for i in xrange(len(_pows)):
-        if what // _pows[i] == long(0):
+    for (i, pow) in enumerate(_pows):
+        if what // pow == 0:
             exp = i - 1
             break
     if exp is None or exp < 0:
@@ -47,7 +58,7 @@ def _float_to_tuple(what):
         what *= -1
     else:
         sign = 1
-    what = long(round(what * 3600000))
+    what = round(what * 3600000)  # pylint: disable=round-builtin
     degrees = int(what // 3600000)
     what -= degrees * 3600000
     minutes = int(what // 60000)
@@ -67,7 +78,7 @@ def _tuple_to_float(what):
 
 
 def _encode_size(what, desc):
-    what = long(what)
+    what = int(what)
     exponent = _exponent_of(what, desc) & 0xF
     base = what // pow(10, exponent) & 0xF
     return base * 16 + exponent
@@ -76,32 +87,18 @@ def _encode_size(what, desc):
 def _decode_size(what, desc):
     exponent = what & 0x0F
     if exponent > 9:
-        raise dns.exception.SyntaxError("bad %s exponent" % desc)
+        raise dns.exception.FormError("bad %s exponent" % desc)
     base = (what & 0xF0) >> 4
     if base > 9:
-        raise dns.exception.SyntaxError("bad %s base" % desc)
-    return long(base) * pow(10, exponent)
+        raise dns.exception.FormError("bad %s base" % desc)
+    return base * pow(10, exponent)
 
 
 class LOC(dns.rdata.Rdata):
 
-    """LOC record
+    """LOC record"""
 
-    @ivar latitude: latitude
-    @type latitude: (int, int, int, int, sign) tuple specifying the degrees, minutes,
-    seconds, milliseconds, and sign of the coordinate.
-    @ivar longitude: longitude
-    @type longitude: (int, int, int, int, sign) tuple specifying the degrees,
-    minutes, seconds, milliseconds, and sign of the coordinate.
-    @ivar altitude: altitude
-    @type altitude: float
-    @ivar size: size of the sphere
-    @type size: float
-    @ivar horizontal_precision: horizontal precision
-    @type horizontal_precision: float
-    @ivar vertical_precision: vertical precision
-    @type vertical_precision: float
-    @see: RFC 1876"""
+    # see: RFC 1876
 
     __slots__ = ['latitude', 'longitude', 'altitude', 'size',
                  'horizontal_precision', 'vertical_precision']
@@ -117,35 +114,31 @@ class LOC(dns.rdata.Rdata):
         degrees. The other parameters are floats. Size, horizontal precision,
         and vertical precision are specified in centimeters."""
 
-        super(LOC, self).__init__(rdclass, rdtype)
-        if isinstance(latitude, int) or isinstance(latitude, long):
+        super().__init__(rdclass, rdtype)
+        if isinstance(latitude, int):
             latitude = float(latitude)
         if isinstance(latitude, float):
             latitude = _float_to_tuple(latitude)
-        self.latitude = latitude
-        if isinstance(longitude, int) or isinstance(longitude, long):
+        object.__setattr__(self, 'latitude', dns.rdata._constify(latitude))
+        if isinstance(longitude, int):
             longitude = float(longitude)
         if isinstance(longitude, float):
             longitude = _float_to_tuple(longitude)
-        self.longitude = longitude
-        self.altitude = float(altitude)
-        self.size = float(size)
-        self.horizontal_precision = float(hprec)
-        self.vertical_precision = float(vprec)
+        object.__setattr__(self, 'longitude', dns.rdata._constify(longitude))
+        object.__setattr__(self, 'altitude', float(altitude))
+        object.__setattr__(self, 'size', float(size))
+        object.__setattr__(self, 'horizontal_precision', float(hprec))
+        object.__setattr__(self, 'vertical_precision', float(vprec))
 
     def to_text(self, origin=None, relativize=True, **kw):
         if self.latitude[4] > 0:
             lat_hemisphere = 'N'
-            lat_degrees = self.latitude[0]
         else:
             lat_hemisphere = 'S'
-            lat_degrees = -1 * self.latitude[0]
         if self.longitude[4] > 0:
             long_hemisphere = 'E'
-            long_degrees = self.longitude[0]
         else:
             long_hemisphere = 'W'
-            long_degrees = -1 * self.longitude[0]
         text = "%d %d %d.%03d %s %d %d %d.%03d %s %0.2fm" % (
             self.latitude[0], self.latitude[1],
             self.latitude[2], self.latitude[3], lat_hemisphere,
@@ -158,14 +151,15 @@ class LOC(dns.rdata.Rdata):
         if self.size != _default_size or \
             self.horizontal_precision != _default_hprec or \
                 self.vertical_precision != _default_vprec:
-            text += " %0.2fm %0.2fm %0.2fm" % (
+            text += " {:0.2f}m {:0.2f}m {:0.2f}m".format(
                 self.size / 100.0, self.horizontal_precision / 100.0,
                 self.vertical_precision / 100.0
             )
         return text
 
     @classmethod
-    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+                  relativize_to=None):
         latitude = [0, 0, 0, 0, 1]
         longitude = [0, 0, 0, 0, 1]
         size = _default_size
@@ -173,9 +167,13 @@ class LOC(dns.rdata.Rdata):
         vprec = _default_vprec
 
         latitude[0] = tok.get_int()
+        if latitude[0] > 90:
+            raise dns.exception.SyntaxError('latitude >= 90')
         t = tok.get_string()
         if t.isdigit():
             latitude[1] = int(t)
+            if latitude[1] >= 60:
+                raise dns.exception.SyntaxError('latitude minutes >= 60')
             t = tok.get_string()
             if '.' in t:
                 (seconds, milliseconds) = t.split('.')
@@ -206,9 +204,13 @@ class LOC(dns.rdata.Rdata):
             raise dns.exception.SyntaxError('bad latitude hemisphere value')
 
         longitude[0] = tok.get_int()
+        if longitude[0] > 180:
+            raise dns.exception.SyntaxError('longitude > 180')
         t = tok.get_string()
         if t.isdigit():
             longitude[1] = int(t)
+            if longitude[1] >= 60:
+                raise dns.exception.SyntaxError('longitude minutes >= 60')
             t = tok.get_string()
             if '.' in t:
                 (seconds, milliseconds) = t.split('.')
@@ -263,21 +265,26 @@ class LOC(dns.rdata.Rdata):
                     vprec = float(value) * 100.0        # m -> cm
                     tok.get_eol()
 
+        # Try encoding these now so we raise if they are bad
+        _encode_size(size, "size")
+        _encode_size(hprec, "horizontal precision")
+        _encode_size(vprec, "vertical precision")
+
         return cls(rdclass, rdtype, latitude, longitude, altitude,
                    size, hprec, vprec)
 
-    def to_wire(self, file, compress=None, origin=None):
+    def _to_wire(self, file, compress=None, origin=None, canonicalize=False):
         milliseconds = (self.latitude[0] * 3600000 +
                         self.latitude[1] * 60000 +
                         self.latitude[2] * 1000 +
                         self.latitude[3]) * self.latitude[4]
-        latitude = long(0x80000000) + milliseconds
+        latitude = 0x80000000 + milliseconds
         milliseconds = (self.longitude[0] * 3600000 +
                         self.longitude[1] * 60000 +
                         self.longitude[2] * 1000 +
                         self.longitude[3]) * self.longitude[4]
-        longitude = long(0x80000000) + milliseconds
-        altitude = long(self.altitude) + long(10000000)
+        longitude = 0x80000000 + milliseconds
+        altitude = int(self.altitude) + 10000000
         size = _encode_size(self.size, "size")
         hprec = _encode_size(self.horizontal_precision, "horizontal precision")
         vprec = _encode_size(self.vertical_precision, "vertical precision")
@@ -286,21 +293,21 @@ class LOC(dns.rdata.Rdata):
         file.write(wire)
 
     @classmethod
-    def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin=None):
+    def from_wire_parser(cls, rdclass, rdtype, parser, origin=None):
         (version, size, hprec, vprec, latitude, longitude, altitude) = \
-            struct.unpack("!BBBBIII", wire[current: current + rdlen])
-        if latitude > long(0x80000000):
-            latitude = float(latitude - long(0x80000000)) / 3600000
-        else:
-            latitude = -1 * float(long(0x80000000) - latitude) / 3600000
-        if latitude < -90.0 or latitude > 90.0:
+            parser.get_struct("!BBBBIII")
+        if latitude < _MIN_LATITUDE or latitude > _MAX_LATITUDE:
             raise dns.exception.FormError("bad latitude")
-        if longitude > long(0x80000000):
-            longitude = float(longitude - long(0x80000000)) / 3600000
+        if latitude > 0x80000000:
+            latitude = (latitude - 0x80000000) / 3600000
         else:
-            longitude = -1 * float(long(0x80000000) - longitude) / 3600000
-        if longitude < -180.0 or longitude > 180.0:
+            latitude = -1 * (0x80000000 - latitude) / 3600000
+        if longitude < _MIN_LONGITUDE or longitude > _MAX_LONGITUDE:
             raise dns.exception.FormError("bad longitude")
+        if longitude > 0x80000000:
+            longitude = (longitude - 0x80000000) / 3600000
+        else:
+            longitude = -1 * (0x80000000 - longitude) / 3600000
         altitude = float(altitude) - 10000000.0
         size = _decode_size(size, "size")
         hprec = _decode_size(hprec, "horizontal precision")
@@ -308,20 +315,12 @@ class LOC(dns.rdata.Rdata):
         return cls(rdclass, rdtype, latitude, longitude, altitude,
                    size, hprec, vprec)
 
-    def _get_float_latitude(self):
+    @property
+    def float_latitude(self):
+        "latitude as a floating point value"
         return _tuple_to_float(self.latitude)
 
-    def _set_float_latitude(self, value):
-        self.latitude = _float_to_tuple(value)
-
-    float_latitude = property(_get_float_latitude, _set_float_latitude,
-                              doc="latitude as a floating point value")
-
-    def _get_float_longitude(self):
+    @property
+    def float_longitude(self):
+        "longitude as a floating point value"
         return _tuple_to_float(self.longitude)
-
-    def _set_float_longitude(self, value):
-        self.longitude = _float_to_tuple(value)
-
-    float_longitude = property(_get_float_longitude, _set_float_longitude,
-                               doc="longitude as a floating point value")

lib/dns/rdtypes/ANY/MX.py

@@ -1,3 +1,5 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
 # Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
 #
 # Permission to use, copy, modify, and distribute this software and its

lib/dns/rdtypes/ANY/NINFO.py

@@ -0,0 +1,25 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
+# Copyright (C) 2006, 2007, 2009-2011 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.
+
+import dns.rdtypes.txtbase
+
+
+class NINFO(dns.rdtypes.txtbase.TXTBase):
+
+    """NINFO record"""
+
+    # see: draft-reid-dnsext-zs-01

lib/dns/rdtypes/ANY/NS.py

@@ -1,3 +1,5 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
 # Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
 #
 # Permission to use, copy, modify, and distribute this software and its

lib/dns/rdtypes/ANY/NSEC.py

@@ -1,3 +1,5 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
 # Copyright (C) 2004-2007, 2009-2011 Nominum, Inc.
 #
 # Permission to use, copy, modify, and distribute this software and its
@@ -13,114 +15,46 @@
 # ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
 # OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
-import struct
-
 import dns.exception
 import dns.rdata
 import dns.rdatatype
 import dns.name
-from dns._compat import xrange
+import dns.rdtypes.util
+
+
+class Bitmap(dns.rdtypes.util.Bitmap):
+    type_name = 'NSEC'
 
 
 class NSEC(dns.rdata.Rdata):
 
-    """NSEC record
-
-    @ivar next: the next name
-    @type next: dns.name.Name object
-    @ivar windows: the windowed bitmap list
-    @type windows: list of (window number, string) tuples"""
+    """NSEC record"""
 
     __slots__ = ['next', 'windows']
 
     def __init__(self, rdclass, rdtype, next, windows):
-        super(NSEC, self).__init__(rdclass, rdtype)
-        self.next = next
-        self.windows = windows
+        super().__init__(rdclass, rdtype)
+        object.__setattr__(self, 'next', next)
+        object.__setattr__(self, 'windows', dns.rdata._constify(windows))
 
     def to_text(self, origin=None, relativize=True, **kw):
         next = self.next.choose_relativity(origin, relativize)
-        text = ''
-        for (window, bitmap) in self.windows:
-            bits = []
-            for i in xrange(0, len(bitmap)):
-                byte = bitmap[i]
-                for j in xrange(0, 8):
-                    if byte & (0x80 >> j):
-                        bits.append(dns.rdatatype.to_text(window * 256 +
-                                                          i * 8 + j))
-            text += (' ' + ' '.join(bits))
-        return '%s%s' % (next, text)
+        text = Bitmap(self.windows).to_text()
+        return '{}{}'.format(next, text)
 
     @classmethod
-    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
-        next = tok.get_name()
-        next = next.choose_relativity(origin, relativize)
-        rdtypes = []
-        while 1:
-            token = tok.get().unescape()
-            if token.is_eol_or_eof():
-                break
-            nrdtype = dns.rdatatype.from_text(token.value)
-            if nrdtype == 0:
-                raise dns.exception.SyntaxError("NSEC with bit 0")
-            if nrdtype > 65535:
-                raise dns.exception.SyntaxError("NSEC with bit > 65535")
-            rdtypes.append(nrdtype)
-        rdtypes.sort()
-        window = 0
-        octets = 0
-        prior_rdtype = 0
-        bitmap = bytearray(b'\0' * 32)
-        windows = []
-        for nrdtype in rdtypes:
-            if nrdtype == prior_rdtype:
-                continue
-            prior_rdtype = nrdtype
-            new_window = nrdtype // 256
-            if new_window != window:
-                windows.append((window, bitmap[0:octets]))
-                bitmap = bytearray(b'\0' * 32)
-                window = new_window
-            offset = nrdtype % 256
-            byte = offset // 8
-            bit = offset % 8
-            octets = byte + 1
-            bitmap[byte] = bitmap[byte] | (0x80 >> bit)
-
-        windows.append((window, bitmap[0:octets]))
+    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+                  relativize_to=None):
+        next = tok.get_name(origin, relativize, relativize_to)
+        windows = Bitmap().from_text(tok)
         return cls(rdclass, rdtype, next, windows)
 
-    def to_wire(self, file, compress=None, origin=None):
-        self.next.to_wire(file, None, origin)
-        for (window, bitmap) in self.windows:
-            file.write(struct.pack('!BB', window, len(bitmap)))
-            file.write(bitmap)
+    def _to_wire(self, file, compress=None, origin=None, canonicalize=False):
+        self.next.to_wire(file, None, origin, False)
+        Bitmap(self.windows).to_wire(file)
 
     @classmethod
-    def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin=None):
-        (next, cused) = dns.name.from_wire(wire[: current + rdlen], current)
-        current += cused
-        rdlen -= cused
-        windows = []
-        while rdlen > 0:
-            if rdlen < 3:
-                raise dns.exception.FormError("NSEC too short")
-            window = wire[current]
-            octets = wire[current + 1]
-            if octets == 0 or octets > 32:
-                raise dns.exception.FormError("bad NSEC octets")
-            current += 2
-            rdlen -= 2
-            if rdlen < octets:
-                raise dns.exception.FormError("bad NSEC bitmap length")
-            bitmap = bytearray(wire[current: current + octets].unwrap())
-            current += octets
-            rdlen -= octets
-            windows.append((window, bitmap))
-        if origin is not None:
-            next = next.relativize(origin)
+    def from_wire_parser(cls, rdclass, rdtype, parser, origin=None):
+        next = parser.get_name(origin)
+        windows = Bitmap().from_wire_parser(parser)
         return cls(rdclass, rdtype, next, windows)
-
-    def choose_relativity(self, origin=None, relativize=True):
-        self.next = self.next.choose_relativity(origin, relativize)

lib/dns/rdtypes/ANY/NSEC3.py

@@ -1,4 +1,6 @@
-# Copyright (C) 2004-2007, 2009-2011 Nominum, Inc.
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
+# Copyright (C) 2004-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,
@@ -15,20 +17,14 @@
 
 import base64
 import binascii
-import string
 import struct
 
 import dns.exception
 import dns.rdata
 import dns.rdatatype
-from dns._compat import xrange, text_type
+import dns.rdtypes.util
+
 
-try:
-    b32_hex_to_normal = string.maketrans('0123456789ABCDEFGHIJKLMNOPQRSTUV',
-                                         'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567')
-    b32_normal_to_hex = string.maketrans('ABCDEFGHIJKLMNOPQRSTUVWXYZ234567',
-                                         '0123456789ABCDEFGHIJKLMNOPQRSTUV')
-except AttributeError:
 b32_hex_to_normal = bytes.maketrans(b'0123456789ABCDEFGHIJKLMNOPQRSTUV',
                                     b'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567')
 b32_normal_to_hex = bytes.maketrans(b'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567',
@@ -41,37 +37,28 @@ SHA1 = 1
 OPTOUT = 1
 
 
+class Bitmap(dns.rdtypes.util.Bitmap):
+    type_name = 'NSEC3'
+
+
 class NSEC3(dns.rdata.Rdata):
 
-    """NSEC3 record
-
-    @ivar algorithm: the hash algorithm number
-    @type algorithm: int
-    @ivar flags: the flags
-    @type flags: int
-    @ivar iterations: the number of iterations
-    @type iterations: int
-    @ivar salt: the salt
-    @type salt: string
-    @ivar next: the next name hash
-    @type next: string
-    @ivar windows: the windowed bitmap list
-    @type windows: list of (window number, string) tuples"""
+    """NSEC3 record"""
 
     __slots__ = ['algorithm', 'flags', 'iterations', 'salt', 'next', 'windows']
 
     def __init__(self, rdclass, rdtype, algorithm, flags, iterations, salt,
                  next, windows):
-        super(NSEC3, self).__init__(rdclass, rdtype)
-        self.algorithm = algorithm
-        self.flags = flags
-        self.iterations = iterations
-        if isinstance(salt, text_type):
-            self.salt = salt.encode()
+        super().__init__(rdclass, rdtype)
+        object.__setattr__(self, 'algorithm', algorithm)
+        object.__setattr__(self, 'flags', flags)
+        object.__setattr__(self, 'iterations', iterations)
+        if isinstance(salt, str):
+            object.__setattr__(self, 'salt', salt.encode())
         else:
-            self.salt = salt
-        self.next = next
-        self.windows = windows
+            object.__setattr__(self, 'salt', salt)
+        object.__setattr__(self, 'next', next)
+        object.__setattr__(self, 'windows', dns.rdata._constify(windows))
 
     def to_text(self, origin=None, relativize=True, **kw):
         next = base64.b32encode(self.next).translate(
@@ -80,70 +67,29 @@ class NSEC3(dns.rdata.Rdata):
             salt = '-'
         else:
             salt = binascii.hexlify(self.salt).decode()
-        text = u''
-        for (window, bitmap) in self.windows:
-            bits = []
-            for i in xrange(0, len(bitmap)):
-                byte = bitmap[i]
-                for j in xrange(0, 8):
-                    if byte & (0x80 >> j):
-                        bits.append(dns.rdatatype.to_text(window * 256 +
-                                                          i * 8 + j))
-            text += (u' ' + u' '.join(bits))
-        return u'%u %u %u %s %s%s' % (self.algorithm, self.flags,
+        text = Bitmap(self.windows).to_text()
+        return '%u %u %u %s %s%s' % (self.algorithm, self.flags,
                                      self.iterations, salt, next, text)
 
     @classmethod
-    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+                  relativize_to=None):
         algorithm = tok.get_uint8()
         flags = tok.get_uint8()
         iterations = tok.get_uint16()
         salt = tok.get_string()
-        if salt == u'-':
+        if salt == '-':
             salt = b''
         else:
             salt = binascii.unhexlify(salt.encode('ascii'))
         next = tok.get_string().encode(
             'ascii').upper().translate(b32_hex_to_normal)
         next = base64.b32decode(next)
-        rdtypes = []
-        while 1:
-            token = tok.get().unescape()
-            if token.is_eol_or_eof():
-                break
-            nrdtype = dns.rdatatype.from_text(token.value)
-            if nrdtype == 0:
-                raise dns.exception.SyntaxError("NSEC3 with bit 0")
-            if nrdtype > 65535:
-                raise dns.exception.SyntaxError("NSEC3 with bit > 65535")
-            rdtypes.append(nrdtype)
-        rdtypes.sort()
-        window = 0
-        octets = 0
-        prior_rdtype = 0
-        bitmap = bytearray(b'\0' * 32)
-        windows = []
-        for nrdtype in rdtypes:
-            if nrdtype == prior_rdtype:
-                continue
-            prior_rdtype = nrdtype
-            new_window = nrdtype // 256
-            if new_window != window:
-                if octets != 0:
-                    windows.append((window, ''.join(bitmap[0:octets])))
-                bitmap = bytearray(b'\0' * 32)
-                window = new_window
-            offset = nrdtype % 256
-            byte = offset // 8
-            bit = offset % 8
-            octets = byte + 1
-            bitmap[byte] = bitmap[byte] | (0x80 >> bit)
-        if octets != 0:
-            windows.append((window, bitmap[0:octets]))
+        windows = Bitmap().from_text(tok)
         return cls(rdclass, rdtype, algorithm, flags, iterations, salt, next,
                    windows)
 
-    def to_wire(self, file, compress=None, origin=None):
+    def _to_wire(self, file, compress=None, origin=None, canonicalize=False):
         l = len(self.salt)
         file.write(struct.pack("!BBHB", self.algorithm, self.flags,
                                self.iterations, l))
@@ -151,42 +97,13 @@ class NSEC3(dns.rdata.Rdata):
         l = len(self.next)
         file.write(struct.pack("!B", l))
         file.write(self.next)
-        for (window, bitmap) in self.windows:
-            file.write(struct.pack("!BB", window, len(bitmap)))
-            file.write(bitmap)
+        Bitmap(self.windows).to_wire(file)
 
     @classmethod
-    def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin=None):
-        (algorithm, flags, iterations, slen) = \
-            struct.unpack('!BBHB', wire[current: current + 5])
-
-        current += 5
-        rdlen -= 5
-        salt = wire[current: current + slen].unwrap()
-        current += slen
-        rdlen -= slen
-        nlen = wire[current]
-        current += 1
-        rdlen -= 1
-        next = wire[current: current + nlen].unwrap()
-        current += nlen
-        rdlen -= nlen
-        windows = []
-        while rdlen > 0:
-            if rdlen < 3:
-                raise dns.exception.FormError("NSEC3 too short")
-            window = wire[current]
-            octets = wire[current + 1]
-            if octets == 0 or octets > 32:
-                raise dns.exception.FormError("bad NSEC3 octets")
-            current += 2
-            rdlen -= 2
-            if rdlen < octets:
-                raise dns.exception.FormError("bad NSEC3 bitmap length")
-            bitmap = bytearray(wire[current: current + octets].unwrap())
-            current += octets
-            rdlen -= octets
-            windows.append((window, bitmap))
+    def from_wire_parser(cls, rdclass, rdtype, parser, origin=None):
+        (algorithm, flags, iterations) = parser.get_struct('!BBH')
+        salt = parser.get_counted_bytes()
+        next = parser.get_counted_bytes()
+        windows = Bitmap().from_wire_parser(parser)
         return cls(rdclass, rdtype, algorithm, flags, iterations, salt, next,
                    windows)
-

lib/dns/rdtypes/ANY/NSEC3PARAM.py

@@ -1,3 +1,5 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
 # Copyright (C) 2004-2007, 2009-2011 Nominum, Inc.
 #
 # Permission to use, copy, modify, and distribute this software and its
@@ -18,33 +20,23 @@ import binascii
 
 import dns.exception
 import dns.rdata
-from dns._compat import text_type
 
 
 class NSEC3PARAM(dns.rdata.Rdata):
 
-    """NSEC3PARAM record
-
-    @ivar algorithm: the hash algorithm number
-    @type algorithm: int
-    @ivar flags: the flags
-    @type flags: int
-    @ivar iterations: the number of iterations
-    @type iterations: int
-    @ivar salt: the salt
-    @type salt: string"""
+    """NSEC3PARAM record"""
 
     __slots__ = ['algorithm', 'flags', 'iterations', 'salt']
 
     def __init__(self, rdclass, rdtype, algorithm, flags, iterations, salt):
-        super(NSEC3PARAM, self).__init__(rdclass, rdtype)
-        self.algorithm = algorithm
-        self.flags = flags
-        self.iterations = iterations
-        if isinstance(salt, text_type):
-            self.salt = salt.encode()
+        super().__init__(rdclass, rdtype)
+        object.__setattr__(self, 'algorithm', algorithm)
+        object.__setattr__(self, 'flags', flags)
+        object.__setattr__(self, 'iterations', iterations)
+        if isinstance(salt, str):
+            object.__setattr__(self, 'salt', salt.encode())
         else:
-            self.salt = salt
+            object.__setattr__(self, 'salt', salt)
 
     def to_text(self, origin=None, relativize=True, **kw):
         if self.salt == b'':
@@ -55,7 +47,8 @@ class NSEC3PARAM(dns.rdata.Rdata):
                                 salt)
 
     @classmethod
-    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+                  relativize_to=None):
         algorithm = tok.get_uint8()
         flags = tok.get_uint8()
         iterations = tok.get_uint16()
@@ -67,23 +60,14 @@ class NSEC3PARAM(dns.rdata.Rdata):
         tok.get_eol()
         return cls(rdclass, rdtype, algorithm, flags, iterations, salt)
 
-    def to_wire(self, file, compress=None, origin=None):
+    def _to_wire(self, file, compress=None, origin=None, canonicalize=False):
         l = len(self.salt)
         file.write(struct.pack("!BBHB", self.algorithm, self.flags,
                                self.iterations, l))
         file.write(self.salt)
 
     @classmethod
-    def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin=None):
-        (algorithm, flags, iterations, slen) = \
-             struct.unpack('!BBHB',
-                           wire[current: current + 5])
-        current += 5
-        rdlen -= 5
-        salt = wire[current: current + slen].unwrap()
-        current += slen
-        rdlen -= slen
-        if rdlen != 0:
-            raise dns.exception.FormError
+    def from_wire_parser(cls, rdclass, rdtype, parser, origin=None):
+        (algorithm, flags, iterations) = parser.get_struct('!BBH')
+        salt = parser.get_counted_bytes()
         return cls(rdclass, rdtype, algorithm, flags, iterations, salt)
-

lib/dns/rdtypes/ANY/OPENPGPKEY.py

@@ -0,0 +1,50 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
+# Copyright (C) 2016 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.
+
+import base64
+
+import dns.exception
+import dns.rdata
+import dns.tokenizer
+
+class OPENPGPKEY(dns.rdata.Rdata):
+
+    """OPENPGPKEY record"""
+
+    # see: RFC 7929
+
+    def __init__(self, rdclass, rdtype, key):
+        super().__init__(rdclass, rdtype)
+        object.__setattr__(self, 'key', key)
+
+    def to_text(self, origin=None, relativize=True, **kw):
+        return dns.rdata._base64ify(self.key)
+
+    @classmethod
+    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+                  relativize_to=None):
+        b64 = tok.concatenate_remaining_identifiers().encode()
+        key = base64.b64decode(b64)
+        return cls(rdclass, rdtype, key)
+
+    def _to_wire(self, file, compress=None, origin=None, canonicalize=False):
+        file.write(self.key)
+
+    @classmethod
+    def from_wire_parser(cls, rdclass, rdtype, parser, origin=None):
+        key = parser.get_remaining()
+        return cls(rdclass, rdtype, key)

lib/dns/rdtypes/ANY/OPT.py

@@ -0,0 +1,67 @@
+# 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.
+
+import struct
+
+import dns.edns
+import dns.exception
+import dns.rdata
+
+
+class OPT(dns.rdata.Rdata):
+
+    """OPT record"""
+
+    __slots__ = ['options']
+
+    def __init__(self, rdclass, rdtype, options):
+        """Initialize an OPT rdata.
+
+        *rdclass*, an ``int`` is the rdataclass of the Rdata,
+        which is also the payload size.
+
+        *rdtype*, an ``int`` is the rdatatype of the Rdata.
+
+        *options*, a tuple of ``bytes``
+        """
+
+        super().__init__(rdclass, rdtype)
+        object.__setattr__(self, 'options', dns.rdata._constify(options))
+
+    def _to_wire(self, file, compress=None, origin=None, canonicalize=False):
+        for opt in self.options:
+            owire = opt.to_wire()
+            file.write(struct.pack("!HH", opt.otype, len(owire)))
+            file.write(owire)
+
+    def to_text(self, origin=None, relativize=True, **kw):
+        return ' '.join(opt.to_text() for opt in self.options)
+
+    @classmethod
+    def from_wire_parser(cls, rdclass, rdtype, parser, origin=None):
+        options = []
+        while parser.remaining() > 0:
+            (otype, olen) = parser.get_struct('!HH')
+            with parser.restrict_to(olen):
+                opt = dns.edns.option_from_wire_parser(otype, parser)
+            options.append(opt)
+        return cls(rdclass, rdtype, options)
+
+    @property
+    def payload(self):
+        "payload size"
+        return self.rdclass

lib/dns/rdtypes/ANY/PTR.py

@@ -1,3 +1,5 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
 # Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
 #
 # Permission to use, copy, modify, and distribute this software and its

lib/dns/rdtypes/ANY/RP.py

@@ -1,3 +1,5 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
 # Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
 #
 # Permission to use, copy, modify, and distribute this software and its
@@ -20,61 +22,36 @@ import dns.name
 
 class RP(dns.rdata.Rdata):
 
-    """RP record
+    """RP record"""
 
-    @ivar mbox: The responsible person's mailbox
-    @type mbox: dns.name.Name object
-    @ivar txt: The owner name of a node with TXT records, or the root name
-    if no TXT records are associated with this RP.
-    @type txt: dns.name.Name object
-    @see: RFC 1183"""
+    # see: RFC 1183
 
     __slots__ = ['mbox', 'txt']
 
     def __init__(self, rdclass, rdtype, mbox, txt):
-        super(RP, self).__init__(rdclass, rdtype)
-        self.mbox = mbox
-        self.txt = txt
+        super().__init__(rdclass, rdtype)
+        object.__setattr__(self, 'mbox', mbox)
+        object.__setattr__(self, 'txt', txt)
 
     def to_text(self, origin=None, relativize=True, **kw):
         mbox = self.mbox.choose_relativity(origin, relativize)
         txt = self.txt.choose_relativity(origin, relativize)
-        return "%s %s" % (str(mbox), str(txt))
+        return "{} {}".format(str(mbox), str(txt))
 
     @classmethod
-    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
-        mbox = tok.get_name()
-        txt = tok.get_name()
-        mbox = mbox.choose_relativity(origin, relativize)
-        txt = txt.choose_relativity(origin, relativize)
+    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+                  relativize_to=None):
+        mbox = tok.get_name(origin, relativize, relativize_to)
+        txt = tok.get_name(origin, relativize, relativize_to)
         tok.get_eol()
         return cls(rdclass, rdtype, mbox, txt)
 
-    def to_wire(self, file, compress=None, origin=None):
-        self.mbox.to_wire(file, None, origin)
-        self.txt.to_wire(file, None, origin)
-
-    def to_digestable(self, origin=None):
-        return self.mbox.to_digestable(origin) + \
-            self.txt.to_digestable(origin)
+    def _to_wire(self, file, compress=None, origin=None, canonicalize=False):
+        self.mbox.to_wire(file, None, origin, canonicalize)
+        self.txt.to_wire(file, None, origin, canonicalize)
 
     @classmethod
-    def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin=None):
-        (mbox, cused) = dns.name.from_wire(wire[: current + rdlen],
-                                           current)
-        current += cused
-        rdlen -= cused
-        if rdlen <= 0:
-            raise dns.exception.FormError
-        (txt, cused) = dns.name.from_wire(wire[: current + rdlen],
-                                          current)
-        if cused != rdlen:
-            raise dns.exception.FormError
-        if origin is not None:
-            mbox = mbox.relativize(origin)
-            txt = txt.relativize(origin)
+    def from_wire_parser(cls, rdclass, rdtype, parser, origin=None):
+        mbox = parser.get_name(origin)
+        txt = parser.get_name(origin)
         return cls(rdclass, rdtype, mbox, txt)
-
-    def choose_relativity(self, origin=None, relativize=True):
-        self.mbox = self.mbox.choose_relativity(origin, relativize)
-        self.txt = self.txt.choose_relativity(origin, relativize)

lib/dns/rdtypes/ANY/RRSIG.py

@@ -1,3 +1,5 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
 # Copyright (C) 2004-2007, 2009-2011 Nominum, Inc.
 #
 # Permission to use, copy, modify, and distribute this software and its
@@ -30,6 +32,8 @@ class BadSigTime(dns.exception.DNSException):
 
 
 def sigtime_to_posixtime(what):
+    if len(what) <= 10 and what.isdigit():
+        return int(what)
     if len(what) != 14:
         raise BadSigTime
     year = int(what[0:4])
@@ -48,26 +52,7 @@ def posixtime_to_sigtime(what):
 
 class RRSIG(dns.rdata.Rdata):
 
-    """RRSIG record
-
-    @ivar type_covered: the rdata type this signature covers
-    @type type_covered: int
-    @ivar algorithm: the algorithm used for the sig
-    @type algorithm: int
-    @ivar labels: number of labels
-    @type labels: int
-    @ivar original_ttl: the original TTL
-    @type original_ttl: long
-    @ivar expiration: signature expiration time
-    @type expiration: long
-    @ivar inception: signature inception time
-    @type inception: long
-    @ivar key_tag: the key tag
-    @type key_tag: int
-    @ivar signer: the signer
-    @type signer: dns.name.Name object
-    @ivar signature: the signature
-    @type signature: string"""
+    """RRSIG record"""
 
     __slots__ = ['type_covered', 'algorithm', 'labels', 'original_ttl',
                  'expiration', 'inception', 'key_tag', 'signer',
@@ -76,16 +61,16 @@ class RRSIG(dns.rdata.Rdata):
     def __init__(self, rdclass, rdtype, type_covered, algorithm, labels,
                  original_ttl, expiration, inception, key_tag, signer,
                  signature):
-        super(RRSIG, self).__init__(rdclass, rdtype)
-        self.type_covered = type_covered
-        self.algorithm = algorithm
-        self.labels = labels
-        self.original_ttl = original_ttl
-        self.expiration = expiration
-        self.inception = inception
-        self.key_tag = key_tag
-        self.signer = signer
-        self.signature = signature
+        super().__init__(rdclass, rdtype)
+        object.__setattr__(self, 'type_covered', type_covered)
+        object.__setattr__(self, 'algorithm', algorithm)
+        object.__setattr__(self, 'labels', labels)
+        object.__setattr__(self, 'original_ttl', original_ttl)
+        object.__setattr__(self, 'expiration', expiration)
+        object.__setattr__(self, 'inception', inception)
+        object.__setattr__(self, 'key_tag', key_tag)
+        object.__setattr__(self, 'signer', signer)
+        object.__setattr__(self, 'signature', signature)
 
     def covers(self):
         return self.type_covered
@@ -104,7 +89,8 @@ class RRSIG(dns.rdata.Rdata):
         )
 
     @classmethod
-    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+                  relativize_to=None):
         type_covered = dns.rdatatype.from_text(tok.get_string())
         algorithm = dns.dnssec.algorithm_from_text(tok.get_string())
         labels = tok.get_int()
@@ -112,45 +98,25 @@ class RRSIG(dns.rdata.Rdata):
         expiration = sigtime_to_posixtime(tok.get_string())
         inception = sigtime_to_posixtime(tok.get_string())
         key_tag = tok.get_int()
-        signer = tok.get_name()
-        signer = signer.choose_relativity(origin, relativize)
-        chunks = []
-        while 1:
-            t = tok.get().unescape()
-            if t.is_eol_or_eof():
-                break
-            if not t.is_identifier():
-                raise dns.exception.SyntaxError
-            chunks.append(t.value.encode())
-        b64 = b''.join(chunks)
+        signer = tok.get_name(origin, relativize, relativize_to)
+        b64 = tok.concatenate_remaining_identifiers().encode()
         signature = base64.b64decode(b64)
         return cls(rdclass, rdtype, type_covered, algorithm, labels,
                    original_ttl, expiration, inception, key_tag, signer,
                    signature)
 
-    def to_wire(self, file, compress=None, origin=None):
+    def _to_wire(self, file, compress=None, origin=None, canonicalize=False):
         header = struct.pack('!HBBIIIH', self.type_covered,
                              self.algorithm, self.labels,
                              self.original_ttl, self.expiration,
                              self.inception, self.key_tag)
         file.write(header)
-        self.signer.to_wire(file, None, origin)
+        self.signer.to_wire(file, None, origin, canonicalize)
         file.write(self.signature)
 
     @classmethod
-    def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin=None):
-        header = struct.unpack('!HBBIIIH', wire[current: current + 18])
-        current += 18
-        rdlen -= 18
-        (signer, cused) = dns.name.from_wire(wire[: current + rdlen], current)
-        current += cused
-        rdlen -= cused
-        if origin is not None:
-            signer = signer.relativize(origin)
-        signature = wire[current: current + rdlen].unwrap()
-        return cls(rdclass, rdtype, header[0], header[1], header[2],
-                   header[3], header[4], header[5], header[6], signer,
-                   signature)
-
-    def choose_relativity(self, origin=None, relativize=True):
-        self.signer = self.signer.choose_relativity(origin, relativize)
+    def from_wire_parser(cls, rdclass, rdtype, parser, origin=None):
+        header = parser.get_struct('!HBBIIIH')
+        signer = parser.get_name(origin)
+        signature = parser.get_remaining()
+        return cls(rdclass, rdtype, *header, signer, signature)

lib/dns/rdtypes/ANY/RT.py

@@ -1,3 +1,5 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
 # Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
 #
 # Permission to use, copy, modify, and distribute this software and its

lib/dns/rdtypes/ANY/SOA.py

@@ -1,3 +1,5 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
 # Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
 #
 # Permission to use, copy, modify, and distribute this software and its
@@ -22,38 +24,23 @@ import dns.name
 
 class SOA(dns.rdata.Rdata):
 
-    """SOA record
+    """SOA record"""
 
-    @ivar mname: the SOA MNAME (master name) field
-    @type mname: dns.name.Name object
-    @ivar rname: the SOA RNAME (responsible name) field
-    @type rname: dns.name.Name object
-    @ivar serial: The zone's serial number
-    @type serial: int
-    @ivar refresh: The zone's refresh value (in seconds)
-    @type refresh: int
-    @ivar retry: The zone's retry value (in seconds)
-    @type retry: int
-    @ivar expire: The zone's expiration value (in seconds)
-    @type expire: int
-    @ivar minimum: The zone's negative caching time (in seconds, called
-    "minimum" for historical reasons)
-    @type minimum: int
-    @see: RFC 1035"""
+    # see: RFC 1035
 
     __slots__ = ['mname', 'rname', 'serial', 'refresh', 'retry', 'expire',
                  'minimum']
 
     def __init__(self, rdclass, rdtype, mname, rname, serial, refresh, retry,
                  expire, minimum):
-        super(SOA, self).__init__(rdclass, rdtype)
-        self.mname = mname
-        self.rname = rname
-        self.serial = serial
-        self.refresh = refresh
-        self.retry = retry
-        self.expire = expire
-        self.minimum = minimum
+        super().__init__(rdclass, rdtype)
+        object.__setattr__(self, 'mname', mname)
+        object.__setattr__(self, 'rname', rname)
+        object.__setattr__(self, 'serial', serial)
+        object.__setattr__(self, 'refresh', refresh)
+        object.__setattr__(self, 'retry', retry)
+        object.__setattr__(self, 'expire', expire)
+        object.__setattr__(self, 'minimum', minimum)
 
     def to_text(self, origin=None, relativize=True, **kw):
         mname = self.mname.choose_relativity(origin, relativize)
@@ -63,11 +50,10 @@ class SOA(dns.rdata.Rdata):
             self.expire, self.minimum)
 
     @classmethod
-    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
-        mname = tok.get_name()
-        rname = tok.get_name()
-        mname = mname.choose_relativity(origin, relativize)
-        rname = rname.choose_relativity(origin, relativize)
+    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+                  relativize_to=None):
+        mname = tok.get_name(origin, relativize, relativize_to)
+        rname = tok.get_name(origin, relativize, relativize_to)
         serial = tok.get_uint32()
         refresh = tok.get_ttl()
         retry = tok.get_ttl()
@@ -77,38 +63,15 @@ class SOA(dns.rdata.Rdata):
         return cls(rdclass, rdtype, mname, rname, serial, refresh, retry,
                    expire, minimum)
 
-    def to_wire(self, file, compress=None, origin=None):
-        self.mname.to_wire(file, compress, origin)
-        self.rname.to_wire(file, compress, origin)
+    def _to_wire(self, file, compress=None, origin=None, canonicalize=False):
+        self.mname.to_wire(file, compress, origin, canonicalize)
+        self.rname.to_wire(file, compress, origin, canonicalize)
         five_ints = struct.pack('!IIIII', self.serial, self.refresh,
                                 self.retry, self.expire, self.minimum)
         file.write(five_ints)
 
-    def to_digestable(self, origin=None):
-        return self.mname.to_digestable(origin) + \
-            self.rname.to_digestable(origin) + \
-            struct.pack('!IIIII', self.serial, self.refresh,
-                        self.retry, self.expire, self.minimum)
-
     @classmethod
-    def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin=None):
-        (mname, cused) = dns.name.from_wire(wire[: current + rdlen], current)
-        current += cused
-        rdlen -= cused
-        (rname, cused) = dns.name.from_wire(wire[: current + rdlen], current)
-        current += cused
-        rdlen -= cused
-        if rdlen != 20:
-            raise dns.exception.FormError
-        five_ints = struct.unpack('!IIIII',
-                                  wire[current: current + rdlen])
-        if origin is not None:
-            mname = mname.relativize(origin)
-            rname = rname.relativize(origin)
-        return cls(rdclass, rdtype, mname, rname,
-                   five_ints[0], five_ints[1], five_ints[2], five_ints[3],
-                   five_ints[4])
-
-    def choose_relativity(self, origin=None, relativize=True):
-        self.mname = self.mname.choose_relativity(origin, relativize)
-        self.rname = self.rname.choose_relativity(origin, relativize)
+    def from_wire_parser(cls, rdclass, rdtype, parser, origin=None):
+        mname = parser.get_name(origin)
+        rname = parser.get_name(origin)
+        return cls(rdclass, rdtype, mname, rname, *parser.get_struct('!IIIII'))

lib/dns/rdtypes/ANY/SPF.py

@@ -1,3 +1,5 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
 # Copyright (C) 2006, 2007, 2009-2011 Nominum, Inc.
 #
 # Permission to use, copy, modify, and distribute this software and its
@@ -18,6 +20,6 @@ import dns.rdtypes.txtbase
 
 class SPF(dns.rdtypes.txtbase.TXTBase):
 
-    """SPF record
+    """SPF record"""
 
-    @see: RFC 4408"""
+    # see: RFC 4408

lib/dns/rdtypes/ANY/SSHFP.py

@@ -1,3 +1,5 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
 # Copyright (C) 2005-2007, 2009-2011 Nominum, Inc.
 #
 # Permission to use, copy, modify, and distribute this software and its
@@ -22,24 +24,18 @@ import dns.rdatatype
 
 class SSHFP(dns.rdata.Rdata):
 
-    """SSHFP record
+    """SSHFP record"""
 
-    @ivar algorithm: the algorithm
-    @type algorithm: int
-    @ivar fp_type: the digest type
-    @type fp_type: int
-    @ivar fingerprint: the fingerprint
-    @type fingerprint: string
-    @see: draft-ietf-secsh-dns-05.txt"""
+    # See RFC 4255
 
     __slots__ = ['algorithm', 'fp_type', 'fingerprint']
 
     def __init__(self, rdclass, rdtype, algorithm, fp_type,
                  fingerprint):
-        super(SSHFP, self).__init__(rdclass, rdtype)
-        self.algorithm = algorithm
-        self.fp_type = fp_type
-        self.fingerprint = fingerprint
+        super().__init__(rdclass, rdtype)
+        object.__setattr__(self, 'algorithm', algorithm)
+        object.__setattr__(self, 'fp_type', fp_type)
+        object.__setattr__(self, 'fingerprint', fingerprint)
 
     def to_text(self, origin=None, relativize=True, **kw):
         return '%d %d %s' % (self.algorithm,
@@ -48,31 +44,21 @@ class SSHFP(dns.rdata.Rdata):
                                                chunksize=128))
 
     @classmethod
-    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+                  relativize_to=None):
         algorithm = tok.get_uint8()
         fp_type = tok.get_uint8()
-        chunks = []
-        while 1:
-            t = tok.get().unescape()
-            if t.is_eol_or_eof():
-                break
-            if not t.is_identifier():
-                raise dns.exception.SyntaxError
-            chunks.append(t.value.encode())
-        fingerprint = b''.join(chunks)
+        fingerprint = tok.concatenate_remaining_identifiers().encode()
         fingerprint = binascii.unhexlify(fingerprint)
         return cls(rdclass, rdtype, algorithm, fp_type, fingerprint)
 
-    def to_wire(self, file, compress=None, origin=None):
+    def _to_wire(self, file, compress=None, origin=None, canonicalize=False):
         header = struct.pack("!BB", self.algorithm, self.fp_type)
         file.write(header)
         file.write(self.fingerprint)
 
     @classmethod
-    def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin=None):
-        header = struct.unpack("!BB", wire[current: current + 2])
-        current += 2
-        rdlen -= 2
-        fingerprint = wire[current: current + rdlen].unwrap()
+    def from_wire_parser(cls, rdclass, rdtype, parser, origin=None):
+        header = parser.get_struct("BB")
+        fingerprint = parser.get_remaining()
         return cls(rdclass, rdtype, header[0], header[1], fingerprint)
-

lib/dns/rdtypes/ANY/TLSA.py

@@ -1,3 +1,5 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
 # Copyright (C) 2005-2007, 2009-2011 Nominum, Inc.
 #
 # Permission to use, copy, modify, and distribute this software and its
@@ -22,27 +24,19 @@ import dns.rdatatype
 
 class TLSA(dns.rdata.Rdata):
 
-    """TLSA record
+    """TLSA record"""
 
-    @ivar usage: The certificate usage
-    @type usage: int
-    @ivar selector: The selector field
-    @type selector: int
-    @ivar mtype: The 'matching type' field
-    @type mtype: int
-    @ivar cert: The 'Certificate Association Data' field
-    @type cert: string
-    @see: RFC 6698"""
+    # see: RFC 6698
 
     __slots__ = ['usage', 'selector', 'mtype', 'cert']
 
     def __init__(self, rdclass, rdtype, usage, selector,
                  mtype, cert):
-        super(TLSA, self).__init__(rdclass, rdtype)
-        self.usage = usage
-        self.selector = selector
-        self.mtype = mtype
-        self.cert = cert
+        super().__init__(rdclass, rdtype)
+        object.__setattr__(self, 'usage', usage)
+        object.__setattr__(self, 'selector', selector)
+        object.__setattr__(self, 'mtype', mtype)
+        object.__setattr__(self, 'cert', cert)
 
     def to_text(self, origin=None, relativize=True, **kw):
         return '%d %d %d %s' % (self.usage,
@@ -52,32 +46,22 @@ class TLSA(dns.rdata.Rdata):
                                                   chunksize=128))
 
     @classmethod
-    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+                  relativize_to=None):
         usage = tok.get_uint8()
         selector = tok.get_uint8()
         mtype = tok.get_uint8()
-        cert_chunks = []
-        while 1:
-            t = tok.get().unescape()
-            if t.is_eol_or_eof():
-                break
-            if not t.is_identifier():
-                raise dns.exception.SyntaxError
-            cert_chunks.append(t.value.encode())
-        cert = b''.join(cert_chunks)
+        cert = tok.concatenate_remaining_identifiers().encode()
         cert = binascii.unhexlify(cert)
         return cls(rdclass, rdtype, usage, selector, mtype, cert)
 
-    def to_wire(self, file, compress=None, origin=None):
+    def _to_wire(self, file, compress=None, origin=None, canonicalize=False):
         header = struct.pack("!BBB", self.usage, self.selector, self.mtype)
         file.write(header)
         file.write(self.cert)
 
     @classmethod
-    def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin=None):
-        header = struct.unpack("!BBB", wire[current: current + 3])
-        current += 3
-        rdlen -= 3
-        cert = wire[current: current + rdlen].unwrap()
+    def from_wire_parser(cls, rdclass, rdtype, parser, origin=None):
+        header = parser.get_struct("BBB")
+        cert = parser.get_remaining()
         return cls(rdclass, rdtype, header[0], header[1], header[2], cert)
-

lib/dns/rdtypes/ANY/TSIG.py

@@ -0,0 +1,91 @@
+# 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.
+
+import struct
+
+import dns.exception
+import dns.rdata
+
+
+class TSIG(dns.rdata.Rdata):
+
+    """TSIG record"""
+
+    __slots__ = ['algorithm', 'time_signed', 'fudge', 'mac',
+                 'original_id', 'error', 'other']
+
+    def __init__(self, rdclass, rdtype, algorithm, time_signed, fudge, mac,
+                 original_id, error, other):
+        """Initialize a TSIG rdata.
+
+        *rdclass*, an ``int`` is the rdataclass of the Rdata.
+
+        *rdtype*, an ``int`` is the rdatatype of the Rdata.
+
+        *algorithm*, a ``dns.name.Name``.
+
+        *time_signed*, an ``int``.
+
+        *fudge*, an ``int`.
+
+        *mac*, a ``bytes``
+
+        *original_id*, an ``int``
+
+        *error*, an ``int``
+
+        *other*, a ``bytes``
+        """
+
+        super().__init__(rdclass, rdtype)
+        object.__setattr__(self, 'algorithm', algorithm)
+        object.__setattr__(self, 'time_signed', time_signed)
+        object.__setattr__(self, 'fudge', fudge)
+        object.__setattr__(self, 'mac', dns.rdata._constify(mac))
+        object.__setattr__(self, 'original_id', original_id)
+        object.__setattr__(self, 'error', error)
+        object.__setattr__(self, 'other', dns.rdata._constify(other))
+
+    def to_text(self, origin=None, relativize=True, **kw):
+        algorithm = self.algorithm.choose_relativity(origin, relativize)
+        return f"{algorithm} {self.fudge} {self.time_signed} " + \
+               f"{len(self.mac)} {dns.rdata._base64ify(self.mac, 0)} " + \
+               f"{self.original_id} {self.error} " + \
+               f"{len(self.other)} {dns.rdata._base64ify(self.other, 0)}"
+
+    def _to_wire(self, file, compress=None, origin=None, canonicalize=False):
+        self.algorithm.to_wire(file, None, origin, False)
+        file.write(struct.pack('!HIHH',
+                               (self.time_signed >> 32) & 0xffff,
+                               self.time_signed & 0xffffffff,
+                               self.fudge,
+                               len(self.mac)))
+        file.write(self.mac)
+        file.write(struct.pack('!HHH', self.original_id, self.error,
+                               len(self.other)))
+        file.write(self.other)
+
+    @classmethod
+    def from_wire_parser(cls, rdclass, rdtype, parser, origin=None):
+        algorithm = parser.get_name(origin)
+        (time_hi, time_lo, fudge) = parser.get_struct('!HIH')
+        time_signed = (time_hi << 32) + time_lo
+        mac = parser.get_counted_bytes(2)
+        (original_id, error) = parser.get_struct('!HH')
+        other = parser.get_counted_bytes(2)
+        return cls(rdclass, rdtype, algorithm, time_signed, fudge, mac,
+                   original_id, error, other)

lib/dns/rdtypes/ANY/TXT.py

@@ -1,3 +1,5 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
 # Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
 #
 # Permission to use, copy, modify, and distribute this software and its

lib/dns/rdtypes/ANY/URI.py

@@ -1,3 +1,5 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
 # Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
 # Copyright (C) 2015 Red Hat, Inc.
 #
@@ -19,40 +21,34 @@ import struct
 import dns.exception
 import dns.rdata
 import dns.name
-from dns._compat import text_type
 
 
 class URI(dns.rdata.Rdata):
 
-    """URI record
+    """URI record"""
 
-    @ivar priority: the priority
-    @type priority: int
-    @ivar weight: the weight
-    @type weight: int
-    @ivar target: the target host
-    @type target: dns.name.Name object
-    @see: draft-faltstrom-uri-13"""
+    # see RFC 7553
 
     __slots__ = ['priority', 'weight', 'target']
 
     def __init__(self, rdclass, rdtype, priority, weight, target):
-        super(URI, self).__init__(rdclass, rdtype)
-        self.priority = priority
-        self.weight = weight
+        super().__init__(rdclass, rdtype)
+        object.__setattr__(self, 'priority', priority)
+        object.__setattr__(self, 'weight', weight)
         if len(target) < 1:
             raise dns.exception.SyntaxError("URI target cannot be empty")
-        if isinstance(target, text_type):
-            self.target = target.encode()
+        if isinstance(target, str):
+            object.__setattr__(self, 'target', target.encode())
         else:
-            self.target = target
+            object.__setattr__(self, 'target', target)
 
     def to_text(self, origin=None, relativize=True, **kw):
         return '%d %d "%s"' % (self.priority, self.weight,
                                self.target.decode())
 
     @classmethod
-    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+                  relativize_to=None):
         priority = tok.get_uint16()
         weight = tok.get_uint16()
         target = tok.get().unescape()
@@ -61,21 +57,15 @@ class URI(dns.rdata.Rdata):
         tok.get_eol()
         return cls(rdclass, rdtype, priority, weight, target.value)
 
-    def to_wire(self, file, compress=None, origin=None):
+    def _to_wire(self, file, compress=None, origin=None, canonicalize=False):
         two_ints = struct.pack("!HH", self.priority, self.weight)
         file.write(two_ints)
         file.write(self.target)
 
     @classmethod
-    def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin=None):
-        if rdlen < 5:
-            raise dns.exception.FormError('URI RR is shorter than 5 octets')
-
-        (priority, weight) = struct.unpack('!HH', wire[current: current + 4])
-        current += 4
-        rdlen -= 4
-        target = wire[current: current + rdlen]
-        current += rdlen
-
+    def from_wire_parser(cls, rdclass, rdtype, parser, origin=None):
+        (priority, weight) = parser.get_struct('!HH')
+        target = parser.get_remaining()
+        if len(target) == 0:
+            raise dns.exception.FormError('URI target may not be empty')
         return cls(rdclass, rdtype, priority, weight, target)
-

lib/dns/rdtypes/ANY/X25.py

@@ -1,3 +1,5 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
 # Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
 #
 # Permission to use, copy, modify, and distribute this software and its
@@ -18,48 +20,40 @@ import struct
 import dns.exception
 import dns.rdata
 import dns.tokenizer
-from dns._compat import text_type
 
 
 class X25(dns.rdata.Rdata):
 
-    """X25 record
+    """X25 record"""
 
-    @ivar address: the PSDN address
-    @type address: string
-    @see: RFC 1183"""
+    # see RFC 1183
 
     __slots__ = ['address']
 
     def __init__(self, rdclass, rdtype, address):
-        super(X25, self).__init__(rdclass, rdtype)
-        if isinstance(address, text_type):
-            self.address = address.encode()
+        super().__init__(rdclass, rdtype)
+        if isinstance(address, str):
+            object.__setattr__(self, 'address', address.encode())
         else:
-            self.address = address
+            object.__setattr__(self, 'address', address)
 
     def to_text(self, origin=None, relativize=True, **kw):
         return '"%s"' % dns.rdata._escapify(self.address)
 
     @classmethod
-    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+                  relativize_to=None):
         address = tok.get_string()
         tok.get_eol()
         return cls(rdclass, rdtype, address)
 
-    def to_wire(self, file, compress=None, origin=None):
+    def _to_wire(self, file, compress=None, origin=None, canonicalize=False):
         l = len(self.address)
         assert l < 256
         file.write(struct.pack('!B', l))
         file.write(self.address)
 
     @classmethod
-    def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin=None):
-        l = wire[current]
-        current += 1
-        rdlen -= 1
-        if l != rdlen:
-            raise dns.exception.FormError
-        address = wire[current: current + l].unwrap()
+    def from_wire_parser(cls, rdclass, rdtype, parser, origin=None):
+        address = parser.get_counted_bytes()
         return cls(rdclass, rdtype, address)
-

lib/dns/rdtypes/ANY/__init__.py

@@ -1,3 +1,5 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
 # Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
 #
 # Permission to use, copy, modify, and distribute this software and its
@@ -17,10 +19,13 @@
 
 __all__ = [
     'AFSDB',
+    'AVC',
+    'CAA',
     'CDNSKEY',
     'CDS',
     'CERT',
     'CNAME',
+    'CSYNC',
     'DLV',
     'DNAME',
     'DNSKEY',
@@ -37,7 +42,8 @@ __all__ = [
     'NSEC',
     'NSEC3',
     'NSEC3PARAM',
-    'TLSA',
+    'OPENPGPKEY',
+    'OPT',
     'PTR',
     'RP',
     'RRSIG',
@@ -45,6 +51,9 @@ __all__ = [
     'SOA',
     'SPF',
     'SSHFP',
+    'TLSA',
+    'TSIG',
     'TXT',
+    'URI',
     'X25',
 ]

lib/dns/rdtypes/CH/A.py

@@ -0,0 +1,56 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
+# Copyright (C) 2003-2007, 2009-2011 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.
+
+import dns.rdtypes.mxbase
+import struct
+
+class A(dns.rdata.Rdata):
+
+    """A record for Chaosnet"""
+
+    # domain: the domain of the address
+    # address: the 16-bit address
+
+    __slots__ = ['domain', 'address']
+
+    def __init__(self, rdclass, rdtype, domain, address):
+        super().__init__(rdclass, rdtype)
+        object.__setattr__(self, 'domain', domain)
+        object.__setattr__(self, 'address', address)
+
+    def to_text(self, origin=None, relativize=True, **kw):
+        domain = self.domain.choose_relativity(origin, relativize)
+        return '%s %o' % (domain, self.address)
+
+    @classmethod
+    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+                  relativize_to=None):
+        domain = tok.get_name(origin, relativize, relativize_to)
+        address = tok.get_uint16(base=8)
+        tok.get_eol()
+        return cls(rdclass, rdtype, domain, address)
+
+    def _to_wire(self, file, compress=None, origin=None, canonicalize=False):
+        self.domain.to_wire(file, compress, origin, canonicalize)
+        pref = struct.pack("!H", self.address)
+        file.write(pref)
+
+    @classmethod
+    def from_wire_parser(cls, rdclass, rdtype, parser, origin=None):
+        domain = parser.get_name(origin)
+        address = parser.get_uint16()
+        return cls(rdclass, rdtype, domain, address)

lib/dns/rdtypes/CH/__init__.py

@@ -0,0 +1,22 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
+# Copyright (C) 2003-2007, 2009-2011 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.
+
+"""Class CH rdata type classes."""
+
+__all__ = [
+    'A',
+]

lib/dns/rdtypes/IN/A.py

@@ -1,3 +1,5 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
 # Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
 #
 # Permission to use, copy, modify, and distribute this software and its
@@ -21,33 +23,30 @@ import dns.tokenizer
 
 class A(dns.rdata.Rdata):
 
-    """A record.
-
-    @ivar address: an IPv4 address
-    @type address: string (in the standard "dotted quad" format)"""
+    """A record."""
 
     __slots__ = ['address']
 
     def __init__(self, rdclass, rdtype, address):
-        super(A, self).__init__(rdclass, rdtype)
+        super().__init__(rdclass, rdtype)
         # check that it's OK
         dns.ipv4.inet_aton(address)
-        self.address = address
+        object.__setattr__(self, 'address', address)
 
     def to_text(self, origin=None, relativize=True, **kw):
         return self.address
 
     @classmethod
-    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+                  relativize_to=None):
         address = tok.get_identifier()
         tok.get_eol()
         return cls(rdclass, rdtype, address)
 
-    def to_wire(self, file, compress=None, origin=None):
+    def _to_wire(self, file, compress=None, origin=None, canonicalize=False):
         file.write(dns.ipv4.inet_aton(self.address))
 
     @classmethod
-    def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin=None):
-        address = dns.ipv4.inet_ntoa(wire[current: current + rdlen]).decode()
+    def from_wire_parser(cls, rdclass, rdtype, parser, origin=None):
+        address = dns.ipv4.inet_ntoa(parser.get_remaining())
         return cls(rdclass, rdtype, address)
-

lib/dns/rdtypes/IN/AAAA.py

@@ -1,3 +1,5 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
 # Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
 #
 # Permission to use, copy, modify, and distribute this software and its
@@ -14,41 +16,37 @@
 # OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
 import dns.exception
-import dns.inet
+import dns.ipv6
 import dns.rdata
 import dns.tokenizer
 
 
 class AAAA(dns.rdata.Rdata):
 
-    """AAAA record.
-
-    @ivar address: an IPv6 address
-    @type address: string (in the standard IPv6 format)"""
+    """AAAA record."""
 
     __slots__ = ['address']
 
     def __init__(self, rdclass, rdtype, address):
-        super(AAAA, self).__init__(rdclass, rdtype)
+        super().__init__(rdclass, rdtype)
         # check that it's OK
-        dns.inet.inet_pton(dns.inet.AF_INET6, address)
-        self.address = address
+        dns.ipv6.inet_aton(address)
+        object.__setattr__(self, 'address', address)
 
     def to_text(self, origin=None, relativize=True, **kw):
         return self.address
 
     @classmethod
-    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+                  relativize_to=None):
         address = tok.get_identifier()
         tok.get_eol()
         return cls(rdclass, rdtype, address)
 
-    def to_wire(self, file, compress=None, origin=None):
-        file.write(dns.inet.inet_pton(dns.inet.AF_INET6, self.address))
+    def _to_wire(self, file, compress=None, origin=None, canonicalize=False):
+        file.write(dns.ipv6.inet_aton(self.address))
 
     @classmethod
-    def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin=None):
-        address = dns.inet.inet_ntop(dns.inet.AF_INET6,
-                                     wire[current: current + rdlen])
+    def from_wire_parser(cls, rdclass, rdtype, parser, origin=None):
+        address = dns.ipv6.inet_ntoa(parser.get_remaining())
         return cls(rdclass, rdtype, address)
-

lib/dns/rdtypes/IN/APL.py

@@ -1,4 +1,6 @@
-# Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
+# Copyright (C) 2003-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,
@@ -13,29 +15,19 @@
 # ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
 # OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
-import struct
 import binascii
+import codecs
+import struct
 
 import dns.exception
-import dns.inet
+import dns.ipv4
+import dns.ipv6
 import dns.rdata
 import dns.tokenizer
-from dns._compat import xrange
 
+class APLItem:
 
-class APLItem(object):
-
-    """An APL list item.
-
-    @ivar family: the address family (IANA address family registry)
-    @type family: int
-    @ivar negation: is this item negated?
-    @type negation: bool
-    @ivar address: the address
-    @type address: string
-    @ivar prefix: the prefix length
-    @type prefix: int
-    """
+    """An APL list item."""
 
     __slots__ = ['family', 'negation', 'address', 'prefix']
 
@@ -53,17 +45,17 @@ class APLItem(object):
 
     def to_wire(self, file):
         if self.family == 1:
-            address = dns.inet.inet_pton(dns.inet.AF_INET, self.address)
+            address = dns.ipv4.inet_aton(self.address)
         elif self.family == 2:
-            address = dns.inet.inet_pton(dns.inet.AF_INET6, self.address)
+            address = dns.ipv6.inet_aton(self.address)
         else:
             address = binascii.unhexlify(self.address)
         #
         # Truncate least significant zero bytes.
         #
         last = 0
-        for i in xrange(len(address) - 1, -1, -1):
-            if address[i] != chr(0):
+        for i in range(len(address) - 1, -1, -1):
+            if address[i] != 0:
                 last = i + 1
                 break
         address = address[0: last]
@@ -78,25 +70,24 @@ class APLItem(object):
 
 class APL(dns.rdata.Rdata):
 
-    """APL record.
+    """APL record."""
 
-    @ivar items: a list of APL items
-    @type items: list of APL_Item
-    @see: RFC 3123"""
+    # see: RFC 3123
 
     __slots__ = ['items']
 
     def __init__(self, rdclass, rdtype, items):
-        super(APL, self).__init__(rdclass, rdtype)
-        self.items = items
+        super().__init__(rdclass, rdtype)
+        object.__setattr__(self, 'items', dns.rdata._constify(items))
 
     def to_text(self, origin=None, relativize=True, **kw):
-        return ' '.join(map(lambda x: str(x), self.items))
+        return ' '.join(map(str, self.items))
 
     @classmethod
-    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+                  relativize_to=None):
         items = []
-        while 1:
+        while True:
             token = tok.get().unescape()
             if token.is_eol_or_eof():
                 break
@@ -115,48 +106,38 @@ class APL(dns.rdata.Rdata):
 
         return cls(rdclass, rdtype, items)
 
-    def to_wire(self, file, compress=None, origin=None):
+    def _to_wire(self, file, compress=None, origin=None, canonicalize=False):
         for item in self.items:
             item.to_wire(file)
 
     @classmethod
-    def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin=None):
+    def from_wire_parser(cls, rdclass, rdtype, parser, origin=None):
+
         items = []
-        while 1:
-            if rdlen == 0:
-                break
-            if rdlen < 4:
-                raise dns.exception.FormError
-            header = struct.unpack('!HBB', wire[current: current + 4])
+        while parser.remaining() > 0:
+            header = parser.get_struct('!HBB')
             afdlen = header[2]
             if afdlen > 127:
                 negation = True
                 afdlen -= 128
             else:
                 negation = False
-            current += 4
-            rdlen -= 4
-            if rdlen < afdlen:
-                raise dns.exception.FormError
-            address = wire[current: current + afdlen].unwrap()
+            address = parser.get_bytes(afdlen)
             l = len(address)
             if header[0] == 1:
                 if l < 4:
-                    address += '\x00' * (4 - l)
-                address = dns.inet.inet_ntop(dns.inet.AF_INET, address)
+                    address += b'\x00' * (4 - l)
+                address = dns.ipv4.inet_ntoa(address)
             elif header[0] == 2:
                 if l < 16:
-                    address += '\x00' * (16 - l)
-                address = dns.inet.inet_ntop(dns.inet.AF_INET6, address)
+                    address += b'\x00' * (16 - l)
+                address = dns.ipv6.inet_ntoa(address)
             else:
                 #
                 # This isn't really right according to the RFC, but it
                 # seems better than throwing an exception
                 #
-                address = address.encode('hex_codec')
-            current += afdlen
-            rdlen -= afdlen
+                address = codecs.encode(address, 'hex_codec')
             item = APLItem(header[0], negation, address, header[1])
             items.append(item)
         return cls(rdclass, rdtype, items)
-

lib/dns/rdtypes/IN/DHCID.py

@@ -1,3 +1,5 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
 # Copyright (C) 2006, 2007, 2009-2011 Nominum, Inc.
 #
 # Permission to use, copy, modify, and distribute this software and its
@@ -20,41 +22,30 @@ import dns.exception
 
 class DHCID(dns.rdata.Rdata):
 
-    """DHCID record
+    """DHCID record"""
 
-    @ivar data: the data (the content of the RR is opaque as far as the
-    DNS is concerned)
-    @type data: string
-    @see: RFC 4701"""
+    # see: RFC 4701
 
     __slots__ = ['data']
 
     def __init__(self, rdclass, rdtype, data):
-        super(DHCID, self).__init__(rdclass, rdtype)
-        self.data = data
+        super().__init__(rdclass, rdtype)
+        object.__setattr__(self, 'data', data)
 
     def to_text(self, origin=None, relativize=True, **kw):
         return dns.rdata._base64ify(self.data)
 
     @classmethod
-    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
-        chunks = []
-        while 1:
-            t = tok.get().unescape()
-            if t.is_eol_or_eof():
-                break
-            if not t.is_identifier():
-                raise dns.exception.SyntaxError
-            chunks.append(t.value.encode())
-        b64 = b''.join(chunks)
+    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+                  relativize_to=None):
+        b64 = tok.concatenate_remaining_identifiers().encode()
         data = base64.b64decode(b64)
         return cls(rdclass, rdtype, data)
 
-    def to_wire(self, file, compress=None, origin=None):
+    def _to_wire(self, file, compress=None, origin=None, canonicalize=False):
         file.write(self.data)
 
     @classmethod
-    def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin=None):
-        data = wire[current: current + rdlen].unwrap()
+    def from_wire_parser(cls, rdclass, rdtype, parser, origin=None):
+        data = parser.get_remaining()
         return cls(rdclass, rdtype, data)
-

lib/dns/rdtypes/IN/IPSECKEY.py

@@ -1,3 +1,5 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
 # Copyright (C) 2006, 2007, 2009-2011 Nominum, Inc.
 #
 # Permission to use, copy, modify, and distribute this software and its
@@ -17,133 +19,63 @@ import struct
 import base64
 
 import dns.exception
-import dns.inet
-import dns.name
+import dns.rdtypes.util
 
 
+class Gateway(dns.rdtypes.util.Gateway):
+    name = 'IPSECKEY gateway'
+
 class IPSECKEY(dns.rdata.Rdata):
 
-    """IPSECKEY record
+    """IPSECKEY record"""
 
-    @ivar precedence: the precedence for this key data
-    @type precedence: int
-    @ivar gateway_type: the gateway type
-    @type gateway_type: int
-    @ivar algorithm: the algorithm to use
-    @type algorithm: int
-    @ivar gateway: the public key
-    @type gateway: None, IPv4 address, IPV6 address, or domain name
-    @ivar key: the public key
-    @type key: string
-    @see: RFC 4025"""
+    # see: RFC 4025
 
     __slots__ = ['precedence', 'gateway_type', 'algorithm', 'gateway', 'key']
 
     def __init__(self, rdclass, rdtype, precedence, gateway_type, algorithm,
                  gateway, key):
-        super(IPSECKEY, self).__init__(rdclass, rdtype)
-        if gateway_type == 0:
-            if gateway != '.' and gateway is not None:
-                raise SyntaxError('invalid gateway for gateway type 0')
-            gateway = None
-        elif gateway_type == 1:
-            # check that it's OK
-            dns.inet.inet_pton(dns.inet.AF_INET, gateway)
-        elif gateway_type == 2:
-            # check that it's OK
-            dns.inet.inet_pton(dns.inet.AF_INET6, gateway)
-        elif gateway_type == 3:
-            pass
-        else:
-            raise SyntaxError(
-                'invalid IPSECKEY gateway type: %d' % gateway_type)
-        self.precedence = precedence
-        self.gateway_type = gateway_type
-        self.algorithm = algorithm
-        self.gateway = gateway
-        self.key = key
+        super().__init__(rdclass, rdtype)
+        Gateway(gateway_type, gateway).check()
+        object.__setattr__(self, 'precedence', precedence)
+        object.__setattr__(self, 'gateway_type', gateway_type)
+        object.__setattr__(self, 'algorithm', algorithm)
+        object.__setattr__(self, 'gateway', gateway)
+        object.__setattr__(self, 'key', key)
 
     def to_text(self, origin=None, relativize=True, **kw):
-        if self.gateway_type == 0:
-            gateway = '.'
-        elif self.gateway_type == 1:
-            gateway = self.gateway
-        elif self.gateway_type == 2:
-            gateway = self.gateway
-        elif self.gateway_type == 3:
-            gateway = str(self.gateway.choose_relativity(origin, relativize))
-        else:
-            raise ValueError('invalid gateway type')
+        gateway = Gateway(self.gateway_type, self.gateway).to_text(origin,
+                                                                   relativize)
         return '%d %d %d %s %s' % (self.precedence, self.gateway_type,
                                    self.algorithm, gateway,
                                    dns.rdata._base64ify(self.key))
 
     @classmethod
-    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+                  relativize_to=None):
         precedence = tok.get_uint8()
         gateway_type = tok.get_uint8()
         algorithm = tok.get_uint8()
-        if gateway_type == 3:
-            gateway = tok.get_name().choose_relativity(origin, relativize)
-        else:
-            gateway = tok.get_string()
-        chunks = []
-        while 1:
-            t = tok.get().unescape()
-            if t.is_eol_or_eof():
-                break
-            if not t.is_identifier():
-                raise dns.exception.SyntaxError
-            chunks.append(t.value.encode())
-        b64 = b''.join(chunks)
+        gateway = Gateway(gateway_type).from_text(tok, origin, relativize,
+                                                  relativize_to)
+        b64 = tok.concatenate_remaining_identifiers().encode()
         key = base64.b64decode(b64)
         return cls(rdclass, rdtype, precedence, gateway_type, algorithm,
                    gateway, key)
 
-    def to_wire(self, file, compress=None, origin=None):
+    def _to_wire(self, file, compress=None, origin=None, canonicalize=False):
         header = struct.pack("!BBB", self.precedence, self.gateway_type,
                              self.algorithm)
         file.write(header)
-        if self.gateway_type == 0:
-            pass
-        elif self.gateway_type == 1:
-            file.write(dns.inet.inet_pton(dns.inet.AF_INET, self.gateway))
-        elif self.gateway_type == 2:
-            file.write(dns.inet.inet_pton(dns.inet.AF_INET6, self.gateway))
-        elif self.gateway_type == 3:
-            self.gateway.to_wire(file, None, origin)
-        else:
-            raise ValueError('invalid gateway type')
+        Gateway(self.gateway_type, self.gateway).to_wire(file, compress,
+                                                         origin, canonicalize)
         file.write(self.key)
 
     @classmethod
-    def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin=None):
-        if rdlen < 3:
-            raise dns.exception.FormError
-        header = struct.unpack('!BBB', wire[current: current + 3])
+    def from_wire_parser(cls, rdclass, rdtype, parser, origin=None):
+        header = parser.get_struct('!BBB')
         gateway_type = header[1]
-        current += 3
-        rdlen -= 3
-        if gateway_type == 0:
-            gateway = None
-        elif gateway_type == 1:
-            gateway = dns.inet.inet_ntop(dns.inet.AF_INET,
-                                         wire[current: current + 4])
-            current += 4
-            rdlen -= 4
-        elif gateway_type == 2:
-            gateway = dns.inet.inet_ntop(dns.inet.AF_INET6,
-                                         wire[current: current + 16])
-            current += 16
-            rdlen -= 16
-        elif gateway_type == 3:
-            (gateway, cused) = dns.name.from_wire(wire[: current + rdlen],
-                                                  current)
-            current += cused
-            rdlen -= cused
-        else:
-            raise dns.exception.FormError('invalid IPSECKEY gateway type')
-        key = wire[current: current + rdlen].unwrap()
+        gateway = Gateway(gateway_type).from_wire_parser(parser, origin)
+        key = parser.get_remaining()
         return cls(rdclass, rdtype, header[0], gateway_type, header[2],
                    gateway, key)
-

lib/dns/rdtypes/IN/KX.py

@@ -1,3 +1,5 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
 # Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
 #
 # Permission to use, copy, modify, and distribute this software and its
@@ -16,6 +18,6 @@
 import dns.rdtypes.mxbase
 
 
-class KX(dns.rdtypes.mxbase.UncompressedMX):
+class KX(dns.rdtypes.mxbase.UncompressedDowncasingMX):
 
     """KX record"""

lib/dns/rdtypes/IN/NAPTR.py

@@ -1,3 +1,5 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
 # Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
 #
 # Permission to use, copy, modify, and distribute this software and its
@@ -18,7 +20,6 @@ import struct
 import dns.exception
 import dns.name
 import dns.rdata
-from dns._compat import xrange, text_type
 
 
 def _write_string(file, s):
@@ -29,41 +30,29 @@ def _write_string(file, s):
 
 
 def _sanitize(value):
-    if isinstance(value, text_type):
+    if isinstance(value, str):
         return value.encode()
     return value
 
 
 class NAPTR(dns.rdata.Rdata):
 
-    """NAPTR record
+    """NAPTR record"""
 
-    @ivar order: order
-    @type order: int
-    @ivar preference: preference
-    @type preference: int
-    @ivar flags: flags
-    @type flags: string
-    @ivar service: service
-    @type service: string
-    @ivar regexp: regular expression
-    @type regexp: string
-    @ivar replacement: replacement name
-    @type replacement: dns.name.Name object
-    @see: RFC 3403"""
+    # see: RFC 3403
 
     __slots__ = ['order', 'preference', 'flags', 'service', 'regexp',
                  'replacement']
 
     def __init__(self, rdclass, rdtype, order, preference, flags, service,
                  regexp, replacement):
-        super(NAPTR, self).__init__(rdclass, rdtype)
-        self.flags = _sanitize(flags)
-        self.service = _sanitize(service)
-        self.regexp = _sanitize(regexp)
-        self.order = order
-        self.preference = preference
-        self.replacement = replacement
+        super().__init__(rdclass, rdtype)
+        object.__setattr__(self, 'flags', _sanitize(flags))
+        object.__setattr__(self, 'service', _sanitize(service))
+        object.__setattr__(self, 'regexp', _sanitize(regexp))
+        object.__setattr__(self, 'order', order)
+        object.__setattr__(self, 'preference', preference)
+        object.__setattr__(self, 'replacement', replacement)
 
     def to_text(self, origin=None, relativize=True, **kw):
         replacement = self.replacement.choose_relativity(origin, relativize)
@@ -75,51 +64,33 @@ class NAPTR(dns.rdata.Rdata):
                 replacement)
 
     @classmethod
-    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+                  relativize_to=None):
         order = tok.get_uint16()
         preference = tok.get_uint16()
         flags = tok.get_string()
         service = tok.get_string()
         regexp = tok.get_string()
-        replacement = tok.get_name()
-        replacement = replacement.choose_relativity(origin, relativize)
+        replacement = tok.get_name(origin, relativize, relativize_to)
         tok.get_eol()
         return cls(rdclass, rdtype, order, preference, flags, service,
                    regexp, replacement)
 
-    def to_wire(self, file, compress=None, origin=None):
+    def _to_wire(self, file, compress=None, origin=None, canonicalize=False):
         two_ints = struct.pack("!HH", self.order, self.preference)
         file.write(two_ints)
         _write_string(file, self.flags)
         _write_string(file, self.service)
         _write_string(file, self.regexp)
-        self.replacement.to_wire(file, compress, origin)
+        self.replacement.to_wire(file, compress, origin, canonicalize)
 
     @classmethod
-    def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin=None):
-        (order, preference) = struct.unpack('!HH', wire[current: current + 4])
-        current += 4
-        rdlen -= 4
+    def from_wire_parser(cls, rdclass, rdtype, parser, origin=None):
+        (order, preference) = parser.get_struct('!HH')
         strings = []
-        for i in xrange(3):
-            l = wire[current]
-            current += 1
-            rdlen -= 1
-            if l > rdlen or rdlen < 0:
-                raise dns.exception.FormError
-            s = wire[current: current + l].unwrap()
-            current += l
-            rdlen -= l
+        for i in range(3):
+            s = parser.get_counted_bytes()
             strings.append(s)
-        (replacement, cused) = dns.name.from_wire(wire[: current + rdlen],
-                                                  current)
-        if cused != rdlen:
-            raise dns.exception.FormError
-        if origin is not None:
-            replacement = replacement.relativize(origin)
+        replacement = parser.get_name(origin)
         return cls(rdclass, rdtype, order, preference, strings[0], strings[1],
                    strings[2], replacement)
-
-    def choose_relativity(self, origin=None, relativize=True):
-        self.replacement = self.replacement.choose_relativity(origin,
-                                                              relativize)

lib/dns/rdtypes/IN/NSAP.py

@@ -1,3 +1,5 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
 # Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
 #
 # Permission to use, copy, modify, and distribute this software and its
@@ -22,23 +24,22 @@ import dns.tokenizer
 
 class NSAP(dns.rdata.Rdata):
 
-    """NSAP record.
+    """NSAP record."""
 
-    @ivar address: a NASP
-    @type address: string
-    @see: RFC 1706"""
+    # see: RFC 1706
 
     __slots__ = ['address']
 
     def __init__(self, rdclass, rdtype, address):
-        super(NSAP, self).__init__(rdclass, rdtype)
-        self.address = address
+        super().__init__(rdclass, rdtype)
+        object.__setattr__(self, 'address', address)
 
     def to_text(self, origin=None, relativize=True, **kw):
         return "0x%s" % binascii.hexlify(self.address).decode()
 
     @classmethod
-    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+                  relativize_to=None):
         address = tok.get_string()
         tok.get_eol()
         if address[0:2] != '0x':
@@ -49,11 +50,10 @@ class NSAP(dns.rdata.Rdata):
         address = binascii.unhexlify(address.encode())
         return cls(rdclass, rdtype, address)
 
-    def to_wire(self, file, compress=None, origin=None):
+    def _to_wire(self, file, compress=None, origin=None, canonicalize=False):
         file.write(self.address)
 
     @classmethod
-    def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin=None):
-        address = wire[current: current + rdlen].unwrap()
+    def from_wire_parser(cls, rdclass, rdtype, parser, origin=None):
+        address = parser.get_remaining()
         return cls(rdclass, rdtype, address)
-

lib/dns/rdtypes/IN/NSAP_PTR.py

@@ -1,3 +1,5 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
 # Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
 #
 # Permission to use, copy, modify, and distribute this software and its

lib/dns/rdtypes/IN/PX.py

@@ -1,3 +1,5 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
 # Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
 #
 # Permission to use, copy, modify, and distribute this software and its
@@ -22,23 +24,17 @@ import dns.name
 
 class PX(dns.rdata.Rdata):
 
-    """PX record.
+    """PX record."""
 
-    @ivar preference: the preference value
-    @type preference: int
-    @ivar map822: the map822 name
-    @type map822: dns.name.Name object
-    @ivar mapx400: the mapx400 name
-    @type mapx400: dns.name.Name object
-    @see: RFC 2163"""
+    # see: RFC 2163
 
     __slots__ = ['preference', 'map822', 'mapx400']
 
     def __init__(self, rdclass, rdtype, preference, map822, mapx400):
-        super(PX, self).__init__(rdclass, rdtype)
-        self.preference = preference
-        self.map822 = map822
-        self.mapx400 = mapx400
+        super().__init__(rdclass, rdtype)
+        object.__setattr__(self, 'preference', preference)
+        object.__setattr__(self, 'map822', map822)
+        object.__setattr__(self, 'mapx400', mapx400)
 
     def to_text(self, origin=None, relativize=True, **kw):
         map822 = self.map822.choose_relativity(origin, relativize)
@@ -46,42 +42,23 @@ class PX(dns.rdata.Rdata):
         return '%d %s %s' % (self.preference, map822, mapx400)
 
     @classmethod
-    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+                  relativize_to=None):
         preference = tok.get_uint16()
-        map822 = tok.get_name()
-        map822 = map822.choose_relativity(origin, relativize)
-        mapx400 = tok.get_name(None)
-        mapx400 = mapx400.choose_relativity(origin, relativize)
+        map822 = tok.get_name(origin, relativize, relativize_to)
+        mapx400 = tok.get_name(origin, relativize, relativize_to)
         tok.get_eol()
         return cls(rdclass, rdtype, preference, map822, mapx400)
 
-    def to_wire(self, file, compress=None, origin=None):
+    def _to_wire(self, file, compress=None, origin=None, canonicalize=False):
         pref = struct.pack("!H", self.preference)
         file.write(pref)
-        self.map822.to_wire(file, None, origin)
-        self.mapx400.to_wire(file, None, origin)
+        self.map822.to_wire(file, None, origin, canonicalize)
+        self.mapx400.to_wire(file, None, origin, canonicalize)
 
     @classmethod
-    def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin=None):
-        (preference, ) = struct.unpack('!H', wire[current: current + 2])
-        current += 2
-        rdlen -= 2
-        (map822, cused) = dns.name.from_wire(wire[: current + rdlen],
-                                             current)
-        if cused > rdlen:
-            raise dns.exception.FormError
-        current += cused
-        rdlen -= cused
-        if origin is not None:
-            map822 = map822.relativize(origin)
-        (mapx400, cused) = dns.name.from_wire(wire[: current + rdlen],
-                                              current)
-        if cused != rdlen:
-            raise dns.exception.FormError
-        if origin is not None:
-            mapx400 = mapx400.relativize(origin)
+    def from_wire_parser(cls, rdclass, rdtype, parser, origin=None):
+        preference = parser.get_uint16()
+        map822 = parser.get_name(origin)
+        mapx400 = parser.get_name(origin)
         return cls(rdclass, rdtype, preference, map822, mapx400)
-
-    def choose_relativity(self, origin=None, relativize=True):
-        self.map822 = self.map822.choose_relativity(origin, relativize)
-        self.mapx400 = self.mapx400.choose_relativity(origin, relativize)

lib/dns/rdtypes/IN/SRV.py

@@ -1,3 +1,5 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
 # Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
 #
 # Permission to use, copy, modify, and distribute this software and its
@@ -22,26 +24,18 @@ import dns.name
 
 class SRV(dns.rdata.Rdata):
 
-    """SRV record
+    """SRV record"""
 
-    @ivar priority: the priority
-    @type priority: int
-    @ivar weight: the weight
-    @type weight: int
-    @ivar port: the port of the service
-    @type port: int
-    @ivar target: the target host
-    @type target: dns.name.Name object
-    @see: RFC 2782"""
+    # see: RFC 2782
 
     __slots__ = ['priority', 'weight', 'port', 'target']
 
     def __init__(self, rdclass, rdtype, priority, weight, port, target):
-        super(SRV, self).__init__(rdclass, rdtype)
-        self.priority = priority
-        self.weight = weight
-        self.port = port
-        self.target = target
+        super().__init__(rdclass, rdtype)
+        object.__setattr__(self, 'priority', priority)
+        object.__setattr__(self, 'weight', weight)
+        object.__setattr__(self, 'port', port)
+        object.__setattr__(self, 'target', target)
 
     def to_text(self, origin=None, relativize=True, **kw):
         target = self.target.choose_relativity(origin, relativize)
@@ -49,33 +43,22 @@ class SRV(dns.rdata.Rdata):
                                 target)
 
     @classmethod
-    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+                  relativize_to=None):
         priority = tok.get_uint16()
         weight = tok.get_uint16()
         port = tok.get_uint16()
-        target = tok.get_name(None)
-        target = target.choose_relativity(origin, relativize)
+        target = tok.get_name(origin, relativize, relativize_to)
         tok.get_eol()
         return cls(rdclass, rdtype, priority, weight, port, target)
 
-    def to_wire(self, file, compress=None, origin=None):
+    def _to_wire(self, file, compress=None, origin=None, canonicalize=False):
         three_ints = struct.pack("!HHH", self.priority, self.weight, self.port)
         file.write(three_ints)
-        self.target.to_wire(file, compress, origin)
+        self.target.to_wire(file, compress, origin, canonicalize)
 
     @classmethod
-    def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin=None):
-        (priority, weight, port) = struct.unpack('!HHH',
-                                                 wire[current: current + 6])
-        current += 6
-        rdlen -= 6
-        (target, cused) = dns.name.from_wire(wire[: current + rdlen],
-                                             current)
-        if cused != rdlen:
-            raise dns.exception.FormError
-        if origin is not None:
-            target = target.relativize(origin)
+    def from_wire_parser(cls, rdclass, rdtype, parser, origin=None):
+        (priority, weight, port) = parser.get_struct('!HHH')
+        target = parser.get_name(origin)
         return cls(rdclass, rdtype, priority, weight, port, target)
-
-    def choose_relativity(self, origin=None, relativize=True):
-        self.target = self.target.choose_relativity(origin, relativize)

lib/dns/rdtypes/IN/WKS.py

@@ -1,3 +1,5 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
 # Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
 #
 # Permission to use, copy, modify, and distribute this software and its
@@ -18,7 +20,6 @@ import struct
 
 import dns.ipv4
 import dns.rdata
-from dns._compat import xrange
 
 _proto_tcp = socket.getprotobyname('tcp')
 _proto_udp = socket.getprotobyname('udp')
@@ -26,39 +27,31 @@ _proto_udp = socket.getprotobyname('udp')
 
 class WKS(dns.rdata.Rdata):
 
-    """WKS record
+    """WKS record"""
 
-    @ivar address: the address
-    @type address: string
-    @ivar protocol: the protocol
-    @type protocol: int
-    @ivar bitmap: the bitmap
-    @type bitmap: string
-    @see: RFC 1035"""
+    # see: RFC 1035
 
     __slots__ = ['address', 'protocol', 'bitmap']
 
     def __init__(self, rdclass, rdtype, address, protocol, bitmap):
-        super(WKS, self).__init__(rdclass, rdtype)
-        self.address = address
-        self.protocol = protocol
-        if not isinstance(bitmap, bytearray):
-            self.bitmap = bytearray(bitmap)
-        else:
-            self.bitmap = bitmap
+        super().__init__(rdclass, rdtype)
+        object.__setattr__(self, 'address', address)
+        object.__setattr__(self, 'protocol', protocol)
+        object.__setattr__(self, 'bitmap', dns.rdata._constify(bitmap))
 
     def to_text(self, origin=None, relativize=True, **kw):
         bits = []
-        for i in xrange(0, len(self.bitmap)):
+        for i in range(0, len(self.bitmap)):
             byte = self.bitmap[i]
-            for j in xrange(0, 8):
+            for j in range(0, 8):
                 if byte & (0x80 >> j):
                     bits.append(str(i * 8 + j))
         text = ' '.join(bits)
         return '%s %d %s' % (self.address, self.protocol, text)
 
     @classmethod
-    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+                  relativize_to=None):
         address = tok.get_string()
         protocol = tok.get_string()
         if protocol.isdigit():
@@ -83,24 +76,21 @@ class WKS(dns.rdata.Rdata):
             i = serv // 8
             l = len(bitmap)
             if l < i + 1:
-                for j in xrange(l, i + 1):
+                for j in range(l, i + 1):
                     bitmap.append(0)
             bitmap[i] = bitmap[i] | (0x80 >> (serv % 8))
         bitmap = dns.rdata._truncate_bitmap(bitmap)
         return cls(rdclass, rdtype, address, protocol, bitmap)
 
-    def to_wire(self, file, compress=None, origin=None):
+    def _to_wire(self, file, compress=None, origin=None, canonicalize=False):
         file.write(dns.ipv4.inet_aton(self.address))
         protocol = struct.pack('!B', self.protocol)
         file.write(protocol)
         file.write(self.bitmap)
 
     @classmethod
-    def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin=None):
-        address = dns.ipv4.inet_ntoa(wire[current: current + 4])
-        protocol, = struct.unpack('!B', wire[current + 4: current + 5])
-        current += 5
-        rdlen -= 5
-        bitmap = wire[current: current + rdlen].unwrap()
+    def from_wire_parser(cls, rdclass, rdtype, parser, origin=None):
+        address = dns.ipv4.inet_ntoa(parser.get_bytes(4))
+        protocol = parser.get_uint8()
+        bitmap = parser.get_remaining()
         return cls(rdclass, rdtype, address, protocol, bitmap)
-

lib/dns/rdtypes/IN/__init__.py

@@ -1,3 +1,5 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
 # Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
 #
 # Permission to use, copy, modify, and distribute this software and its
@@ -20,6 +22,7 @@ __all__ = [
     'AAAA',
     'APL',
     'DHCID',
+    'IPSECKEY',
     'KX',
     'NAPTR',
     'NSAP',

lib/dns/rdtypes/__init__.py

@@ -1,3 +1,5 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
 # Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
 #
 # Permission to use, copy, modify, and distribute this software and its
@@ -18,7 +20,9 @@
 __all__ = [
     'ANY',
     'IN',
+    'CH',
     'euibase',
     'mxbase',
     'nsbase',
+    'util'
 ]

lib/dns/rdtypes/dnskeybase.py

@@ -1,3 +1,5 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
 # Copyright (C) 2004-2007, 2009-2011 Nominum, Inc.
 #
 # Permission to use, copy, modify, and distribute this software and its
@@ -14,6 +16,7 @@
 # OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
 import base64
+import enum
 import struct
 
 import dns.exception
@@ -21,116 +24,51 @@ import dns.dnssec
 import dns.rdata
 
 # wildcard import
-__all__ = ["SEP", "REVOKE", "ZONE",
-           "flags_to_text_set", "flags_from_text_set"]
+__all__ = ["SEP", "REVOKE", "ZONE"]   # noqa: F822
 
-# flag constants
+class Flag(enum.IntFlag):
     SEP = 0x0001
     REVOKE = 0x0080
     ZONE = 0x0100
 
-_flag_by_text = {
-    'SEP': SEP,
-    'REVOKE': REVOKE,
-    'ZONE': ZONE
-}
-
-# We construct the inverse mapping programmatically to ensure that we
-# cannot make any mistakes (e.g. omissions, cut-and-paste errors) that
-# would cause the mapping not to be true inverse.
-_flag_by_value = dict((y, x) for x, y in _flag_by_text.items())
-
-
-def flags_to_text_set(flags):
-    """Convert a DNSKEY flags value to set texts
-    @rtype: set([string])"""
-
-    flags_set = set()
-    mask = 0x1
-    while mask <= 0x8000:
-        if flags & mask:
-            text = _flag_by_value.get(mask)
-            if not text:
-                text = hex(mask)
-            flags_set.add(text)
-        mask <<= 1
-    return flags_set
-
-
-def flags_from_text_set(texts_set):
-    """Convert set of DNSKEY flag mnemonic texts to DNSKEY flag value
-    @rtype: int"""
-
-    flags = 0
-    for text in texts_set:
-        try:
-            flags += _flag_by_text[text]
-        except KeyError:
-            raise NotImplementedError(
-                "DNSKEY flag '%s' is not supported" % text)
-    return flags
+globals().update(Flag.__members__)
 
 
 class DNSKEYBase(dns.rdata.Rdata):
 
-    """Base class for rdata that is like a DNSKEY record
-
-    @ivar flags: the key flags
-    @type flags: int
-    @ivar protocol: the protocol for which this key may be used
-    @type protocol: int
-    @ivar algorithm: the algorithm used for the key
-    @type algorithm: int
-    @ivar key: the public key
-    @type key: string"""
+    """Base class for rdata that is like a DNSKEY record"""
 
     __slots__ = ['flags', 'protocol', 'algorithm', 'key']
 
     def __init__(self, rdclass, rdtype, flags, protocol, algorithm, key):
-        super(DNSKEYBase, self).__init__(rdclass, rdtype)
-        self.flags = flags
-        self.protocol = protocol
-        self.algorithm = algorithm
-        self.key = key
+        super().__init__(rdclass, rdtype)
+        object.__setattr__(self, 'flags', flags)
+        object.__setattr__(self, 'protocol', protocol)
+        object.__setattr__(self, 'algorithm', algorithm)
+        object.__setattr__(self, 'key', key)
 
     def to_text(self, origin=None, relativize=True, **kw):
         return '%d %d %d %s' % (self.flags, self.protocol, self.algorithm,
                                 dns.rdata._base64ify(self.key))
 
     @classmethod
-    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+                  relativize_to=None):
         flags = tok.get_uint16()
         protocol = tok.get_uint8()
         algorithm = dns.dnssec.algorithm_from_text(tok.get_string())
-        chunks = []
-        while 1:
-            t = tok.get().unescape()
-            if t.is_eol_or_eof():
-                break
-            if not t.is_identifier():
-                raise dns.exception.SyntaxError
-            chunks.append(t.value.encode())
-        b64 = b''.join(chunks)
+        b64 = tok.concatenate_remaining_identifiers().encode()
         key = base64.b64decode(b64)
         return cls(rdclass, rdtype, flags, protocol, algorithm, key)
 
-    def to_wire(self, file, compress=None, origin=None):
+    def _to_wire(self, file, compress=None, origin=None, canonicalize=False):
         header = struct.pack("!HBB", self.flags, self.protocol, self.algorithm)
         file.write(header)
         file.write(self.key)
 
     @classmethod
-    def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin=None):
-        if rdlen < 4:
-            raise dns.exception.FormError
-        header = struct.unpack('!HBB', wire[current: current + 4])
-        current += 4
-        rdlen -= 4
-        key = wire[current: current + rdlen].unwrap()
+    def from_wire_parser(cls, rdclass, rdtype, parser, origin=None):
+        header = parser.get_struct('!HBB')
+        key = parser.get_remaining()
         return cls(rdclass, rdtype, header[0], header[1], header[2],
                    key)
-
-    def flags_to_text_set(self):
-        """Convert a DNSKEY flags value to set texts
-        @rtype: set([string])"""
-        return flags_to_text_set(self.flags)

lib/dns/rdtypes/dsbase.py

@@ -1,3 +1,5 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
 # Copyright (C) 2010, 2011 Nominum, Inc.
 #
 # Permission to use, copy, modify, and distribute this software and its
@@ -16,33 +18,24 @@
 import struct
 import binascii
 
+import dns.dnssec
 import dns.rdata
 import dns.rdatatype
 
 
 class DSBase(dns.rdata.Rdata):
 
-    """Base class for rdata that is like a DS record
-
-    @ivar key_tag: the key tag
-    @type key_tag: int
-    @ivar algorithm: the algorithm
-    @type algorithm: int
-    @ivar digest_type: the digest type
-    @type digest_type: int
-    @ivar digest: the digest
-    @type digest: int
-    @see: draft-ietf-dnsext-delegation-signer-14.txt"""
+    """Base class for rdata that is like a DS record"""
 
     __slots__ = ['key_tag', 'algorithm', 'digest_type', 'digest']
 
     def __init__(self, rdclass, rdtype, key_tag, algorithm, digest_type,
                  digest):
-        super(DSBase, self).__init__(rdclass, rdtype)
-        self.key_tag = key_tag
-        self.algorithm = algorithm
-        self.digest_type = digest_type
-        self.digest = digest
+        super().__init__(rdclass, rdtype)
+        object.__setattr__(self, 'key_tag', key_tag)
+        object.__setattr__(self, 'algorithm', algorithm)
+        object.__setattr__(self, 'digest_type', digest_type)
+        object.__setattr__(self, 'digest', digest)
 
     def to_text(self, origin=None, relativize=True, **kw):
         return '%d %d %d %s' % (self.key_tag, self.algorithm,
@@ -51,34 +44,24 @@ class DSBase(dns.rdata.Rdata):
                                                   chunksize=128))
 
     @classmethod
-    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+                  relativize_to=None):
         key_tag = tok.get_uint16()
-        algorithm = tok.get_uint8()
+        algorithm = dns.dnssec.algorithm_from_text(tok.get_string())
         digest_type = tok.get_uint8()
-        chunks = []
-        while 1:
-            t = tok.get().unescape()
-            if t.is_eol_or_eof():
-                break
-            if not t.is_identifier():
-                raise dns.exception.SyntaxError
-            chunks.append(t.value.encode())
-        digest = b''.join(chunks)
+        digest = tok.concatenate_remaining_identifiers().encode()
         digest = binascii.unhexlify(digest)
         return cls(rdclass, rdtype, key_tag, algorithm, digest_type,
                    digest)
 
-    def to_wire(self, file, compress=None, origin=None):
+    def _to_wire(self, file, compress=None, origin=None, canonicalize=False):
         header = struct.pack("!HBB", self.key_tag, self.algorithm,
                              self.digest_type)
         file.write(header)
         file.write(self.digest)
 
     @classmethod
-    def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin=None):
-        header = struct.unpack("!HBB", wire[current: current + 4])
-        current += 4
-        rdlen -= 4
-        digest = wire[current: current + rdlen].unwrap()
+    def from_wire_parser(cls, rdclass, rdtype, parser, origin=None):
+        header = parser.get_struct("!HBB")
+        digest = parser.get_remaining()
         return cls(rdclass, rdtype, header[0], header[1], header[2], digest)
-

lib/dns/rdtypes/euibase.py

@@ -21,11 +21,9 @@ import dns.rdata
 
 class EUIBase(dns.rdata.Rdata):
 
-    """EUIxx record
+    """EUIxx record"""
 
-    @ivar fingerprint: xx-bit Extended Unique Identifier (EUI-xx)
-    @type fingerprint: string
-    @see: rfc7043.txt"""
+    # see: rfc7043.txt
 
     __slots__ = ['eui']
     # define these in subclasses
@@ -33,24 +31,24 @@ class EUIBase(dns.rdata.Rdata):
     # text_len = byte_len * 3 - 1  # 01-23-45-67-89-ab
 
     def __init__(self, rdclass, rdtype, eui):
-        super(EUIBase, self).__init__(rdclass, rdtype)
+        super().__init__(rdclass, rdtype)
         if len(eui) != self.byte_len:
             raise dns.exception.FormError('EUI%s rdata has to have %s bytes'
                                           % (self.byte_len * 8, self.byte_len))
-        self.eui = eui
+        object.__setattr__(self, 'eui', eui)
 
     def to_text(self, origin=None, relativize=True, **kw):
         return dns.rdata._hexify(self.eui, chunksize=2).replace(' ', '-')
 
     @classmethod
-    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+                  relativize_to=None):
         text = tok.get_string()
         tok.get_eol()
         if len(text) != cls.text_len:
             raise dns.exception.SyntaxError(
                 'Input text must have %s characters' % cls.text_len)
-        expected_dash_idxs = range(2, cls.byte_len * 3 - 1, 3)
-        for i in expected_dash_idxs:
+        for i in range(2, cls.byte_len * 3 - 1, 3):
             if text[i] != '-':
                 raise dns.exception.SyntaxError('Dash expected at position %s'
                                                 % i)
@@ -61,11 +59,10 @@ class EUIBase(dns.rdata.Rdata):
             raise dns.exception.SyntaxError('Hex decoding error: %s' % str(ex))
         return cls(rdclass, rdtype, data)
 
-    def to_wire(self, file, compress=None, origin=None):
+    def _to_wire(self, file, compress=None, origin=None, canonicalize=False):
         file.write(self.eui)
 
     @classmethod
-    def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin=None):
-        eui = wire[current:current + rdlen].unwrap()
+    def from_wire_parser(cls, rdclass, rdtype, parser, origin=None):
+        eui = parser.get_bytes(cls.byte_len)
         return cls(rdclass, rdtype, eui)
-

lib/dns/rdtypes/mxbase.py

@@ -1,3 +1,5 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
 # Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
 #
 # Permission to use, copy, modify, and distribute this software and its
@@ -15,7 +17,6 @@
 
 """MX-like base classes."""
 
-from io import BytesIO
 import struct
 
 import dns.exception
@@ -25,57 +26,38 @@ import dns.name
 
 class MXBase(dns.rdata.Rdata):
 
-    """Base class for rdata that is like an MX record.
-
-    @ivar preference: the preference value
-    @type preference: int
-    @ivar exchange: the exchange name
-    @type exchange: dns.name.Name object"""
+    """Base class for rdata that is like an MX record."""
 
     __slots__ = ['preference', 'exchange']
 
     def __init__(self, rdclass, rdtype, preference, exchange):
-        super(MXBase, self).__init__(rdclass, rdtype)
-        self.preference = preference
-        self.exchange = exchange
+        super().__init__(rdclass, rdtype)
+        object.__setattr__(self, 'preference', preference)
+        object.__setattr__(self, 'exchange', exchange)
 
     def to_text(self, origin=None, relativize=True, **kw):
         exchange = self.exchange.choose_relativity(origin, relativize)
         return '%d %s' % (self.preference, exchange)
 
     @classmethod
-    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+                  relativize_to=None):
         preference = tok.get_uint16()
-        exchange = tok.get_name()
-        exchange = exchange.choose_relativity(origin, relativize)
+        exchange = tok.get_name(origin, relativize, relativize_to)
         tok.get_eol()
         return cls(rdclass, rdtype, preference, exchange)
 
-    def to_wire(self, file, compress=None, origin=None):
+    def _to_wire(self, file, compress=None, origin=None, canonicalize=False):
         pref = struct.pack("!H", self.preference)
         file.write(pref)
-        self.exchange.to_wire(file, compress, origin)
-
-    def to_digestable(self, origin=None):
-        return struct.pack("!H", self.preference) + \
-            self.exchange.to_digestable(origin)
+        self.exchange.to_wire(file, compress, origin, canonicalize)
 
     @classmethod
-    def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin=None):
-        (preference, ) = struct.unpack('!H', wire[current: current + 2])
-        current += 2
-        rdlen -= 2
-        (exchange, cused) = dns.name.from_wire(wire[: current + rdlen],
-                                               current)
-        if cused != rdlen:
-            raise dns.exception.FormError
-        if origin is not None:
-            exchange = exchange.relativize(origin)
+    def from_wire_parser(cls, rdclass, rdtype, parser, origin=None):
+        preference = parser.get_uint16()
+        exchange = parser.get_name(origin)
         return cls(rdclass, rdtype, preference, exchange)
 
-    def choose_relativity(self, origin=None, relativize=True):
-        self.exchange = self.exchange.choose_relativity(origin, relativize)
-
 
 class UncompressedMX(MXBase):
 
@@ -83,13 +65,8 @@ class UncompressedMX(MXBase):
     is not compressed when converted to DNS wire format, and whose
     digestable form is not downcased."""
 
-    def to_wire(self, file, compress=None, origin=None):
-        super(UncompressedMX, self).to_wire(file, None, origin)
-
-    def to_digestable(self, origin=None):
-        f = BytesIO()
-        self.to_wire(f, None, origin)
-        return f.getvalue()
+    def _to_wire(self, file, compress=None, origin=None, canonicalize=False):
+        super()._to_wire(file, None, origin, False)
 
 
 class UncompressedDowncasingMX(MXBase):
@@ -97,5 +74,5 @@ class UncompressedDowncasingMX(MXBase):
     """Base class for rdata that is like an MX record, but whose name
     is not compressed when convert to DNS wire format."""
 
-    def to_wire(self, file, compress=None, origin=None):
-        super(UncompressedDowncasingMX, self).to_wire(file, None, origin)
+    def _to_wire(self, file, compress=None, origin=None, canonicalize=False):
+        super()._to_wire(file, None, origin, canonicalize)

lib/dns/rdtypes/nsbase.py

@@ -1,3 +1,5 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
 # Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
 #
 # Permission to use, copy, modify, and distribute this software and its
@@ -15,8 +17,6 @@
 
 """NS-like base classes."""
 
-from io import BytesIO
-
 import dns.exception
 import dns.rdata
 import dns.name
@@ -24,47 +24,33 @@ import dns.name
 
 class NSBase(dns.rdata.Rdata):
 
-    """Base class for rdata that is like an NS record.
-
-    @ivar target: the target name of the rdata
-    @type target: dns.name.Name object"""
+    """Base class for rdata that is like an NS record."""
 
     __slots__ = ['target']
 
     def __init__(self, rdclass, rdtype, target):
-        super(NSBase, self).__init__(rdclass, rdtype)
-        self.target = target
+        super().__init__(rdclass, rdtype)
+        object.__setattr__(self, 'target', target)
 
     def to_text(self, origin=None, relativize=True, **kw):
         target = self.target.choose_relativity(origin, relativize)
         return str(target)
 
     @classmethod
-    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
-        target = tok.get_name()
-        target = target.choose_relativity(origin, relativize)
+    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+                  relativize_to=None):
+        target = tok.get_name(origin, relativize, relativize_to)
         tok.get_eol()
         return cls(rdclass, rdtype, target)
 
-    def to_wire(self, file, compress=None, origin=None):
-        self.target.to_wire(file, compress, origin)
-
-    def to_digestable(self, origin=None):
-        return self.target.to_digestable(origin)
+    def _to_wire(self, file, compress=None, origin=None, canonicalize=False):
+        self.target.to_wire(file, compress, origin, canonicalize)
 
     @classmethod
-    def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin=None):
-        (target, cused) = dns.name.from_wire(wire[: current + rdlen],
-                                             current)
-        if cused != rdlen:
-            raise dns.exception.FormError
-        if origin is not None:
-            target = target.relativize(origin)
+    def from_wire_parser(cls, rdclass, rdtype, parser, origin=None):
+        target = parser.get_name(origin)
         return cls(rdclass, rdtype, target)
 
-    def choose_relativity(self, origin=None, relativize=True):
-        self.target = self.target.choose_relativity(origin, relativize)
-
 
 class UncompressedNS(NSBase):
 
@@ -72,10 +58,5 @@ class UncompressedNS(NSBase):
     is not compressed when convert to DNS wire format, and whose
     digestable form is not downcased."""
 
-    def to_wire(self, file, compress=None, origin=None):
-        super(UncompressedNS, self).to_wire(file, None, origin)
-
-    def to_digestable(self, origin=None):
-        f = BytesIO()
-        self.to_wire(f, None, origin)
-        return f.getvalue()
+    def _to_wire(self, file, compress=None, origin=None, canonicalize=False):
+        self.target.to_wire(file, None, origin, False)

lib/dns/rdtypes/txtbase.py

@@ -1,4 +1,6 @@
-# Copyright (C) 2006, 2007, 2009-2011 Nominum, Inc.
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
+# Copyright (C) 2006-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,
@@ -20,54 +22,61 @@ import struct
 import dns.exception
 import dns.rdata
 import dns.tokenizer
-from dns._compat import binary_type
 
 
 class TXTBase(dns.rdata.Rdata):
 
-    """Base class for rdata that is like a TXT record
-
-    @ivar strings: the text strings
-    @type strings: list of string
-    @see: RFC 1035"""
+    """Base class for rdata that is like a TXT record (see RFC 1035)."""
 
     __slots__ = ['strings']
 
     def __init__(self, rdclass, rdtype, strings):
-        super(TXTBase, self).__init__(rdclass, rdtype)
-        if isinstance(strings, str):
-            strings = [strings]
-        self.strings = strings[:]
+        """Initialize a TXT-like rdata.
+
+        *rdclass*, an ``int`` is the rdataclass of the Rdata.
+
+        *rdtype*, an ``int`` is the rdatatype of the Rdata.
+
+        *strings*, a tuple of ``bytes``
+        """
+        super().__init__(rdclass, rdtype)
+        if isinstance(strings, (bytes, str)):
+            strings = (strings,)
+        encoded_strings = []
+        for string in strings:
+            if isinstance(string, str):
+                string = string.encode()
+            else:
+                string = dns.rdata._constify(string)
+            encoded_strings.append(string)
+        object.__setattr__(self, 'strings', tuple(encoded_strings))
 
     def to_text(self, origin=None, relativize=True, **kw):
         txt = ''
         prefix = ''
         for s in self.strings:
-            txt += '%s"%s"' % (prefix, dns.rdata._escapify(s))
+            txt += '{}"{}"'.format(prefix, dns.rdata._escapify(s))
             prefix = ' '
         return txt
 
     @classmethod
-    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
+    def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True,
+                  relativize_to=None):
         strings = []
         while 1:
-            token = tok.get().unescape()
+            token = tok.get().unescape_to_bytes()
             if token.is_eol_or_eof():
                 break
             if not (token.is_quoted_string() or token.is_identifier()):
                 raise dns.exception.SyntaxError("expected a string")
             if len(token.value) > 255:
                 raise dns.exception.SyntaxError("string too long")
-            value = token.value
-            if isinstance(value, binary_type):
-                strings.append(value)
-            else:
-                strings.append(value.encode())
+            strings.append(token.value)
         if len(strings) == 0:
             raise dns.exception.UnexpectedEnd
         return cls(rdclass, rdtype, strings)
 
-    def to_wire(self, file, compress=None, origin=None):
+    def _to_wire(self, file, compress=None, origin=None, canonicalize=False):
         for s in self.strings:
             l = len(s)
             assert l < 256
@@ -75,17 +84,9 @@ class TXTBase(dns.rdata.Rdata):
             file.write(s)
 
     @classmethod
-    def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin=None):
+    def from_wire_parser(cls, rdclass, rdtype, parser, origin=None):
         strings = []
-        while rdlen > 0:
-            l = wire[current]
-            current += 1
-            rdlen -= 1
-            if l > rdlen:
-                raise dns.exception.FormError
-            s = wire[current: current + l].unwrap()
-            current += l
-            rdlen -= l
+        while parser.remaining() > 0:
+            s = parser.get_counted_bytes()
             strings.append(s)
         return cls(rdclass, rdtype, strings)
-

lib/dns/rdtypes/util.py

@@ -0,0 +1,166 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
+# Copyright (C) 2006, 2007, 2009-2011 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.
+
+import struct
+
+import dns.exception
+import dns.name
+import dns.ipv4
+import dns.ipv6
+
+class Gateway:
+    """A helper class for the IPSECKEY gateway and AMTRELAY relay fields"""
+    name = ""
+
+    def __init__(self, type, gateway=None):
+        self.type = type
+        self.gateway = gateway
+
+    def _invalid_type(self):
+        return f"invalid {self.name} type: {self.type}"
+
+    def check(self):
+        if self.type == 0:
+            if self.gateway not in (".", None):
+                raise SyntaxError(f"invalid {self.name} for type 0")
+            self.gateway = None
+        elif self.type == 1:
+            # check that it's OK
+            dns.ipv4.inet_aton(self.gateway)
+        elif self.type == 2:
+            # check that it's OK
+            dns.ipv6.inet_aton(self.gateway)
+        elif self.type == 3:
+            if not isinstance(self.gateway, dns.name.Name):
+                raise SyntaxError(f"invalid {self.name}; not a name")
+        else:
+            raise SyntaxError(self._invalid_type())
+
+    def to_text(self, origin=None, relativize=True):
+        if self.type == 0:
+            return "."
+        elif self.type in (1, 2):
+            return self.gateway
+        elif self.type == 3:
+            return str(self.gateway.choose_relativity(origin, relativize))
+        else:
+            raise ValueError(self._invalid_type())
+
+    def from_text(self, tok, origin=None, relativize=True, relativize_to=None):
+        if self.type in (0, 1, 2):
+            return tok.get_string()
+        elif self.type == 3:
+            return tok.get_name(origin, relativize, relativize_to)
+        else:
+            raise dns.exception.SyntaxError(self._invalid_type())
+
+    def to_wire(self, file, compress=None, origin=None, canonicalize=False):
+        if self.type == 0:
+            pass
+        elif self.type == 1:
+            file.write(dns.ipv4.inet_aton(self.gateway))
+        elif self.type == 2:
+            file.write(dns.ipv6.inet_aton(self.gateway))
+        elif self.type == 3:
+            self.gateway.to_wire(file, None, origin, False)
+        else:
+            raise ValueError(self._invalid_type())
+
+    def from_wire_parser(self, parser, origin=None):
+        if self.type == 0:
+            return None
+        elif self.type == 1:
+            return dns.ipv4.inet_ntoa(parser.get_bytes(4))
+        elif self.type == 2:
+            return dns.ipv6.inet_ntoa(parser.get_bytes(16))
+        elif self.type == 3:
+            return parser.get_name(origin)
+        else:
+            raise dns.exception.FormError(self._invalid_type())
+
+class Bitmap:
+    """A helper class for the NSEC/NSEC3/CSYNC type bitmaps"""
+    type_name = ""
+
+    def __init__(self, windows=None):
+        self.windows = windows
+
+    def to_text(self):
+        text = ""
+        for (window, bitmap) in self.windows:
+            bits = []
+            for (i, byte) in enumerate(bitmap):
+                for j in range(0, 8):
+                    if byte & (0x80 >> j):
+                        rdtype = window * 256 + i * 8 + j
+                        bits.append(dns.rdatatype.to_text(rdtype))
+            text += (' ' + ' '.join(bits))
+        return text
+
+    def from_text(self, tok):
+        rdtypes = []
+        while True:
+            token = tok.get().unescape()
+            if token.is_eol_or_eof():
+                break
+            rdtype = dns.rdatatype.from_text(token.value)
+            if rdtype == 0:
+                raise dns.exception.SyntaxError(f"{self.type_name} with bit 0")
+            rdtypes.append(rdtype)
+        rdtypes.sort()
+        window = 0
+        octets = 0
+        prior_rdtype = 0
+        bitmap = bytearray(b'\0' * 32)
+        windows = []
+        for rdtype in rdtypes:
+            if rdtype == prior_rdtype:
+                continue
+            prior_rdtype = rdtype
+            new_window = rdtype // 256
+            if new_window != window:
+                if octets != 0:
+                    windows.append((window, bitmap[0:octets]))
+                bitmap = bytearray(b'\0' * 32)
+                window = new_window
+            offset = rdtype % 256
+            byte = offset // 8
+            bit = offset % 8
+            octets = byte + 1
+            bitmap[byte] = bitmap[byte] | (0x80 >> bit)
+        if octets != 0:
+            windows.append((window, bitmap[0:octets]))
+        return windows
+
+    def to_wire(self, file):
+        for (window, bitmap) in self.windows:
+            file.write(struct.pack('!BB', window, len(bitmap)))
+            file.write(bitmap)
+
+    def from_wire_parser(self, parser):
+        windows = []
+        last_window = -1
+        while parser.remaining() > 0:
+            window = parser.get_uint8()
+            if window <= last_window:
+                raise dns.exception.FormError(f"bad {self.type_name} bitmap")
+            bitmap = parser.get_counted_bytes()
+            if len(bitmap) == 0 or len(bitmap) > 32:
+                raise dns.exception.FormError(f"bad {self.type_name} octets")
+            windows.append((window, bitmap))
+            last_window = window
+        return windows

lib/dns/renderer.py

@@ -1,4 +1,6 @@
-# Copyright (C) 2001-2007, 2009-2011 Nominum, Inc.
+# 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,
@@ -15,15 +17,14 @@
 
 """Help for building DNS wire format messages"""
 
-from io import BytesIO
+import contextlib
+import io
 import struct
 import random
 import time
-import sys
 
 import dns.exception
 import dns.tsig
-from ._compat import long
 
 
 QUESTION = 0
@@ -32,8 +33,7 @@ AUTHORITY = 2
 ADDITIONAL = 3
 
 
-class Renderer(object):
-
+class Renderer:
     """Helper class for building DNS wire-format messages.
 
     Most applications can use the higher-level L{dns.message.Message}
@@ -55,43 +55,29 @@ class Renderer(object):
         r.add_tsig(keyname, secret, 300, 1, 0, '', request_mac)
         wire = r.get_wire()
 
-    @ivar output: where rendering is written
-    @type output: BytesIO object
-    @ivar id: the message id
-    @type id: int
-    @ivar flags: the message flags
-    @type flags: int
-    @ivar max_size: the maximum size of the message
-    @type max_size: int
-    @ivar origin: the origin to use when rendering relative names
-    @type origin: dns.name.Name object
-    @ivar compress: the compression table
-    @type compress: dict
-    @ivar section: the section currently being rendered
-    @type section: int (dns.renderer.QUESTION, dns.renderer.ANSWER,
-    dns.renderer.AUTHORITY, or dns.renderer.ADDITIONAL)
-    @ivar counts: list of the number of RRs in each section
-    @type counts: int list of length 4
-    @ivar mac: the MAC of the rendered message (if TSIG was used)
-    @type mac: string
+    output, an io.BytesIO, where rendering is written
+
+    id: the message id
+
+    flags: the message flags
+
+    max_size: the maximum size of the message
+
+    origin: the origin to use when rendering relative names
+
+    compress: the compression table
+
+    section: an int, the section currently being rendered
+
+    counts: list of the number of RRs in each section
+
+    mac: the MAC of the rendered message (if TSIG was used)
     """
 
     def __init__(self, id=None, flags=0, max_size=65535, origin=None):
-        """Initialize a new renderer.
+        """Initialize a new renderer."""
 
-        @param id: the message id
-        @type id: int
-        @param flags: the DNS message flags
-        @type flags: int
-        @param max_size: the maximum message size; the default is 65535.
-        If rendering results in a message greater than I{max_size},
-        then L{dns.exception.TooBig} will be raised.
-        @type max_size: int
-        @param origin: the origin to use when rendering relative names
-        @type origin: dns.name.Name or None.
-        """
-
-        self.output = BytesIO()
+        self.output = io.BytesIO()
         if id is None:
             self.id = random.randint(0, 65535)
         else:
@@ -106,12 +92,9 @@ class Renderer(object):
         self.mac = ''
 
     def _rollback(self, where):
-        """Truncate the output buffer at offset I{where}, and remove any
+        """Truncate the output buffer at offset *where*, and remove any
         compression table entries that pointed beyond the truncation
         point.
-
-        @param where: the offset
-        @type where: int
         """
 
         self.output.seek(where)
@@ -129,9 +112,7 @@ class Renderer(object):
         Sections must be rendered order: QUESTION, ANSWER, AUTHORITY,
         ADDITIONAL.  Sections may be empty.
 
-        @param section: the section
-        @type section: int
-        @raises dns.exception.FormError: an attempt was made to set
+        Raises dns.exception.FormError if an attempt was made to set
         a section value less than the current section.
         """
 
@@ -140,25 +121,21 @@ class Renderer(object):
                 raise dns.exception.FormError
             self.section = section
 
-    def add_question(self, qname, rdtype, rdclass=dns.rdataclass.IN):
-        """Add a question to the message.
+    @contextlib.contextmanager
+    def _track_size(self):
+        start = self.output.tell()
+        yield start
+        if self.output.tell() > self.max_size:
+            self._rollback(start)
+            raise dns.exception.TooBig
 
-        @param qname: the question name
-        @type qname: dns.name.Name
-        @param rdtype: the question rdata type
-        @type rdtype: int
-        @param rdclass: the question rdata class
-        @type rdclass: int
-        """
+    def add_question(self, qname, rdtype, rdclass=dns.rdataclass.IN):
+        """Add a question to the message."""
 
         self._set_section(QUESTION)
-        before = self.output.tell()
+        with self._track_size():
             qname.to_wire(self.output, self.compress, self.origin)
             self.output.write(struct.pack("!HH", rdtype, rdclass))
-        after = self.output.tell()
-        if after >= self.max_size:
-            self._rollback(before)
-            raise dns.exception.TooBig
         self.counts[QUESTION] += 1
 
     def add_rrset(self, section, rrset, **kw):
@@ -166,20 +143,11 @@ class Renderer(object):
 
         Any keyword arguments are passed on to the rdataset's to_wire()
         routine.
-
-        @param section: the section
-        @type section: int
-        @param rrset: the rrset
-        @type rrset: dns.rrset.RRset object
         """
 
         self._set_section(section)
-        before = self.output.tell()
+        with self._track_size():
             n = rrset.to_wire(self.output, self.compress, self.origin, **kw)
-        after = self.output.tell()
-        if after >= self.max_size:
-            self._rollback(before)
-            raise dns.exception.TooBig
         self.counts[section] += n
 
     def add_rdataset(self, section, name, rdataset, **kw):
@@ -188,124 +156,79 @@ class Renderer(object):
 
         Any keyword arguments are passed on to the rdataset's to_wire()
         routine.
-
-        @param section: the section
-        @type section: int
-        @param name: the owner name
-        @type name: dns.name.Name object
-        @param rdataset: the rdataset
-        @type rdataset: dns.rdataset.Rdataset object
         """
 
         self._set_section(section)
-        before = self.output.tell()
+        with self._track_size():
             n = rdataset.to_wire(name, self.output, self.compress, self.origin,
                                  **kw)
-        after = self.output.tell()
-        if after >= self.max_size:
-            self._rollback(before)
-            raise dns.exception.TooBig
         self.counts[section] += n
 
     def add_edns(self, edns, ednsflags, payload, options=None):
-        """Add an EDNS OPT record to the message.
-
-        @param edns: The EDNS level to use.
-        @type edns: int
-        @param ednsflags: EDNS flag values.
-        @type ednsflags: int
-        @param payload: The EDNS sender's payload field, which is the maximum
-        size of UDP datagram the sender can handle.
-        @type payload: int
-        @param options: The EDNS options list
-        @type options: list of dns.edns.Option instances
-        @see: RFC 2671
-        """
+        """Add an EDNS OPT record to the message."""
 
         # make sure the EDNS version in ednsflags agrees with edns
-        ednsflags &= long(0xFF00FFFF)
+        ednsflags &= 0xFF00FFFF
         ednsflags |= (edns << 16)
-        self._set_section(ADDITIONAL)
-        before = self.output.tell()
-        self.output.write(struct.pack('!BHHIH', 0, dns.rdatatype.OPT, payload,
-                                      ednsflags, 0))
-        if options is not None:
-            lstart = self.output.tell()
-            for opt in options:
-                stuff = struct.pack("!HH", opt.otype, 0)
-                self.output.write(stuff)
-                start = self.output.tell()
-                opt.to_wire(self.output)
-                end = self.output.tell()
-                assert end - start < 65536
-                self.output.seek(start - 2)
-                stuff = struct.pack("!H", end - start)
-                self.output.write(stuff)
-                self.output.seek(0, 2)
-            lend = self.output.tell()
-            assert lend - lstart < 65536
-            self.output.seek(lstart - 2)
-            stuff = struct.pack("!H", lend - lstart)
-            self.output.write(stuff)
-            self.output.seek(0, 2)
-        after = self.output.tell()
-        if after >= self.max_size:
-            self._rollback(before)
-            raise dns.exception.TooBig
-        self.counts[ADDITIONAL] += 1
+        opt = dns.message.Message._make_opt(ednsflags, payload, options)
+        self.add_rrset(ADDITIONAL, opt)
 
     def add_tsig(self, keyname, secret, fudge, id, tsig_error, other_data,
                  request_mac, algorithm=dns.tsig.default_algorithm):
-        """Add a TSIG signature to the message.
+        """Add a TSIG signature to the message."""
 
-        @param keyname: the TSIG key name
-        @type keyname: dns.name.Name object
-        @param secret: the secret to use
-        @type secret: string
-        @param fudge: TSIG time fudge
-        @type fudge: int
-        @param id: the message id to encode in the tsig signature
-        @type id: int
-        @param tsig_error: TSIG error code; default is 0.
-        @type tsig_error: int
-        @param other_data: TSIG other data.
-        @type other_data: string
-        @param request_mac: This message is a response to the request which
-        had the specified MAC.
-        @type request_mac: string
-        @param algorithm: the TSIG algorithm to use
-        @type algorithm: dns.name.Name object
-        """
-
-        self._set_section(ADDITIONAL)
-        before = self.output.tell()
         s = self.output.getvalue()
-        (tsig_rdata, self.mac, ctx) = dns.tsig.sign(s,
-                                                    keyname,
-                                                    secret,
-                                                    int(time.time()),
-                                                    fudge,
-                                                    id,
-                                                    tsig_error,
-                                                    other_data,
-                                                    request_mac,
-                                                    algorithm=algorithm)
+
+        if isinstance(secret, dns.tsig.Key):
+            key = secret
+        else:
+            key = dns.tsig.Key(keyname, secret, algorithm)
+        tsig = dns.message.Message._make_tsig(keyname, algorithm, 0, fudge,
+                                              b'', id, tsig_error, other_data)
+        (tsig, _) = dns.tsig.sign(s, key, tsig[0], int(time.time()),
+                                  request_mac)
+        self._write_tsig(tsig, keyname)
+
+    def add_multi_tsig(self, ctx, keyname, secret, fudge, id, tsig_error,
+                       other_data, request_mac,
+                       algorithm=dns.tsig.default_algorithm):
+        """Add a TSIG signature to the message. Unlike add_tsig(), this can be
+        used for a series of consecutive DNS envelopes, e.g. for a zone
+        transfer over TCP [RFC2845, 4.4].
+
+        For the first message in the sequence, give ctx=None. For each
+        subsequent message, give the ctx that was returned from the
+        add_multi_tsig() call for the previous message."""
+
+        s = self.output.getvalue()
+
+        if isinstance(secret, dns.tsig.Key):
+            key = secret
+        else:
+            key = dns.tsig.Key(keyname, secret, algorithm)
+        tsig = dns.message.Message._make_tsig(keyname, algorithm, 0, fudge,
+                                              b'', id, tsig_error, other_data)
+        (tsig, ctx) = dns.tsig.sign(s, key, tsig[0], int(time.time()),
+                                    request_mac, ctx, True)
+        self._write_tsig(tsig, keyname)
+        return ctx
+
+    def _write_tsig(self, tsig, keyname):
+        self._set_section(ADDITIONAL)
+        with self._track_size():
             keyname.to_wire(self.output, self.compress, self.origin)
             self.output.write(struct.pack('!HHIH', dns.rdatatype.TSIG,
                                           dns.rdataclass.ANY, 0, 0))
             rdata_start = self.output.tell()
-        self.output.write(tsig_rdata)
+            tsig.to_wire(self.output)
+
         after = self.output.tell()
-        assert after - rdata_start < 65536
-        if after >= self.max_size:
-            self._rollback(before)
-            raise dns.exception.TooBig
         self.output.seek(rdata_start - 2)
         self.output.write(struct.pack('!H', after - rdata_start))
         self.counts[ADDITIONAL] += 1
         self.output.seek(10)
         self.output.write(struct.pack('!H', self.counts[ADDITIONAL]))
-        self.output.seek(0, 2)
+        self.output.seek(0, io.SEEK_END)
 
     def write_header(self):
         """Write the DNS message header.
@@ -319,12 +242,9 @@ class Renderer(object):
         self.output.write(struct.pack('!HHHHHH', self.id, self.flags,
                                       self.counts[0], self.counts[1],
                                       self.counts[2], self.counts[3]))
-        self.output.seek(0, 2)
+        self.output.seek(0, io.SEEK_END)
 
     def get_wire(self):
-        """Return the wire format message.
-
-        @rtype: string
-        """
+        """Return the wire format message."""
 
         return self.output.getvalue()

lib/dns/reversename.py

@@ -1,4 +1,6 @@
-# Copyright (C) 2006, 2007, 2009-2011 Nominum, Inc.
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
+# Copyright (C) 2006-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,
@@ -13,16 +15,9 @@
 # ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
 # OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
-"""DNS Reverse Map Names.
-
-@var ipv4_reverse_domain: The DNS IPv4 reverse-map domain, in-addr.arpa.
-@type ipv4_reverse_domain: dns.name.Name object
-@var ipv6_reverse_domain: The DNS IPv6 reverse-map domain, ip6.arpa.
-@type ipv6_reverse_domain: dns.name.Name object
-"""
+"""DNS Reverse Map Names."""
 
 import binascii
-import sys
 
 import dns.name
 import dns.ipv6
@@ -32,58 +27,74 @@ ipv4_reverse_domain = dns.name.from_text('in-addr.arpa.')
 ipv6_reverse_domain = dns.name.from_text('ip6.arpa.')
 
 
-def from_address(text):
+def from_address(text, v4_origin=ipv4_reverse_domain,
+                 v6_origin=ipv6_reverse_domain):
     """Convert an IPv4 or IPv6 address in textual form into a Name object whose
     value is the reverse-map domain name of the address.
-    @param text: an IPv4 or IPv6 address in textual form (e.g. '127.0.0.1',
-    '::1')
-    @type text: str
-    @rtype: dns.name.Name object
+
+    *text*, a ``str``, is an IPv4 or IPv6 address in textual form
+    (e.g. '127.0.0.1', '::1')
+
+    *v4_origin*, a ``dns.name.Name`` to append to the labels corresponding to
+    the address if the address is an IPv4 address, instead of the default
+    (in-addr.arpa.)
+
+    *v6_origin*, a ``dns.name.Name`` to append to the labels corresponding to
+    the address if the address is an IPv6 address, instead of the default
+    (ip6.arpa.)
+
+    Raises ``dns.exception.SyntaxError`` if the address is badly formed.
+
+    Returns a ``dns.name.Name``.
     """
+
     try:
         v6 = dns.ipv6.inet_aton(text)
         if dns.ipv6.is_mapped(v6):
-            if sys.version_info >= (3,):
             parts = ['%d' % byte for byte in v6[12:]]
-            else:
-                parts = ['%d' % ord(byte) for byte in v6[12:]]
-            origin = ipv4_reverse_domain
+            origin = v4_origin
         else:
             parts = [x for x in str(binascii.hexlify(v6).decode())]
-            origin = ipv6_reverse_domain
-    except:
+            origin = v6_origin
+    except Exception:
         parts = ['%d' %
-                 byte for byte in bytearray(dns.ipv4.inet_aton(text))]
-        origin = ipv4_reverse_domain
-    parts.reverse()
-    return dns.name.from_text('.'.join(parts), origin=origin)
+                 byte for byte in dns.ipv4.inet_aton(text)]
+        origin = v4_origin
+    return dns.name.from_text('.'.join(reversed(parts)), origin=origin)
 
 
-def to_address(name):
+def to_address(name, v4_origin=ipv4_reverse_domain,
+               v6_origin=ipv6_reverse_domain):
     """Convert a reverse map domain name into textual address form.
-    @param name: an IPv4 or IPv6 address in reverse-map form.
-    @type name: dns.name.Name object
-    @rtype: str
+
+    *name*, a ``dns.name.Name``, an IPv4 or IPv6 address in reverse-map name
+    form.
+
+    *v4_origin*, a ``dns.name.Name`` representing the top-level domain for
+    IPv4 addresses, instead of the default (in-addr.arpa.)
+
+    *v6_origin*, a ``dns.name.Name`` representing the top-level domain for
+    IPv4 addresses, instead of the default (ip6.arpa.)
+
+    Raises ``dns.exception.SyntaxError`` if the name does not have a
+    reverse-map form.
+
+    Returns a ``str``.
     """
-    if name.is_subdomain(ipv4_reverse_domain):
-        name = name.relativize(ipv4_reverse_domain)
-        labels = list(name.labels)
-        labels.reverse()
-        text = b'.'.join(labels)
-        # run through inet_aton() to check syntax and make pretty.
+
+    if name.is_subdomain(v4_origin):
+        name = name.relativize(v4_origin)
+        text = b'.'.join(reversed(name.labels))
+        # run through inet_ntoa() to check syntax and make pretty.
         return dns.ipv4.inet_ntoa(dns.ipv4.inet_aton(text))
-    elif name.is_subdomain(ipv6_reverse_domain):
-        name = name.relativize(ipv6_reverse_domain)
-        labels = list(name.labels)
-        labels.reverse()
+    elif name.is_subdomain(v6_origin):
+        name = name.relativize(v6_origin)
+        labels = list(reversed(name.labels))
         parts = []
-        i = 0
-        l = len(labels)
-        while i < l:
+        for i in range(0, len(labels), 4):
             parts.append(b''.join(labels[i:i + 4]))
-            i += 4
         text = b':'.join(parts)
-        # run through inet_aton() to check syntax and make pretty.
+        # run through inet_ntoa() to check syntax and make pretty.
         return dns.ipv6.inet_ntoa(dns.ipv6.inet_aton(text))
     else:
         raise dns.exception.SyntaxError('unknown reverse-map address family')

lib/dns/rrset.py

@@ -1,4 +1,6 @@
-# Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
+# Copyright (C) 2003-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,
@@ -20,7 +22,6 @@ import dns.name
 import dns.rdataset
 import dns.rdataclass
 import dns.renderer
-from ._compat import string_types
 
 
 class RRset(dns.rdataset.Rdataset):
@@ -40,12 +41,12 @@ class RRset(dns.rdataset.Rdataset):
                  deleting=None):
         """Create a new RRset."""
 
-        super(RRset, self).__init__(rdclass, rdtype, covers)
+        super().__init__(rdclass, rdtype, covers)
         self.name = name
         self.deleting = deleting
 
     def _clone(self):
-        obj = super(RRset, self)._clone()
+        obj = super()._clone()
         obj.name = self.name
         obj.deleting = self.deleting
         return obj
@@ -61,27 +62,25 @@ class RRset(dns.rdataset.Rdataset):
             dtext = ''
         return '<DNS ' + str(self.name) + ' ' + \
                dns.rdataclass.to_text(self.rdclass) + ' ' + \
-               dns.rdatatype.to_text(self.rdtype) + ctext + dtext + ' RRset>'
+               dns.rdatatype.to_text(self.rdtype) + ctext + dtext + \
+               ' RRset: ' + self._rdata_repr() + '>'
 
     def __str__(self):
         return self.to_text()
 
     def __eq__(self, other):
-        """Two RRsets are equal if they have the same name and the same
-        rdataset
-
-        @rtype: bool"""
         if not isinstance(other, RRset):
             return False
         if self.name != other.name:
             return False
-        return super(RRset, self).__eq__(other)
+        return super().__eq__(other)
 
     def match(self, name, rdclass, rdtype, covers, deleting=None):
-        """Returns True if this rrset matches the specified class, type,
-        covers, and deletion state."""
+        """Returns ``True`` if this rrset matches the specified class, type,
+        covers, and deletion state.
+        """
 
-        if not super(RRset, self).match(rdclass, rdtype, covers):
+        if not super().match(rdclass, rdtype, covers):
             return False
         if self.name != name or self.deleting != deleting:
             return False
@@ -90,52 +89,63 @@ class RRset(dns.rdataset.Rdataset):
     def to_text(self, origin=None, relativize=True, **kw):
         """Convert the RRset into DNS master file format.
 
-        @see: L{dns.name.Name.choose_relativity} for more information
-        on how I{origin} and I{relativize} determine the way names
+        See ``dns.name.Name.choose_relativity`` for more information
+        on how *origin* and *relativize* determine the way names
         are emitted.
 
         Any additional keyword arguments are passed on to the rdata
-        to_text() method.
+        ``to_text()`` method.
 
-        @param origin: The origin for relative names, or None.
-        @type origin: dns.name.Name object
-        @param relativize: True if names should names be relativized
-        @type relativize: bool"""
+        *origin*, a ``dns.name.Name`` or ``None``, the origin for relative
+        names.
 
-        return super(RRset, self).to_text(self.name, origin, relativize,
+        *relativize*, a ``bool``.  If ``True``, names will be relativized
+        to *origin*.
+        """
+
+        return super().to_text(self.name, origin, relativize,
                                self.deleting, **kw)
 
     def to_wire(self, file, compress=None, origin=None, **kw):
-        """Convert the RRset to wire format."""
+        """Convert the RRset to wire format.
 
-        return super(RRset, self).to_wire(self.name, file, compress, origin,
+        All keyword arguments are passed to ``dns.rdataset.to_wire()``; see
+        that function for details.
+
+        Returns an ``int``, the number of records emitted.
+        """
+
+        return super().to_wire(self.name, file, compress, origin,
                                self.deleting, **kw)
 
     def to_rdataset(self):
         """Convert an RRset into an Rdataset.
 
-        @rtype: dns.rdataset.Rdataset object
+        Returns a ``dns.rdataset.Rdataset``.
         """
         return dns.rdataset.from_rdata_list(self.ttl, list(self))
 
 
-def from_text_list(name, ttl, rdclass, rdtype, text_rdatas):
+def from_text_list(name, ttl, rdclass, rdtype, text_rdatas,
+                   idna_codec=None):
     """Create an RRset with the specified name, TTL, class, and type, and with
     the specified list of rdatas in text format.
 
-    @rtype: dns.rrset.RRset object
+    *idna_codec*, a ``dns.name.IDNACodec``, specifies the IDNA
+    encoder/decoder to use; if ``None``, the default IDNA 2003
+    encoder/decoder is used.
+
+    Returns a ``dns.rrset.RRset`` object.
     """
 
-    if isinstance(name, string_types):
-        name = dns.name.from_text(name, None)
-    if isinstance(rdclass, string_types):
-        rdclass = dns.rdataclass.from_text(rdclass)
-    if isinstance(rdtype, string_types):
-        rdtype = dns.rdatatype.from_text(rdtype)
+    if isinstance(name, str):
+        name = dns.name.from_text(name, None, idna_codec=idna_codec)
+    rdclass = dns.rdataclass.RdataClass.make(rdclass)
+    rdtype = dns.rdatatype.RdataType.make(rdtype)
     r = RRset(name, rdclass, rdtype)
     r.update_ttl(ttl)
     for t in text_rdatas:
-        rd = dns.rdata.from_text(r.rdclass, r.rdtype, t)
+        rd = dns.rdata.from_text(r.rdclass, r.rdtype, t, idna_codec=idna_codec)
         r.add(rd)
     return r
 
@@ -144,21 +154,26 @@ def from_text(name, ttl, rdclass, rdtype, *text_rdatas):
     """Create an RRset with the specified name, TTL, class, and type and with
     the specified rdatas in text format.
 
-    @rtype: dns.rrset.RRset object
+    Returns a ``dns.rrset.RRset`` object.
     """
 
     return from_text_list(name, ttl, rdclass, rdtype, text_rdatas)
 
 
-def from_rdata_list(name, ttl, rdatas):
+def from_rdata_list(name, ttl, rdatas, idna_codec=None):
     """Create an RRset with the specified name and TTL, and with
     the specified list of rdata objects.
 
-    @rtype: dns.rrset.RRset object
+    *idna_codec*, a ``dns.name.IDNACodec``, specifies the IDNA
+    encoder/decoder to use; if ``None``, the default IDNA 2003
+    encoder/decoder is used.
+
+    Returns a ``dns.rrset.RRset`` object.
+
     """
 
-    if isinstance(name, string_types):
-        name = dns.name.from_text(name, None)
+    if isinstance(name, str):
+        name = dns.name.from_text(name, None, idna_codec=idna_codec)
 
     if len(rdatas) == 0:
         raise ValueError("rdata list must not be empty")
@@ -175,7 +190,7 @@ def from_rdata(name, ttl, *rdatas):
     """Create an RRset with the specified name and TTL, and with
     the specified rdata objects.
 
-    @rtype: dns.rrset.RRset object
+    Returns a ``dns.rrset.RRset`` object.
     """
 
     return from_rdata_list(name, ttl, rdatas)