def checkTXTRecord(query_domain, main_domain):
time.sleep(SLEEP)
dns_list = []
resolver = dns.resolver.Resolver(configure=False)
resolver.nameservers = ['8.8.8.8']
answers = dns.resolver.resolve(main_domain, 'NS')
for rdata in answers:
rdata = str(rdata)[:-1]
dns_list.append(rdata)
dns_list.sort()
new_dns_list = []
resolver = dns.resolver.Resolver(configure=False)
for item in dns_list:
answers = dns.resolver.resolve(item, 'A')
for rdata in answers:
rdata = str(rdata)
new_dns_list.append(rdata)
resolver = dns.resolver.Resolver(configure=False)
i = 1
dns_size = len(dns_list)
for server in dns_list:
resolver.nameservers = [server]
try:
resolver.resolve(f'_acme-challenge.{query_domain}', 'TXT')
return True
except dns.resolver.NXDOMAIN as err:
if i >= dns_size:
return False
i += 1
pass
def main():
parser = argparse.ArgumentParser()
parser.add_argument('commandfile', metavar='c', type=str, help='Command file')
args = parser.parse_args()
resolver = Resolver()
with open(args.commandfile, 'r') as f:
for line in f:
print('COMMAND: ' + line)
line = line.split(sep=' ')
cmd = line[0]
if cmd != 'quit':
arg1 = line[1]
if cmd == 'print' and arg1 == 'cache\n':
resolver.printcache()
elif cmd == 'resolve':
domain = arg1
record = line[2].replace('\n', '')
resolver.resolve(domain, record)
else:
print('Unknown command.\n')
print('***************************************************\n')
else:
print('Program terminated\n')
exit(0)
def ping(resolver, hostname, dnsrecord, ttl, src_ip, use_edns=False):
global _ttl
reached = False
dns.query.socket_factory = CustomSocket
_ttl = ttl
if use_edns:
resolver.use_edns(edns=0, payload=8192, ednsflags=dns.flags.edns_from_text('DO'))
try:
resolver.resolve(hostname, dnsrecord, source=src_ip, raise_on_no_answer=False)
except dns.resolver.NoNameservers as e:
if not quiet:
print("no or bad response:", e)
sys.exit(1)
except dns.resolver.NXDOMAIN as e:
if not quiet:
print("Invalid hostname:", e)
sys.exit(1)
except dns.resolver.Timeout:
pass
except dns.resolver.NoAnswer:
if not quiet:
print("invalid answer")
except SystemExit:
pass
except Exception as e:
print("unxpected error: ", e)
sys.exit(1)
else:
reached = True
return reached
def trace(self, name, rdtype=dns.rdatatype.A):
if isinstance(rdtype,basestring):
rdtype = dns.rdatatype.from_text(rdtype)
if self.name == '.' and not self.resolvers:
self.find_root_resolvers()
if not name.endswith('.'):
name += '.'
for resolver in sorted(self.resolvers.values(), key=lambda x: x.name):
resolver.resolve(name, rdtype=rdtype)
def trace(self, name, rdtype=dns.rdatatype.A):
if isinstance(rdtype, basestring):
rdtype = dns.rdatatype.from_text(rdtype)
if self.name == '.' and not self.resolvers:
self.find_root_resolvers()
if not name.endswith('.'):
name += '.'
for resolver in sorted(self.resolvers.values(), key=lambda x: x.name):
resolver.resolve(name, rdtype=rdtype)
def get_dnstime(fqdn):
dns_start = time.time()
resolver = dns.resolver.Resolver(configure=False)
resolver.nameservers = ['8.8.8.8', '8.8.4.4', '1.1.1.1']
try:
resolver.resolve(fqdn, 'A')
dns_time = time.time() - dns_start
except Exception as e:
print(e)
dns_time = None
return dns_time
def query_dns(domain, record_type, cache=None, nameservers=None, timeout=2.0):
"""
Queries DNS
Args:
domain (str): The domain or subdomain to query about
record_type (str): The record type to query for
cache (ExpiringDict): Cache storage
nameservers (list): A list of one or more nameservers to use
(Cloudflare's public DNS resolvers by default)
timeout (float): Sets the DNS timeout in seconds
Returns:
list: A list of answers
"""
domain = str(domain).lower()
record_type = record_type.upper()
cache_key = "{0}_{1}".format(domain, record_type)
if cache:
records = cache.get(cache_key, None)
if records:
return records
resolver = dns.resolver.Resolver()
timeout = float(timeout)
if nameservers is None:
nameservers = [
"1.1.1.1",
"1.0.0.1",
"2606:4700:4700::1111",
"2606:4700:4700::1001",
]
resolver.nameservers = nameservers
resolver.timeout = timeout
resolver.lifetime = timeout
if record_type == "TXT":
resource_records = list(
map(lambda r: r.strings,
resolver.resolve(domain, record_type, lifetime=timeout)))
_resource_record = [
resource_record[0][:0].join(resource_record)
for resource_record in resource_records if resource_record
]
records = [r.decode() for r in _resource_record]
else:
records = list(
map(lambda r: r.to_text().replace('"', '').rstrip("."),
resolver.resolve(domain, record_type, lifetime=timeout)))
if cache:
cache[cache_key] = records
return records
def fetch_ip_from_google():
ns_address, query_address = 'ns1.google.com', 'o-o.myaddr.l.google.com'
resolver = dns.resolver.Resolver(configure=True)
resp = resolver.resolve(ns_address)
ns_ip = resp[0].to_text()
resolver.nameservers = [ns_ip]
resp_two = resolver.resolve(query_address, 'TXT')
ip = resp_two[0].to_text()
ip = ip.replace('"', '')
return ip
def resolveDomain(dns_list):
time.sleep(SLEEP)
resolver = dns.resolver.Resolver(configure = False)
i = 1
dns_size = len(dns_list)
for server in dns_list:
resolver.nameservers = [server]
try:
resolver.resolve(f'_acme-challenge.{CERTBOT_DOMAIN}', 'TXT')
return True
except dns.resolver.NXDOMAIN as err:
if i >= dns_size:
return False
i += 1
pass
def is_ip_uptodate(self, ip: str, ipv6: str):
"""check if IP address is up-to-date
Some provider will block the domain, if they detect to many update requests
without changes.
A nameserver of the provider should be set because it will be updated fast. This
method compare the ip address of the nameserver with the actual ip address.
Args:
ip (str): actual IPv4 address
ipv6 (str): actual IPv6 address
Returns:
bool: True, if IP address is uptodate
"""
resolver = dns.resolver.Resolver()
if "Nameservers" in self.Config.keys():
nameservers = self.Config["Nameservers"].split(",")
for ns in nameservers:
for record in ["A", "AAAA"]:
try:
nsips = dns.resolver.resolve(ns, record)
for nsip in nsips:
resolver.nameservers.insert(0, nsip.to_text())
except dns.resolver.NXDOMAIN:
self.log.warning("nameserver %s does not exist", ns)
except dns.resolver.NoAnswer:
pass
name = self.Config["Name"]
if ip:
try:
answers = resolver.resolve(name, "A")
if not str(answers[0]) == ip:
return False
except dns.resolver.NoAnswer:
return False
if ipv6:
try:
answers = resolver.resolve(name, "AAAA")
if not str(answers[0]) == ipv6:
return False
except dns.resolver.NoAnswer:
return False
self.log.debug("IP has not changed")
return True
def needs_update(
self, address_update: Union[IPv4AddressUpdate,
IPv6AddressUpdate]) -> bool:
"""
Checks if the name configured in this updater has a different address than the
provided address and thus needs to be updated. Throws an exception if an answer
can't be determined.
Defaults to a simple DNS resolution, supporting IPv4 and IPv6 addresses. For
other classes, or other record types, override this method.
It is generally recommended to override this method with an API call to whatever
service the updater represents. The DNS will not provide as timely an answer as
directly asking the authoritative source.
:param address_update: The address being checked.
:return True if the address needs updating, False if it does not.
:raises If it is unknown whether the address needs updating or not.
"""
if not isinstance(address_update, IPv4AddressUpdate) or isinstance(
address_update, IPv6AddressUpdate):
raise DDNSWolfProgramException(
f"Unsupported address update for {type(self).__name__}: "
f"{address_update}")
# Use the system default resolver.
answers = resolver.resolve(self.config["name"], address_update.rdtype,
RdataClass.IN)
for answer in answers:
if answer.rdtype == address_update.rdtype:
return ipaddress.ip_address(
answer.address) != address_update.address
# Assume no RR of the correct type means it needs updating.
return True
def make_query(resolver: dns.resolver.Resolver, qname: str, qtype: str,
use_tcp: bool) -> Dict[str, Any]:
q_rdtype = dns.rdatatype.from_text(qtype)
q_rdclass = dns.rdataclass.from_text("IN")
try:
ans = resolver.resolve(qname,
q_rdtype,
q_rdclass,
tcp=use_tcp,
lifetime=DNS_QUERY_TTL,
raise_on_no_answer=True)
except (dns.resolver.NoAnswer, dns.resolver.NXDOMAIN):
return {}
if ans.rrset is None:
return {}
result: Dict[str, List[str]] = {}
result[qtype] = [
rr.to_text() for rr in ans.rrset if
(rr is not None and rr.rdtype == q_rdtype and rr.rdclass == q_rdclass)
]
return result
def has_dane_record(domain, timeout=10):
try:
result = resolver.resolve(f'_25._tcp.{domain}',
dns.rdatatype.TLSA,
dns.rdataclass.IN,
lifetime=timeout)
if result.response.flags & dns.flags.AD:
for record in result:
if isinstance(record, dns.rdtypes.ANY.TLSA.TLSA):
if record.usage in [2, 3] and record.selector in [
0, 1
] and record.mtype in [0, 1, 2]:
return True
except dns.resolver.NoNameservers:
# If the DNSSEC data is invalid and the DNS resolver is DNSSEC enabled
# we will receive this non-specific exception. The safe behaviour is to
# accept to defer the email.
app.logger.warn(
f'Unable to lookup the TLSA record for {domain}. Is the DNSSEC zone okay on https://dnsviz.net/d/{domain}/dnssec/?'
)
return app.config['DEFER_ON_TLS_ERROR']
except dns.exception.Timeout:
app.logger.warn(
f'Timeout while resolving the TLSA record for {domain} ({timeout}s).'
)
except (dns.resolver.NXDOMAIN, dns.name.EmptyLabel):
pass # this is expected, not TLSA record is fine
except Exception as e:
app.logger.info(
f'Error while looking up the TLSA record for {domain} {e}')
pass
def test_DNS():
import dns.resolver
import dns.exception
import dns.flags
import dns.rdtypes
import dns.rdatatype
import dns.rdataclass
import time
# DNS stub configured to do DNSSEC enabled queries
resolver = dns.resolver.Resolver()
resolver.use_edns(0, 0, 1232)
resolver.flags = dns.flags.AD | dns.flags.RD
nameservers = resolver.nameservers
for ns in nameservers:
resolver.nameservers = [ns]
while True:
try:
result = resolver.resolve('example.org',
dns.rdatatype.A,
dns.rdataclass.IN,
lifetime=10)
except Exception as e:
log.critical(
"Your DNS resolver at %s is not working (%s). Please use another resolver or enable unbound via https://setup.mailu.io.",
ns, e)
else:
if result.response.flags & dns.flags.AD:
break
log.critical(
"Your DNS resolver at %s isn't doing DNSSEC validation; Please use another resolver or enable unbound via https://setup.mailu.io.",
ns)
time.sleep(5)
def query_data(name, server, query_type):
serv_addr = resolver.resolve(server, "A")[0].address
name_message = message.make_query(name, query_type)
return name_message, serv_addr
def set_secondary_dns(hostnames, env):
if len(hostnames) > 0:
# Validate that all hostnames are valid and that all zone-xfer IP addresses are valid.
resolver = dns.resolver.get_default_resolver()
resolver.timeout = 5
for item in hostnames:
if not item.startswith("xfr:"):
# Resolve hostname.
try:
response = resolver.resolve(item, "A")
except (dns.resolver.NoNameservers, dns.resolver.NXDOMAIN, dns.resolver.NoAnswer):
try:
response = resolver.query(item, "AAAA")
except (dns.resolver.NoNameservers, dns.resolver.NXDOMAIN, dns.resolver.NoAnswer):
raise ValueError("Could not resolve the IP address of %s." % item)
else:
# Validate IP address.
try:
if "/" in item[4:]:
v = ipaddress.ip_network(item[4:]) # raises a ValueError if there's a problem
else:
v = ipaddress.ip_address(item[4:]) # raises a ValueError if there's a problem
except ValueError:
raise ValueError("'%s' is not an IPv4 or IPv6 address or subnet." % item[4:])
# Set.
set_custom_dns_record("_secondary_nameserver", "A", " ".join(hostnames), "set", env)
else:
# Clear.
set_custom_dns_record("_secondary_nameserver", "A", None, "set", env)
# Apply.
return do_dns_update(env)
def auto_cdn_check(self):
try:
cdn_name = ""
checked_doamin = []
with open("cname", "r", encoding="utf-8") as cname_file:
cname_list = json.load(cname_file)
url_list = []
for res_url in self.result:
url_list.append(res_url[0])
for url in url_list:
domain = self.domain_stripper(url)
if len(domain) > 0 and domain not in checked_doamin:
checked_doamin.append(domain) # 去重
ans = resolver.resolve(domain, 'CNAME')
for i in ans.response.answer:
for j in i.items:
for cdn in cname_list:
if cdn in j.to_text():
cdn_name = cname_list[cdn]['name']
print("""%s 已启用CDN，CDN信息如下 :
%s""" % (url, str(cname_list[cdn])))
else:
continue
if cdn_name == "":
print("恭喜, %s 没有启用CDN!" % url)
except Exception as e:
print(str(e))
logging.warning(str(e))
def main():
try:
arguments = docopt.docopt(__doc__)
opts = dict()
opts["host"] = arguments["--host"]
if resolver and "," not in opts["host"]:
try:
hosts = []
for x in resolver.resolve(opts["host"], "A"):
hosts.append(x.to_text())
opts["host"] = ",".join(hosts)
except resolver.NXDOMAIN:
pass
opts["user"] = arguments["--user"]
opts["password"] = arguments["--password"]
opts["concurrent"] = int(arguments["--concurrent"])
opts["timeout"] = int(arguments["--timeout"])
opts["maxrun"] = int(arguments["--maxrun"])
opts["size"] = int(arguments["--size"])
opts["workdir"] = arguments["<workdir>"]
opts["csvfilename"] = arguments["--csv"]
opts["fixevery"] = int(arguments["--fixevery"])
opts["countfiles"] = int(arguments["--files"])
except docopt.DocoptExit as e:
print(e.message)
else:
if arguments["login"]:
run_bench_login(opts)
elif arguments["upload"]:
run_bench_upload(opts)
elif arguments["download"]:
run_bench_download(opts)
def resolve(self, qname, rdtype, rdclass):
rdata = None
# First try specific methods.
if rdclass == "IN":
for resolver in self.resolvers:
if rdtype == "A":
rdata = resolver.resolve_a(qname)
elif rdtype == "AAAA":
rdata = resolver.resolve_a(qname, True)
elif rdtype == "MX":
rdata = resolver.resolve_mx(qname)
if rdata is not None:
return rdata
# If that fails, try the generic method.
for resolver in self.resolvers:
rdata = resolver.resolve(qname, rdtype, rdclass)
if rdata is not None:
return rdata
# None of the resolvers matched. Try resolving using an
# actual DNS server.
answer = self.fallback.query(qname, rdtype, rdclass)
return answer.rrset
def test_DNS():
import dns.resolver
import dns.exception
import dns.flags
import dns.rdtypes
import dns.rdatatype
import dns.rdataclass
import time
# DNS stub configured to do DNSSEC enabled queries
resolver = dns.resolver.Resolver()
resolver.use_edns(0, dns.flags.DO, 1232)
resolver.flags = dns.flags.AD | dns.flags.RD
nameservers = resolver.nameservers
for ns in nameservers:
resolver.nameservers=[ns]
while True:
try:
result = resolver.resolve('example.org', dns.rdatatype.A, dns.rdataclass.IN, lifetime=10)
except Exception as e:
log.critical("Your DNS resolver at %s is not working (%s). Please see https://mailu.io/master/faq.html#the-admin-container-won-t-start-and-its-log-says-critical-your-dns-resolver-isn-t-doing-dnssec-validation", ns, e);
else:
if result.response.flags & dns.flags.AD:
break
log.critical("Your DNS resolver at %s isn't doing DNSSEC validation; Please see https://mailu.io/master/faq.html#the-admin-container-won-t-start-and-its-log-says-critical-your-dns-resolver-isn-t-doing-dnssec-validation.", ns)
time.sleep(5)
def get_dns_records(name, typ, resolver=None):
"""Retrieve DNS records for given name and type."""
logger = logging.getLogger("modoboa.admin")
if not resolver:
resolver = get_dns_resolver()
try:
dns_answers = resolver.resolve(name, typ, search=True)
except dns.resolver.NXDOMAIN as e:
logger.error(_("No DNS record found for %s") % name, exc_info=e)
except dns.resolver.NoAnswer as e:
logger.error(_("No %(type)s record for %(name)s") % {
"type": typ,
"name": name
},
exc_info=e)
except dns.resolver.NoNameservers as e:
logger.error(_("No working name servers found"), exc_info=e)
except dns.resolver.Timeout as e:
logger.warning(
_("DNS resolution timeout, unable to query %s at the moment") %
name,
exc_info=e)
except dns.name.NameTooLong as e:
logger.error(_("DNS name is too long: %s" % name), exc_info=e)
else:
return dns_answers
return None
def get_master_ns(name, server=resolver.get_default_resolver().nameservers[0]):
try:
response = resolver.resolve(name, "SOA")
return response.response.answer[0][0].mname.to_text()
except resolver.NoAnswer:
try:
server_name = gethostbyaddr(server)[0]
message, address = query_data(name, server_name, "SOA")
response = query.udp(message, address)
return response.authority[0].to_rdataset()[0].mname.to_text()
except:
return False
except:
return False
def query(number, domains, resolver=None):
"""Look for NAPTR RRs for the specified number in the specified domains.
e.g. lookup('16505551212', ['e164.dnspython.org.', 'e164.arpa.'])
*number*, a ``str`` is the number to look for.
*domains* is an iterable containing ``dns.name.Name`` values.
*resolver*, a ``dns.resolver.Resolver``, is the resolver to use. If
``None``, the default resolver is used.
"""
if resolver is None:
resolver = dns.resolver.get_default_resolver()
e_nx = dns.resolver.NXDOMAIN()
for domain in domains:
if isinstance(domain, str):
domain = dns.name.from_text(domain)
qname = dns.e164.from_e164(number, domain)
try:
return resolver.resolve(qname, 'NAPTR')
except dns.resolver.NXDOMAIN as e:
e_nx += e
raise e_nx
def resolve(self, question, resolver):
"""Resolve ONE question, in the form of (name, rrtype)"""
name, rrtype = question
try:
if rrtype == 'PTR' and self.transform_ptr:
answer = resolver.resolve_address(name, lifetime=3, search=False)
else:
answer = resolver.resolve(name, rrtype, lifetime=3, search=False)
return answer
except dns.exception.Timeout:
self.tcex.log.debug(f'Timeout resolving {name} {rrtype}')
except dns.resolver.NXDOMAIN:
self.tcex.log.debug(f'NXDOMAIN resolving {name} {rrtype}')
except dns.resolver.YXDOMAIN:
self.tcex.log.debug(f'YXDOMAIN resolving {name} {rrtype}')
except dns.resolver.NoAnswer:
self.tcex.log.debug(f'No answer resolving {name} {rrtype}')
except dns.resolver.NoNameservers:
self.tcex.log.debug(f'No nameservers resolving {name} {rrtype}')
except Exception as e:
self.tcex.log.error(f'Error resolving question: {e}')
self.tcex.log.error(traceback.format_exc())
return None
def query_uri(uri):
try:
answers = resolve(uri, rdatatype.URI)
except DNSException as e:
logger.debug("DNS record not found: %s", e.__class__.__name__)
answers = []
return answers
def resolveasn(resolver, ip):
asn = int([
x.to_text() for x in resolver.resolve(
'.'.join(reversed(ip.split('.'))) +
'.origin.asn.cymru.com', 'TXT').response.answer
][0].split('\"')[1].split(' ')[0])
return asn
def __dns_query(self, nameserver, domain):
resolver = dns.resolver.Resolver()
resolver.nameservers = [nameserver]
if domain in self.host.blacklist:
if (self.host.redirect_ip == None) == False:
if len(list(self.host.redirect_ip)) < 1:
return "0.0.0.0"
else:
self.host.log("\nrequest for {}\nblacklisted, redirecting to {}".format(domain, self.host.redirect_ip))
return self.host.redirect_ip
return
else:
try:
try:
response = self.host.cache[domain]
self.host.log("\nrequest for {}\nretrieved {} from cache".format(domain, response))
return response
except Exception:
response = resolver.resolve(domain, 'A')
self.host.log("\nrequest for {}\nresponded with {}".format(domain, str(response[0])))
cache = self.host.add_cache(domain, str(response[0]))
self.host.log(cache)
return str(response[0])
except Exception as e:
print("EXCEPTION, ", e)
def genNetworkList(list):
resolver = dns.resolver.Resolver()
hostnames = []
networks = []
for key in list:
if isIpNetwork(key):
networks.append(key)
else:
hostnames.append(key)
for hostname in hostnames:
hostname_ips = []
for rdtype in ['A', 'AAAA']:
try:
answer = resolver.resolve(qname=hostname, rdtype=rdtype, lifetime=3)
except dns.exception.Timeout:
logInfo('Hostname %s timedout on resolve' % hostname)
break
except (dns.resolver.NXDOMAIN, dns.resolver.NoAnswer):
continue
except dns.exception.DNSException as dnsexception:
logInfo('%s' % dnsexception)
continue
for rdata in answer:
hostname_ips.append(rdata.to_text())
networks.extend(hostname_ips)
return set(networks)
def __threaded_query(hostname):
"""Perform the requests to the DNS server."""
try:
answer = resolver.resolve(hostname)
return answer
except Exception:
return None
def resolve(self, host, tries=10, nameserver=None):
if nameserver is None:
resolver = self.getResolver()
else:
resolver = dns.resolver.Resolver()
resolver.nameservers = [nameserver]
self.sf.debug(
f"Resolving {host} using nameserver {resolver.nameservers[0]}")
ips = set()
for recordType in ["A", "AAAA"]:
try:
for answer in resolver.resolve(host, recordType):
ips.add(str(answer))
break
except dns.resolver.NXDOMAIN:
break
except Exception as e:
self.sf.debug(
f"Error resolving \"{host}\": {e.__class__.__name__}: {e}")
if tries > 0:
self.sf.debug(f"Retrying \"{host}\"")
return self.resolve(host,
tries=tries - 1,
nameserver=nameserver)
else:
self.sf.debug(
f"Max retries ({tries:,}) exceeded for \"{host}\"")
return (host, [])
return (host, list(ips))
async def _verify_dns(self, header_uuid: str) -> bool:
resolver = dns.resolver.Resolver(configure=False)
resolver.nameservers = [self._dns_host]
answer = resolver.resolve(header_uuid + ".c", "TXT")
if answer[0].strings[0].decode("utf-8") == "true":
return True
return False
def resolve_dns(dom):
""" devulve las ip asociadas al dominio """
try:
resolver = dns.resolver.Resolver()
answer = resolver.resolve(dom, "A")
return answer
except DNSException:
return None
def resolve(self, name, rdtype=dns.rdatatype.A):
if self.name == '.' and not self.resolvers:
self.find_root_resolvers()
if name in self.root.names:
return self.root.names[name].ip
if name in self.resolvers:
# Misconfiguration a la otenet.gr, ns1.otenet.gr isn't glued anywhere. www.cosmote.gr A lookup triggered it
pass
for resolver in self.resolvers.values():
if resolver.ip:
return resolver.resolve(name, rdtype=rdtype, register=False)
else:
# No glue at all
return self.resolvers.values()[0].resolve(name, rdtype=rdtype, register=False)
def resolve(self):
ans = _cache.lookup(self.addr)
if ans is not None:
return ans
deadline = time.time() + self.lifetime
for serverconf in self.conf['dns_servers']:
if _domain_filtered(self.addr, serverconf):
continue
resolver = _classdict[serverconf['type']](self.addr, serverconf)
resolver.timeout = min(resolver.timeout, deadline - time.time())
ans = resolver.resolve()
if ans:
_cache.insert(self.addr, ans)
return ans
raise ProxyException('cannot resolve hostname')
def iplookup(domains):
'''
This function is used to lookup all IP addresses assigned to a domain using DNS resolution.
:param domains: single domain as a string, or multiple domains as a List type
:return: Returns a List of IP Addresses from the domains supplied as Params
'''
# convert single string arg to single item list
ip_list = []
if isinstance(domains, str):
domains = domains.split()
elif not isinstance(domains, list):
raise TypeError('iplookup only supports strings or lists')
for domain in domains:
try:
answer = resolve(domain)
except Exception as e:
print("Error occured doing lookup for {}".format(domain))
break
ip_list += [ str(ip.to_text()) for ip in answer if not ip == None ]
return ip_list