示例#1
0
class ArcTestResolver(object):
    def __init__(self, records, port=8053, verbose=False):
        self.records = records
        self.port = port
        self.verbose = verbose

    def __enter__(self):
        zones = []
        for (domain, txt) in self.records.items():
            n = 255
            frags = [("'" + txt[i:i+n] + "'") for i in range(0, len(txt), n)]
            zones.append(domain + " IN TXT " + " ".join(frags))

        resolver = ZoneResolver("\n".join(zones))
        
        if self.verbose:
            logger = DNSLogger()
        else:
            logger = NullLogger()

        self.server = DNSServer(resolver, port=self.port, logger=logger)
        self.server.start_thread()

    def __exit__(self, type, value, traceback):
        self.server.stop()
示例#2
0
class CatlogResolver(BaseResolver):
    def __init__(self):
        self.txtMap = {}
        self.udp_server = None

    def setTxt(self, domain: str, value: str) -> None:
        self.txtMap[domain.lower()] = value

    def clearTxt(self, domain: str) -> None:
        del self.txtMap[domain.lower()]

    def resolve(self, request, handler):
        """
            Respond to DNS request - parameters are request packet & handler.
            Method is expected to return DNS response
        """
        reply = request.reply()
        qname = request.q.qname.idna()[:-1].lower()
        qtype = QTYPE[request.q.qtype]
        if qtype == 'TXT' and qname in self.txtMap:
            reply.add_answer(*RR.fromZone('{} IN TXT "{}"'.format(
                qname, self.txtMap[qname])))
        else:
            reply.header.rcode = RCODE.NXDOMAIN
        return reply

    def start(self):
        self.udp_server = DNSServer(self, port=53, logger=SilentLogger())
        self.udp_server.start_thread()

    def stop(self):
        self.udp_server.stop()
示例#3
0
def serveDNS(logger, status_ctrl, main_frame):

    resolver = InterceptResolver('8.8.8.8', 53, '60s', status_ctrl, main_frame)

    DNSHandler.log = {
        'log_request',  # DNS Request
        'log_reply',  # DNS Response
        'log_truncated',  # Truncated
        'log_error',  # Decoding error
    }

    config = wx.ConfigBase.Get()
    host = config.Read("host") or socket.gethostbyname(socket.gethostname())
    dnsport = config.Read("dnsport") or "53"
    try:
        udp_server = DNSServer(resolver,
                               port=int(dnsport),
                               address=host,
                               logger=logger)
    except Exception as e:
        evt = custom_events.wxStatusEvent(
            message='Error starting DNS proxy: %s' % e)
        wx.PostEvent(status_ctrl, evt)
        return

    udp_server.start_thread()

    evt = custom_events.wxStatusEvent(message="proxy started")
    wx.PostEvent(status_ctrl, evt)

    try:
        while udp_server.isAlive():
            time.sleep(1)
    except KeyboardInterrupt:
        sys.exit()
示例#4
0
    def run(self):

        port = int(os.getenv("PORT", 53))
        upstream = os.getenv("UPSTREAM", "8.8.8.8")
        zone_file = Path(C.DNSHOSTS)
        self.logger_dns = LocalDNSLogger(self.sendRequests)
        self.resolver = Resolver(upstream, zone_file, self.sendRequests)
        self.udp_server = DNSServer(self.resolver,
                                    port=port,
                                    logger=self.logger_dns)
        self.tcp_server = DNSServer(self.resolver,
                                    port=port,
                                    logger=self.logger_dns,
                                    tcp=True)
        print(
            display_messages("starting {}".format(self.objectName()),
                             info=True))

        # logger.info('starting DNS server on port %d, upstream DNS server "%s"', port, upstream)
        self.udp_server.start_thread()
        self.tcp_server.start_thread()

        try:
            while self.udp_server.isAlive():
                sleep(1)
        except KeyboardInterrupt:
            pass
示例#5
0
文件: dnsserver.py 项目: tcinbis/acme
class ACMEDNS:
    def __init__(self, zone: str = ""):
        LOGGER.debug(f"DNS Server received zones: \n {zone}")
        self.resolver = ZoneResolver(textwrap.dedent(zone))
        self.dns_logger = DNSLogger(prefix=False)
        self.server = DNSServer(self.resolver,
                                port=10053,
                                address="0.0.0.0",
                                logger=self.dns_logger)

    def start(self):
        LOGGER.info("Starting DNS server...")
        self.server.start_thread()

    def stop(self):
        LOGGER.info("Stopping DNS server...")
        self.server.server.server_close()

    def update_zone(self, new_zone: str):
        LOGGER.debug(f"Updating DNS with new zone:\n {new_zone}")
        self.stop()
        self.resolver = ZoneResolver(textwrap.dedent(new_zone))
        self.server = DNSServer(self.resolver,
                                port=10053,
                                address="0.0.0.0",
                                logger=self.dns_logger)
        self.start()
    def _perform(self, domain, validation_name, validation):
        if self.resolver is None:
            self.resolver = _AcmeResolver()

        self.resolver.addToken(validation)

        if self.servers is None:
            self.servers = []
            active_udp_server = False
            error = None

            for Server in [TCP6Server, TCPServer, UDP6Server, UDPServer]:
                # Try IPv6 version first since it may listen on IPv4 as well.
                try:
                    if Server.address_family == AF_INET6:
                        address = self.conf('ipv6-address')
                    else:
                        address = self.conf('address')
                    if address is not None:
                        server = DNSServer(self.resolver,
                                           port=int(self.conf('port')),
                                           address=address,
                                           server=Server,
                                           logger=dnsLogger)
                        server.start_thread()
                        self.servers.append(server)
                        if Server.socket_type == SOCK_DGRAM:
                            active_udp_server = True
                except Exception as e:
                    error = e

            if not active_udp_server:
                # Re-raise the exception when no UDP server was started successfully.
                raise errors.PluginError(
                    'Error starting DNS server: {0}'.format(error))
示例#7
0
    def __init__(self, listen_addresses: List[IpAndPort],
                 upstream_dns_server: IpAndPort, dns_domains, default_domain,
                 default_host_ip, handler, cli):
        super().__init__()

        self.default_domain = default_domain
        self.handler = handler

        self.dns_domains_globs = [
            '*%s' % domain if domain.startswith('.') else domain
            for domain in dns_domains
        ]

        self.resolver = ZoneResolver([], glob=True)
        self.servers = []

        resolver = InterceptResolver(
            self.dns_domains_globs, self.resolver,
            ProxyResolver(upstream_dns_server.ip.exploded,
                          port=upstream_dns_server.port,
                          timeout=5))
        self.handler.log("Unhandled DNS requests will be resolved using %s" %
                         upstream_dns_server)
        self.handler.log("DNS server listening on %s" %
                         ", ".join(map(lambda x: str(x), listen_addresses)))

        for ip_and_port in listen_addresses:
            server = DNSServer(resolver,
                               address=ip_and_port.ip.exploded,
                               port=ip_and_port.port)
            server.thread_name = "%s:%s" % (ip_and_port.ip, ip_and_port.port)
            self.servers.append(server)

        self.watcher = DockerWatcher(self, default_host_ip, cli)
示例#8
0
def start_dns_server(proxy, upstream, subscription_server_uri=None):
    """Start handling DNS requests. """
    logger.info("uWSGI-DNS resolver is starting...")

    resolver = LocalResolver(
        proxy,
        upstream
    )

    dns_server = DNSServer(
        resolver=resolver,
        address=DNS_HOST,
        port=DNS_PORT,
        server=ThreadedUDPServer,
        logger=LocalDNSLogger()
    )

    # Start the subscription listener BEFORE the server.
    start_subscription_listener(resolver.add_domain_from_uwsgi)

    if subscription_server_uri:
        # Start the subscription checker BEFORE the server.
        start_subscription_checker(subscription_server_uri, resolver.add_domains)

    # And start the DNS server.
    dns_server.start()
示例#9
0
class MyDNSServer:

    server = None

    @classmethod
    def start(self, address):

        my_resolver = MyResolver(address)

        logger = DNSLogger(prefix=False)

        self.server = DNSServer(my_resolver,
                                port=10053,
                                address=str(address),
                                logger=logger)

        self.server.start_thread()
        print("DNS server is UP")
        # while server.isAlive():
        #   time.sleep(1)

    @classmethod
    def shut_down(self):
        print("shutting down the DNS server..\n")
        self.server.stop()
示例#10
0
 def start(self):
     logger = DNSLogger(prefix=False)
     udp_server = DNSServer(self,
                            port=10053,
                            address=self.address,
                            logger=logger)
     udp_server.start_thread()
示例#11
0
文件: resolver.py 项目: mihau/labDNS
def main():
    import argparse
    import json
    import time
    from importlib import import_module

    from dnslib.server import DNSLogger, DNSServer

    parser = argparse.ArgumentParser(
        description="Database lookup based DNS resolver"
    )

    parser.add_argument(
        "--storage", "-s", default='labDNS.storages.DictStorage'
    )
    parser.add_argument("--config", "-c", type=json.loads, default=dict())
    parser.add_argument("--zone", "-z")
    parser.add_argument("--ttl", "-t", default=10, type=int)
    parser.add_argument("--log", "-l", default="request,reply,truncated,error")
    parser.add_argument("--port", "-p", default=53, type=int)
    parser.add_argument("--address", "-a", default="localhost")
    parser.add_argument("--keymaker", "-k", default=None)
    parser.add_argument("--processor", default=None)
    parser.add_argument("--upstream", "-u", default=None)
    parser.add_argument("--bypass", "-b", default=[], nargs='+')

    args = parser.parse_args()

    config = args.config

    Storage = locate(args.storage)
    storage = Storage(config)

    keymaker = import_module(args.keymaker).keymaker if args.keymaker else None
    processor = (
        import_module(args.processor).processor if args.processor else None
    )

    resolver = DatabaseLookupResolver(
        storage,
        args.zone,
        ttl=args.ttl,
        keymaker=keymaker,
        upstream=args.upstream,
        processor=processor,
        bypass=args.bypass,
    )
    logger = DNSLogger(args.log)

    server = DNSServer(
        resolver,
        port=args.port,
        address=args.address,
        logger=logger,
    )

    server.start_thread()

    while server.isAlive():
        time.sleep(1)
示例#12
0
    def setUp(self):
        zone_file = '''
crate.internal.               600   IN   SOA   localhost localhost ( 2007120710 1d 2h 4w 1h )
crate.internal.               400   IN   NS    localhost
crate.internal.               600   IN   A     127.0.0.1'''

        transport_ports = [bind_port() for _ in range(self.num_nodes)]
        for port in transport_ports:
            zone_file += '''
_test._srv.crate.internal.    600   IN   SRV   1 10 {port} 127.0.0.1.'''.format(
                port=port)

        dns_port = bind_port()
        self.dns_server = DNSServer(ZoneResolver(zone_file), port=dns_port)
        self.dns_server.start_thread()

        self.nodes = nodes = []
        for i in range(self.num_nodes):
            settings = {
                'node.name': f'node-{i}',
                'cluster.name': 'crate-dns-discovery',
                'psql.port': 0,
                'transport.tcp.port': transport_ports[i],
                "discovery.seed_providers": "srv",
                "discovery.srv.query": "_test._srv.crate.internal.",
                "discovery.srv.resolver": "127.0.0.1:" + str(dns_port)
            }
            if i is 0:
                settings['cluster.initial_master_nodes'] = f'node-{i}'
            node = CrateNode(crate_dir=crate_path(),
                             version=(4, 0, 0),
                             settings=settings,
                             env={'CRATE_HEAP_SIZE': '256M'})
            node.start()
            nodes.append(node)
示例#13
0
 def start(self):
     if not self.server:
         print(" * Starting DNS server on {}:53".format(self.default_ip))
         try:
             self.server = DNSServer(self.resolver, port=53, address=self.default_ip)
             self.server.start_thread()
         except Exception as e:
             print(" * ERROR: Unable to bind to port 53. DNS server could not start: {}".format(e))
示例#14
0
文件: dnsserver.py 项目: tcinbis/acme
 def __init__(self, zone: str = ""):
     LOGGER.debug(f"DNS Server received zones: \n {zone}")
     self.resolver = ZoneResolver(textwrap.dedent(zone))
     self.dns_logger = DNSLogger(prefix=False)
     self.server = DNSServer(self.resolver,
                             port=10053,
                             address="0.0.0.0",
                             logger=self.dns_logger)
示例#15
0
def main():
    if DEBUG:
        logging.basicConfig(level=logging.DEBUG, format='%(asctime)s %(name)-24s %(levelname)-8s %(message)s')
    logger = DNSLogger()
    resolver = DdnssResolver(UPSTREAM_ADDRESS, UPSTREAM_PORT, API_SERVER, API_SERVER_USERNAME, API_SERVER_PASSWORD, ZONES, TTL, MAPPINGS)
    server = DNSServer(resolver, port=int(SERVER_PORT), logger=logger, tcp=USE_TCP)
    print(f'running on 0.0.0.0:{SERVER_PORT}/{USE_TCP and "tcp" or "udp"}')
    server.start()
示例#16
0
class DnsSrvDiscoveryTest(TestCase):

    num_nodes = 3

    def setUp(self):
        zone_file = '''
crate.internal.               600   IN   SOA   localhost localhost ( 2007120710 1d 2h 4w 1h )
crate.internal.               400   IN   NS    localhost
crate.internal.               600   IN   A     127.0.0.1'''

        transport_ports = [bind_port() for _ in range(self.num_nodes)]
        for port in transport_ports:
            zone_file += '''
_test._srv.crate.internal.    600   IN   SRV   1 10 {port} 127.0.0.1.'''.format(
                port=port)

        dns_port = bind_port()
        self.dns_server = DNSServer(ZoneResolver(zone_file), port=dns_port)
        self.dns_server.start_thread()

        self.nodes = nodes = []
        for i in range(self.num_nodes):
            settings = {
                'node.name': f'node-{i}',
                'cluster.name': 'crate-dns-discovery',
                'psql.port': 0,
                'transport.tcp.port': transport_ports[i],
                "discovery.seed_providers": "srv",
                "discovery.srv.query": "_test._srv.crate.internal.",
                "discovery.srv.resolver": "127.0.0.1:" + str(dns_port)
            }
            if i == 0:
                settings['cluster.initial_master_nodes'] = f'node-{i}'
            node = CrateNode(crate_dir=crate_path(),
                             version=(4, 0, 0),
                             settings=settings,
                             env={
                                 'CRATE_HEAP_SIZE':
                                 '256M',
                                 'CRATE_JAVA_OPTS':
                                 '-Dio.netty.leakDetection.level=paranoid',
                             })
            node.start()
            nodes.append(node)

    def tearDown(self):
        for node in self.nodes:
            node.stop()
        self.dns_server.server.server_close()
        self.dns_server.stop()

    def test_nodes_discover_each_other(self):
        with connect(self.nodes[0].http_url) as conn:
            c = conn.cursor()
            c.execute('''select count(*) from sys.nodes''')
            result = c.fetchone()
        self.assertEqual(result[0], self.num_nodes,
                         'Nodes must be able to join')
示例#17
0
文件: dnsserver.py 项目: tcinbis/acme
 def update_zone(self, new_zone: str):
     LOGGER.debug(f"Updating DNS with new zone:\n {new_zone}")
     self.stop()
     self.resolver = ZoneResolver(textwrap.dedent(new_zone))
     self.server = DNSServer(self.resolver,
                             port=10053,
                             address="0.0.0.0",
                             logger=self.dns_logger)
     self.start()
示例#18
0
 def __init__(self, server, port=53, queue=None, ifname='eth0'):
     resolver = PACDNSResolver(server,
                               port,
                               timeout=5,
                               queue=queue,
                               ifname=ifname)
     handler = DNSHandler
     logger = DNSLogger("request", False)
     self.udp_server = DNSServer(resolver, logger=logger, handler=handler)
示例#19
0
class DnsServer:
    def __init__(self, host: str, record: str, url: str):
        resolver = FixedResolver(record, url)
        self._server = DNSServer(resolver, port=10053, address=host)

    def start(self):
        self._server.start_thread()

    def shutDown(self):
        self._server.stop()
示例#20
0
    def run(self):
        zones = self.get_zones()
        upstream = self.get_upstream()
        api_url = self.get_api_url()
        api_token = self.get_api_token()
        port = self.get_port()
        listen = self.get_listen()

        resolver = Resolver(zones, upstream, api_url, api_token)
        udp_server = DNSServer(resolver,
                               address=listen,
                               port=port,
                               logger=DnsLogger())
        tcp_server = DNSServer(resolver,
                               address=listen,
                               port=port,
                               tcp=True,
                               logger=DnsLogger())

        logger.info(
            'starting DNS server on port %d, upstream DNS server "%s", %d zones',
            port,
            upstream,
            len(zones),
        )
        udp_server.start_thread()
        tcp_server.start_thread()

        try:
            while udp_server.isAlive():
                sleep(1)
        except KeyboardInterrupt:
            pass
示例#21
0
class DnsSrvDiscoveryTest(TestCase):

    num_nodes = 3

    def setUp(self):
        zone_file = '''
crate.internal.               600   IN   SOA   localhost localhost ( 2007120710 1d 2h 4w 1h )
crate.internal.               400   IN   NS    localhost
crate.internal.               600   IN   A     127.0.0.1'''

        transport_ports = [bind_port() for _ in range(self.num_nodes)]
        for port in transport_ports:
            zone_file += '''
_test._srv.crate.internal.    600   IN   SRV   1 10 {port} 127.0.0.1.'''.format(port=port)

        dns_port = bind_port()
        self.dns_server = DNSServer(ZoneResolver(zone_file), port=dns_port)
        self.dns_server.start_thread()

        self.nodes = nodes = []
        for i in range(self.num_nodes):
            settings = {
                         'node.name': f'node-{i}',
                         'cluster.name': 'crate-dns-discovery',
                         'psql.port': 0,
                         'transport.tcp.port': transport_ports[i],
                         "discovery.seed_providers": "srv",
                         "discovery.srv.query": "_test._srv.crate.internal.",
                         "discovery.srv.resolver": "127.0.0.1:" + str(dns_port)
                     }
            if i is 0:
                settings['cluster.initial_master_nodes'] = f'node-{i}'
            node = CrateNode(
                crate_dir=crate_path(),
                version=(4, 0, 0),
                settings=settings,
                env={
                    'CRATE_HEAP_SIZE': '256M'
                }
            )
            node.start()
            nodes.append(node)

    def tearDown(self):
        for node in self.nodes:
            node.stop()
        self.dns_server.server.server_close()
        self.dns_server.stop()

    def test_nodes_discover_each_other(self):
        with connect(self.nodes[0].http_url) as conn:
            c = conn.cursor()
            c.execute('''select count(*) from sys.nodes''')
            result = c.fetchone()
        self.assertEqual(result[0], self.num_nodes, 'Nodes must be able to join')
示例#22
0
文件: dnsd.py 项目: xiaket/etc
def main():
    resolver = SocksResolver(REAL_SERVER, 53)
    logger = DNSLogger("request,reply,truncated,error", False)

    server = DNSServer(
        resolver, port=53, address=LISTEN_ADDR, logger=logger,
    )
    try:
        server.start()
    except KeyboardInterrupt:
        server.stop()
示例#23
0
class PACDNSServer():
    def __init__(self, server, port=53, queue=None, ifname='eth0'):
        resolver = PACDNSResolver(server, port, timeout=5, queue=queue, ifname=ifname)
        handler = DNSHandler
        logger = DNSLogger("request", False)
        self.udp_server = DNSServer(resolver, logger=logger, handler=handler)

    def start(self, no_exit=False):
        self.udp_server.start_thread()
        while no_exit and self.udp_server.isAlive():
            time.sleep(1)
示例#24
0
def main():
    zone = '''
*.{dnsdomain}.       IN      A       {serverip}
{dnsdomain}.       IN      A       {serverip}
'''.format(dnsdomain=config.DNS_DOMAIN, serverip=config.SERVER_IP)
    resolver = ZoneResolver(zone, True)
    logger = MysqlLogger()
    print("Starting Zone Resolver (%s:%d) [%s]" % ("*", 53, "UDP"))

    udp_server = DNSServer(resolver, port=53, address='', logger=logger)
    udp_server.start()
示例#25
0
def start_dns_server():
    global server
    logging.info("starting dns server thread ... ")
    logging.debug("Binding on IP:" + GConfig["dnsserver"])
    resolver = DNSListResolver()
    logger = DNSLogger(log="+send", prefix=False)
    server = DNSServer(resolver,
                       port=GConfig['port'],
                       address=GConfig['dnsserver'],
                       logger=logger)
    server.start_thread()
    return (1)
示例#26
0
 def __init__(self):
     resolver = Resolver()
     self.servers = [
         DNSServer(resolver,
                   port=CONFIG.server['port'],
                   address=CONFIG.server['address'],
                   tcp=True),
         DNSServer(resolver,
                   port=CONFIG.server['port'],
                   address=CONFIG.server['address'],
                   tcp=False),
     ]
示例#27
0
class DNS(object):
    def __init__(self):
        self.default_ip = get_default_ip()
        self.resolver = None
        self.server = None
        self.base_zone_data = None
        self.reset()

    def wait_for_query(self, record_type, record_name, timeout):
        self.resolver.wait_for_query(record_type, record_name, timeout)

    def load_zone(self, api_version, api_protocol, zone_name, port_base):
        zone_file = open(zone_name).read()
        template = Template(zone_file)
        zone_data = template.render(ip_address=self.default_ip,
                                    api_ver=api_version,
                                    api_proto=api_protocol,
                                    domain=CONFIG.DNS_DOMAIN,
                                    port_base=port_base)
        self.resolver = WatchingResolver(self.base_zone_data + zone_data)
        self.stop()
        print(" * Loading DNS zone file '{}' with api_ver={}".format(
            zone_name, api_version))
        self.start()

    def reset(self):
        zone_file = open("test_data/core/dns_base.zone").read()
        template = Template(zone_file)
        self.base_zone_data = template.render(ip_address=self.default_ip,
                                              domain=CONFIG.DNS_DOMAIN)
        self.resolver = WatchingResolver(self.base_zone_data)
        self.stop()
        print(" * Loading DNS zone base file")
        self.start()

    def start(self):
        if not self.server:
            print(" * Starting DNS server on {}:53".format(self.default_ip))
            try:
                self.server = DNSServer(self.resolver,
                                        port=53,
                                        address=self.default_ip)
                self.server.start_thread()
            except Exception as e:
                print(
                    " * ERROR: Unable to bind to port 53. DNS server could not start: {}"
                    .format(e))

    def stop(self):
        if self.server:
            print(" * Stopping DNS server on {}:53".format(self.default_ip))
            self.server.stop()
            self.server = None
示例#28
0
 def start_bind(self):
     """
     启动监听,udp监听同一个端口时只有第一个有用
     :return: 
     """
     self.logger.info("\n" + self.zone)
     resolver = ZoneResolver(textwrap.dedent(self.zone), True)
     dns_logger = DnsLogger()
     self.udp_server = DNSServer(resolver,
                                 port=self.port,
                                 address=self.host,
                                 logger=dns_logger)
     return True
示例#29
0
    def start(self, address):

        my_resolver = MyResolver(address)

        logger = DNSLogger(prefix=False)

        self.server = DNSServer(my_resolver,
                                port=10053,
                                address=str(address),
                                logger=logger)

        self.server.start_thread()
        print("DNS server is UP")
示例#30
0
    def _reload(cls, first_run=False):
        from utils import setting, logger

        # restart threads
        dns_servers = cls.parse_server_config(setting.conf)
        for server in dns_servers:
            resolver = RouterResolver(server)
            empty_logger = EmptyDNSLogger()
            _server = DNSServer(resolver, address=server['hostname'], port=server['port'],
                                tcp=server['scheme'] == "tcp", logger=empty_logger)
            _server.start_thread()
            cls.servers.append(_server)
            if not first_run:
                logger.info('Config file reloaded: ' + ArgumentParser.args['config'])
            logger.info('Started local DNS server: ' + server['url'], LOGGER_NAME)
示例#31
0
class PACDNSServer():
    def __init__(self, server, port=53, queue=None, ifname='eth0'):
        resolver = PACDNSResolver(server,
                                  port,
                                  timeout=5,
                                  queue=queue,
                                  ifname=ifname)
        handler = DNSHandler
        logger = DNSLogger("request", False)
        self.udp_server = DNSServer(resolver, logger=logger, handler=handler)

    def start(self, no_exit=False):
        self.udp_server.start_thread()
        while no_exit and self.udp_server.isAlive():
            time.sleep(1)
示例#32
0
class DNSServerThread(QThread):
    """ Simple DNS server UDP resolver """

    sendRequests = pyqtSignal(object)  # I'll use this object in future feature

    def __init__(self, conf):
        super(DNSServerThread, self).__init__(parent=None)
        self.resolver = None
        self.conf = conf

    def run(self):

        port = int(os.getenv("PORT", 53))
        upstream = os.getenv("UPSTREAM", "8.8.8.8")
        zone_file = Path(C.DNSHOSTS)
        self.logger_dns = LocalDNSLogger(self.sendRequests)
        self.resolver = Resolver(upstream, zone_file, self.sendRequests)
        self.udp_server = DNSServer(self.resolver,
                                    port=port,
                                    logger=self.logger_dns)
        self.tcp_server = DNSServer(self.resolver,
                                    port=port,
                                    logger=self.logger_dns,
                                    tcp=True)
        print(
            display_messages("starting {}".format(self.objectName()),
                             info=True))

        # logger.info('starting DNS server on port %d, upstream DNS server "%s"', port, upstream)
        self.udp_server.start_thread()
        self.tcp_server.start_thread()

        try:
            while self.udp_server.isAlive():
                sleep(1)
        except KeyboardInterrupt:
            pass

    def getpid(self):
        """ return the pid of current process in background"""
        return "thread"

    def getID(self):
        """ return the name of process in background"""
        return self.objectName()

    def stop(self):
        self.udp_server.stop()
        self.tcp_server.stop()
        print(
            display_messages("thread {} successfully stopped".format(
                self.objectName()),
                             info=True))
示例#33
0
class DNS(object):
    def __init__(self):
        self.default_ip = get_default_ip()
        self.resolver = None
        self.server = None
        self.base_zone_data = None
        self.reset()

    def load_zone(self, api_version, api_protocol):
        zone_file = open("test_data/IS0401/dns_records.zone").read()
        template = Template(zone_file)
        zone_data = template.render(ip_address=self.default_ip,
                                    api_ver=api_version,
                                    api_proto=api_protocol,
                                    domain=DNS_DOMAIN)
        self.resolver = ZoneResolver(self.base_zone_data + zone_data)
        self.stop()
        print(" * Loading DNS zone file with api_ver={}".format(api_version))
        self.start()

    def reset(self):
        zone_file = open("test_data/IS0401/dns_base.zone").read()
        template = Template(zone_file)
        self.base_zone_data = template.render(ip_address=self.default_ip,
                                              domain=DNS_DOMAIN)
        self.resolver = ZoneResolver(self.base_zone_data)
        self.stop()
        print(" * Loading DNS zone base file")
        self.start()

    def start(self):
        if not self.server:
            print(" * Starting DNS server on {}:53".format(self.default_ip))
            try:
                self.server = DNSServer(self.resolver,
                                        port=53,
                                        address=self.default_ip)
                self.server.start_thread()
            except Exception as e:
                print(
                    " * ERROR: Unable to bind to port 53. DNS server could not start: {}"
                    .format(e))

    def stop(self):
        if self.server:
            print(" * Stopping DNS server on {}:53".format(self.default_ip))
            self.server.stop()
            self.server = None
    def _perform(self, domain, validation_name, validation):
        if self.resolver is None:
            self.resolver = _AcmeResolver()

        self.resolver.addToken(validation)

        if self.udp_server is None:
            try:
                self.udp_server = DNSServer(self.resolver,
                                            port=53,
                                            address=self.conf('address'),
                                            logger=dnsLogger)
                self.udp_server.start_thread()
            except Exception as e:
                raise errors.PluginError(
                    'Error starting DNS server: {0}'.format(e))
示例#35
0
def main():
    zone = '''
*.{dnsdomain}.       IN      NS      {ns1domain}.
*.{dnsdomain}.       IN      NS      {ns2domain}.
*.{dnsdomain}.       IN      A       {serverip}
{dnsdomain}.       IN      A       {serverip}
'''.format(
        dnsdomain=settings.DNS_DOMAIN,
        ns1domain=settings.NS1_DOMAIN,
        ns2domain=settings.NS2_DOMAIN,
        serverip=settings.SERVER_IP)
    resolver = ZoneResolver(zone, True)
    logger = MysqlLogger()
    print("Starting Zone Resolver (%s:%d) [%s]" % ("*", 53, "UDP"))

    udp_server = DNSServer(resolver, port=53, address='', logger=logger)
    udp_server.start()
示例#36
0
def serveDNS(hostaddr):
    dnsport = 53
    resolver = InterceptResolver('8.8.8.8',
                                 dnsport,
                                 '60s',
                                 hostaddr)
    try:
        udp_server = DNSServer(resolver,
                           port=dnsport,
                           address=hostaddr,
                           logger = DNSLogger("-send,-recv,-request,-reply,-truncated,-error", False))
    except Exception as e:
        raise
    
    udp_server.start_thread()
    
    try:
        while udp_server.isAlive():
            time.sleep(1)
    except KeyboardInterrupt:
        sys.exit()
示例#37
0
文件: proxy.py 项目: Macronut/Proxy46
def main():
    loadconfig()
    
    proxy_server = ThreadingTCPServer(('', 1081), ProxyServer)
    thread = threading.Thread(target=proxy_server.serve_forever)
    thread.daemon = True
    thread.start()
    print 'proxy running'

    resolver = DNSProxyResolver(DefaultDNS, 53, 10)
    logger = DNSLogger(log='-log_request, -log_reply', prefix=False)
    dns_server = DNSServer(resolver, port=5353, address='127.0.0.1', logger=logger, handler=DNSHandler)
    dns_server.start_thread()
    print 'dns running'
    
    try:
        while True:
            time.sleep(600)
            sys.stderr.flush()
            sys.stdout.flush()
    except socket.error, e:
        logging.error(e)
示例#38
0
def serveDNS(logger, status_ctrl, main_frame):
    
    resolver = InterceptResolver('8.8.8.8',
                                 53,
                                 '60s',
                                 status_ctrl,
                                 main_frame)
    
    DNSHandler.log = { 
        'log_request',      # DNS Request
        'log_reply',        # DNS Response
        'log_truncated',    # Truncated
        'log_error',        # Decoding error
    }

    config = wx.ConfigBase.Get()
    host = config.Read("host") or socket.gethostbyname(socket.gethostname())
    dnsport = config.Read("dnsport") or "53"
    try:
        udp_server = DNSServer(resolver,
                           port=int(dnsport),
                           address=host,
                           logger=logger)
    except Exception as e:
        evt = custom_events.wxStatusEvent(message='Error starting DNS proxy: %s' % e)
        wx.PostEvent(status_ctrl,evt)
        return

    udp_server.start_thread()

    evt = custom_events.wxStatusEvent(message="proxy started")            
    wx.PostEvent(status_ctrl,evt)

    try:
        while udp_server.isAlive():
            time.sleep(1)
    except KeyboardInterrupt:
        sys.exit()
示例#39
0
def server_start(zone=None, ttl=3600, **kwargs):
    if zone == None:
        def zone_builder():
            zone = StringIO.StringIO()
            server_zone_list(zone=zone)
            zone.seek(0)
            return zone
    elif zone == '-':
        def zone_builder():
            return sys.stdin
    else:
        def zone_builder():
            return open(zone)
    resolver = ZoneResolver(zone_builder, False, ttl)
    logger = DNSLogger("request,reply,truncated,error", False)
    def reload_dns_config(signum, frame):
        if signum == signal.SIGUSR1:
            resolver.load()
    signal.signal(signal.SIGUSR1, reload_dns_config)
    udp_server = DNSServer(resolver,
                           port=53,
                           address="",
                           logger=logger)
    udp_server.start()
示例#40
0
文件: dnspc.py 项目: chepazzo/dnspc
 def start(self):
     handler = DNSHandler
     # log options: "recv,send,request,reply,truncated,error,data"
     # log defaults: "request,reply,truncated,error"
     # It's just too much stuff!
     logger = DNSLogger("truncated,error",True)
     self.log.info("Starting UDP server")
     if 'udp_server' not in dir(self):
         self.udp_server = DNSServer(self,
                         port=self.LOCAL_PORT,
                         address=self.LOCAL_IP,
                         logger=logger,
                         handler=handler)
     self.udp_server.start_thread()
     if self.TCP:
         self.log.info("Starting TCP server")
         if 'tcp_server' not in dir(self):
             self.tcp_server = DNSServer(self,
                             port=self.LOCAL_PORT,
                             address=self.LOCAL_IP,
                             tcp=True,
                             logger=logger,
                             handler=handler)
         self.tcp_server.start_thread()
示例#41
0
    def setUp(self):
        zone_file = '''
crate.internal.               600   IN   SOA   localhost localhost ( 2007120710 1d 2h 4w 1h )
crate.internal.               400   IN   NS    localhost
crate.internal.               600   IN   A     127.0.0.1'''

        transport_ports = [bind_port() for _ in range(self.num_nodes)]
        for port in transport_ports:
            zone_file += '''
_test._srv.crate.internal.    600   IN   SRV   1 10 {port} 127.0.0.1.'''.format(port=port)

        dns_port = bind_port()
        self.dns_server = DNSServer(ZoneResolver(zone_file), port=dns_port)
        self.dns_server.start_thread()

        self.nodes = nodes = []
        for i in range(self.num_nodes):
            settings = {
                         'node.name': f'node-{i}',
                         'cluster.name': 'crate-dns-discovery',
                         'psql.port': 0,
                         'transport.tcp.port': transport_ports[i],
                         "discovery.seed_providers": "srv",
                         "discovery.srv.query": "_test._srv.crate.internal.",
                         "discovery.srv.resolver": "127.0.0.1:" + str(dns_port)
                     }
            if i is 0:
                settings['cluster.initial_master_nodes'] = f'node-{i}'
            node = CrateNode(
                crate_dir=crate_path(),
                version=(4, 0, 0),
                settings=settings,
                env={
                    'CRATE_HEAP_SIZE': '256M'
                }
            )
            node.start()
            nodes.append(node)
示例#42
0
    def handle(self, *args, **options):
        # map django command verbosity to logging options
        logger = DNSLogger(log={
            '0': '-request,-reply,-truncated,-error',
            '1': '',
            '2': '+data',
            '3': '+recv,+send,+data'
        }[options['verbosity']])

        udp_server = DNSServer(
            resolver=InterceptingResolver(),
            address=options['address'],
            port=options['port'],
            logger=logger
        )
        udp_server.start_thread()

        try:
            while udp_server.isAlive():
                time.sleep(1)
        except KeyboardInterrupt:
            udp_server.stop()
示例#43
0
            'hello.subnet.lan',
            rdata=dnslib.A('192.168.0.0')
        ))
        return reply


if __name__ == '__main__':
    DBusGMainLoop(set_as_default=True)

    try:
        resolver = AvahiBrowser()

        logger = DNSLogger(prefix=False)
        server = DNSServer(
            resolver,
            port=8053,
            address='0.0.0.0',
            # tcp=True,
            logger=logger)

        resolver.connect()

        # scanner.browse_domain("local", "_ssh._tcp")
        resolver.browse_domain('local')
        server.start_thread()
        # server.start()

    except dbus.DBusException as e:
        print("Failed to connect to Avahi, is it running?: {}".format(e))
        sys.exit(1)

    loop = gobject.MainLoop()
示例#44
0
def main():
    global OPTIONS, ARGS

    parser = OptionParser()

    parser.add_option("-b", "--bind", dest = "bind", \
                      type = "string", default = "127.0.0.7:53", \
                      help = "set bind address/port to IP[:PORT]. " \
                      "Default value is `127.0.0.7:53'.", \
                      metavar = "IP[:PORT]")
    parser.add_option("-t", "--timeout", dest = "timeout", \
                      type = "int", default = "5", \
                      help = "set DNS resolving timeout to SECONDS", \
                      metavar = "SECONDS")
    parser.add_option("-r", "--retry", dest = "retry", \
                      type = "int", default = "3", \
                      help = "set retry count to COUNT", metavar = "COUNT")
    parser.add_option("-i", "--invalid-resolve", dest = "invalid_resolve", \
                      type = "string", default = r"10\.10\.34\.\d+", \
                      help = "REGEX is a an IP address or a regular " \
                      "expression that will not be prefered on DNS " \
                      "resolving. Default value is `10.10.34.\\d+'.", \
                      metavar = "REGEX")
    parser.add_option("--request-bind", dest = "request_bind", \
                      type = "string", default = "", \
                      help = "bind to IP address before sending DNS " \
                      "requests.", metavar = "IP")
    parser.add_option("-q", "--quiet", dest = "quiet", \
                      action = "store_true", default = False, \
                      help = "do not print any log")
    
    parser.set_usage("%s [OPTION]... DNS_SERVER[:PORT]..." % \
                     sys.argv[0])
    parser.set_description(__doc__)

    OPTIONS, ARGS = parser.parse_args()

    if len(ARGS) < 1:
        parser.print_help()
        exit(1)

    def get_address_port(arg):
        address_port = arg if ":" in arg else "%s:53" % arg
        address_port = address_port.split(":")
        return address_port[0], int(address_port[1])

    bind_address, bind_port = get_address_port(OPTIONS.bind)
    dns_servers = [get_address_port(arg) for arg in ARGS]

    resolver = ProxyResolver(dns_servers, request_bind_address = \
                             (OPTIONS.request_bind or None))
    logger = DNSLogger("request,reply,truncated,error", False) \
             if not OPTIONS.quiet else \
             DNSLogger("-request,-reply,-truncated,-error,-log_recv," \
                       "-log_send,-log_data", False)
    udp_server = DNSServer(resolver,
                           port = bind_port,
                           address = bind_address,
                           logger = logger if not OPTIONS.quiet else None,
                           handler = DNSHandler,
                           server = UDPServer)

    udp_server.start_thread()

    try:
        while udp_server.isAlive():
            time.sleep(1)
    except KeyboardInterrupt:
        if not OPTIONS.quiet:
            print("Shutting down the server with user request...")
        udp_server.stop()
        exit(0)
示例#45
0
def start_server(resolver):
    server = DNSServer(resolver=resolver, **config['server']['service'])
    server.start()
示例#46
0
	args=parser.parse_args()

	if dnslib_imported:
		try:
			dns_srv, dns_port=args.dns_server.split(':',1)
			dns_port=int(dns_port)
		except Exception as e:
			display("[-] %s"%e)
			display("[-] Invalid dns server : %s"%args.dns_server)
			exit(1)
		resolver = ProxyResolver(dns_srv,dns_port)
		handler = PassthroughDNSHandler # if args.passthrough else DNSHandler
		logger = DNSLogger("request,reply,truncated,error", False)
		udp_server = DNSServer(resolver,
							   port=args.dns_port,
							   address="127.0.0.1",
							   logger=logger,
							   handler=handler)
		udp_server.start_thread()
		display("[+] DNS server started on %s:%s forwarding all DNS trafic to %s:%s using TCP"%("127.0.0.1", args.dns_port, dns_srv, dns_port))

	ptype,proxy_addr,proxy_port=args.proxy.split(":",2)
	t=None
	if ptype.upper()=="SOCKS5":
		t=socks.PROXY_TYPE_SOCKS5
	elif ptype.upper()=="SOCKS4":
		t=socks.PROXY_TYPE_SOCKS4
	elif ptype.upper()=="HTTP":
		t=socks.PROXY_TYPE_HTTP
	else:
		display("[-] --proxy : unknown proxy type %s"%ptype)
                for ns in settings.NAMESERVERS:
                    reply.add_answer(RR(request.q.qname, ttl=settings.TTL, rtype=QTYPE.NS, rdata=NS(ns)))
            return reply

        name = str(name.stripSuffix(settings.ROOT_DOMAIN))

        match = re.match(r'ip-(\d{1,3})-(\d{1,3})-(\d{1,3})-(\d{1,3})\.?', name)

        if match is None:
            return nxdomain()

        ip = tuple(map(int, match.groups()))

        for octet in ip:
            if octet > 255:
                return nxdomain()

        # Now we return an empty response for not-A, or an actual response for A.
        # This is because we should not NXDOMAIN for domains that exist but have no records of
        # the specified type, so we have to go through the motions of checking validity first.
        reply = request.reply()
        if request.q.qtype == QTYPE.A or any_q:
            reply.add_answer(RR(request.q.qname, ttl=settings.TTL, rdata=A('%d.%d.%d.%d' % ip)))

        return reply


if __name__ == "__main__":
    server = DNSServer(PebbleResolver(), port=settings.PORT)
    server.start()
示例#48
0
文件: dnspc.py 项目: chepazzo/dnspc
class ParentalControls(BaseResolver):

    """
        Intercepting resolver 
        
        Proxy requests to upstream server optionally intercepting requests
        matching local records
    """

    def __init__(self):
        self.log = logging.getLogger('dnspc.dnspc.ParentalControls')
        self.rules = []
        self.hosts = []
        self.LOCAL_IP = settings.DNS['LOCAL_IP']
        self.LOCAL_PORT = settings.DNS['LOCAL_PORT']
        self.UP_IP = settings.DNS['UP_IP']
        self.UP_PORT = settings.DNS['UP_PORT']
        self.TCP = settings.DNS['TCP']
        self.TTL = parse_time(settings.DNS['TTL'])
        self.store ={
            'rules': settings.DATA['RULES'],
            'hosts': settings.DATA['HOSTS']
        }
        self.load_rules()
        self.load_hosts()

    ## Rules
    def load_rules(self):
        stored_rules = self.store['rules'].loadRecords()
        uids = [r['_uid'] for r in self.rules]
        for sr in stored_rules:
            if sr['_uid'] in uids:
                continue
            rule = PCRule(**sr)
            self.rules.append(rule)
        self.log.debug("WTF:rules: {}".format(self.rules))
    def update_rule(self,rule):
        uid = rule._uid
        idxs = [i for i,c in enumerate(self.rules) if c._uid == uid]
        if len(idxs) == 0:
            self.rules.append(rule)
        else:
            self.rules[idxs[0]] = rule
        return rule

    def save_rule(self,d=None,**kwargs):
        #print "save_rule({})".format(kwargs)
        ## Remove angularjs artifacts:
        kwargs.pop('$$hashKey',None)
        saved_rule = self.store['rules'].editRecord(kwargs)
        self.log.debug("WTF: saved_rule: {}".format(saved_rule))
        rule = PCRule(**saved_rule)
        ## Not sure if I should update the rule, or just reload from disk.
        self.update_rule(rule)
        return rule

    def del_rule(self,uid):
        ''' del_rule(uid) returns:
             None: uid did not appear in list.
             True: success
            False: failure
        '''
        #print "del_rule({})".format(uid)
        #pp([x._serialize() for x in self.rules])
        self.store['rules'].deleteRecord({'_uid':uid})
        if uid not in [x._uid for x in self.rules]:
            return None
        self.rules = [x for x in self.rules if x._uid != uid]
        if uid in [x._uid for x in self.rules]:
            return False
        return True

    def get_rules(self):
        return self.rules

    def get_matching_rules(self,src_ip,dst_str):
        rs = [ r for r in self.rules if r.is_match(src_ip,dst_str) ]
        return rs

    ## Hosts
    def load_hosts(self):
        stored_hosts = self.store['hosts'].loadRecords()
        uids = [r['_uid'] for r in self.hosts]
        for sr in stored_hosts:
            if sr['_uid'] in uids:
                continue
            rule = PCHost(**sr)
            self.hosts.append(rule)
    def update_host(self,host):
        uid = host._uid
        idxs = [i for i,c in enumerate(self.hosts) if c._uid == uid]
        if len(idxs) == 0:
            self.hosts.append(host)
        else:
            self.hosts[idxs[0]] = host
        return host

    def save_host(self,d=None,**kwargs):
        #print "save_host({})".format(kwargs)
        ## Key generated by filestore.
        ## Can't risk overlap.
        #key = self._genkey(self.hosts)
        #print "WTF: Created key:",key
        kwargs.pop('$$hashKey',None)
        saved_host = self.store['hosts'].editRecord(kwargs)
        self.log.debug("WTF: saved_host: {}".format(saved_host))
        host = PCHost(**saved_host)
        self.update_host(host)
        #pp(self.hosts)
        return host

    def del_host(self,uid):
        ''' del_host(uid) returns:
             None: uid did not appear in list.
             True: success
            False: failure
        '''
        #print "del_host({})".format(uid)
        #pp([x._serialize() for x in self.hosts])
        self.store['hosts'].deleteRecord({'_uid':uid})
        if uid not in [x._uid for x in self.hosts]:
            return None
        self.hosts = [x for x in self.hosts if x._uid != uid]
        if uid in [x._uid for x in self.hosts]:
            return False
        return True

    def get_hosts(self):
        return self.hosts

    def _genkey(self,st):
        #print "WTF: _genkey()"
        key = int(time.strftime('%Y%U%w000'))
        #print "WTF: My key:",key
        keys = [r._uid for r in st]
        #print "WTF: keys:",keys
        #while len([1 for r in st if int(r['_uid']) == key]) > 0:
        while key in keys:
            key = key + 1
        return key

    ## DNS Server Methods
    def start(self):
        handler = DNSHandler
        # log options: "recv,send,request,reply,truncated,error,data"
        # log defaults: "request,reply,truncated,error"
        # It's just too much stuff!
        logger = DNSLogger("truncated,error",True)
        self.log.info("Starting UDP server")
        if 'udp_server' not in dir(self):
            self.udp_server = DNSServer(self,
                            port=self.LOCAL_PORT,
                            address=self.LOCAL_IP,
                            logger=logger,
                            handler=handler)
        self.udp_server.start_thread()
        if self.TCP:
            self.log.info("Starting TCP server")
            if 'tcp_server' not in dir(self):
                self.tcp_server = DNSServer(self,
                                port=self.LOCAL_PORT,
                                address=self.LOCAL_IP,
                                tcp=True,
                                logger=logger,
                                handler=handler)
            self.tcp_server.start_thread()

    def stop(self):
        self.log.debug( dir(self) )
        if 'udp_server' in dir(self):
            self.log.debug( "    Stopping UDP server." )
            self.udp_server.stop()
        if 'tcp_server' in dir(self) and self.TCP:
            self.log.debug( "    Stopping TCP server." )
            self.tcp_server.stop()

    def resolve(self,request,handler):
        client_ip = handler.client_address[0]
        #print "Request from IP: {}".format(client_ip)
        qname = request.q.qname
        qtype = QTYPE[request.q.qtype]
        reply = request.reply()
        self.log.debug("{} request for {} by {}".format(qtype,qname,client_ip))
        #print "query: {}".format(qname)
        #print "query: {}".format(qname.matchGlob("*.yahoo.com"))
        # Try to resolve locally unless on skip list
        rules = self.get_matching_rules(client_ip,qname)
        self.log.debug("Matched rules: {}".format(rules))
        if any(rules):
            ## Collecting info on match for logging
            match_time = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
            match_name = client_ip
            match_hosts = [h.name for h in self.hosts if h.ip == client_ip]
            if any(match_hosts):
                match_name = ",".join(match_hosts)
            for rule in rules:
                if rule.action == 'monitor':
                    monitor.info({'time':match_time,'match_name':match_name,'client_ip':client_ip,'qname':str(qname)})
                if rule.action == 'redirect':
                    self.log.debug( "[{}] REDIRECT {}-->{} to {}".format(match_time,match_name,qname,rule.redirect) )
                    redir = rule.redirect
                    reply.add_answer(*RR.fromZone("{} 3600 IN A {}".format(qname,redir)))
                    return reply
                if rule.action == 'block':
                    self.log.debug( "[{}] BLOCKED {}({})-->{}".format(match_time,match_name,client_ip,qname) )
                    return reply
                if rule.action == 'allow':
                    self.log.debug( "[{}] ALLOWED {}({})-->{}".format(match_time,match_name,client_ip,qname) )
        ## If no match or action == 'allow', then proxy the request to IP_UP
        if handler.protocol == 'udp':
            proxy_r = request.send(self.UP_IP,self.UP_PORT)
        else:
            proxy_r = request.send(self.UP_IP,self.UP_PORT,tcp=True)
        reply = DNSRecord.parse(proxy_r)
        return reply
示例#49
0
 def __init__(self, server, port=53, queue=None, ifname='eth0'):
     resolver = PACDNSResolver(server, port, timeout=5, queue=queue, ifname=ifname)
     handler = DNSHandler
     logger = DNSLogger("request", False)
     self.udp_server = DNSServer(resolver, logger=logger, handler=handler)
示例#50
0
    logger = DNSLogger(args.log,args.log_prefix)

    print("Starting Zone Resolver (%s:%d) [%s]" % (
                        args.address or "*",
                        args.port,
                        "UDP/TCP" if args.tcp else "UDP"))

    for rr in resolver.zone:
        print("    | ",rr[2].toZone(),sep="")
    print()

    if args.udplen:
        DNSHandler.udplen = args.udplen

    udp_server = DNSServer(resolver,
                           port=args.port,
                           address=args.address,
                           logger=logger)
    udp_server.start_thread()

    if args.tcp:
        tcp_server = DNSServer(resolver,
                               port=args.port,
                               address=args.address,
                               tcp=True,
                               logger=logger)
        tcp_server.start_thread()

    while udp_server.isAlive():
        time.sleep(1)

示例#51
0
        qname = request.q.qname
        if not qname.label[-1] == "salt":
            # We don't know anything!
            return reply
        grain_path = qname.label[0:-1]
        grain_query = ":".join(reversed(grain_path))
        minions = self.caller.sminion.functions["mine.get"](
            grain_query,
            "network.ipaddrs",
            expr_form="grain"
        )
        random.shuffle(minions)  # load balancing!
        # only return the first three minions
        for hostname, addrs in minions.items()[0:2]:
            for addr in addrs:
                answer = RR(hostname, QTYPE.A, rdata=A(addr), ttl=5)
                reply.add_answer(answer)
        return reply


if __name__ == "__main__":
    resolver = SaltResolver()
    server = DNSServer(
        resolver,
        port=5435,
        address="127.0.0.1"
    )
    server.start_thread()
    while server.isAlive():
        time.sleep(1)