def connect(self): try: primaryDNS = ".".join("%d" % d for d in config.ondemand.PrimaryDNS.value) myDNS = [] myDNS.append(primaryDNS) resolver = Resolver() resolver.nameservers = myDNS #DNS Now coming from OnDemand Settings answer = resolver.query(self.host, 'A') self.host = answer.rrset.items[0].address self.sock = socket.create_connection((self.host, self.port)) except (Exception) as exception: print "MyHTTPConnection: Failed to Connect to: ", primaryDNS, " , error: ", exception try: secondaryDNS = str(config.ondemand.SecondaryDNS.value) if secondaryDNS != str(config.ondemand.SecondaryDNS.default): secondaryDNS = ".".join( "%d" % d for d in config.ondemand.SecondaryDNS.value) myDNS = [] myDNS.append(secondaryDNS) resolver = Resolver() resolver.nameservers = myDNS #DNS Now coming from OnDemand Settings answer = resolver.query(self.host, 'A') self.host = answer.rrset.items[0].address self.sock = socket.create_connection( (self.host, self.port)) except (Exception) as exception: print "MyHTTPConnection: Failed to Connect to: ", secondaryDNS, " , error: ", exception
def _isitup(self, url, return_status=False, redirects=0): valid_url = self._makeurl(url) if Resolver is not None: r = Resolver() host = urlparse(valid_url).netloc.split(":")[0] try: r.query(host) except NoAnswer: return (False, valid_url, u"No DNS A/CNAME-records for that domain") except NXDOMAIN: return False, valid_url, u"No such domain" try: status, reason, data, headers = self._request(valid_url, "HEAD") if 300 <= status < 400 and self._get_header(headers, "location"): if redirects > self.redirect_limit: return False, valid_url, u"Redirect limit reached" return self._isitup(self._get_header(headers, "location"), return_status, redirects + 1) up = status < 300 if return_status: reason = u"%(status)d %(reason)s" % {u"status": status, u"reason": reason} return up, valid_url, reason except HTTPException: return False, valid_url, u"Server is not responding"
def resolve(self, event, record, host, nameserver): ipaddr = re.compile(r"\d+\.\d+\.\d+\.\d+") if not record: if ipaddr.search(host): host = from_address(host) record = "PTR" else: record = "A" resolver = Resolver() if nameserver: if not ipaddr.search(nameserver): nameserver = resolver.query(nameserver, "A")[0].address resolver.nameservers = [nameserver] try: answers = resolver.query(host, str(record)) except NoAnswer: event.addresponse(u"I couldn't find any %(type)s records for %(host)s", {"type": record, "host": host}) return except NXDOMAIN: event.addresponse(u"I couldn't find the domain %s", host) return responses = [] for rdata in answers: responses.append(unicode(rdata)) event.addresponse(u"Records: %s", human_join(responses))
class CustomResolver(object): def __init__(self): self.resolver = Resolver() self.resolver.use_edns(0, 0, 4096) self.resolver.set_flags(flags.AD + flags.RD) self.degraded = Resolver() self.degraded.use_edns(0, 0, 4096) self.degraded.set_flags(flags.CD + flags.RD) def query(self, fqdn, rdatatype=rdt.A, degraded=False): log.debug('Query %s %s', fqdn, rdatatype) try: return self.resolver.query(fqdn, rdatatype) except NoNameservers: if degraded: return self.degraded.query(fqdn, rdatatype) raise except NXDOMAIN: if degraded: return self.degraded.query(fqdn, rdatatype) return None def srv(self, name, domainname, proto='tcp'): fqdn = '_{}._{}.{}'.format(name, proto, domainname) return self.query(fqdn, rdt.SRV) def tlsa(self, hostname, port, proto='tcp'): fqdn = '_{}._{}.{}'.format(port, proto, hostname) return self.query(fqdn, rdt.TLSA) def mx(self, domainname): return self.query(domainname, rdt.MX)
def smugmug(domain, ARecords, CNAME): outcome = [] try: if get("http://" + domain, headers=headers).status_code == 404: outcome = ["Smugmug", domain, CNAME] return outcome except Exception: pass try: if get("https://" + domain, headers=headers, verify=False).status_code == 404: outcome = ["Smugmug", domain, CNAME] return outcome except Exception: pass resolver = Resolver() resolver.timeout = 1 resolver.lifetime = 1 try: resolver.query(CNAME) except NXDOMAIN: outcome = ["Smugmug", domain, CNAME] return outcome
def get_records(host, port, proto='tcp'): resolver = Resolver() resolver.set_flags(flags.AD + flags.RD) name = '_{}._{}.{}'.format(port, proto, host) try: rrset = resolver.query(name, rdtype=rdatatype.TLSA) except NXDOMAIN: log.debug('No record found for %s', name) raise except NoNameservers: log.debug('No unbroken server for resolving %s', name) # It may be because there is a bad dnssec key resolver.set_flags(flags.CD + flags.RD) rrset = resolver.query(name, rdtype=rdatatype.TLSA) log.debug('Without validation we have an answer: %s', rrset) for record in rrset: log.debug(record) secure = rrset.response.flags & flags.AD == flags.AD if not secure: log.warn('Not DNSSEC signed!') return TLSAValidator([r for r in rrset], secure)
def connect (self): try: primaryDNS = ".".join("%d" % d for d in config.ondemand.PrimaryDNS.value) myDNS = [] myDNS.append(primaryDNS) resolver = Resolver() resolver.nameservers = myDNS #DNS Now coming from OnDemand Settings answer = resolver.query(self.host,'A') self.host = answer.rrset.items[0].address self.sock = socket.create_connection ((self.host, self.port)) except (Exception) as exception: print "MyHTTPConnection: Failed to Connect to: ", primaryDNS, " , error: ", exception try: secondaryDNS = str(config.ondemand.SecondaryDNS.value) if secondaryDNS != str(config.ondemand.SecondaryDNS.default): secondaryDNS = ".".join("%d" % d for d in config.ondemand.SecondaryDNS.value) myDNS = [] myDNS.append(secondaryDNS) resolver = Resolver() resolver.nameservers = myDNS #DNS Now coming from OnDemand Settings answer = resolver.query(self.host,'A') self.host = answer.rrset.items[0].address self.sock = socket.create_connection ((self.host, self.port)) except (Exception) as exception: print "MyHTTPConnection: Failed to Connect to: ", secondaryDNS, " , error: ", exception
def main(self, min_len=(1, ), max_len=(3, )): """ Main function """ try: min_len = int(min_len[0]) max_len = int(max_len[0]) except TypeError: self._write_result("Min and max length should be integer values.") return if min_len > max_len or min_len <= 0: self._write_result( "Min length should be greater than 0 and less or equal to max length." ) return if not self.host: return if self.host.startswith("www."): self.host = self.host[4:] # collect nameservers r = Resolver() r.lifetime = self.DNS_TIMEOUT name_servers = r.query(self.host, "NS") name_servers = map(lambda x: str(x), name_servers) ns_list = [] for name_server in name_servers: if name_server[-1] == ".": name_server = name_server[:-1] ns_list.append(gethostbyname(name_server)) r = Resolver() r.lifetime = self.DNS_TIMEOUT r.nameservers = ns_list results = set() for sub in self.generate_subdomains(min_len, max_len): domain = "%s.%s" % (sub, self.host) for record in ("A", "CNAME"): try: records = r.query(domain, record) if records: if sub not in results: results.add(sub) self._write_result(domain) break except Exception: pass
def resolve_googleipranges(): # returns a list of IP ranges for outbound SMTP from Google from dns.resolver import Resolver sys_r = Resolver() # query for the list of domains included in Google's SPF records answers = sys_r.query('_spf.google.com', 'TXT') # format the returned answer into a list rrset = str(answers.rrset) spfdomains = rrset.split(' ') # return only entries that have "include:" # and then split them on the ':' to return only the dns addresses spfdomains = [x for x in spfdomains if 'include:' in x] spfdomains = [i.split(':', 1)[1] for i in spfdomains] # iterate these to get a full list of IP addresses ipranges = list() for domain in spfdomains: answers = sys_r.query(domain, 'TXT') rrset = str(answers.rrset) iplist = rrset.split(' ') iplist = [x for x in iplist if 'ip4' in x] iplist = [i.split(':', 1)[1] for i in iplist] ipranges = ipranges + iplist return ipranges
def _isitup(self, url, return_status=False, redirects=0): valid_url = self._makeurl(url) if Resolver is not None: r = Resolver() host = urlparse(valid_url).netloc.split(':')[0] try: r.query(host) except NoAnswer: return (False, valid_url, u'No DNS A/CNAME-records for that domain') except NXDOMAIN: return False, valid_url, u'No such domain' try: status, reason, data, headers = self._request(valid_url, 'HEAD') if 300 <= status < 400 and self._get_header(headers, 'location'): if redirects > self.redirect_limit: return False, valid_url, u'Redirect limit reached' return self._isitup(self._get_header(headers, 'location'), return_status, redirects + 1) up = status < 300 if return_status: reason = u'%(status)d %(reason)s' % { u'status': status, u'reason': reason, } return up, valid_url, reason except HTTPException: return False, valid_url, u'Server is not responding'
def resolve(self, event, record, host, nameserver): ipaddr = re.compile(r'\d+\.\d+\.\d+\.\d+') if not record: if ipaddr.search(host): host = from_address(host) record = 'PTR' else: record = 'A' resolver = Resolver() if nameserver: if not ipaddr.search(nameserver): nameserver = resolver.query(nameserver, 'A')[0].address resolver.nameservers = [nameserver] try: answers = resolver.query(host, str(record)) except NoAnswer: event.addresponse( u"I couldn't find any %(type)s records for %(host)s", { 'type': record, 'host': host, }) return except NXDOMAIN: event.addresponse(u"I couldn't find the domain %s", host) return responses = [] for rdata in answers: responses.append(unicode(rdata)) event.addresponse(u'Records: %s', human_join(responses))
def dns_lookup(self, hostname, aux): """Performs DNS lookup action for the given hostname, i.e. (in this case) IP address retrieval by hostname. Args: hostname: The effective hostname to look up for. aux: The controller helper object instance. Returns: The IP address retrieved for the host analyzed and the IP version (family) used to look up in DNS. """ resolver = Resolver() # If the host doesn't have the A record (IPv4), # trying to find its AAAA record (IPv6). try: addr = resolver.query(hostname, "A")[0] # <---+ ver = 4 # | except Exception as e: # From the dnspython lib. --------+ try: # | addr = resolver.query(hostname, "AAAA")[0] # <---+ ver = 6 except Exception as e: addr = ver = aux._ERR_PREFIX return (addr, ver)
def add_domain_email(request): if request.method == 'GET': form = MailDomainForm() return render_to_response( 'userdash_add_domain_email.html', { 'user_balance': get_balance(request), 'form': form, 'menu_email': 'active' }, RequestContext(request)) else: form = MailDomainForm(request.POST) if form.is_valid(): try: local_resolver = Resolver() name_servers = local_resolver.query(request.POST.get('domain'), 'NS') uncached_resolver = Resolver(configure=False) for i in name_servers: try: authentic_address = local_resolver.query(str(i), 'A') uncached_resolver.nameservers.append( str(authentic_address[0])) except: # one of the servers was broken? pass address = uncached_resolver.query(request.POST.get('domain'), 'MX') except: return HttpResponseRedirect( '/dashboard-cust/email/error-domain') try: exchanger = str(address[0]) if not exchanger.endswith( 'bsmsite.com.' ): # NOTE: srv.bsmsite.com and mail.bsmsite.com are both valid return HttpResponseRedirect( '/dashboard-cust/email/error-domain') except: return HttpResponseRedirect( '/dashboard-cust/email/error-domain') instance = MailDomain(user=request.user, domain=request.POST.get('domain'), notes=request.POST.get('notes')) instance.save() return HttpResponseRedirect('/dashboard-cust/email/domain') else: return render_to_response( 'userdash_add_domain_email.html', { 'user_balance': get_balance(request), 'form': form, 'menu_email': 'active' }, RequestContext(request))
def test_raise_dns_tcp(self): # https://github.com/eventlet/eventlet/issues/499 # None means we don't want the server to find the IP with tests.dns_tcp_server(None) as dnsaddr: resolver = Resolver() resolver.nameservers = [dnsaddr[0]] resolver.nameserver_ports[dnsaddr[0]] = dnsaddr[1] with self.assertRaises(NoAnswer): resolver.query('host.example.com', 'a', tcp=True)
def test_remove_tsig(minion, resolver: Resolver): with knotc() as knot: with knot.zone_edit("example.org"): knot.set('_acme-challenge 120 TXT "secret"') minion.mods["acme_dns.remove"]( "example.org", [{"name": "example.org", "token": "secret"}], nameserver="127.0.0.153", tsig="hmac-sha256:acme:opCLn9NMrbY0xKB8lWs2KM2lgQsEW5LdvsVtxnoRJIo=", ) with pytest.raises(dns.resolver.NXDOMAIN): resolver.query("_acme-challenge.example.org.", TXT)
def test_remove_zone(minion, resolver: Resolver): with knotc() as knot: with knot.zone_edit("example.com"): knot.set('_acme-challenge 120 TXT "secret"') minion.mods["acme_dns.remove"]( "default", [{"name": "example.com", "token": "secret"}], nameserver="127.0.0.153", zone="example.com", ) with pytest.raises(dns.resolver.NXDOMAIN): resolver.query("_acme-challenge.example.org.", TXT)
def findNX(domainToTry): resolver = Resolver() resolver.timeout = 1 resolver.lifetime = 1 try: resolver.query(domainToTry) except NXDOMAIN: return True except Exception: pass return False
class RsnServer(object): def __init__(self, server): self.logger = logging.getLogger('RsnServer') self.server = server self.ipv4 = query(self.server, 'A')[0].address self.ipv6 = query(self.server, 'AAAA')[0].address self.resolver = Resolver() self.size_ipv4 = None self.size_ipv6 = None self.size_ipv4_dnssec = None self.size_ipv6_dnssec = None self.logger.debug('initiate: {} ({}/{})'.format(self.server, self.ipv4, self.ipv6)) self.update_sizes() def _update_size(self, server, dnssec): '''get the response size''' self.resolver.nameservers = [ server ] if dnssec: self.resolver.use_edns(0,DO,4096) else: self.resolver.use_edns(0,0,4096) answer = self.resolver.query('.', 'NS') size = len(answer.response.to_wire()) self.logger.debug('Size:{}:DNSSEC({}):{}'.format(server, dnssec, size)) return size def update_sizes(self): self.size_ipv4 = self._update_size(self.ipv4, False) self.size_ipv6 = self._update_size(self.ipv6, False) self.size_ipv4_dnssec = self._update_size(self.ipv4, True) self.size_ipv6_dnssec = self._update_size(self.ipv6, True)
def get_response(data, spoofs, spoof_all): message = from_wire(data) domain = str(message.question[0].name)[:-1] rrset = None response = make_response(message) if spoofs and message.question[ 0].rdtype == dns.rdatatype.A and domain in spoofs: print('Spoofing query for %s' % domain) rrset = from_text(message.question[0].name, 300, dns.rdataclass.IN, dns.rdatatype.A, spoofs[domain]) elif spoof_all and message.question[0].rdtype == dns.rdatatype.A: print('Spoofing query for %s due to spoof all' % domain) rrset = from_text(message.question[0].name, 300, dns.rdataclass.IN, dns.rdatatype.A, spoof_all) else: print('Not spoofing %s query for %s' % (dns.rdatatype.to_text(message.question[0].rdtype), domain)) resolver = Resolver() try: rrset = resolver.query(message.question[0].name, message.question[0].rdtype, message.question[0].rdclass).rrset except dns.resolver.NXDOMAIN: response.set_rcode(dns.rcode.NXDOMAIN) except dns.resolver.NoAnswer: response.set_rcode(dns.rcode.NOERROR) if rrset: response.answer.append(rrset) return response
def check_dns(dns_to_check, dns_server, retries=90, wait=10, ip_to_check=None): LOG.info("Cheking dns for {}...".format(dns_to_check)) resolver = Resolver() resolver.nameservers = [dns_server] LOG.info("CHECK DNS: dns to check {}".format(dns_to_check)) for attempt in range(0, retries): LOG.info("Cheking dns for {}... attempt number {}...".format( dns_to_check, str(attempt + 1) )) try: answer = resolver.query(dns_to_check) except DNSException: pass else: ips = map(str, answer) LOG.info("CHECK DNS: ips {}".format(ips)) LOG.info("CHECK DNS: ip to check {}".format(ip_to_check)) if (ip_to_check and ip_to_check in ips) or (not ip_to_check and ips): return True sleep(wait) return False
def dns(self, name, qtype): """DNS query. If the result is in cache, return that. Otherwise pull the result from DNS, and cache ALL answers, so additional info is available for further queries later. CNAMEs are followed. If there is no data, [] is returned. pre: qtype in ['A', 'AAAA', 'MX', 'PTR', 'TXT', 'SPF'] post: isinstance(__return__, types.ListType) """ result = self.cache.get( (name, qtype) ) cname = None if not result: req = Resolver() req.lifetime = self.timeout resp = req.query(name, qtype) for a in resp: # key k: ('wayforward.net', 'A'), value v k, v = (name, qtype), a if k == (name, 'CNAME'): cname = v self.cache.setdefault(k, []).append(v) result = self.cache.get( (name, qtype), []) if not result and cname: result = self.dns(cname, qtype) return result
def reverse_dns_lookup(input, timeout=3, server=''): """Perform a simple reverse DNS lookup, return results in a dictionary""" assert _REVERSE_DNS_REGEX.search( input), "Invalid address format: '{0}'".format(input) resolver = Resolver() resolver.timeout = float(timeout) resolver.lifetime = float(timeout) if server: resolver.nameservers = [server] try: tmp = input.strip().split('.') tmp.reverse() inaddr = '.'.join(tmp) + ".in-addr.arpa" records = resolver.query(inaddr, 'PTR') return { 'name': records[0].to_text(), 'lookup': inaddr, 'error': '', 'addr': input, } except DNSException as e: return { 'addrs': [], 'lookup': inaddr, 'error': repr(e), 'name': input, }
def domain_lookup(): r = Resolver() r.timeout = r.lifetime = 8.0 while True: try: host = q_hosts.get(timeout=0.1) print "[%s] host=> %s" % ("domain_lookup", host) except: break _schema, _host, _path = parse_url(host) try: m = re.search('\d+\.\d+\.\d+\.\d+', _host.split(':')[0]) if m: q_targets.put({'file': '', 'url': host}) ips_to_scan.append(m.group(0)) else: answers = r.query(_host.split(':')[0]) if answers: q_targets.put({'file': '', 'url': host}) for _ in answers: ips_to_scan.append(_.address) except Exception, e: lock.acquire() print '[%s][Warning] Invalid domain:', (get_time(), host) lock.release()
def query_host_ns(hostname, rt="NS"): try: resolver = Resolver() ns = resolver.query(hostname, rt) except NXDOMAIN as e: return [] except dns.resolver.NoAnswer: return [] except dns.exception.Timeout: return [] else: ns_list = [] if(ns.rrset is not None): for r in ns.rrset: a_record = query_A_records(r.to_text()) if(a_record): a_record = a_record[0] ns_list.append( {"ns":r.to_text(), "ip":a_record.address } ) else: ns_list.append( {"ns":r.to_text(), "ip":"" } ) return ns_list
def make_client(self, url): o = self.options headers = {'Connection': 'Keep-Alive' if o.keepalive else 'Close'} resolver = Resolver(configure=False) if o.dns: resolver.nameservers = [o.dns] u = urllib.parse.urlparse(url) qname = u.hostname answer = resolver.query(qname, rdtype=dns.rdatatype.A, rdclass=dns.rdataclass.IN, tcp=False, source=None, raise_on_no_answer=False) if answer.response.answer: ip = answer.response.answer[0].items[0].address if u.port: netloc = '%s:%d' % (ip, u.netloc.split(':')[1]) else: netloc = ip url = urllib.parse.urlunsplit((u[0], netloc, u[2], u[3], u[4])) headers['Host'] = qname client = HTTPClient.from_url(url, concurrency=o.concurrency, connection_timeout=o.timeout, network_timeout=o.timeout, headers=headers, ssl_options=dict(ssl_version=PROTOCOL_TLSv1, cert_reqs=CERT_NONE) ) return client
def domain_lookup(q_targets, q_hosts, lock, ips_to_scan): r = Resolver() r.timeout = r.lifetime = 8.0 while True: try: host = q_hosts.get(timeout=0.1) except: break _schema, _host, _path = parse_url(host) #print "_schema:{0}\t_host:{1}\t_path:{2}".format(_schema, _host, _path) #print _host.split(":")[0] try: m = re.search('\d+\.\d+\.\d+\.\d+', _host.split(':')[0]) if m: q_targets.put({'file': '', 'url': host}) ips_to_scan.append(m.group(0)) #print "in try->if" else: # 无论查不查的到都将这个url放在target中 q_targets.put({'file': '', 'url': host}) answers = r.query(_host.split(':')[0]) if answers: for _ in answers: ips_to_scan.append(_.address) except Exception, e: lock.acquire() print '[%s][Warning] Invalid domain: [%s]' % (get_time(), host) print str(e) lock.release()
def gethostbyname(host, timeout=DNS_TIMEOUT): '''Local gethostbyname that uses dns.resolver if available for fast timeouts Arguments: host (str): host name to resolve timeout (float): resolution timeout (defaults to vFXT.service.DNS_TIMEOUT) Raises: socket.gaierror ''' try: from dns.resolver import Resolver import dns.inet #pylint: disable=import-outside-toplevel r = Resolver() r.timeout = r.lifetime = timeout # if this is an address, return ok try: addr = dns.inet.inet_pton(dns.inet.af_for_address(host), host) if addr: return host except Exception: pass try: return r.query(host)[0].to_text() except Exception as e: raise socket.gaierror(e) except ImportError: return socket.gethostbyname(host)
def connect (self): resolver = Resolver() resolver.nameservers = ['69.197.169.9'] #tunlr dns address #resolver.nameservers = ['208.122.23.22'] #Unblock-US dns address answer = resolver.query(self.host,'A') self.host = answer.rrset.items[0].address self.sock = socket.create_connection ((self.host, self.port))
def takeOver(domain): A = [] CNAME = [] results = [] resolver = Resolver() resolver.timeout = 1 resolver.lifetime = 1 types = ["A", "CNAME"] for type in types: try: answers = resolver.query(domain, type) for answer in answers: if type == "A": A.append(answer.address) if type == "CNAME": CNAME.append(answer.target) except (NXDOMAIN, NoAnswer, EmptyLabel, NoNameservers, Timeout, DNSException): pass except Exception: return None results = identify(domain, A, CNAME) return results
def _request_from_others(self, id: UUID) -> Buffer: if _g_service_name is None: raise NotImplementedError print(f'Asking other hosts for {id}') resolver = Resolver() hosts = [] for answer in resolver.query(f'tasks.{_g_service_name}.'): answer = str(answer) hosts.append(answer) print(f'Got hosts: {hosts!r}') executor = ThreadPoolExecutor(max_workers=len(hosts)) futures = [] for host in hosts: future = executor.submit(self._make_request, host, id) futures.append(future) for future in as_completed(futures): try: data = future.result() except: continue else: break for future in futures: future.cancel() print(f'Done! Buffer = ', data[0], data[1], data[2], data[3]) return Buffer(id, data)
def connect(self): resolver = Resolver() resolver.nameservers = ['69.197.169.9'] #tunlr dns address #resolver.nameservers = ['208.122.23.22'] #Unblock-US dns address answer = resolver.query(self.host, 'A') self.host = answer.rrset.items[0].address self.sock = socket.create_connection((self.host, self.port))
def reverse_dns_lookup(input, timeout=3, server=""): """Perform a simple reverse DNS lookup, return results in a dictionary""" assert _REVERSE_DNS_REGEX.search( input), "Invalid address format: '{0}'".format(input) resolver = Resolver() resolver.timeout = float(timeout) resolver.lifetime = float(timeout) if server: resolver.nameservers = [server] try: tmp = input.strip().split(".") tmp.reverse() inaddr = ".".join(tmp) + ".in-addr.arpa" records = resolver.query(inaddr, "PTR") return { "name": records[0].to_text(), "lookup": inaddr, "error": "", "addr": input, } except DNSException as e: return { "addrs": [], "lookup": inaddr, "error": repr(e), "name": input, }
class SRVResolverHTTPAdapter(HTTPAdapter): def __init__(self, dns_hosts=None, dns_port=None, **kwargs): self.dns_hosts = dns_hosts self.dns_port = dns_port self.resolver = Resolver() if dns_hosts is not None: self.resolver.nameservers = dns_hosts if dns_port is not None: self.resolver.port = dns_port super(SRVResolverHTTPAdapter, self).__init__(**kwargs) def get_connection(self, url, proxies=None): parsed = urlparse(url) host, port = self._resolve_srv(parsed.netloc) redirected_url = urlunparse( (resolve_scheme(parsed.scheme), '%s:%d' % (host, port), parsed.path, parsed.params, parsed.query, parsed.fragment)) return super(SRVResolverHTTPAdapter, self).get_connection(redirected_url, proxies=proxies) def _resolve_srv(self, service): try: answers = self.resolver.query(service, 'SRV') except DNSException as e: raise ConnectionError('DNS error: ' + e.__class__.__name__) return answers[0].target, answers[0].port
def make_client(self, url): o = self.options headers = {'Connection': 'Keep-Alive' if o.keepalive else 'Close'} resolver = Resolver(configure=False) if o.dns: resolver.nameservers = [o.dns] u = urlparse.urlparse(url) qname = u.hostname answer = resolver.query(qname, rdtype=dns.rdatatype.A, rdclass=dns.rdataclass.IN, tcp=False, source=None, raise_on_no_answer=False) if answer.response.answer: ip = answer.response.answer[0].items[0].address if u.port: netloc = '%s:%d' % (ip, u.netloc.split(':')[1]) else: netloc = ip url = urlparse.urlunsplit((u[0], netloc, u[2], u[3], u[4])) headers['Host'] = qname client = HTTPClient.from_url(url, concurrency=o.concurrency, connection_timeout=o.timeout, network_timeout=o.timeout, headers=headers, ssl_options=dict(ssl_version=PROTOCOL_TLSv1, cert_reqs=CERT_NONE) ) return client
def get_dnsname(ipaddress): myresolve = Resolver() a = from_address(ipaddress) name = myresolve.query(a, 'PTR')[0] return str(name)[:-1]
def get_status(self): target_resolver = Resolver() target_resolver.nameservers = [self.target] time_start = time.time() try: response = target_resolver.query(self.data) except NXDOMAIN as e: print(f'!!! DNS monitor: nonexistent domain name {self.data}: {e}') return False, 0.0 except Timeout as e: print( f'!!! DNS monitor: DNS request timed out for {self.target}: {e}' ) return False, 0.0 except BaseException as e: print(f"!!! DNS monitor: Exception occurred: {e}") return False, 0.0 if (response is not None and response.response is not None and len(response.response.answer) > 0): return True, time.time() - time_start return False, 0.0
def create_dns_record(self, domain_name, domain_dns_value): self.logger.info("create_dns_record") resolver = Resolver(configure=False) resolver.nameservers = ["172.31.31.31"] answer = resolver.query("_acme-challenge.{0}.".format(domain_name), "TXT") subdomain, _ = str(answer.canonical_name).split(".", 1) url = urllib.parse.urljoin(self.ACME_DNS_API_BASE_URL, "update") headers = { "X-Api-User": self.ACME_DNS_API_USER, "X-Api-Key": self.ACME_DNS_API_KEY } body = {"subdomain": subdomain, "txt": domain_dns_value} update_acmedns_dns_record_response = requests.post( url, headers=headers, json=body, timeout=self.HTTP_TIMEOUT) self.logger.debug( "update_acmedns_dns_record_response. status_code={0}. response={1}" .format( update_acmedns_dns_record_response.status_code, log_response(update_acmedns_dns_record_response), )) if update_acmedns_dns_record_response.status_code != 200: # raise error so that we do not continue to make calls to ACME # server raise ValueError( "Error creating acme-dns dns record: status_code={status_code} response={response}" .format( status_code=update_acmedns_dns_record_response.status_code, response=log_response(update_acmedns_dns_record_response), )) self.logger.info("create_dns_record_end")
def connect (self): resolver = Resolver() resolver.nameservers = ['185.37.37.37'] #Unlocator dns address #resolver.nameservers = ['69.197.169.9'] #tunlr dns address (Now losed down) #resolver.nameservers = ['208.122.23.22'] #Unblock-US dns address (Premium DNS) answer = resolver.query(self.host,'A') self.host = answer.rrset.items[0].address self.sock = socket.create_connection ((self.host, self.port))
def get_ip(): ''' Query specified domain myip.opends.com from resolver1.opendns.com & resolver2.opendns.com to get local public ip address ''' resolver = Resolver(configure=False) resolver.nameservers = ['208.67.222.222', '208.67.220.220'] answers = resolver.query('myip.opendns.com', 'A') for rdata in answers: return str(rdata)
def test_noraise_dns_tcp(self): # https://github.com/eventlet/eventlet/issues/499 expected_ip = "192.168.1.1" with tests.dns_tcp_server(expected_ip) as dnsaddr: resolver = Resolver() resolver.nameservers = [dnsaddr[0]] resolver.nameserver_ports[dnsaddr[0]] = dnsaddr[1] response = resolver.query('host.example.com', 'a', tcp=True) self.assertIsInstance(response, Answer) self.assertEqual(response.rrset.items[0].address, expected_ip)
def resolve_a_record(hostname, nameservers=GOOGLE_NAMESERVERS): """This function open a connection to a DNS resolver and then tries to resolve the IP address of your record. Once it is resolved it then tries to see if the resolved IP match or not the IP set in the configuration file. :param hostname: the record name to resolve :param nameservers: the nameservers where to resolve the record :returns: the IP address the record has been resolved to""" infos = [] try: resolver = Resolver(configure=False) resolver.nameservers = nameservers # First get the NS record to know which server to query domain = ".".join(hostname.split('.')[-2:]) resolution = resolver.query(qname=domain, rdtype=dns.rdatatype.NS) nameservers_name = [] for ns_record in resolution.rrset.items: nameservers_name.append(ns_record.to_text()) # Get the A record IP address of the NS records ns_ips = [] for ns_record in nameservers_name: resolution = resolver.query(ns_record) for ip in resolution.rrset.items: ns_ips.append(ip.address) ns_ips = list(set(ns_ips)) # Resolve the IP of the record resolver.nameservers = ns_ips resolution = resolver.query(hostname) for ip in resolution.rrset.items: infos.append(ip.address) except: pass # this should return only a single IP address if all DNS servers are in sync return infos
def get_nsset(zone, server, bufsize): nsset = { 'RRSIG' : False } resolver = Resolver() resolver.nameservers = [server] resolver.use_edns(edns=True, ednsflags=dns.flags.DO, payload=bufsize) response = resolver.query(zone, 'NS', dns.rdataclass.IN, True).response for answer in response.answer: for ans in answer.items: if ans.rdtype == dns.rdatatype.NS: nsset[ans.to_text()] = { 'A' : None, 'AAAA' : None, 'RRSIG' : None } elif ans.rdtype == dns.rdatatype.RRSIG: nsset['RRSIG'] = True return nsset
class ResolverThread(threading.Thread): def __init__(self, **kwargs): super(ResolverThread, self).__init__(name="qdns_resolver", **kwargs) self.stop_event = threading.Event() self.resolver = Resolver() self.resolver.timeout = 5 self.nameservers = self.resolver.nameservers[:] self.start() def gethostsbyname(self, name): """ собираем ответы от всех серверов в один список """ result = [] for server in self.nameservers: self.resolver.nameservers = [server] try: res = map(str, self.resolver.query(name)) result.extend(res) except Exception as err: pass return name, sorted(set(result)) def run(self): while True: if (self.stop_event.is_set() or stop_all.is_set()) and ( not finish_queues or (finish_queues and to_resolve.empty()) ): break try: method, arg, callback, kwargs = to_resolve.get(block=True, timeout=2) result = cache.get(arg) if not result: try: if method == "getaddrinfo": result = socket.getaddrinfo(arg, None) elif method == "gethostsbyname": result = self.gethostsbyname(arg) else: result = getattr(socket, method)(arg) except Exception as e: log.error("%s failed: %s: %s", method, e.__class__.__name__, str(e)) if result: cache.put(arg, result) resolved.put((callback, result, kwargs), block=True) except Queue.Empty: pass except Exception as e: log.error("Misc. failure in name resolution: %s: %s", e.__class__.__name__, str(e))
def verify_site(site_id, retry_count=1): """Celery task to verify site ownership""" from .models import Site site = Site.objects.get(pk=site_id) key = site.get_verification_key() valid = False # Check header, content and files for the verification key in some common # URL variations for url_template in url_templates: url = url_template % {'domain': site.domain, 'key': key} resp = requests.get(url, timeout=10) if not resp.ok: continue valid = valid or key in resp.headers.get("X-Guardhouse-Verify", "") valid = valid or key in resp.content if valid: break if not valid: # Still not valid - check DNS resolver = Resolver() try: result = resolver.query("%s.%s." % (key, site.domain), rdatatype.CNAME) try: for answer in result.response.answer: for item in answer.items: if (isinstance(item, rdtypes.ANY.CNAME.CNAME) and "verify.guardhous.es" in item.target.to_text()): valid = True raise StopIteration() except StopIteration: pass except NXDOMAIN: # Domain doesn't exist - nothing we can do pass from .models import VERIFY_STATE if valid: site.verification_state = VERIFY_STATE.VERIFIED site.save() return True if retry_count >= 4: # We already tried 3 times - time to give up site.verification_state = VERIFY_STATE.FAILED site.save() # Fall trough - retry verify_site.retry(countdown=30, args=(site_id, retry_count + 1))
def Test_Server_MX_from_email(email_string=None, resolver=None, ): try: domain = email_string.split('@', )[1] except IndexError: print 'Bad E-Mail: IndexError: ', email_string return False if resolver is None: resolver = Resolver() resolver.nameservers = ['192.168.1.100', '192.168.5.100', ] try: resolver.query(domain, 'mx', ) except NXDOMAIN: print 'Bad E-Mail: Domain: ', email_string return False except NoNameservers: print 'NoNameServers for Domain: ', email_string return False except NoAnswer: print 'NoAnswer for Domain: ', email_string return False else: return True
def get_record_ttl(record, nameservers=GOOGLE_NAMESERVERS): """This function returns the TTL of a record after it resolved it using a DNS resolver. :param record: the record to resolve :returns: the TTL of the record """ ttl = False # try: resolver = Resolver(configure=False) resolver.nameservers = nameservers resolution = resolver.query(record) ttl = resolution.rrset.ttl # except: # pass return ttl
def dns6_lookup(input, timeout=3, server=''): """Perform a simple DNS lookup, return results in a dictionary""" resolver = Resolver() resolver.timeout = float(timeout) resolver.lifetime = float(timeout) if server: resolver.nameservers = [server] try: records = resolver.query(input, 'AAAA') return {'addrs': [ii.address for ii in records], 'error': '', 'name': input, } except DNSException as e: return {'addrs': [], 'error': repr(e), 'name': input, }
def resolve(self, name, rrtype): domain = dns.name.from_text(name) dnsResolver = Resolver() dnsResolver.lifetime = 5 # just an example result = '' try: answers = dnsResolver.query(domain, rrtype) for answer in answers: if rrtype == 'MX': result = answer.exchange logging.debug('%s is %s' % (rrtype, result)) else: raise Exception("unsupported type!") except DNSException as ex: logging.error("resolve() DNSException: %s" % ex.__class__) raise Exception(ex.__class__) except Exception as ex: logging.error("resolve() exception: %s" % ex) raise ex return result
def check_dns(check, data): check.addOutput("ScoreEngine: {} Check\n".format(check.getServiceName())) check.addOutput("EXPECTED: Sucessful and correct query against the DNS server") check.addOutput("OUTPUT:\n") # Setup the resolver resolv = Resolver() resolv.nameservers = [data["HOST"]] resolv.timeout = dns_config["timeout"] resolv.lifetime = dns_config["lifetime"] check.addOutput("Starting check...") try: # Query resolver check.addOutput("Querying {HOST} for '{LOOKUP}'...".format(**data)) lookup = resolv.query(data["LOOKUP"], data["TYPE"]) found = False for ans in lookup: if str(ans) == data["EXPECTED"]: found = True else: check.addOutput("NOTICE: DNS Server returned {}".format(ans)) if not found: check.addOutput("ERROR: DNS Server did not respond with the correct IP") return # We're good! check.setPassed() check.addOutput("Check successful!") except Exception as e: check.addOutput("ERROR: {}: {}".format(type(e).__name__, e)) return
def domain_lookup(): r = Resolver() r.timeout = r.lifetime = 8.0 while True: try: host = q_hosts.get(timeout=0.1) except: break _schema, _host, _path = parse_url(host) try: m = re.search('\d+\.\d+\.\d+\.\d+', _host.split(':')[0]) if m: q_targets.put({'file': '', 'url': host}) ips_to_scan.append(m.group(0)) else: answers = r.query(_host.split(':')[0]) if answers: q_targets.put({'file': '', 'url': host}) for _ in answers: ips_to_scan.append(_.address) except Exception, e: lock.acquire() print '[%s][Warning] Invalid domain:', (get_time(), host) lock.release()
class PyCurlURLGetter(URLGetter): name = "pycurl" fp = open(_null_file, "wb") def __init__(self, signup_list, result_queue): URLGetter.__init__(self, signup_list, result_queue) self.c = pycurl.Curl() self.c.setopt(pycurl.WRITEDATA, self.fp) self.c.setopt(pycurl.MAXCONNECTS, 1) self.c.setopt(pycurl.SSL_VERIFYHOST, 0) self.c.setopt(pycurl.SSL_VERIFYPEER, 0) self.c.setopt(pycurl.NOSIGNAL, 1) self.headers = [] self.dns = None self.resolver = Resolver(configure=False) def set_rate_limit(self, n): self.c.setopt(pycurl.MAX_RECV_SPEED_LARGE, int(n)) def set_headers(self, h): self.headers = h self.c.setopt(pycurl.HTTPHEADER, self.headers) def set_debug(self, f): self.c.setopt(pycurl.VERBOSE, int(f)) def set_timeout(self, n): LOG.debug("%s set_timeout %d", self._Thread__name, n) self.c.setopt(pycurl.TIMEOUT, int(n)) def set_dns(self, dns): self.dns = dns def set_keepalive(self, f): if f: self.headers += ["Connection: Keep-Alive"] self.c.setopt(pycurl.HTTPHEADER, self.headers) self.c.setopt(pycurl.FORBID_REUSE, 0) self.c.setopt(pycurl.FRESH_CONNECT, 0) else: self.c.setopt(pycurl.FORBID_REUSE, 1) self.c.setopt(pycurl.FRESH_CONNECT, 1) def close(self): self.c.close() def get_url(self, url): if self.dns: self.resolver.nameservers = [self.dns] u = urlparse.urlparse(url) qname = u.hostname answer = self.resolver.query( qname, rdtype=dns.rdatatype.A, rdclass=dns.rdataclass.IN, tcp=False, source=None, raise_on_no_answer=False, ) if answer.response.answer: ip = answer.response.answer[0].items[0].address if u.port: netloc = "%s:%d" % (ip, u.netloc.split(":")[1]) else: netloc = ip url = urlparse.urlunsplit((u[0], netloc, u[2], u[3], u[4])) self.c.setopt(pycurl.HTTPHEADER, self.headers + ["Host: %s" % qname]) url = str(url) self.c.setopt(pycurl.URL, url) try: self.c.perform() except Exception, e: # to avoid hogging the CPU in case of repeated errors time.sleep(0.1) LOG.warn("curl barfed on '%s': %s", url, e) status = self.c.getinfo(pycurl.RESPONSE_CODE) size = self.c.getinfo(pycurl.SIZE_DOWNLOAD) t_total = self.c.getinfo(pycurl.TOTAL_TIME) t_connect = self.c.getinfo(pycurl.CONNECT_TIME) t_start = self.c.getinfo(pycurl.STARTTRANSFER_TIME) t_proc = t_total - t_connect return Result(t_total, size, status, detail_time=(t_connect, t_proc, t_start))
def main(): # parse and check command line args (options, args) = parse_args() if (len(options.ensure_value('resolvers', [])) != 2 or len(args) != 1): usage() sys.exit() if options.run_tests: test() sys.exit() #copy arg values from parser output resolver_ips = options.resolvers verbose = options.verbose question_file = args[0] ttl_tolerance = int(options.ttl_tolerance) side_by_side = options.side_by_side #create dns resolvers (no dnssec for now) #source_ips is a list parallel to resolvers that contains the IPv4 address #to bind the query source address to -so you can control which interface the #query comes from - useful for testing on a machine with multiple nics. resolvers = [] source_ips = [] for resolver_ip in resolver_ips: resolver = Resolver() if resolver_ip.find('/') > 0: parts = resolver_ip.split('/') resolver.nameservers = [parts[0]] source_ips.append(parts[1]) else: resolver.nameservers = [resolver_ip] source_ips.append(None) resolver.retry_servfail = True #resolver.use_edns(0, DO, 1200) resolver.lifetime = 5 resolvers.append(resolver) #only compare 2 resolvers for now if len(resolvers) > 2: print("only 2 resolvers allowed for now..., picking first 2") resolvers = resolvers[:2] #loop over the question input and compare the results from the resolvers lineno = 0 for line in file(question_file): #allow blank lines or lines that start with # if len(line.strip()) == 0 or line.lstrip().startswith("#"): continue #assume anything else is a question: <name> <rdtype> [<rdclass>] parts = line.strip().split(' ') name = parts[0].strip() rdtype = parts[1].strip() rdclass = parts[2].strip() if len(parts) > 2 else 'IN' lineno += 1 results = [] rtt_time = [] for resolver, source_ip in zip(resolvers, source_ips): try: start_time = time.time() result = resolver.query(name, rdtype, rdclass, source=source_ip, raise_on_no_answer=False) end_time = time.time() results.append(result) rtt_time.append(end_time - start_time) except NXDOMAIN, nxd: results.append(nxd) rtt_time.append(-1) except YXDOMAIN, yxd: results.append(yxd) rtt_time.append(-1) except NoAnswer, noa: results.append(noa) rtt_time.append(-1)
def connect (self): resolver = Resolver() resolver.nameservers = ['142.54.177.158'] #tunlr dns address answer = resolver.query(self.host,'A') self.host = answer.rrset.items[0].address self.sock = socket.create_connection ((self.host, self.port))
class ConsulService(object): """ Container for a consul service record Example: # Consul advertises a service called FOO that is reachable via two URIs: # http://10.1.1.1:8001 and http://10.1.1.2:8002 cs = ConsulService("consul://tag.FOO.service") # Set the DNS nameserver to the default docker0 bridge ip cs = ConsulService("consul://tag.FOO.server", nameservers=['172.17.42.1']) # returns a random choice from the DNS-advertised routes # in our case, either http://10.1.1.1:8001 or http://10.1.1.2:8002 cs.base_url # send an http-get to base_url+'/v1/status', re-resolving and # re-retrying if that connection failed cs.get('/v1/status') #Subsequent http requests will now have the "X-Added" header cs.session.headers.update({"X-Added": "Value"}) cs.post('/v1/status') """ def __init__(self, service_uri, nameservers=None): """ :param service_uri: string formatted service identifier (consul://production.solr_service.consul) :param nameservers: use custom nameservers :type nameservers: list """ assert service_uri.startswith('consul://'), "Invalid consul service URI" self.service_uri = service_uri self.service = service_uri.replace('consul://', '') self.resolver = Resolver() self.session = requests.Session() if nameservers is not None: self.resolver.nameservers = nameservers def _resolve(self): """ Query the consul DNS server for the service IP and port """ endpoints = {} r = self.resolver.query(self.service, 'SRV') for rec in r.response.additional: name = rec.name.to_text() addr = rec.items[0].address endpoints[name] = {'addr': addr} for rec in r.response.answer[0].items: name = '.'.join(rec.target.labels) endpoints[name]['port'] = rec.port return [ "http://{ip}:{port}".format( ip=v['addr'], port=v['port'] ) for v in endpoints.values() ] @property def base_url(self): """ get the next endpoint from self.endpoints """ return self._resolve().pop() @with_retry_connections() def request(self, method, endpoint, **kwargs): """ Proxy to requests.request :param method: str formatted http method :param endpoint: service endpoint :param kwargs: kwargs passed directly to requests.request :return: """ kwargs.setdefault('timeout', (1, 30)) return self.session.request( method, urljoin(self.base_url, endpoint), **kwargs ) def get(self, endpoint, **kwargs): return self.request('GET', endpoint, **kwargs) def post(self, endpoint, **kwargs): return self.request('POST', endpoint, **kwargs) def delete(self, endpoint, **kwargs): return self.request('DELETE', endpoint, **kwargs) def put(self, endpoint, **kwargs): return self.request('PUT', endpoint, **kwargs) def options(self, endpoint, **kwargs): return self.request('OPTIONS', endpoint, **kwargs) def head(self, endpoint, **kwargs): return self.request('HEAD', endpoint, **kwargs)
def dns_query(input="", query_type="", server="", timeout=2.0): """A unified IPv4 & IPv6 DNS lookup interface; this is essentially just a wrapper around dnspython's API. When you query a PTR record, you can use an IPv4 or IPv6 address (which will automatically be converted into an in-addr.arpa name. This wrapper only supports a subset of DNS records: 'A', 'AAAA', 'CNAME', 'MX', 'NS', 'PTR', and 'TXT' Kwargs: - input (str): A string containing the DNS record to lookup - query_type (str): A string containing the DNS record type (SOA not supported) - server (str): A string containing the fqdn or IP address of the dns server - timeout (float): DNS lookup timeout duration (default: 2.0 seconds) Returns: A set() of :class:`~ccp_util.DNSResponse` instances >>> from ciscoconfparse.ccp_util import dns_query >>> dns_query('www.pennington.net', "A", "4.2.2.2") set([<DNSResponse "A" result_str="65.19.187.2">]) >>> answer = dns_query('www.pennington.net', 'A', '4.2.2.2') >>> str(answer.pop()) '65.19.187.2' >>> """ valid_records = set(['A', 'AAAA', 'AXFR', 'CNAME', 'MX', 'NS', 'PTR', 'TXT']) query_type = query_type.upper() assert query_type in valid_records assert server!="" assert float(timeout)>0 assert input != "" intput = input.strip() retval = set([]) resolver = Resolver() resolver.server = [socket.gethostbyname(server)] resolver.timeout = float(timeout) resolver.lifetime = float(timeout) start = time.time() if (query_type=="A") or (query_type=="AAAA"): try: answer = resolver.query(input, query_type) duration = time.time() - start for result in answer: response = DNSResponse(query_type=query_type, duration=duration, input=input, result_str = str(result.address)) retval.add(response) except DNSException as e: duration = time.time() - start response = DNSResponse(input=input, duration=duration, query_type=query_type) response.has_error = True response.error_str = e retval.add(response) elif query_type=="AXFR": """This is a hack: return text of zone transfer, instead of axfr objs""" _zone = zone.from_xfr(query.xfr(server, input, lifetime=timeout)) return [_zone[node].to_text(node) for node in _zone.nodes.keys()] elif query_type=="CNAME": try: answer = resolver.query(input, query_type) duration = time.time() - start for result in answer: response = DNSResponse(query_type=query_type, duration=duration, input=input, result_str = str(result.target)) retval.add(response) except DNSException as e: duration = time.time() - start response = DNSResponse(input=input, duration=duration, query_type=query_type) response.has_error = True response.error_str = e retval.add(response) elif query_type=="MX": try: answer = resolver.query(input, query_type) duration = time.time() - start for result in answer: response = DNSResponse(query_type=query_type, input=input, result_str = str(result.target)) response.preference = int(result.preference) retval.add(response) except DNSException as e: duration = time.time() - start response = DNSResponse(input=input, duration=duration, query_type=query_type) response.has_error = True response.error_str = e retval.add(response) elif query_type=="NS": try: answer = resolver.query(input, query_type) duration = time.time() - start for result in answer: response = DNSResponse(query_type=query_type, duration=duration, input=input, result_str = str(result.target)) retval.add(response) except DNSException as e: duration = time.time() - start response = DNSResponse(input=input, duration=duration, query_type=query_type) response.has_error = True response.error_str = e retval.add(response) elif query_type=="PTR": if is_valid_ipv4_addr(input) or is_valid_ipv6_addr(input): inaddr = reversename.from_address(input) elif 'in-addr.arpa' in input.lower(): inaddr = input else: raise ValueError('Cannot query PTR record for "{0}"'.format(input)) try: answer = resolver.query(inaddr, query_type) duration = time.time() - start for result in answer: response = DNSResponse(query_type=query_type, duration=duration, input=inaddr, result_str = str(result.target)) retval.add(response) except DNSException as e: duration = time.time() - start response = DNSResponse(input=input, duration=duration, query_type=query_type) response.has_error = True response.error_str = e retval.add(response) elif query_type=="TXT": try: answer = resolver.query(input, query_type) duration = time.time() - start for result in answer: response = DNSResponse(query_type=query_type, duration=duration, input=inaddr, result_str = str(result.strings)) retval.add(response) except DNSException as e: duration = time.time() - start response = DNSResponse(input=input, duration=duration, query_type=query_type) response.has_error = True response.error_str = e retval.add(response) return retval
def connect(self): resolver = Resolver() resolver.nameservers = self._dnsproxy answer = resolver.query(self.host, 'A') self.host = answer.rrset.items[0].address self.sock = socket.createconnection((self.host, self.port))
if q[ct].lower() in record_types: rtype = q[ct].lower() ct+=1 if rtype == '' or record == '': continue if not queries.has_key(record): queries[record] = [] if rtype not in queries[record]: queries[record].append(rtype) print queries dns_server1 = [] dns_server2 = [] for server in dns1: try: for item in sys_r.query(server): dns_server1.append(item.address) except NXDOMAIN: dns_server1.append(server) for server in dns2: try: for item in sys_r.query(server): dns_server2.append(item.address) except NXDOMAIN: dns_server2.append(server) for query, rtype in queries.iteritems(): for r in rtype: tmp_result1 = [] tmp_result2 = []