def _getResolver(self, serverResponses, maximumQueries=10):
"""
Create and return a new L{root.Resolver} modified to resolve queries
against the record data represented by C{servers}.
@param serverResponses: A mapping from dns server addresses to
mappings. The inner mappings are from query two-tuples (name,
type) to dictionaries suitable for use as **arguments to
L{_respond}. See that method for details.
"""
roots = ["1.1.2.3"]
resolver = Resolver(roots, maximumQueries)
def query(query, serverAddresses, timeout, filter):
msg("Query for QNAME {} at {!r}".format(query.name,
serverAddresses))
for addr in serverAddresses:
try:
server = serverResponses[addr]
except KeyError:
continue
records = server[query.name.name, query.type]
return succeed(self._respond(**records))
resolver._query = query
return resolver
def query(self, query, address, timeout=None):
name = str(query.name)
type = query.type
cls = dns.IN
records = _get_records(self)
now = datetime.datetime.now()
print now.strftime('%A %H:%M:%S') + ' -- ' + address[0] + ' -- ' + str(dns.QUERY_TYPES[type]) + ' ' + str(name)
if name in records:
def _query(query, servers, timeout, filter):
name = str(query.name)
if type in records[name]:
record = records[name][type]
answers, authority, additional = record['ans'], [], []
if 'aut' in record: authority = record['aut']
if 'add' in record: additional = record['add']
response = dns.Message()
for (section, data) in [(response.answers, answers), (response.authority, authority), (response.additional, additional)]:
section.extend([dns.RRHeader(name, record.TYPE, getattr(record, 'CLASS', dns.IN), payload=record, auth=True) for record in data])
#print 'does exist'
return defer.succeed(response)
else:
#print 'doesn't exist'
return defer.fail(error.DNSQueryRefusedError(name))
resolver = Resolver([])
resolver._query = _query
d = resolver._lookup(name, cls, type, timeout)
def display(ans, auth, add):
# print ans, auth, add
return (ans, auth, add)
d.addCallback(lambda (ans, auth, add): display(ans, auth, add))
return d
else:
#print 'not in record'
return self.upstream.queryUDP([dns.Query(name, type, cls)]).addCallback(_results_passthrough)
def _queryTest(self, filter):
"""
Invoke L{Resolver._query} and verify that it sends the correct DNS
query. Deliver a canned response to the query and return whatever the
L{Deferred} returned by L{Resolver._query} fires with.
@param filter: The value to pass for the C{filter} parameter to
L{Resolver._query}.
"""
reactor = MemoryReactor()
resolver = Resolver([], reactor=reactor)
d = resolver._query(
Query(b'foo.example.com', A, IN), [('1.1.2.3', 1053)], (30,),
filter)
# A UDP port should have been started.
portNumber, transport = reactor.udpPorts.popitem()
# And a DNS packet sent.
[(packet, address)] = transport._sentPackets
message = Message()
message.fromStr(packet)
# It should be a query with the parameters used above.
self.assertEqual(message.queries, [Query(b'foo.example.com', A, IN)])
self.assertEqual(message.answers, [])
self.assertEqual(message.authority, [])
self.assertEqual(message.additional, [])
response = []
d.addCallback(response.append)
self.assertEqual(response, [])
# Once a reply is received, the Deferred should fire.
del message.queries[:]
message.answer = 1
message.answers.append(RRHeader(
b'foo.example.com', payload=Record_A('5.8.13.21')))
transport._protocol.datagramReceived(
message.toStr(), ('1.1.2.3', 1053))
return response[0]
def _queryTest(self, filter):
"""
Invoke L{Resolver._query} and verify that it sends the correct DNS
query. Deliver a canned response to the query and return whatever the
L{Deferred} returned by L{Resolver._query} fires with.
@param filter: The value to pass for the C{filter} parameter to
L{Resolver._query}.
"""
reactor = MemoryReactor()
resolver = Resolver([], reactor=reactor)
d = resolver._query(
Query(b'foo.example.com', A, IN), [('1.1.2.3', 1053)], (30,),
filter)
# A UDP port should have been started.
portNumber, transport = reactor.udpPorts.popitem()
# And a DNS packet sent.
[(packet, address)] = transport._sentPackets
message = Message()
message.fromStr(packet)
# It should be a query with the parameters used above.
self.assertEqual(message.queries, [Query(b'foo.example.com', A, IN)])
self.assertEqual(message.answers, [])
self.assertEqual(message.authority, [])
self.assertEqual(message.additional, [])
response = []
d.addCallback(response.append)
self.assertEqual(response, [])
# Once a reply is received, the Deferred should fire.
del message.queries[:]
message.answer = 1
message.answers.append(RRHeader(
b'foo.example.com', payload=Record_A('5.8.13.21')))
transport._protocol.datagramReceived(
message.toStr(), ('1.1.2.3', 1053))
return response[0]
def _getResolver(self, serverResponses, maximumQueries=10):
"""
Create and return a new L{root.Resolver} modified to resolve queries
against the record data represented by C{servers}.
@param serverResponses: A mapping from dns server addresses to
mappings. The inner mappings are from query two-tuples (name,
type) to dictionaries suitable for use as **arguments to
L{_respond}. See that method for details.
"""
roots = ['1.1.2.3']
resolver = Resolver(roots, maximumQueries)
def query(query, serverAddresses, timeout, filter):
msg("Query for QNAME %s at %r" % (query.name, serverAddresses))
for addr in serverAddresses:
try:
server = serverResponses[addr]
except KeyError:
continue
records = server[str(query.name), query.type]
return succeed(self._respond(**records))
resolver._query = query
return resolver
