首页 / 问题 / 正文

Python和ADNS，在哪儿陷入无限循环

2 投票
2 回答
1058 浏览
提问于 2025-04-16 04:57

我写了一段代码来查询 DNS（域名系统）。这个代码有个问题，就是它会卡住。让我来解释一下这个情况：

  • 假设我的 DNS 列表是 ["8.8.4.4", "8.8.8.8", "208.67.220.220", "208.67.222.222", "192.168.50.1"]。
  • 代码会从这个列表中取出一个 DNS 进行查询，这意味着 DNS 查询是按反向顺序进行的。
  • 不管我怎么做，它总是不会显示第一个取出的 DNS 的结果（在这个例子中是 192.168.50.1）。
  • 我不确定这个 DNS 是否有回复，所以我做了以下尝试：
    • 首先，我把 DNS 列表改成只包含最后一个 DNS 服务器，这样代码就能正常执行了。
    • 其次，我用了原来的 5 个 DNS 服务器的列表，只是最后一个是我自己管理的，这样我可以追踪代码是否真的查询了它，结果让我惊讶，查询确实发生了。
    • 所以查询是进行了，我们得到了结果，但出于某种原因，这个结果从未被插入到 resolved_hosts 中。因为这个结果没有被插入，它的数量就会一直少于 DNS 列表的数量，导致了无限循环。

你觉得这个问题可能是什么原因造成的，应该怎么解决呢？

代码执行结果

Inside class's init'
Data
host www.yahoo.com
dnslist length 5
intensity 1
Inside resolve()
inside finished_resolving()
Resolved : 0/5
Inside 'while not finished_resolving'
Queue: 0/1
Launching Querying for www.yahoo.com/1 on 192.168.50.1
Queue: 1/1
Launching Querying for www.yahoo.com/1 on 208.67.222.222
inside collect_results()
inside finished_resolving()
Resolved : 0/5
Inside 'while not finished_resolving'
------------------------ CLIPPED ----------------
Inside 'while not finished_resolving'
inside collect_results()
Inside collect_results's for query in self.adns.completed()
DNS used was208.67.222.222
Answered : (0, 'any-fp.wa1.b.yahoo.com', 1286169807, ('69.147.125.65', '67.195.160.76'))
Resolved www.yahoo.com to 69.147.125.65 using 208.67.222.222
Resolved hosts count1
And they are: 
{'208.67.222.222': '69.147.125.65'}


inside finished_resolving()
Resolved : 1/5
Inside 'while not finished_resolving'
Queue: 1/1
Launching Querying for www.yahoo.com/1 on 208.67.220.220
inside collect_results()
inside finished_resolving()
Resolved : 1/5
Inside 'while not finished_resolving'
-------------------------- CLIPPED --------------------
inside collect_results()
Inside collect_results's for query in self.adns.completed()
DNS used was208.67.220.220
Answered : (0, 'any-fp.wa1.b.yahoo.com', 1286169790, ('67.195.160.76', '69.147.125.65'))
Resolved www.yahoo.com to 67.195.160.76 using 208.67.220.220
Resolved hosts count2
And they are: 
{'208.67.222.222': '69.147.125.65', '208.67.220.220': '67.195.160.76'}


inside finished_resolving()
Resolved : 2/5
Inside 'while not finished_resolving'
Queue: 1/1
Launching Querying for www.yahoo.com/1 on 8.8.8.8
inside collect_results()
inside finished_resolving()
Resolved : 2/5
Inside 'while not finished_resolving'
-------------------------- CLIPPED --------------------
inside collect_results()
Inside collect_results's for query in self.adns.completed()
DNS used was8.8.8.8
Answered : (0, 'eu-fp.wa1.b.yahoo.com', 1286169758, ('87.248.122.122',))
Resolved www.yahoo.com to 87.248.122.122 using 8.8.8.8
Resolved hosts count3
And they are: 
{'208.67.222.222': '69.147.125.65', '208.67.220.220': '67.195.160.76', '8.8.8.8': '87.248.122.122'}


inside finished_resolving()
Resolved : 3/5
Inside 'while not finished_resolving'
Queue: 1/1
Launching Querying for www.yahoo.com/1 on 8.8.4.4
inside collect_results()
inside finished_resolving()
Resolved : 3/5
Inside 'while not finished_resolving'
-------------------- CLIPPED -------------------------------------
inside collect_results()
Inside collect_results's for query in self.adns.completed()
DNS used was8.8.4.4
Answered : (0, 'eu-fp.wa1.b.yahoo.com', 1286169757, ('87.248.122.122',))
Resolved www.yahoo.com to 87.248.122.122 using 8.8.4.4
Resolved hosts count4
And they are: 
{'208.67.222.222': '69.147.125.65', '208.67.220.220': '67.195.160.76', '8.8.8.8': '87.248.122.122', '8.8.4.4': '87.248.122.122'}


inside finished_resolving()
Resolved : 4/5
Inside 'while not finished_resolving'
inside collect_results()
inside finished_resolving()
Resolved : 4/5
---------------- CLIPPED -------------------------------

(最后一块代码一直重复，直到系统开始卡顿，负载达到 24)

代码

test.py

import adns
from time import time
from async_dns import AsyncResolver



dnslist2 = ["8.8.4.4", "8.8.8.8", "208.67.220.220", "208.67.222.222", "192.168.50.1"]  #192.168.50.1  is a dns server i manage
host = "www.yahoo.com"
record = adns.rr.A
intensity = len(dnslist2)/5+1

ar = AsyncResolver(dnslist2, host, record, intensity)
start = time()
resolved = ar.resolve()
end = time()

print "\n\n"

for dns, ip in resolved.items():
  if ip is None:
    print "%s could not resolv %s." % (dns, host)
  else:
    print "%s resolved it to %s : %s" % (dns, host, ip)

print "\n\n----------------------------------------------------"
print "It took %.2f seconds to query %d dns." % (end-start, len(dnslist))
print "----------------------------------------------------"

async_dns.py

#!/usr/bin/python
#

import sys
import adns
from time import time

class AsyncResolver(object):
    def __init__(self, dnslist, host, record, intensity=10):

        """
        dnslist: a list of dns used to resolve
        host : hostname to resolve
        record: recordtype to resolve
        intensity: how many hosts to resolve at once
        """
        print "Inside class's init'"
        self.dnslist = dnslist
        self.host = host
        self.record = record


        if intensity >= len(dnslist) :
            self.intensity = len(dnslist)/5+1
        else:
            self.intensity = intensity

        print "Data"
        print "host " + host
        print "dnslist length " + str(len(dnslist))
        print "intensity " + str(intensity)




    def resolve(self):
        """ Resolves hosts and returns a dictionary of { 'dns': 'ip' }. """
        print "Inside resolve()"

        host = self.host
        record = self.record
        resolved_hosts = {}
        active_queries = {}
        dns_queue = self.dnslist[:]

        def collect_results():
            print "inside collect_results()"
            for query in self.adns.completed():
                print "Inside collect_results's for query in self.adns.completed()"
                answer = query.check()
                dns = active_queries[query]
                print "DNS used was" + dns
                print "Answered : " + str(answer)
                del active_queries[query]
                if answer[0] == 0:
                    #print "Inside answer[0] == 0 , ip:" + answer[3][0]
                    ip = answer[3][0]
                    resolved_hosts[dns] = ip
                    print "Resolved %s to %s using %s" % (host, ip, dns)
                    print "Resolved hosts count" + str(len(resolved_hosts))
                    print "And they are: "
                    print str(resolved_hosts)
                    print "\n"

                elif answer[0] == 101 and not record == adns.rr.CNAME: # CNAME if CNAME wasn't required'
                    print "ooopppps, i got a CNAME, gotta find its A"
                    print "\n"
                    query = self.adns.submit(answer[1], adns.rr.A)
                    active_queries[query] = dns
                else:
                    resolved_hosts[dns] = None
                    print "THIS COULD NOT BE RESOLVED"

        def finished_resolving():
            print "inside finished_resolving()"
            print "Resolved : " + str(len(resolved_hosts)) + "/" + str(len(self.dnslist))
            return len(resolved_hosts) == len(self.dnslist)

        while not finished_resolving():
            print "Inside 'while not finished_resolving'"
            while dns_queue and len(active_queries) <= self.intensity:
                print "Queue: " + str(len(active_queries)) + "/" + str(self.intensity)
                dns = dns_queue.pop()
                self.adns = adns.init(adns.iflags.noautosys,sys.stderr,"nameserver "+dns)
                query = self.adns.submit(host, record)
                print "Launching Querying for " + host + "/" + str(record) + " on " + dns
                active_queries[query] = dns
            collect_results()
        return resolved_hosts
代码调试 异步编程 结果处理 无限循环 服务器管理 dns查询 负载监控 域名系统

2 个回答

0

你的 while not finished_resolving() 循环会一直运行，只要 finished_resolving() 返回 True。这个函数其实就是在比较 len(resolved_hosts) 和 len(self.dnslist) 的长度。不过，从我看到的情况来看，你在这个循环里面并没有改变这两个变量的长度，所以这个循环会一直持续下去，变成一个无限循环。

编辑：根据评论 在这两个代码块里面，没有任何东西会影响这两个变量的长度。请解释一下你认为它们是怎么被改变的。

回答于 2025-04-16 由 Python大师
分享 举报
1

我刚刚尝试使用adns的Python绑定，遇到了类似的问题——完成的查询数组从来没有完全填满，导致检查循环一直在运行。在我的情况下，似乎那些无法解析的域名（比如因为NXDOMAIN等原因）从来没有被添加到完成的查询数组中（值是空的或为Null）。

我查看了一下C语言的绑定，但没有看到一个单独的数据结构来保存失败的结果，所以看起来这些结果应该以某种方式被添加到“完成”的查询中。我怀疑在这个绑定或adns库中有一个bug，导致这种情况无法发生。

回答于 2025-04-16 由 Python大师
分享 举报

撰写回答