本文整理汇总了Python中dns.resolver.timeout方法的典型用法代码示例。如果您正苦于以下问题:Python resolver.timeout方法的具体用法?Python resolver.timeout怎么用?Python resolver.timeout使用的例子?那么, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类dns.resolver
的用法示例。
在下文中一共展示了resolver.timeout方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: run
# 需要导入模块: from dns import resolver [as 别名]
# 或者: from dns.resolver import timeout [as 别名]
def run(self):
#Every user will get a different set of resovlers, this helps redistribute traffic.
random.shuffle(self.resolver_list)
if not self.verify(self.resolver_list):
#This should never happen, inform the user.
sys.stderr.write('Warning: No nameservers found, trying fallback list.\n')
#Try and fix it for the user:
self.verify(self.backup_resolver)
#End of the resolvers list.
try:
self.resolver_q.put(False, timeout = 1)
except:
pass
#Only add the nameserver to the queue if we can detect wildcards.
#Returns False on error.
示例2: run
# 需要导入模块: from dns import resolver [as 别名]
# 或者: from dns.resolver import timeout [as 别名]
def run(domain):
ips = []
resolver = dns.resolver.Resolver()
resolver.lifetime = resolver.timeout = 5.0
try:
answers = resolver.query(domain, "A")
for a in answers:
ips.append(a.address)
return ips
except Exception:
# print("Regular DNS Not Resolved\n")
# Temporarily disabling - seems to cause massive delays at times.
# pass
# try:
# ips = [ str(i[4][0]) for i in socket.getaddrinfo(domain, 443) ]
# return ips
# except Exception:
# print("Unable to Resolve\n")
return ips
示例3: _get_a_record
# 需要导入模块: from dns import resolver [as 别名]
# 或者: from dns.resolver import timeout [as 别名]
def _get_a_record(site, querytype='A', dnsserver=None):
resolver = dns.resolver.Resolver()
resolver.timeout = 5
resolver.lifetime = 5
if dnsserver:
resolver.nameservers = [dnsserver]
result = []
while len(resolver.nameservers):
try:
resolved = resolver.query(site, querytype)
print_debug(str(resolved.response))
for item in resolved.rrset.items:
result.append(item.to_text())
return result
except dns.exception.Timeout:
print_debug("DNS Timeout for", site, "using", resolver.nameservers[0])
resolver.nameservers.remove(resolver.nameservers[0])
# If all the requests failed
return ""
示例4: get_reverse_dns
# 需要导入模块: from dns import resolver [as 别名]
# 或者: from dns.resolver import timeout [as 别名]
def get_reverse_dns(ip_address, cache=None, nameservers=None, timeout=2.0):
"""
Resolves an IP address to a hostname using a reverse DNS query
Args:
ip_address (str): The IP address to resolve
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 query timeout in seconds
Returns:
str: The reverse DNS hostname (if any)
"""
hostname = None
try:
address = dns.reversename.from_address(ip_address)
hostname = query_dns(address, "PTR", cache=cache,
nameservers=nameservers,
timeout=timeout)[0]
except dns.exception.DNSException:
pass
return hostname
示例5: __init__
# 需要导入模块: from dns import resolver [as 别名]
# 或者: from dns.resolver import timeout [as 别名]
def __init__(self, to_addr, from_addr, SMTP_addr, port=25, timeout=10):
Print(u"check config", sign=u"[+]")
Print(u"to address: "+to_addr)
Print(u"from address: "+from_addr)
Print(u"SMTP address: "+SMTP_addr)
Print(u"SMTP port: "+str(port))
Print(u"socket timeout: "+str(timeout))
Print(u"verbose level: "+str(verbose))
Print(u"no problem, maybe", sign=u" [*]")
self.to_addr = to_addr
self.from_addr = from_addr
self.port = port
self.timeout = timeout
self.SMTP_addr = SMTP_addr
self.quit_flag = 1
self.succ_num = 0
示例6: DNSQuery
# 需要导入模块: from dns import resolver [as 别名]
# 或者: from dns.resolver import timeout [as 别名]
def DNSQuery(to_addr):
resolver = dns.resolver.Resolver()
resolver.timeout = 3
resolver.lifetime = 3
Print(u"query MX of DNS for %s" % to_addr, sign=u"[+]")
try:
SMTP_addr = b'.'.join(dns.resolver.query(
to_addr[to_addr.find(u"@")+1:], u'MX')[0].exchange.labels).decode(u"utf8")
assert SMTP_addr != u""
except Exception as e:
Print(u"query MX of %s failed: " % to_addr + str(e),
threshold=0, color=u"red", sign=u"[X]", flag=0)
return 0
Print(u"success", sign=u" [*]")
return SMTP_addr
示例7: __init__
# 需要导入模块: from dns import resolver [as 别名]
# 或者: from dns.resolver import timeout [as 别名]
def __init__(self, to_addr, from_addr, SMTP_addr, port=25, timeout=10):
Print(u"check config", sign=u"[+]")
Print(u"to address: "+to_addr)
Print(u"from address: "+from_addr)
Print(u"SMTP address: "+SMTP_addr)
Print(u"SMTP port: "+str(port))
Print(u"socket timeout: "+str(timeout))
Print(u"verbose level: "+str(verbose))
Print(u"no problem, maybe", sign=u" [*]")
self.to_addr = to_addr
self.from_addr = from_addr
self.port = port
self.timeout = timeout
self.SMTP_addr = SMTP_addr
self.quit_flag = 1
self.succ_num = 0
self.failed_num = 0
self.msg = PutColor("Connecting...", "yellow")
示例8: DNSQuery
# 需要导入模块: from dns import resolver [as 别名]
# 或者: from dns.resolver import timeout [as 别名]
def DNSQuery(self):
resolver = dns.resolver.Resolver()
resolver.timeout = 3
resolver.lifetime = 3
try:
host = self.to_addr[self.to_addr.find(u"@")+1:]
# dns 列表
self.SMTP_addrs = [b'.'.join(d.exchange.labels).decode(u"utf8") for d in dns.resolver.query(host, u'MX')]
assert len(self.SMTP_addrs) > 1 # 确保 dns 有结果
except Exception as e:
return (False, u"get MX record of %s failed: " % self.to_addr + str(e))
return (True, u"get MX record of %s success" % host)
示例9: _may_retry_on_error
# 需要导入模块: from dns import resolver [as 别名]
# 或者: from dns.resolver import timeout [as 别名]
def _may_retry_on_error(response, retry_policy, wait):
if response.status_code not in (301, 302, 401, 503):
# Don't retry if we didn't get a status code that we can hope to recover from
log.debug('No retry: wrong status code %s', response.status_code)
return False
if retry_policy.fail_fast:
log.debug('No retry: no fail-fast policy')
return False
if wait > retry_policy.max_wait:
# We lost patience. Session is cleaned up in outer loop
raise RateLimitError(
'Max timeout reached', url=response.url, status_code=response.status_code, total_wait=wait)
# The genericerrorpage.htm/internalerror.asp is ridiculous behaviour for random outages. Redirect to
# '/internalsite/internalerror.asp' or '/internalsite/initparams.aspx' is caused by e.g. TLS certificate
# f*ckups on the Exchange server.
if (response.status_code == 401) \
or (response.headers.get('connection') == 'close') \
or (response.status_code == 302 and response.headers.get('location', '').lower() ==
'/ews/genericerrorpage.htm?aspxerrorpath=/ews/exchange.asmx') \
or (response.status_code == 503):
log.debug('Retry allowed: conditions met')
return True
return False
示例10: __init__
# 需要导入模块: from dns import resolver [as 别名]
# 或者: from dns.resolver import timeout [as 别名]
def __init__(self):
super().__init__()
self.parser.add_argument("query", type=str, help="Query string.")
self.parser.add_argument("-t", "--rdtype", type=str, default=1, help="Query type.")
self.parser.add_argument("-c", "--rdclass", type=str, default=1, help="Query class.")
self.parser.add_argument("-m", "--metaquery", action="store_true", help="Execute as MetaQuery.")
self.parser.add_argument("-s", "--source", type=str, default=socket.gethostbyname(socket.gethostname()), help="Source address.")
self.parser.add_argument("-sP", "--source-port", type=int, default=random.randint(1, 65535), help="Source port.")
self.parser.add_argument("--tcp", action="store_true", help="Use TCP to make the query.")
self.parser.add_argument("-ns", "--nameservers", nargs="+", type=str, help="A list of nameservers to query. Each nameserver is a string which contains the IP address of a nameserver.")
self.parser.add_argument("-p", "--port", type=int, default=53, help="The port to which to send queries (Defaults to 53).")
self.parser.add_argument("-T", "--timeout", type=int, default=8, help="The number of seconds to wait for a response from a server, before timing out.")
self.parser.add_argument("-l", "--lifetime", type=int, default=8, help="The total number of seconds to spend trying to get an answer to the question. If the lifetime expires, a Timeout exception will occur.")
self.parser.add_argument("-e", "--edns", type=int, default=-1, help="The EDNS level to use (Defaults to -1, no Edns).")
self.parser.add_argument("-eF", "--edns-flags", type=int, help="The EDNS flags.")
self.parser.add_argument("-eP", "--edns-payload", type=int, default=0, help="The EDNS payload size (Defaults to 0).")
self.parser.add_argument("-S", "--want-dnssec", action="store_true", help="Indicate that DNSSEC is desired.")
self.parser.add_argument("-f", "--flags", type=int, default=None, help="The message flags to use (Defaults to None (i.e. not overwritten)).")
self.parser.add_argument("-r", "--retry-servfail", action="store_true", help="Retry a nameserver if it says SERVFAIL.")
self.parser.add_argument("-R", "--one-rr-per-rrset", action="store_true", help="Put each RR into its own RRset (Only useful when executing MetaQueries).")
self.parser.add_argument("--filename", type=argparse.FileType("r"), help="The filename of a configuration file in standard /etc/resolv.conf format. This parameter is meaningful only when I{configure} is true and the platform is POSIX.")
self.parser.add_argument("--configure-resolver", action="store_false", help="If True (the default), the resolver instance is configured in the normal fashion for the operating system the resolver is running on. (I.e. a /etc/resolv.conf file on POSIX systems and from the registry on Windows systems.")
示例11: run
# 需要导入模块: from dns import resolver [as 别名]
# 或者: from dns.resolver import timeout [as 别名]
def run(self):
arguments = self.arguments.__dict__
nameservers = arguments.get("nameservers")
resolver = dns.resolver.Resolver(arguments.get("filename"), arguments.get("configure_resolver"))
resolver.set_flags(arguments.get("flags"))
resolver.use_edns(arguments.get("edns"), arguments.get("edns_flags"), arguments.get("edns_payload"))
if nameservers:
resolver.nameservers = nameservers
resolver.port = arguments.get("port")
resolver.timeout = arguments.get("timeout")
resolver.lifetime = arguments.get("lifetime")
resolver.retry_servfail = arguments.get("retry_servfail")
if arguments.pop("metaquery"):
kwargs = {v: arguments.get(k) for k, v in {"rdclass": "rdclass", "edns": "use_edns", "want_dnssec": "want_dnssec", "edns_flags": "ednsflags", "edns_payload": "request_payload"}.items()}
message = dns.message.make_query(arguments.get("query"), arguments.get("rdtype"), **kwargs)
kwargs = {k: arguments.get(k) for k in ["timeout", "port", "source", "source_port", "one_rr_per_rrset"]}
if arguments.get("tcp"):
resp = dns.query.tcp(message, resolver.nameservers[0], **kwargs)
else:
resp = dns.query.udp(message, resolver.nameservers[0], **kwargs)
print(resp)
else:
kwargs = {k: arguments.get(k) for k in ["rdtype", "rdclass", "tcp", "source", "source_port"]}
answer = resolver.query(arguments.pop("query"), **kwargs)
print(answer.response)
示例12: retIP
# 需要导入模块: from dns import resolver [as 别名]
# 或者: from dns.resolver import timeout [as 别名]
def retIP(domain, ns=None):
# added the ns option to handle CDN case where cn format = "x.x.x.x",
# consider using public name servers provided http://public-dns.tk or use nameservers.keys()
ip = ''
c_name = ''
if domain == '':
return ip, c_name
resolver = dns.resolver.Resolver()
resolver.timeout = 1
try:
answers = resolver.query(domain)
ip = str(answers[0]).split(": ")[0]
c_name = answers.canonical_name
except Exception, e:
msg = '[*] No IP Addressed: Timeout, NXDOMAIN, NoAnswer or NoNameservers'
logging.info(msg)
示例13: __init__
# 需要导入模块: from dns import resolver [as 别名]
# 或者: from dns.resolver import timeout [as 别名]
def __init__(self, cfg, transact, reporter, code_id):
logger.info('Resolver init')
self.code_id = code_id
self.transact = transact
self.cfg = cfg
self.reporter = reporter
self.domain_sql = self.reporter.domain_rollback_sql(0, 'ignore')
self.dns_servers = str(cfg.DNS()).split(' ')
self.resolvers = [dns.resolver.Resolver(configure=False) for i in range(len(self.dns_servers))]
for resolver, dns_server in zip(self.resolvers, self.dns_servers):
resolver.nameservers = [dns_server]
resolver.timeout = self.cfg.QueryTimeout()
resolver.lifetime = self.cfg.QueryTimeout()
logger.info('Resolver history.id: %s', self.code_id)
示例14: _test_server
# 需要导入模块: from dns import resolver [as 别名]
# 或者: from dns.resolver import timeout [as 别名]
def _test_server(self, server):
resolver = dns.resolver.Resolver()
resolver.lifetime = resolver.timeout = 10.0
try:
resolver.nameservers = [server]
answers = resolver.query('public-dns-a.baidu.com') # test lookup a existed domain
if answers[0].address != '180.76.76.76':
raise Exception('incorrect DNS response')
try:
resolver.query('test.bad.dns.lijiejie.com') # Non-existed domain test
with open('bad_dns_servers.txt', 'a') as f:
f.write(server + '\n')
self._print_msg('[+] Bad DNS Server found %s' % server)
except:
self.dns_servers.append(server)
self._print_msg('[+] Check DNS Server %s < OK > Found %s' % (server.ljust(16), len(self.dns_servers)))
except:
self._print_msg('[+] Check DNS Server %s <Fail> Found %s' % (server.ljust(16), len(self.dns_servers)))
示例15: __init__
# 需要导入模块: from dns import resolver [as 别名]
# 或者: from dns.resolver import timeout [as 别名]
def __init__(self, target, record_type, resolver_q, resolver_list, wildcards):
multiprocessing.Process.__init__(self, target = self.run)
self.daemon = True
signal_init()
self.time_to_die = False
self.resolver_q = resolver_q
self.wildcards = wildcards
#Do we need wildcards for other types of records?
#This needs testing!
self.record_type = "A"
if record_type == "AAAA":
self.record_type = record_type
self.resolver_list = resolver_list
resolver = dns.resolver.Resolver()
#The domain provided by the user.
self.target = target
#1 website in the world, modify the following line when this status changes.
#www.google.cn, I'm looking at you ;)
self.most_popular_website = "www.google.com"
#We shouldn't need the backup_resolver, but we we can use them if need be.
#We must have a resolver, and localhost can work in some environments.
self.backup_resolver = resolver.nameservers + ['127.0.0.1', '8.8.8.8', '8.8.4.4']
#Ideally a nameserver should respond in less than 1 sec.
resolver.timeout = 1
resolver.lifetime = 1
try:
#Lets test the letancy of our connection.
#Google's DNS server should be an ideal time test.
resolver.nameservers = ['8.8.8.8']
resolver.query(self.most_popular_website, self.record_type)
except:
#Our connection is slower than a junebug in molasses
resolver = dns.resolver.Resolver()
self.resolver = resolver