def recvd_ptr(result): answer, auth, additional = result if len(answer) != 1: raise LookupException("Not exactly one answer in PTR response for %s" % ip) hostname = str(answer[0].payload.name) def recvd_addr(result): answers, auth, additional = result if not answers: raise LookupException("No answers in A/AAAA response for %s" % hostname) addresses = [ inet_ntop(ipver, answer.payload.address) for answer in answers ] if ip not in addresses: raise VerificationException("IP mismatch: %s is not in %s (%s)" % (ip, repr(addresses), hostname)) d.callback(hostname) if ipobj.version == 4: client.lookupAddress(hostname, *args, **kwargs).addCallback(recvd_addr).addErrback(d.errback) else: client.lookupIPV6Address(hostname, *args, **kwargs).addCallback(recvd_addr).addErrback(d.errback)
def connect(self): if self._ipAddr and not isip(self._ipAddr): return client.lookupAddress(self._ipAddr).addCallbacks( self._lookupProxyIp, self._lookupProxyIpErr) if self._hostname and not isip(self._hostname): return client.lookupAddress(self._hostname).addCallbacks( self._getIp, self._lookupErr) return self.request()
def srvResolved(self, record): if not record[0]: d = client.lookupAddress(self.host) d.addCallback(self.resolved) else: payload = record[0][0].payload self.port = payload.port d = client.lookupAddress(payload.target.name) d.addCallback(self.resolved) return True
def connect(self): if self._ipAddr and not isip(self._ipAddr): return client.lookupAddress(self._ipAddr).addCallbacks( self._lookupProxyIp, self._lookupProxyIpErr ) if self._hostname and not isip(self._hostname): return client.lookupAddress(self._hostname).addCallbacks( self._getIp, self._lookupErr ) return self.request()
def dns_consistency(self, hostname): cached_value = yield self.lookup('dns_consistency', hostname) if cached_value is not None: defer.returnValue(cached_value) dns_info = { 'addrs': [], 'failure': None } try: records = yield dns_client.lookupAddress(hostname) answers = records[0] for answer in answers: if answer.type is dns.A: dns_info['addrs'].append(answer.payload.dottedQuad()) elif answer.type is dns.CNAME: dns_info['addrs'].append(answer.payload.name.name) except DNSNameError: dns_info['failure'] = 'dns_name_error' except DNSServerError: dns_info['failure'] = 'dns_server_failure' except: dns_info['failure'] = 'unknown_error' yield self.cache_value('dns_consistency', hostname, dns_info) defer.returnValue(dns_info)
def process(self): conn = self.db() try: nas_list = conn.query(models.TrwBas) for nas in nas_list: if not nas.dns_name: continue results, _, _ = yield client.lookupAddress(nas.dns_name) if not results: logger.error("domain {0} resolver empty".format(nas.dns_name)) if results[0].type == dns.A: ipaddr = ".".join(str(i) for i in struct.unpack("BBBB", results[0].payload.address)) if ipaddr: nas.ip_addr = ipaddr conn.commit() logger.info("domain {0} resolver {1} success".format(nas.dns_name,ipaddr)) else: logger.info("domain {0} no ip address,{1}".format(nas.dns_name, repr(results))) except Exception as err: logger.error('ddns process error %s' % utils.safeunicode(err.message)) finally: conn.close() reactor.callLater(60, self.process, )
def dns_consistency(self, hostname): cached_value = yield self.lookup('dns_consistency', hostname) if cached_value is not None: defer.returnValue(cached_value) dns_info = { 'addrs': [], 'failure': None } try: records = yield dns_client.lookupAddress(hostname) answers = records[0] for answer in answers: if answer.type is dns.A: dns_info['addrs'].append(answer.payload.dottedQuad()) elif answer.type is dns.CNAME: dns_info['addrs'].append(answer.payload.name.name) except DNSNameError: dns_info['failure'] = 'dns_name_error' except DNSServerError: dns_info['failure'] = 'dns_server_failure' except: dns_info['failure'] = 'unknown_error' yield self.cache_value('dns_consistency', hostname, dns_info) defer.returnValue(dns_info)
def process(self, *args, **kwargs): dispatch.pub(logger.EVENT_INFO, "process ddns update task..") with make_db(self.db) as db: try: nas_list = db.query(models.TrBas) for nas in nas_list: if not nas.dns_name: continue results, _, _ = yield client.lookupAddress(nas.dns_name) if not results: dispatch.pub(logger.EVENT_INFO, "domain {0} resolver empty".format(nas.dns_name)) if results[0].type == dns.A: ipaddr = ".".join(str(i) for i in struct.unpack("BBBB", results[0].payload.address)) if ipaddr: nas.ip_addr = ipaddr db.commit() dispatch.pub( logger.EVENT_INFO, "domain {0} resolver {1} success".format(nas.dns_name, ipaddr) ) else: dispatch.pub( logger.EVENT_INFO, "domain {0} no ip address,{1}".format(nas.dns_name, repr(results)) ) except Exception as err: dispatch.pub(logger.EVENT_ERROR, "ddns process error %s" % utils.safeunicode(err.message)) defer.returnValue(60)
def process(self): conn = self.db() try: nas_list = conn.query(models.TrwBas) for nas in nas_list: if not nas.dns_name: continue results, _, _ = yield client.lookupAddress(nas.dns_name) if not results: logger.error("domain {0} resolver empty".format( nas.dns_name)) if results[0].type == dns.A: ipaddr = ".".join( str(i) for i in struct.unpack( "BBBB", results[0].payload.address)) if ipaddr: nas.ip_addr = ipaddr conn.commit() logger.info("domain {0} resolver {1} success".format( nas.dns_name, ipaddr)) else: logger.info("domain {0} no ip address,{1}".format( nas.dns_name, repr(results))) except Exception as err: logger.error('ddns process error %s' % utils.safeunicode(err.message)) finally: conn.close() reactor.callLater( 60, self.process, )
def process(self, *args, **kwargs): with make_db(self.db) as db: try: nas_list = db.query(models.TrBas) for nas in nas_list: if not nas.dns_name: continue results, _, _ = yield client.lookupAddress(nas.dns_name) if not results: logger.info("domain {0} resolver empty".format( nas.dns_name)) if results[0].type == dns.A: ipaddr = ".".join( str(i) for i in struct.unpack( "BBBB", results[0].payload.address)) if ipaddr: nas.ip_addr = ipaddr db.commit() logger.info( "domain {0} resolver {1} success".format( nas.dns_name, ipaddr)) else: logger.info("domain {0} no ip address,{1}".format( nas.dns_name, repr(results))) except Exception as err: logger.error('ddns process error %s' % utils.safeunicode(err.message)) defer.returnValue(60)
def lookupAs(hostname, *args, **kwargs): def callback(result): answer, auth, add = result if len(answer) == 0: raise LookupException, "No ANSWERS in A response for %s." % repr(hostname) return [x.payload.dottedQuad() for x in answer] return client.lookupAddress(hostname, *args, **kwargs).addCallback(callback)
def test_lookupAddress(self): """ Do a lookup and test that the resolver will issue the correct type of query type. We do this by checking that FakeResolver returns a result record with the same query type as what we issued. """ d = client.lookupAddress(self.hostname) d.addCallback(self.checkResult, dns.A) return d
def test_lookupAddress(self): """ Do a lookup and test that the resolver will issue the correct type of query type. We do this by checking that FakeResolver returns a result record with the same query type as what we issued. """ d = client.lookupAddress(self.hostname) d.addCallback(self.checkResult, dns.A) return d
def setUpClass(cls): try: answers = yield client.lookupAddress(cls.localOptions["dns-discovery"]) assert len(answers) > 0 assert len(answers[0]) > 0 cls.resolverIp = answers[0][0].payload.dottedQuad() except Exception as exc: log.exception(exc) log.err("Failed to lookup the resolver IP address")
def gethostbyname(name): """Lookup the IP of a given hostname. Unlike socket.gethostbyname() which can take an arbitrary amount of time to finish, this function will raise crochet.TimeoutError if more than 5 seconds elapse without an answer being received. """ d = client.lookupAddress(name) d.addCallback(lambda result: result[0][0].payload.dottedQuad()) return d
def lookupAs(hostname, *args, **kwargs): def callback(result): answer, auth, add = result if len(answer) == 0: raise LookupException, "No ANSWERS in A response for %s." % repr( hostname) return [x.payload.dottedQuad() for x in answer] return client.lookupAddress(hostname, *args, **kwargs).addCallback(callback)
def setUpClass(cls): try: answers = yield client.lookupAddress( cls.localOptions['dns-discovery']) assert len(answers) > 0 assert len(answers[0]) > 0 cls.resolverIp = answers[0][0].payload.dottedQuad() except Exception as exc: log.exception(exc) log.err("Failed to lookup the resolver IP address")
def resolved(self, record): if not record[0]: print 'resolution failed...' else: payload = record[0][0].payload if record[0][0].type == 5: # evil cname d = client.lookupAddress(payload.name.name) d.addCallback(self.resolved) else: reactor.connectTCP(payload.dottedQuad(), self.port, self.factory) return True
def check(self, vars, mc, data, protocol, peer): source = vars.get('_context') or vars.get('_source') if (source and not source.startswith('psyc://%s'%(peer.host))): u = parseUNL(source) d = client.lookupAddress(u['host']) d.addCallback(self.resolved, peer.host, vars, mc, data, protocol) elif source: # numeric address self.handle(vars, mc, data, protocol) else: protocol.msg({ '_source' : self.myname }, '_error_syntax_protocol_missing_source', 'Your implementation is broken')
def recvd_ptr(result): answer, auth, additional = result if len(answer) != 1: raise LookupException( "Not exactly one answer in PTR response for %s" % ip) hostname = str(answer[0].payload.name) def recvd_addr(result): answers, auth, additional = result if not answers: raise LookupException("No answers in A/AAAA response for %s" % hostname) addresses = [ inet_ntop(ipver, answer.payload.address) for answer in answers ] if ip not in addresses: raise VerificationException( "IP mismatch: %s is not in %s (%s)" % (ip, repr(addresses), hostname)) d.callback(hostname) if ipobj.version == 4: client.lookupAddress(hostname, *args, **kwargs).addCallback(recvd_addr).addErrback( d.errback) else: client.lookupIPV6Address( hostname, *args, **kwargs).addCallback(recvd_addr).addErrback(d.errback)
def _get_IP_addresses(host_address): """ Resolves an an address/URL to a list of IPv4 addresses """ if isIPAddress(host_address): returnValue([host_address]) else: answers, auth, addit = yield DNSclient.lookupAddress(host_address) if answers: IP_addresses = [] for answer in answers: IP_addresses.append(answer.payload.dottedQuad()) returnValue(IP_addresses) else: returnValue(None)
def check_dnsl(self, lst, ip): '''Check the IP address in a DNS list. @type ip: string @param ip: the IP to check @type lst: sting @param lst: the DNS list to check in @rtype: C{Deferred} @return: twisted.names.client resolver ''' rip = reverse_ip(ip) lookup = '%s.%s' % (rip, lst) d = client.lookupAddress(lookup) return d
def resolveHostname(self): """Attempts to resolve the server's hostname to an IP address for better reliability.""" timeout = [1, 2, 5] lookups = [] query = dns.Query(self.host, dns.A) lookups.append(client.lookupAddress(self.host, timeout ).addCallback(self._lookupFinished, socket.AF_INET, query)) query = dns.Query(self.host, dns.AAAA) lookups.append(client.lookupIPV6Address(self.host, timeout ).addCallback(self._lookupFinished, socket.AF_INET6, query)) return defer.DeferredList(lookups).addBoth(self._hostnameResolved)
def check_dnsl(self, lst, ip): '''Check the IP address in a DNS list. @type ip: string @param ip: the IP to check @type lst: sting @param lst: the DNS list to check in @rtype: C{Deferred} @return: twisted.names.client resolver ''' rip = bleyhelpers.reverse_ip(ip) lookup = '%s.%s' % (rip, lst) d = client.lookupAddress(lookup) return d
def _get_IP_addresses(hostname): """ Resolve a hostname to a list of IPv4 addresses. :param str hostname: hostname or IP address :returns: :class:`list` of :class:`str` IPv4 addresses """ try: answers, auth, addit = yield DNSclient.lookupAddress(hostname) except Exception as exc: # Too many different DNS failures to catch... log.exception('DNS Resolution failure: %r for name: %r', exc, hostname) returnValue([]) returnValue( [answer.payload.dottedQuad() for answer in answers if answer.type == dns.A])
def lookup_host(bot, user, channel, msg, guess_best): hostname = msg if len(hostname): if guess_best: d = client.getHostByName(hostname) d.addCallback(resultCb, hostname, bot, user, channel) d.addErrback(errorCb, hostname, bot, user, channel) else: pending = [] pending.append(client.lookupAddress(hostname)) pending.append(client.lookupIPV6Address(hostname)) allResults = defer.DeferredList(pending, consumeErrors=False) allResults.addCallback(resultCb, hostname, bot, user, channel) allResults.addErrback(errorCb, hostname, bot, user, channel) else: bot.msg(channel, 'Usage: !host <hostname>')
def _get_IP_addresses(hostname): """ Resolves an an address/URL to a list of IPv4 addresses """ if isIPAddress(hostname): returnValue([hostname]) else: try: answers, auth, addit = yield DNSclient.lookupAddress(hostname) except Exception as exc: # Too many different DNS failures to catch... log.error('DNS Resolution failure: %r for name: %r', exc, hostname) returnValue([]) returnValue( [answer.payload.dottedQuad() for answer in answers if answer.type == dns.A])
def resolveHostname(self): """Attempts to resolve the server's hostname to an IP address for better reliability.""" timeout = [1, 2, 5] lookups = [] query = dns.Query(self.host, dns.A) lookups.append( client.lookupAddress(self.host, timeout).addCallback(self._lookupFinished, socket.AF_INET, query)) query = dns.Query(self.host, dns.AAAA) lookups.append( client.lookupIPV6Address(self.host, timeout).addCallback( self._lookupFinished, socket.AF_INET6, query)) return defer.DeferredList(lookups).addBoth(self._hostnameResolved)
def resolved(self, record, shouldbe, vars, mc, data, protocol): v = { '_source' : self.myname, '_target' : vars['_source'] } if not record[0]: print 'name not resolvable' protocol.msg(v, '_error_rejected_relay', '[_source] is not resolvable. Goodbye') protocol.transport.loseConnection() elif record[0][0].type == 5: payload = record[0][0].payload d = client.lookupAddress(payload.name.name) d.addCallback(self.resolved, shouldbe, vars, mc, data, protocol) else: payload = record[0][0].payload if payload.dottedQuad() == shouldbe: self.handle(vars, mc, data, protocol) else: print 'rejected relay' protocol.msg(v, '_error_rejected_relay', '[_source] does not resolve to your ip.') protocol.transport.loseConnection()
def lookupIp(ip): # Try look in the leases config first conf = __import__('config') leases = conf.DHCP.get('leases', {}) for lip, hostmac in conf.DHCP.get('leases', {}).items(): host, mac = hostmac if lip == ip: return host from twisted.names import client def res(lookup): name = str(lookup[0][0].payload.name) # Take away our common domain and strip any residual dots return name.replace(Settings.defaultDomain, '').strip('.') def failure(eek): return ip def ipToPtr(ip): return "%s.in-addr.arpa" % '.'.join( [i for i in reversed(ip.split('.'))]) return client.lookupAddress(ipToPtr(ip)).addCallbacks(res, failure)
def process(self, *args, **kwargs): self.logtimes() with make_db(self.db) as db: try: nas_list = db.query(models.TrBas) for nas in nas_list: if not nas.dns_name: continue results, _, _ = yield client.lookupAddress(nas.dns_name) if not results: logger.info("domain {0} resolver empty".format(nas.dns_name)) if results[0].type == dns.A: ipaddr = ".".join(str(i) for i in struct.unpack("BBBB", results[0].payload.address)) if ipaddr: nas.ip_addr = ipaddr db.commit() logger.info("domain {0} resolver {1} success".format(nas.dns_name,ipaddr)) else: logger.info("domain {0} no ip address,{1}".format(nas.dns_name, repr(results))) except Exception as err: logger.error('ddns process error %s' % utils.safeunicode(err.message)) defer.returnValue(self.get_notify_interval())
def discover(config): def direct(result): (answer, authority, additional) = result httpAgent = Agent(reactor) def responded(response, addr): addr_or_defer = None if hasattr(response, "code") and response.code == 200: addr_or_defer = addr else: addr_or_defer = deferLater(reactor, 0, test) return addr_or_defer def test(): try: a = answer.pop() except IndexError: return defer.fail(IOError("No hosts available")) addr = str(a.payload.dottedQuad()) location = "://".join(('http', name)) uri = "://".join(('http', addr)) d = httpAgent.request(method="HEAD", headers = Headers({"location": location}), uri = uri) d.addBoth(responded, addr) return d d = deferLater(reactor, 0, test) return d def ipaddr(addr): return addr d = None if config.resolve == "endpoint": endpoint = choice(config.endpoints) netloc = urlparse.urlparse(endpoint).netloc d = client.lookupAddress(netloc) d.addCallback(direct) else: d = getOwnIpAddr() d.addCallback(ipaddr) return d
def gethostbyname(name): d = client.lookupAddress(name) d.addCallback(lambda result: result[0][0].payload.dottedQuad()) return d
def connect(self): if not isip(self._hostname): return client.lookupAddress(self._hostname).addCallbacks( self._getIp, self._lookupErr) return self.request()
def lookup(self, name=None): if not name: return d = client.lookupAddress(name=name) d.addCallback(self.print_result)