def start(self):
app_for_context = create_app()
dns_logging = DatabaseDNSLogging(app_for_context)
clients = [
DatabaseDNSResolver(app_for_context,
Provider().dns_manager(), dns_logging)
]
if self.__forwarding_enabled and len(self.__forwarders) > 0:
clients.append(client.Resolver(servers=self.__forwarders))
factory = DatabaseDNSFactory(clients=clients, verbose=2)
factory.app = app_for_context
factory.logging = dns_logging
factory.restrictions = Provider().dns_restrictions()
factory.csv_location = self.__csv_location
observer = log.PythonLoggingObserver()
observer.start()
logging.basicConfig()
logger = logging.getLogger()
logger.setLevel(logging.DEBUG)
reactor.listenUDP(self.__port,
DNSDatagramProtocol(factory),
interface=self.__host)
reactor.listenTCP(self.__port, factory, interface=self.__host)
reactor.run()
def datagramReceived(self, data, addr):
if data[:8] == 'R6fnvWJ8':
# here comes a special curve
nonce = data[8:20]
box = self._outstandingDNSCurveQueries.get(nonce)
if box is None:
return
try:
reply = box.decrypt(data[32:], data[8:32])
except CryptoError:
return
else:
del self._outstandingDNSCurveQueries[nonce]
else:
reply = data
DNSDatagramProtocol.datagramReceived(self, reply, addr)
def datagramReceived(self, data, addr):
if data[:8] == 'R6fnvWJ8':
# here comes a special curve
nonce = data[8:20]
box = self._outstandingDNSCurveQueries.get(nonce)
if box is None:
return
try:
reply = box.decrypt(data[32:], data[8:32])
except CryptoError:
return
else:
del self._outstandingDNSCurveQueries[nonce]
else:
reply = data
DNSDatagramProtocol.datagramReceived(self, reply, addr)
def doWork():
for ip in file("list12.txt"):
i = a.next()
ip = ip.strip()
d = Deferred()
name = Name('version.bind')
axf = AXFRController(name,d)
dns = DNSDatagramProtocol(axf)
query = Query()
query.name = Name('version.bind')
query.type = TXT
query.cls = CH
query = [query]
d1 = dns.query((ip,53), query)
d1.addCallback(getResult,ip)
d1.addErrback(getError,ip)
yield d1
def __init__(self, conf):
service.MultiService.__init__(self)
self.conf = conf
forwarders = self.conf['forwarders'].split()
savedir = self.conf['savedir']
self.port = self.conf['udp_port']
self.authorities = []
self.factory = CallsignServerFactory(forwarders, savedir, self.get_ent())
self.protocol = DNSDatagramProtocol(self.factory)
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 __init__(self, controller, serverHosts, reactor=None):
DNSDatagramProtocol.__init__(self, controller, reactor)
self.serverHosts = serverHosts
self._key = PrivateKey.generate()
self._outstandingDNSCurveQueries = {}
def __init__(self, controller, serverHosts, reactor=None):
DNSDatagramProtocol.__init__(self, controller, reactor)
self.serverHosts = serverHosts
self._key = PrivateKey.generate()
self._outstandingDNSCurveQueries = {}
