def makeMobileService(config=None):
# Set dns service
dnsService = service.MultiService()
hostsResolver = hosts.Resolver('/etc/hosts')
tcpFactory = server.DNSServerFactory([hostsResolver])
internet.TCPServer(3330, tcpFactory,
interface='192.168.0.91').setServiceParent(dnsService)
# Set log file
logfile = DailyLogFile("mobile.log", "/tmp")
#application.setComponent(ILogObserver, FileLogObserver(logfile).emit)
# Set redis service
# Proxy Server
agent = MobileAgent(3333, 2)
agent.setServiceParent(dnsService)
mobileFactory = IProxyServerFactory(agent)
mobileService = internet.TCPServer(3331,
mobileFactory,
interface='192.168.0.91')
mobileService.setServiceParent(dnsService)
return dnsService
def createResolver(servers=None, resolvconf=None, hosts=None):
if hosts is None:
hosts = b'/etc/hosts' if platform.getType() == 'posix' else r'c:\windows\hosts'
theResolver = Resolver(resolvconf, servers)
hostResolver = hostsModule.Resolver(hosts)
chain = [hostResolver, cache.CacheResolver(), theResolver]
return resolve.ResolverChain(chain)
def setUp(self):
f = open('EtcHosts', 'w')
f.write('''
1.1.1.1 EXAMPLE EXAMPLE.EXAMPLETHING
1.1.1.2 HOOJY
::1 ip6thingy
''')
f.close()
self.resolver = hosts.Resolver('EtcHosts')
def createResolver(servers=None, resolvconf=None, hosts=None):
from twisted.names import resolve, cache, root, hosts as hostsModule
if platform.getType() == 'posix':
if resolvconf is None:
resolvconf = '/etc/resolv.conf'
if hosts is None:
hosts = '/etc/hosts'
theResolver = HardcoreResolver(resolvconf, servers)
hostResolver = hostsModule.Resolver(hosts)
else:
if hosts is None:
hosts = r'c:\windows\hosts'
from twisted.internet import reactor
bootstrap = _ThreadedResolverImpl(reactor)
hostResolver = hostsModule.Resolver(hosts)
theResolver = root.bootstrap(bootstrap)
L = [hostResolver, cache.CacheResolver(), theResolver]
return resolve.ResolverChain(L)
def createResolver(servers=None, resolvconf=None, hosts=None):
r"""
Create and return a Resolver.
@type servers: C{list} of C{(str, int)} or L{None}
@param servers: If not L{None}, interpreted as a list of domain name servers
to attempt to use. Each server is a tuple of address in C{str} dotted-quad
form and C{int} port number.
@type resolvconf: C{str} or L{None}
@param resolvconf: If not L{None}, on posix systems will be interpreted as
an alternate resolv.conf to use. Will do nothing on windows systems. If
L{None}, /etc/resolv.conf will be used.
@type hosts: C{str} or L{None}
@param hosts: If not L{None}, an alternate hosts file to use. If L{None}
on posix systems, /etc/hosts will be used. On windows, C:\windows\hosts
will be used.
@rtype: C{IResolver}
"""
if platform.getType() == "posix":
if resolvconf is None:
resolvconf = b"/etc/resolv.conf"
if hosts is None:
hosts = b"/etc/hosts"
theResolver = Resolver(resolvconf, servers)
hostResolver = hostsModule.Resolver(hosts)
else:
if hosts is None:
hosts = r"c:\windows\hosts"
from twisted.internet import reactor
bootstrap = _ThreadedResolverImpl(reactor)
hostResolver = hostsModule.Resolver(hosts)
theResolver = root.bootstrap(bootstrap, resolverFactory=Resolver)
L = [hostResolver, cache.CacheResolver(), theResolver]
return resolve.ResolverChain(L)
def createResolver(servers=None, resolvconf=None, hosts=None):
"""
Create and return a Resolver.
@type servers: C{list} of C{(str, int)} or C{None}
@param servers: If not C{None}, interpreted as a list of addresses of
domain name servers to attempt to use. Addresses should be in dotted-quad
form.
@type resolvconf: C{str} or C{None}
@param resolvconf: If not C{None}, on posix systems will be interpreted as
an alternate resolv.conf to use. Will do nothing on windows systems. If
C{None}, /etc/resolv.conf will be used.
@type hosts: C{str} or C{None}
@param hosts: If not C{None}, an alternate hosts file to use. If C{None}
on posix systems, /etc/hosts will be used. On windows, C:\windows\hosts
will be used.
@rtype: C{IResolver}
"""
from twisted.names import resolve, cache, root, hosts as hostsModule
if platform.getType() == 'posix':
if resolvconf is None:
resolvconf = '/etc/resolv.conf'
if hosts is None:
hosts = '/etc/hosts'
theResolver = Resolver(resolvconf, servers)
hostResolver = hostsModule.Resolver(hosts)
else:
if hosts is None:
hosts = r'c:\windows\hosts'
from twisted.internet import reactor
bootstrap = _ThreadedResolverImpl(reactor)
hostResolver = hostsModule.Resolver(hosts)
theResolver = root.bootstrap(bootstrap)
L = [hostResolver, cache.CacheResolver(), theResolver]
return resolve.ResolverChain(L)
def main(reactor, duration):
concurrency = 10
controller = DNSServerFactory([hosts.Resolver()])
port = reactor.listenUDP(0, DNSDatagramProtocol(controller))
# Have queries time out no sooner than the duration of this benchmark so
# we don't have to deal with retries or timeout errors.
client = Client(reactor, port.getHost().port, duration)
d = client.run(concurrency, duration)
def cleanup(passthrough):
d = port.stopListening()
d.addCallback(lambda ign: passthrough)
return d
d.addBoth(cleanup)
return d
def makeClientService(config=None):
# set dns service
dnsService = service.MultiService()
hostsResolver = hosts.Resolver('/etc/hosts')
tcpFactory = server.DNSServerFactory([hostsResolver])
internet.TCPServer(3332, tcpFactory,
interface='192.168.0.91').setServiceParent(dnsService)
#Client Server Service
clientService = Client(3335, 3336, 3)
clientServerFactory = IClientServerFactory(clientService)
clientService.setServiceParent(dnsService)
clientServerService = internet.TCPServer(3333,
clientServerFactory,
interface='192.168.0.91')
clientServerService.setServiceParent(dnsService)
return dnsService
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 client, cache, 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 main():
parser = argparse.ArgumentParser(
description="A lightweight yet useful proxy DNS server")
parser.add_argument(
'-b',
'--bind-addr',
type=str,
help='local address to listen',
default=DEFAULT_LOCAL_ADDRESS,
)
parser.add_argument(
'-p',
'--bind-port',
type=int,
help="local port to listen",
default=DEFAULT_LOCAL_PORT,
)
parser.add_argument('--upstream-ip',
type=str,
help="upstream DNS server ip address",
default=DEFAULT_UPSTREAM_SERVER)
parser.add_argument('--upstream-port',
type=int,
help="upstream DNS server port",
default=53)
parser.add_argument('--query-timeout',
type=int,
help="time before close port used for querying",
default=10)
parser.add_argument('--min-ttl',
type=int,
help="the minimum time a record is held in cache",
default=0)
parser.add_argument('--max-ttl',
type=int,
help="the maximum time a record is held in cache",
default=604800)
parser.add_argument('--cache-size',
type=int,
help="record cache size",
default=1000)
parser.add_argument('-t',
'--tcp-server',
help="enables TCP serving",
action="store_true")
parser.add_argument('--hosts-file', help="hosts file", default="")
parser.add_argument('--dispatch-conf',
help="URL dispatch conf file",
default=DEFAULT_CONF_PATH)
parser.add_argument('-v',
'--verbosity',
type=int,
choices=[0, 1, 2],
help="output verbosity",
default=0)
parser.add_argument('-q',
'--quiet',
help="disable output",
action='store_true')
parser.add_argument('-V',
'--version',
action='version',
version="SimpleDNS " + str(__version__))
args = parser.parse_args()
if not args.quiet:
log.startLogging(sys.stdout)
addr = args.bind_addr
port = args.bind_port
log.msg("Listening on " + addr + ':' + str(port))
log.msg("Using " + args.upstream_ip + ':' + str(args.upstream_port) +
' as upstream server')
hosts_file = None
if not args.hosts_file:
hosts_file = DEFAULT_HOSTS_PATH
if os.environ.__contains__('WINDIR'):
hosts_file = DEFAULT_WIN_HOSTS_PATH
else:
hosts_file = args.hosts_file
local_cache = None
if os.path.isfile(DEFAULT_CACHE_PATH):
local_cache = open(DEFAULT_CACHE_PATH, 'rb')
factory = ExtendDNSServerFactory(
caches=[
ExtendCacheResolver(verbose=args.verbosity,
_cache=local_cache,
cacheSize=args.cache_size,
minTTL=args.min_ttl,
maxTTL=args.max_ttl)
],
clients=[
hosts.Resolver(hosts_file),
DispatchResolver(args.dispatch_conf,
servers=[(args.upstream_ip, args.upstream_port)],
minTTL=args.min_ttl,
query_timeout=args.query_timeout,
verbose=args.verbosity)
],
verbose=args.verbosity)
if local_cache:
local_cache.close()
protocol = dns.DNSDatagramProtocol(controller=factory)
if args.verbosity < 2:
dns.DNSDatagramProtocol.noisy = False
server.DNSServerFactory.noisy = False
try:
reactor.listenUDP(port, protocol, addr)
if args.tcp_server:
reactor.listenTCP(port, factory, interface=addr)
if TORNADO_AVAILABLE:
if args.verbosity > 1:
log.msg("Using Tornado ioloop")
signal.signal(
signal.SIGINT, lambda sig, frame: tornado.ioloop.IOLoop.
instance().add_callback_from_signal(try_exit_tornado_ioloop))
tornado.ioloop.IOLoop.instance().start()
else:
if args.verbosity > 1:
log.msg("Using Twisted reactor")
reactor.run()
except error.CannotListenError:
log.msg("Can not listen on " + addr + ':' + str(port))
log.msg('Check if BIND_PORT is already in use')
log.msg('Try to run this with sudo')
def main():
"""
Run the server.
"""
parser = argparse.ArgumentParser(
description='Resolve DNS queries from Database')
parser.add_argument('-c', '--config',
dest='config_file',
type=str, action='store',
default='./config.yml',
help='Path to the configuration file'
)
parser.add_argument('--port', '-p',
dest='port',
type=int, action='store',
default=10053,
help='Port number for the service'
)
parser.add_argument('--dry-run', '-d',
dest='dry_run',
action='store_true',
help='Dry run, just check the config file'
)
#parser.add_argument('--verbose', '-v',
# dest='verbose',
# action='store_true',
# help='Be verbose'
#)
params = parser.parse_args()
# Log to stdout, as this is intended to run in docker
log.startLogging(sys.stdout)
# Make new logging style compatible to traditional one
def observer(event, log=log):
log.msg(event['log_format'].format(**event))
if 'log_failure' in event:
log.err(event['log_failure'])
logger = Logger(namespace='default', observer=observer)
# Read config file
config = Config(params.config_file, logger)
logger.debug("Running with the following parameters:\n{data}", data=config)
# Dry run
if params.dry_run:
sys.exit(0)
# Build a connection lasting the lifetime of the service
connection = adbapi.ConnectionPool(
config.db_driver,
host=config.db_host,
port=config.db_port,
user=config.db_user,
passwd=config.db_passwd,
db=config.db_name,
cp_reconnect=True
)
# Build a global Resolver lasting the lifetime of the service
resolver = client.createResolver()
customResolver = DynamicResolver(config, connection, resolver, logger)
# Factory and protocol services
factory = server.DNSServerFactory(
caches=[
cache.CacheResolver(),
],
# Use "clients" instead of "authorities", so caching works
clients=[
hosts.Resolver(file=config.dns_hosts, ttl=config.dns_ttl),
customResolver,
]
)
protocol = dns.DNSDatagramProtocol(controller=factory)
# Start polling loop, to avoid timeouts
poller = LoopingCall(customResolver.poll)
poller.start(config.poll_time)
# Listen TCP and UDP
reactor.listenUDP(params.port, protocol)
reactor.listenTCP(params.port, factory)
reactor.run()
def main():
parser = argparse.ArgumentParser(
description="A lightweight yet useful proxy DNS server")
parser.add_argument(
'-b',
'--bind-addr',
type=str,
help='local address to listen',
default='127.0.0.1',
)
parser.add_argument(
'-p',
'--bind-port',
type=int,
help="local port to listen",
default=53,
)
parser.add_argument('--upstream-ip',
type=str,
help="upstream DNS server ip address",
default='208.67.222.222')
parser.add_argument('--upstream-port',
type=int,
help="upstream DNS server port",
default=53)
parser.add_argument('--query-timeout',
type=int,
help="time before close port used for querying",
default=1)
parser.add_argument('--min-ttl',
type=int,
help="the minimum time a record is held in cache",
default=0)
parser.add_argument('--max-ttl',
type=int,
help="the maximum time a record is held in cache",
default=604800)
parser.add_argument('--cache-size',
type=int,
help="record cache size",
default=500)
parser.add_argument('-t',
'--tcp-server',
help="enables TCP serving",
action="store_true")
parser.add_argument('--hosts-file', help="hosts file", default="")
parser.add_argument('--dispatch-conf',
help="URL dispatch conf file",
default="/usr/local/etc/simpledns/dispatch.conf")
parser.add_argument('-v',
'--verbosity',
type=int,
choices=[0, 1, 2],
help="output verbosity",
default=0)
parser.add_argument('-q',
'--quiet',
help="disable output",
action='store_true')
parser.add_argument('-V',
'--version',
help="print version number and exit",
action='store_true')
args = parser.parse_args()
if args.version:
print("SimpleDNS " + __version__)
return
if not args.quiet:
log.startLogging(sys.stdout)
addr = args.bind_addr
port = args.bind_port
log.msg("Listening on " + addr + ':' + str(port))
log.msg("Using " + args.upstream_ip + ':' + str(args.upstream_port) +
' as upstream server')
hosts_file = None
if not args.hosts_file:
hosts_file = '/etc/hosts'
if os.environ.__contains__('WINDIR'):
hosts_file = os.environ['WINDIR'] + '/system32/drivers/etc/hosts'
else:
hosts_file = args.hosts_file
factory = ExtendDNSServerFactory(
caches=[
ExtendCacheResolver(verbose=args.verbosity,
cacheSize=args.cache_size,
minTTL=args.min_ttl,
maxTTL=args.max_ttl)
],
clients=[
hosts.Resolver(hosts_file),
DispatchResolver(args.dispatch_conf,
servers=[(args.upstream_ip, args.upstream_port)],
minTTL=args.min_ttl,
query_timeout=args.query_timeout,
verbose=args.verbosity)
],
verbose=args.verbosity)
protocol = dns.DNSDatagramProtocol(controller=factory)
if args.verbosity < 2:
dns.DNSDatagramProtocol.noisy = False
server.DNSServerFactory.noisy = False
try:
reactor.listenUDP(port, protocol, addr)
if args.tcp_server:
reactor.listenTCP(port, factory, interface=addr)
try:
tornado.ioloop.IOLoop.instance().start()
except NameError:
log.msg("Tornado not found. Using twisted reactor")
reactor.run()
except error.CannotListenError:
log.msg("Couldn't listen on " + addr + ':' + str(port))
log.msg('Check if BIND_PORT is already in use')
log.msg('Try using sudo to run this program')
