FM / names

/usr/lib/python3/dist-packages/twisted/names/

/usr/lib/python3/dist-packages/twisted/names

Name	Size	Mode	Actions
test/	-	0755	rm
__pycache__/	-	0755	rm
authority.py	16683	0644	edit dl rm
cache.py	4035	0644	edit dl rm
client.py	24520	0644	edit dl rm
common.py	9360	0644	edit dl rm
dns.py	104319	0644	edit dl rm
error.py	2024	0644	edit dl rm
hosts.py	4807	0644	edit dl rm
resolve.py	3249	0644	edit dl rm
root.py	12424	0644	edit dl rm
secondary.py	7142	0644	edit dl rm
server.py	22182	0644	edit dl rm
srvconnect.py	9196	0644	edit dl rm
tap.py	4801	0644	edit dl rm
_rfc1982.py	9156	0644	edit dl rm
__init__.py	135	0644	edit dl rm

Edit: /usr/lib/python3/dist-packages/twisted/names/tap.py (4801B)

# -*- test-case-name: twisted.names.test.test_tap -*-
# Copyright (c) Twisted Matrix Laboratories.
# See LICENSE for details.

"""
Domain Name Server
"""

import os
import traceback

from twisted.application import internet, service
from twisted.names import authority, dns, secondary, server
from twisted.python import usage

class Options(usage.Options):
    optParameters = [
        ["interface", "i", "", "The interface to which to bind"],
        ["port", "p", "53", "The port on which to listen"],
        [
            "resolv-conf",
            None,
            None,
            "Override location of resolv.conf (implies --recursive)",
        ],
        ["hosts-file", None, None, "Perform lookups with a hosts file"],
    ]

optFlags = [
        ["cache", "c", "Enable record caching"],
        ["recursive", "r", "Perform recursive lookups"],
        ["verbose", "v", "Log verbosely"],
    ]

compData = usage.Completions(
        optActions={"interface": usage.CompleteNetInterfaces()}
    )

zones = None
    zonefiles = None

def __init__(self):
        usage.Options.__init__(self)
        self["verbose"] = 0
        self.bindfiles = []
        self.zonefiles = []
        self.secondaries = []

def opt_pyzone(self, filename):
        """Specify the filename of a Python syntax zone definition"""
        if not os.path.exists(filename):
            raise usage.UsageError(filename + ": No such file")
        self.zonefiles.append(filename)

def opt_bindzone(self, filename):
        """Specify the filename of a BIND9 syntax zone definition"""
        if not os.path.exists(filename):
            raise usage.UsageError(filename + ": No such file")
        self.bindfiles.append(filename)

def opt_secondary(self, ip_domain):
        """Act as secondary for the specified domain, performing
        zone transfers from the specified IP (IP/domain)
        """
        args = ip_domain.split("/", 1)
        if len(args) != 2:
            raise usage.UsageError("Argument must be of the form IP[:port]/domain")
        address = args[0].split(":")
        if len(address) == 1:
            address = (address[0], dns.PORT)
        else:
            try:
                port = int(address[1])
            except ValueError:
                raise usage.UsageError(
                    f"Specify an integer port number, not {address[1]!r}"
                )
            address = (address[0], port)
        self.secondaries.append((address, [args[1]]))

def opt_verbose(self):
        """Increment verbosity level"""
        self["verbose"] += 1

def postOptions(self):
        if self["resolv-conf"]:
            self["recursive"] = True

self.svcs = []
        self.zones = []
        for f in self.zonefiles:
            try:
                self.zones.append(authority.PySourceAuthority(f))
            except Exception:
                traceback.print_exc()
                raise usage.UsageError("Invalid syntax in " + f)
        for f in self.bindfiles:
            try:
                self.zones.append(authority.BindAuthority(f))
            except Exception:
                traceback.print_exc()
                raise usage.UsageError("Invalid syntax in " + f)
        for f in self.secondaries:
            svc = secondary.SecondaryAuthorityService.fromServerAddressAndDomains(*f)
            self.svcs.append(svc)
            self.zones.append(self.svcs[-1].getAuthority())
        try:
            self["port"] = int(self["port"])
        except ValueError:
            raise usage.UsageError("Invalid port: {!r}".format(self["port"]))

def _buildResolvers(config):
    """
    Build DNS resolver instances in an order which leaves recursive
    resolving as a last resort.

@type config: L{Options} instance
    @param config: Parsed command-line configuration

@return: Two-item tuple of a list of cache resovers and a list of client
        resolvers
    """
    from twisted.names import cache, client, hosts

ca, cl = [], []
    if config["cache"]:
        ca.append(cache.CacheResolver(verbose=config["verbose"]))
    if config["hosts-file"]:
        cl.append(hosts.Resolver(file=config["hosts-file"]))
    if config["recursive"]:
        cl.append(client.createResolver(resolvconf=config["resolv-conf"]))
    return ca, cl

def makeService(config):
    ca, cl = _buildResolvers(config)

f = server.DNSServerFactory(config.zones, ca, cl, config["verbose"])
    p = dns.DNSDatagramProtocol(f)
    f.noisy = 0
    ret = service.MultiService()
    for (klass, arg) in [(internet.TCPServer, f), (internet.UDPServer, p)]:
        s = klass(config["port"], arg, interface=config["interface"])
        s.setServiceParent(ret)
    for svc in config.svcs:
        svc.setServiceParent(ret)
    return ret

cmd: