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')