Exemple #1
0
  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)
Exemple #2
0
 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()
Exemple #3
0
 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()
Exemple #5
0
    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, )
Exemple #7
0
    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)
Exemple #8
0
    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)
Exemple #9
0
    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)
Exemple #11
0
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)
Exemple #12
0
 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
Exemple #13
0
 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")
Exemple #15
0
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
Exemple #16
0
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)
Exemple #17
0
 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")
Exemple #18
0
 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
Exemple #19
0
 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')
Exemple #20
0
    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)
Exemple #21
0
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)
Exemple #22
0
    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
Exemple #23
0
    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)
Exemple #24
0
    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
Exemple #25
0
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])
Exemple #26
0
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>')
Exemple #27
0
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])
Exemple #28
0
    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)
Exemple #29
0
 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()
Exemple #30
0
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)
Exemple #31
0
    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())
Exemple #32
0
 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
Exemple #33
0
def gethostbyname(name):
    d = client.lookupAddress(name)
    d.addCallback(lambda result: result[0][0].payload.dottedQuad())
    return d
Exemple #34
0
 def connect(self):
     if not isip(self._hostname):
         return client.lookupAddress(self._hostname).addCallbacks(
             self._getIp, self._lookupErr)
     return self.request()
Exemple #35
0
 def lookup(self, name=None):
     if not name:
         return
     d = client.lookupAddress(name=name)
     d.addCallback(self.print_result)