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')
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)
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()
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)
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()
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()
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
resolver = FixedResolver(args.response)
logger = DNSLogger(args.log, args.log_prefix)
print("Starting Fixed Resolver (%s:%d) [%s]" %
(args.address or "*", args.port, "UDP/TCP" if args.tcp else "UDP"))
for rr in resolver.rrs:
print(" | ", rr.toZone().strip(), 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)
class DnsServer(BaseCommand):
name = "dns-server"
aliases = ["dns"]
description = "run dns server"
add_log_level = True
add_debug = True
def __init__(self, *args, **kwargs):
self.api_client = None
self.resolver = None
self.udp_server = None
self.tcp_server = None
super().__init__(*args, **kwargs)
@classmethod
def parser(cls, parser):
parser.add_argument(
"-a",
"--api-url",
default="http://127.0.0.1:8080",
action="store",
help="api url",
)
parser.add_argument("-t",
"--api-token",
action="store",
help="api token")
parser.add_argument("-p",
"--port",
action="store",
type=int,
default=53,
help="listen port")
parser.add_argument("-l",
"--listen",
action="store",
default="127.0.0.1",
help="bind address")
parser.add_argument("--no-sync",
action="store_true",
help="sync api token back to database")
parser.add_argument(
"-r",
"--refresh-ttl",
type=int,
default=3600,
action="store",
help="time to wait before polling for new records",
)
return parser
async def run(self):
# TODO: thread issues?
self.api_client = ApiClient(self.get_api_url(), self.get_api_token())
if not self.api_client.wait_for_up():
logger.critical("could not connect to api. quitting")
self.exit(1)
if self.option("no_sync"):
logger.info("skipping syncing api token")
else:
self.api_client.sync()
self.boot()
self.start_servers()
try:
count = 0
while self.udp_server.isAlive():
if count > 0 and count % self.option("refresh_ttl") == 0:
if self.api_client.refresh_zones_if_needed():
logger.critical(
"API Client found new or changed zones. Stopping servers..."
)
# TODO: figure out why "stop" does not release the address
self.stop_servers()
sleep(1)
stop_count = 0
logger.critical("Waiting for UDP Server to stop...")
while self.udp_server.thread and self.udp_server.isAlive(
):
if stop_count > 30:
logger.critical(
"UDP Server did not stop while reloading zones"
)
raise Exception(
"UDP Server threads went rogue during zone reload"
)
logger.info(
"Waiting for DNS Server to stop before reloading zones"
)
stop_count = stop_count + 1
sleep(1)
stop_count = 0
logger.critical("Waiting for TCP Server to stop...")
while self.tcp_server.thread and self.tcp_server.isAlive(
):
if stop_count > 30:
logger.critical(
"TCP Server did not stop while reloading zones"
)
raise Exception(
"TCP Server threads went rogue during zone reload"
)
logger.info(
"Waiting for DNS Server to stop before reloading zones"
)
stop_count = stop_count + 1
sleep(1)
logger.critical("Rebooting server with fresh zones...")
self.boot()
self.start_servers()
count = count + 1
sleep(1)
except KeyboardInterrupt:
pass
def get_api_url(self):
if os.environ.get("API_URL", None):
return os.environ.get("API_URL")
return self.option("api_url")
def get_api_token(self):
if os.environ.get("API_TOKEN", None):
return os.environ.get("API_TOKEN")
if self.option("api_token", None):
return self.option("api_token")
logger.critical("api token required")
self.exit(1)
def get_port(self):
return self.option("port")
def get_listen(self):
return self.option("listen")
def boot(self):
port = self.get_port()
listen = self.get_listen()
self.resolver = Resolver(self.api_client)
self.udp_server = DNSServer(
self.resolver,
address=listen,
port=port,
handler=DNSHandler,
logger=DNSLogger(self.api_client),
)
self.tcp_server = DNSServer(
self.resolver,
address=listen,
port=port,
tcp=True,
handler=DNSHandler,
logger=DNSLogger(self.api_client),
)
logger.info("starting DNS server on port %d", port)
def start_servers(self):
self.udp_server.start_thread()
self.tcp_server.start_thread()
def stop_servers(self):
self.udp_server.stop()
self.udp_server.server.socket.close()
self.udp_server.server.server_close()
self.tcp_server.stop()
self.tcp_server.server.socket.close()
self.tcp_server.server.server_close()
def main():
signal.signal(signal.SIGTERM, handle_sig)
parser = argparse.ArgumentParser(description='LocalTLS')
parser.add_argument('--domain',
required=True,
help="Your domain or subdomain.")
parser.add_argument(
'--soa-master',
help="Primary master name server for SOA record. You should fill this."
)
parser.add_argument(
'--soa-email',
help=
"Email address for administrator for SOA record. You should fill this."
)
parser.add_argument('--ns-servers',
help="List of ns servers, separated by comma")
parser.add_argument('--dns-port', default=53, help="DNS server port")
parser.add_argument(
'--domain-ipv4',
default='',
help="The IPV4 for the naked domain. If empty, use this machine's.")
parser.add_argument(
'--domain-ipv6',
default='',
help="The IPV6 for the naked domain. If empty, use this machine's.")
parser.add_argument('--only-private-ips',
action='store_true',
default=False,
help="Resolve only IPs in private ranges.")
parser.add_argument('--dns-fallback',
default='1.1.1.1',
help="DNS fallback server. Default: 1.1.1.1")
parser.add_argument(
'--http-port',
help="HTTP server port. If not set, no HTTP server is started")
parser.add_argument('--http-index-file',
default='index.html',
help="HTTP index.html file.")
parser.add_argument('--log-level',
default='ERROR',
help="INFO|WARNING|ERROR|DEBUG")
args = parser.parse_args()
# The primary addresses
confs.LOCAL_IPV4 = args.domain_ipv4 if args.domain_ipv4 else get_ipv4()
confs.LOCAL_IPV6 = args.domain_ipv6 if args.domain_ipv6 else get_ipv6()
try:
ipaddress.ip_address(confs.LOCAL_IPV4)
except:
logger.critical('Invalid IPV4 %s', LOCAL_IPV4)
sys.exit(1)
try:
if confs.LOCAL_IPV6:
ipaddress.ip_address(confs.LOCAL_IPV6)
except:
logger.critical('Invalid IPV6 %s', LOCAL_IPV6)
sys.exit(1)
logger.setLevel(args.log_level)
confs.ONLY_PRIVATE_IPS = args.only_private_ips
confs.BASE_DOMAIN = args.domain
confs.SOA_MNAME = args.soa_master
confs.SOA_RNAME = args.soa_email
if not confs.SOA_MNAME or not confs.SOA_RNAME:
logger.error('Setting SOA is strongly recommended')
if args.ns_servers:
confs.NS_SERVERS = args.ns_servers.split(',')
# handle local messages to add TXT records
threadMessage = threading.Thread(target=messageListener)
threadMessage.start()
# open the DNS server
port = int(args.dns_port)
upstream = args.dns_fallback
resolver = Resolver(upstream)
if args.log_level == 'debug':
logmode = "+request,+reply,+truncated,+error"
else:
logmode = "-request,-reply,-truncated,+error"
dnslogger = DNSLogger(log=logmode, prefix=False)
udp_server = DNSServer(resolver, port=port, logger=dnslogger)
tcp_server = DNSServer(resolver, port=port, tcp=True, logger=dnslogger)
logger.critical(
'starting DNS server on %s/%s on port %d, upstream DNS server "%s"',
confs.LOCAL_IPV4, confs.LOCAL_IPV6, port, upstream)
udp_server.start_thread()
tcp_server.start_thread()
# open the HTTP server
if args.http_port:
logger.critical('Starting httpd...')
threadHTTP = threading.Thread(target=httpserver.run,
kwargs={
"port": int(args.http_port),
"index": args.http_index_file
})
threadHTTP.start()
try:
while udp_server.isAlive():
sleep(1)
except KeyboardInterrupt:
pass
import dnslib
import time
class HardcodedResolver:
ANSWER = "192.168.0.1"
def resolve(self, request, handler):
reply = request.reply()
if request.questions[0].qname == QUESTION_ADDRESS:
fake_rr = RR(rname=QUESTION_ADDRESS,
ttl=5,
rdata=A(HardcodedResolver.ANSWER))
reply.add_answer(fake_rr)
else:
reply.header.rcode = dnslib.RCODE.REFUSED
return reply
resolver = HardcodedResolver()
logger = DNSLogger(prefix=False)
server = DNSServer(resolver,
port=PORT,
address=ADDRESS,
logger=logger,
tcp=False)
server.start_thread()
time.sleep(100.0)
class SCIONDnsServer(SCIONElement):
"""
SCION DNS Server. Responsible for starting the DNS resolver threads, and
frequently updating the shared instance data from ZK.
:cvar float SYNC_TIME: How frequently (in seconds) to update the shared
instance data from ZK.
:cvar list SRV_TYPES: Service types to monitor/export
"""
SERVICE_TYPE = DNS_SERVICE
SYNC_TIME = 1.0
SRV_TYPES = (BEACON_SERVICE, CERTIFICATE_SERVICE,
DNS_SERVICE, PATH_SERVICE, SIBRA_SERVICE)
def __init__(self, server_id, conf_dir, setup=False, prom_export=None): # pragma: no cover
"""
:param str server_id: server identifier.
:param str conf_dir: configuration directory.
:param str prom_export: prometheus export address.
:param bool setup: should setup() be called?
"""
super().__init__(server_id, conf_dir, prom_export=prom_export)
self.domain = DNSLabel(self.topology.dns_domain)
self.lock = threading.Lock()
self.services = {}
if setup:
self.setup()
def setup(self):
"""
Set up various servers and connections required.
"""
self.resolver = ZoneResolver(self.lock, self.domain)
self.udp_server = DNSServer(self.resolver, port=SCION_DNS_PORT,
address=str(self.addr.host),
server=SCIONDnsUdpServer,
logger=SCIONDnsLogger())
self.tcp_server = DNSServer(self.resolver, port=SCION_DNS_PORT,
address=str(self.addr.host),
server=SCIONDnsTcpServer,
logger=SCIONDnsLogger())
self.name_addrs = "\0".join([self.id, str(SCION_DNS_PORT),
str(self.addr.host)])
self.zk = Zookeeper(self.topology.isd_as, DNS_SERVICE, self.name_addrs,
self.topology.zookeepers)
self._parties = {}
self._setup_parties()
def _setup_parties(self):
"""
Join all the necessary ZK parties.
"""
logging.debug("Joining parties")
for type_ in self.SRV_TYPES:
prefix = "/%s/%s" % (self.addr.isd_as, type_)
autojoin = False
# Join only the DNS service party, for the rest we just want to
# setup the party so we can monitor the members.
if type_ == DNS_SERVICE:
autojoin = True
self._parties[type_] = self.zk.retry(
"Joining %s party" % type_, self.zk.party_setup, prefix=prefix,
autojoin=autojoin)
def _sync_zk_state(self):
"""
Update shared instance data from ZK.
"""
# Clear existing state
self.services = {}
try:
self.zk.wait_connected(timeout=10.0)
except ZkNoConnection:
logging.warning("No connection to Zookeeper, can't update services")
return
# Retrieve alive instance details from ZK for each service.
for srv_type in self.SRV_TYPES:
srv_domain = self.domain.add(srv_type)
self.services[srv_domain] = []
party = self._parties[srv_type]
try:
srvs = party.list()
except ZkNoConnection:
# If the connection drops, don't update
return
for i in srvs:
self._parse_srv_inst(i, srv_domain)
# Update DNS zone data
with self.lock:
self.resolver.services = self.services
def _parse_srv_inst(self, inst, srv_domain):
"""
Parse a server instance block into name/port/addresses,
and add them to the services list.
:param str inst: Server instance block (null-seperated strings)
:param dnslib.DNSLabel srv_domain: service domain
"""
name, port, *addresses = inst.split("\0")
self.services[srv_domain].extend(addresses)
def handle_request(self, packet, sender, from_local_socket=True):
raise NotImplementedError
def run(self):
"""
Run SCION Dns server.
"""
self._sync_zk_state()
self.udp_server.start_thread()
self.tcp_server.start_thread()
while self.udp_server.isAlive() and self.tcp_server.isAlive():
self._sync_zk_state()
sleep(self.SYNC_TIME)
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)
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 set_expected_query(self, record_type, record_names):
self.resolver.set_expected_query(record_type, record_names)
def is_query_received(self):
return self.resolver.is_query_received()
def load_zone(self, api_version, api_protocol, api_authorization, 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,
api_auth=str(api_authorization).lower(), 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)
extra_services = {}
if CONFIG.ENABLE_AUTH:
auth_proto = "https" if CONFIG.ENABLE_HTTPS else "http"
extra_services["auth"] = {
"host": CONFIG.AUTH_SERVER_HOSTNAME,
"ip": CONFIG.AUTH_SERVER_IP,
"port": CONFIG.AUTH_SERVER_PORT,
"txt": ["api_ver=v1.0", "api_proto={}".format(auth_proto), "pri=0"]
}
if CONFIG.ENABLE_MQTT_BROKER:
extra_services["mqtt"] = {
"host": CONFIG.MQTT_BROKER_HOSTNAME,
"ip": CONFIG.MQTT_BROKER_IP,
"port": CONFIG.MQTT_BROKER_PORT,
"txt": ["api_proto=mqtt", "api_auth=false"]
}
self.base_zone_data = template.render(ip_address=self.default_ip, domain=CONFIG.DNS_DOMAIN,
extra_services=extra_services)
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
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()
run_forever = True
if run_forever:
loop.run()
else:
main_context = loop.get_context()
changed = True
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)
########################
# DNS
########################
print("DNS ....")
# start dns
class RecordResolver:
answers = ["*. 60 A {}".format(args.record)]
def resolve(self,request,handler):
reply = request.reply()
[reply.add_answer(*RR.fromZone(a)) for a in self.answers]
return reply
resolver = RecordResolver()
dns = DNSServer(resolver,port=10053,address="0.0.0.0" )#, logger=DNSLogger("-request,-reply,-truncated"))
dns.start_thread()
#######################
# HTTP
#######################
print("HTTP ....")
http01 = http.server.HTTPServer(('0.0.0.0', 5002), http.server.SimpleHTTPRequestHandler)
threading.Thread(target=http01.serve_forever).start()
class httpShutHandler(http.server.BaseHTTPRequestHandler):
def do_GET(self):
global ALIVE
ALIVE=False
try:
os.system(r'ps o pid,comm | \
grep python | \
