def _extractClientInformation(self, msg):
power = msg.get("power")
mid = msg.get("mid")
pid = msg.get("pid")
if power is None:
self._sendError("I need your computing power")
raise Exception("Newly connected client did not send "
"it's computing power value, sending back "
"the error message")
if mid is None:
self._sendError("I need your machine id")
raise Exception("Newly connected client did not send "
"it's machine id, sending back the error "
"message")
if pid is None:
self._sendError("I need your process id")
raise Exception("Newly connected client did not send "
"it's process id, sending back the error "
"message")
self.nodes[self.id] = {
"power": power, "mid": mid, "pid": pid, "id": self.id, "jobs": 0,
"backend": msg.get("backend"), "device": msg.get("device"),
"argv": msg.get("argv"), "executable": msg.get("executable"),
"PYTHONPATH": msg.get("PYTHONPATH"), "cwd": msg.get("cwd")}
dns.lookupPointer(
".".join(reversed(self.addr.host.split("."))) + ".in-addr.arpa") \
.addCallback(self._resolveAddr).addErrback(self._failToResolveAddr)
return power, mid, pid
def lookupAndVerifyPTR(ip, *args, **kwargs):
d = defer.Deferred()
ipobj = ip_address(unicode(ip))
if ipobj.version == 4:
ipver = AF_INET
else:
ipver = AF_INET6
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)
client.lookupPointer(ipobj.reverse_pointer, *args,
**kwargs).addCallback(recvd_ptr).addErrback(d.errback)
return d
def test_lookupPointer(self):
"""
See L{test_lookupAddress}
"""
d = client.lookupPointer(self.hostname)
d.addCallback(self.checkResult, dns.PTR)
return d
def __init__(self, blacklist):
super(ManagerBlacklistDialog, self).__init__()
uic.loadUi('manager_blacklist.ui', self)
self.blacklist = blacklist
#self.addr_list.cellDoubleClicked.connect(self.select_ip)
self.actionAllow.clicked.connect(self.allow_ip)
self.actionDeny.clicked.connect(self.deny_ip)
self.insert.clicked.connect(self.insert_ip)
self.remove.clicked.connect(self.remove_ip)
self.addr_list.setColumnWidth(1, 120)
self.addr_list.setColumnWidth(0, 50)
for idx, (IP, netsize, hostname, allow) in enumerate(self.blacklist.items):
self.addr_list.insertRow(idx)
self.addr_list.setItem(idx, 0, QtGui.QTableWidgetItem(str(allow)))
self.addr_list.setItem(idx, 1, QtGui.QTableWidgetItem("%s/%s" % (IP, netsize) ))
if netsize > 32:
self.addr_list.setItem(idx, 2, QtGui.QTableWidgetItem("<Network>"))
elif hostname:
self.addr_list.setItem(idx, 2, QtGui.QTableWidgetItem(hostname))
else:
self.addr_list.setItem(idx, 2, QtGui.QTableWidgetItem("<resolving>"))
record_name = ".".join(IP.split(".")[::-1]) + ".in-addr.arpa"
print "looking up IP address %s" % (record_name,)
d = nameclient.lookupPointer(record_name)
d.addCallbacks(callback = self.update_name,
errback = self.name_error,
callbackArgs = (idx,),
errbackArgs = (idx,))
def test_lookupPointer(self):
"""
See L{test_lookupAddress}
"""
d = client.lookupPointer(self.hostname)
d.addCallback(self.checkResult, dns.PTR)
return d
def main(reactor):
pending = []
for addr in IPNetwork('79.170.40.0/24'):
d = client.lookupPointer(addr.reverse_dns, timeout=(1,))
pending.append(d)
return defer.DeferredList(pending, consumeErrors=True).addCallback(printResult)
def resolve_name(self):
#try:
# self.hostname = socket.gethostbyaddr(self.ip_addr)[0]
#except socket.herror:
# self.hostname = "Unknown"
self.d = client.lookupPointer(name=self.reverse_name_for_ip_address())
self.d.addCallback(self.lookup_ptr_callback)
return self.d
def _taskGenerator(self):
for ip in self.ips:
addr = ip
ptr = IPy.IP(addr).reverseName()
d = client.lookupPointer(ptr, timeout=self.timeouts
).addCallback(lambda x, addr=addr: self._lookupSuccess(x, addr)
).addErrback(lambda x, addr=addr: self._lookupError(x, addr))
yield d
def _reverse_IPv4_lookup(self, ipString):
"""
@param ipString: dotted-quad IP address.
"""
parts = ipString.split('.')
parts.reverse()
host = '.'.join(parts) + '.in-addr.arpa'
return lookupPointer(host).addCallback(self._gotReverseLookupResult)
def _startDNSResolving(self, timeout):
ip = self.ip
if ipIsV4(ip):
addr = "{}.in-addr.arpa".format(".".join(reversed(ip.split("."))))
else:
addr = reversed(expandIPv6Address(ip).replace(":", ""))
addr = "{}.ip6.arpa".format(".".join(addr))
resolveDeferred = dnsClient.lookupPointer(addr, ((timeout/2),))
resolveDeferred.addCallbacks(callback=self._verifyDNSResolution, callbackArgs=(timeout,), errback=self._cancelDNSResolution)
def lookupPTR(ip, *args, **kwargs):
def callback(result):
answer, auth, add = result
if len(answer) == 0:
raise LookupException, "No ANSWERS in PTR response for %s." % repr(ip)
return str(answer[0].payload.name)
ptr = ".".join(ip.split(".")[::-1]) + ".in-addr.arpa."
return client.lookupPointer(ptr, **kwargs).addCallback(callback)
def lookupAndVerifyPTR(ip, *args, **kwargs):
d = defer.Deferred()
ipobj = ip_address(unicode(ip))
if ipobj.version == 4:
ipver = AF_INET
else:
ipver = AF_INET6
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)
client.lookupPointer(ipobj.reverse_pointer, *args, **kwargs).addCallback(recvd_ptr).addErrback(d.errback)
return d
def lookupPTRv6(ip, *args, **kwargs):
def callback(result):
answer, auth, add = result
answer = [x for x in answer if x.type == dns.PTR]
if len(answer) == 0:
raise LookupException("No ANSWERS in PTR response for %s." %
repr(ip))
return str(answer[0].payload.name)
ptr = ".".join(reversed(expandIPv6(ip))) + ".ip6.arpa."
return client.lookupPointer(ptr, **kwargs).addCallback(callback)
def _startDNSResolving(self, timeout):
ip = self.ip
if ipIsV4(ip):
addr = "{}.in-addr.arpa".format(".".join(reversed(ip.split("."))))
else:
addr = reversed(expandIPv6Address(ip).replace(":", ""))
addr = "{}.ip6.arpa".format(".".join(addr))
resolveDeferred = dnsClient.lookupPointer(addr, ((timeout / 2), ))
resolveDeferred.addCallbacks(callback=self._verifyDNSResolution,
callbackArgs=(timeout, ),
errback=self._cancelDNSResolution)
def lookupPTR(ip, *args, **kwargs):
def callback(result):
answer, auth, add = result
if len(answer) == 0:
raise LookupException, "No ANSWERS in PTR response for %s." % repr(
ip)
return str(answer[0].payload.name)
ptr = ".".join(ip.split(".")[::-1]) + ".in-addr.arpa."
return client.lookupPointer(ptr, **kwargs).addCallback(callback)
def reversedns(self, addr):
"""
Perform a reverse DNS lookup on an IP
Arguments:
addr -- IPv4 Address
"""
try:
ptr = ipaddress.ip_address(addr).reverse_pointer
except ValueError:
return None
d = client.lookupPointer(ptr, timeout=self.timeout)
return d
def reversedns(self, addr):
"""
Perform a reverse DNS lookup on an IP
Arguments:
addr -- IPv4 Address
"""
try:
ptr = ipaddress.ip_address(addr).reverse_pointer
except ValueError:
return None
d = client.lookupPointer(ptr, timeout=self.timeout)
return d
def _extractClientInformation(self, msg):
power = msg.get("power")
mid = msg.get("mid")
pid = msg.get("pid")
if power is None:
self._sendError("I need your computing power")
raise Exception("Newly connected client did not send "
"it's computing power value, sending back "
"the error message")
if mid is None:
self._sendError("I need your machine id")
raise Exception("Newly connected client did not send "
"it's machine id, sending back the error "
"message")
if pid is None:
self._sendError("I need your process id")
raise Exception("Newly connected client did not send "
"it's process id, sending back the error "
"message")
self.nodes[self.id] = {
"power": power,
"mid": mid,
"pid": pid,
"id": self.id,
"jobs": 0,
"backend": msg.get("backend"),
"device": msg.get("device"),
"argv": msg.get("argv"),
"executable": msg.get("executable"),
"PYTHONPATH": msg.get("PYTHONPATH"),
"cwd": msg.get("cwd")
}
dns.lookupPointer(
".".join(reversed(self.addr.host.split("."))) + ".in-addr.arpa") \
.addCallback(self._resolveAddr).addErrback(self._failToResolveAddr)
return power, mid, pid
def asyncNameLookup(address, uselibcresolver = True):
"""
Turn IP addreses into names using deferreds
"""
if uselibcresolver:
# This is the most reliable way to do a lookup use it
return threads.deferToThread(lambda : socket.gethostbyaddr(address)[0])
else:
# There is a problem with this method because it will ignore /etc/hosts
address = '.'.join(address.split('.')[::-1]) + '.in-addr.arpa'
d = lookupPointer(address, [1,2,4])
def ip(result):
return str(result[0][0].payload.name)
d.addCallback(ip)
return d
def reverse_lookup(address):
"""This function performs the Reverse Lookup for each ip of
lookup answer"""
outer_deferred = defer.Deferred()
def wrap_result(result):
""" Wrap result returned by Twisted """
outer_deferred.callback(ReverseAnswer(result))
def wrap_error(err):
""" Wrap error returned by Twisted """
outer_deferred.errback(ReverseErrors(err))
rev_ip = reverse_ip_address(address=address)
inner_deferred = client.lookupPointer(rev_ip, timeout=[5, 10, 20, 30])
inner_deferred.addCallbacks(wrap_result, wrap_error)
return outer_deferred
def reverse_lookup(address):
"""This function performs the Reverse Lookup for each ip of
lookup answer"""
outer_deferred = defer.Deferred()
def wrap_result(result):
""" Wrap result returned by Twisted """
outer_deferred.callback(ReverseAnswer(result))
def wrap_error(err):
""" Wrap error returned by Twisted """
outer_deferred.errback(ReverseErrors(err))
rev_ip = reverse_ip_address(address=address)
inner_deferred = client.lookupPointer(rev_ip, timeout=[5, 10, 20, 30])
inner_deferred.addCallbacks(wrap_result, wrap_error)
return outer_deferred
def main(reactor):
hosts = readList()
for host in hosts:
inicio = datetime.datetime.now()
if host[1] == 'A\n':
d = client.getHostByName(host[0])
l = [time()]
a = d.addCallback(printResult2, l)
print l
print a, type(a)
b = d.addErrback(error, inicio)
print b
else:
d = client.lookupPointer(name=reverseNameFromIPAddress(
address=host[0]))
d.addCallback(printResult, inicio)
d.addErrback(error, inicio)
return d
def main(reactor, *argv):
options = Options()
try:
options.parseOptions(argv)
except usage.UsageError as errortext:
sys.stderr.write(str(options) + "\n")
sys.stderr.write(f"ERROR: {errortext}\n")
raise SystemExit(1)
pending = []
for address in options["addresses"]:
pointerName = reverseNameFromIPAddress(address)
# Force a single 1s timeout, so that slow or offline servers don't
# adversely slow down the script.
result = client.lookupPointer(pointerName, timeout=(1,))
result.addCallback(printResult)
pending.append(result)
allResults = defer.DeferredList(pending, consumeErrors=False)
allResults.addCallback(printSummary)
return allResults
def main(reactor, *argv):
options = Options()
try:
options.parseOptions(argv)
except usage.UsageError as errortext:
sys.stderr.write(str(options) + '\n')
sys.stderr.write('ERROR: %s\n' % (errortext,))
raise SystemExit(1)
pending = []
for address in options['addresses']:
pointerName = reverseNameFromIPAddress(address)
# Force a single 1s timeout, so that slow or offline servers don't
# adversely slow down the script.
result = client.lookupPointer(pointerName, timeout=(1,))
result.addCallback(printResult)
pending.append(result)
allResults = defer.DeferredList(pending, consumeErrors=False)
allResults.addCallback(printSummary)
return allResults
def add_ip(self, new_addr):
print "adding host to list: %s" % (new_addr,)
self.activeHost.setText('')
if not new_addr:
return
if new_addr[0] not in "1234567890":
self.add_hostname(new_addr)
return
new_addr, _, new_netsize = new_addr.partition('/')
try:
socket.inet_aton(new_addr)
except Exception as e:
print "Invalid IP"
return
new_netsize = int(new_netsize) if new_netsize else 32
for idx in range(self.addr_list.rowCount()):
old_addr = str(self.addr_list.item(idx, 1).text())
old_addr, _, old_netsize = old_addr.partition('/')
old_netsize = 32 if not old_netsize else int(old_netsize)
if old_addr == new_addr and old_netsize == new_netsize:
return
idx = idx+1
self.addr_list.insertRow(idx)
self.addr_list.setItem(idx, 0, QtGui.QTableWidgetItem("False"))
self.addr_list.setItem(idx, 1, QtGui.QTableWidgetItem("%s/%s" % (new_addr, new_netsize) ))
if new_netsize < 32:
self.addr_list.setItem(idx, 2, QtGui.QTableWidgetItem("<network>"))
else:
self.addr_list.setItem(idx, 2, QtGui.QTableWidgetItem("<resolving>"))
record_name = ".".join(new_addr.split(".")[::-1]) + ".in-addr.arpa"
print "looking up IP address %s" % (record_name,)
d = nameclient.lookupPointer(record_name)
d.addCallbacks(callback = self.update_name,
errback = self.name_error,
callbackArgs = (idx,),
errbackArgs = (idx,))
def main(reactor, address):
d = client.lookupPointer(name=reverseNameFromIPAddress(address=address))
d.addCallback(printResult)
return d
def data_dns(self, ctx, data):
ptr = '.'.join(str(self.ip).split('.')[::-1]) + '.in-addr.arpa'
d = client.lookupPointer(ptr)
d.addErrback(lambda x: None)
return d
def main(reactor, address):
d = client.lookupPointer(name=reverseNameFromIPAddress(address=address))
d.addCallback(printResult)
return d
def data_solvedip(self, ctx, ip):
ptr = '.'.join(ip.split('.')[::-1]) + '.in-addr.arpa'
d = client.lookupPointer(ptr)
d.addErrback(lambda x: None)
return d
def data_dns(self, ctx, data):
ptr = '.'.join(str(self.ip).split('.')[::-1]) + '.in-addr.arpa'
d = client.lookupPointer(ptr)
d.addErrback(lambda x: None)
return d
def reverseLookup(address, outFile):
d = client.lookupPointer(name=reverseNameFromIP(address), timeout=(1, 3, 5, 10))
d.addCallback(writeResult, address, outFile)
d.addErrback(lookupFailed, address, outFile)
return d
def data_solvedip(self, ctx, ip):
ptr = '.'.join(ip.split('.')[::-1]) + '.in-addr.arpa'
d = client.lookupPointer(ptr)
d.addErrback(lambda x: None)
return d
