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 _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