def __init__(self, authorities=None, caches=None, clients=None, verbose=0):
global reload_redirects
self.RM = RedirectManager()
self.RM.reload_redirects = reload_redirects
self.no_logging = no_logging
DNSServerFactory.__init__(self, authorities=authorities, caches=caches, clients=clients, verbose=verbose)
def gotResolverResponse(self, response, protocol, message,
address):
args = (self, response, protocol, message, address)
_q_s.logs.info([
'servers', {
'server': 'dns_server',
'action': 'connection',
'ip': address[0],
'port': address[1]
}
])
try:
for items in response:
for item in items:
_q_s.logs.info([
'servers', {
'server': 'dns_server',
'action': 'query',
'ip': address[0],
'port': address[1],
'payload': item.payload
}
])
except Exception as e:
_q_s.logs.error([
'errors', {
'server': 'dns_server',
'error': 'gotResolverResponse',
'type': 'error -> ' + repr(e)
}
])
return DNSServerFactory.gotResolverResponse(*args)
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 makeService(config, reactor=reactor):
parent = MultiService()
basedir = FilePath(os.path.expanduser(config["basedir"]))
basedir.makedirs(ignoreExistingDirectory=True)
basedir.chmod(0o700)
data = Data(basedir.child("config.json"))
dns_server = DNSServerFactory(verbose=0)
s1 = UDPServer(int(config["dns-port"]), dns.DNSDatagramProtocol(dns_server),
interface=config["dns-interface"])
s1.setServiceParent(parent)
s2 = TCPServer(int(config["dns-port"]), dns_server,
interface=config["dns-interface"])
s2.setServiceParent(parent)
s = Server(data, dns_server)
s.update_records()
certFile = basedir.child("tub.data").path
#furlFile = basedir.child("server.furl").path
t = Tub(certFile=certFile)
t.setOption("keepaliveTimeout", 60) # ping after 60s of idle
t.setOption("disconnectTimeout", 5*60) # disconnect/reconnect after 5m
#t.setOption("logLocalFailures", True)
#t.setOption("logRemoteFailures", True)
#t.unsafeTracebacks = True
fp = config["foolscap-port"]
if not fp.startswith("tcp:"):
raise usage.UsageError("I don't know how to handle non-tcp foolscap-port=")
port = int(fp.split(":")[1])
assert port > 1
t.listenOn(fp)
t.setLocation("tcp:%s:%d" % (config["hostname"], port))
c = Controller(data, s)
cf = t.registerReference(c, furlFile=basedir.child("controller.furl").path)
furl_prefix = cf[:cf.rfind("/")+1]
c.set_furl_prefix(furl_prefix)
t.registerNameLookupHandler(c.lookup)
t.setServiceParent(parent)
return parent
default="http")
args = parser.parse_args()
if args.type == "http":
root = Root()
factory = Site(root)
httpPort = reactor.listenTCP(0, factory)
contextFactory = ssl_context_factory()
httpsPort = reactor.listenSSL(0, factory, contextFactory)
def print_listening():
httpHost = httpPort.getHost()
httpsHost = httpsPort.getHost()
httpAddress = "http://%s:%d" % (httpHost.host, httpHost.port)
httpsAddress = "https://%s:%d" % (httpsHost.host, httpsHost.port)
print(httpAddress)
print(httpsAddress)
elif args.type == "dns":
clients = [MockDNSResolver()]
factory = DNSServerFactory(clients=clients)
protocol = dns.DNSDatagramProtocol(controller=factory)
listener = reactor.listenUDP(0, protocol)
def print_listening():
host = listener.getHost()
print("%s:%s" % (host.host, host.port))
reactor.callWhenRunning(print_listening)
reactor.run()
def handleQuery(self, message, protocol, address):
print "Got", message.toStr(), protocol, address
return DNSServerFactory.handleQuery(self, message, protocol, address)
def connectionMade(self, protocol):
print "Got a connection", protocol
return DNSServerFactory.connectionMade(self, protocol)
def __init__(self, authorities = None, caches = None,
clients = None, verbose = 0):
r=DNSServerFactory.__init__(self, authorities, caches, clients, verbose)
return r
def handleQuery(self, message, protocol, address):
print "Got", message.toStr(), protocol, address
return DNSServerFactory.handleQuery(self, message, protocol, address)
def connectionMade(self, protocol):
print "Got a connection", protocol
return DNSServerFactory.connectionMade(self, protocol)
def __init__(self, authorities=None, caches=None, clients=None, verbose=0):
r = DNSServerFactory.__init__(self, authorities, caches, clients,
verbose)
return r
def server_init(options, reactor):
import transports
# from twisted.internet import reactor
if (options.interface == 'stdio'):
import interfaces
iface = interfaces.stdiface()
stdio.StandardIO(iface)
elif (options.interface == 'tun'):
import interfaces
iface = interfaces.tuniface(reactor)
# f, s = iface.ifaceSockets()
else:
print "Currently not supported. Exiting"
sys.exit(0)
# import transports
# from twisted.internet import reactor
if options.transport == 'tcp':
transportLayer = transports.tcpTransportFactory(iface, reactor)
iface.getTransport(transportLayer)
reactor.listenTCP(options.port, transportLayer)
elif options.transport == 'http':
from twisted.web.resource import Resource
from twisted.web.server import Site
transportLayer = transports.asymQueue(iface)
root = Resource()
root.putChild("warpzone", transports.httpServe(iface, transportLayer))
site = Site(root)
iface.getTransport(transportLayer)
reactor.listenTCP(options.port, site)
elif options.transport == 'dns':
from twisted.names.server import DNSServerFactory
from twisted.names import dns
transportLayer = transports.dnsServer(iface, options)
factory = DNSServerFactory(clients=[transportLayer])
protocol = dns.DNSDatagramProtocol(controller=factory)
iface.getTransport(transportLayer)
reactor.listenUDP(53, protocol)
reactor.listenTCP(53, factory)
elif options.transport == 'udp':
transportLayer = transports.udpTransportHandler(
iface, reactor, None, None)
iface.getTransport(transportLayer)
reactor.listenUDP(options.port, transportLayer)
elif options.transport == 'icmp':
transportLayer = transports.icmpTransportHandler(
iface, reactor, options)
iface.getTransport(transportLayer)
else:
print "Bad transport layer selected"
sys.exit(0)
def __init__(self, redis_client, **kwargs):
kwargs['caches'] = [cache.CacheResolver()]
kwargs['clients'] = [DynamicResolver(redis_client)]
DNSServerFactory.__init__(self, **kwargs)
def __init__(self):
self.custom = CustomResolver()
DNSServerFactory.__init__(self, authorities=None,
#caches=[cache.CacheResolver()], behaves a bit strange on non-existing domains
clients=[self.custom])
for data, metadata in records.items():
if type == A:
payload = dns.Record_A(data)
elif type == CNAME:
# TODO: Add proper CNAME support that sends corresponding "A" records.
payload = dns.Record_CNAME(data)
elif type == MX:
payload = dns.Record_MX(metadata["preference"], data)
elif type == NS:
payload = dns.Record_NS(data)
header = dns.RRHeader(name,
type=type,
payload=payload,
ttl=metadata["ttl"],
auth=True)
results.append(header)
return defer.succeed((results, authority, additional))
#return defer.fail(failure.Failure(dns.DomainError(name)))
authorities = [CassandraNamesResolver()]
factory = DNSServerFactory(authorities, verbose=True)
protocol = dns.DNSDatagramProtocol(factory)
if __name__ == '__main__':
log.startLogging(sys.stdout)
reactor.listenUDP(1053, protocol)
reactor.listenTCP(1053, factory)
reactor.run()
