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)
