"Any programmer who fails to comply with the standard naming, formatting,

or commenting conventions should be shot. If it so happens that it is inconvenient to shoot him, then he is to be politely requested to recode his program in adherence to the above standard." -- Michael Spier, Digital Equipment Corporation svn path=/branches/tk705/; revision=6152
author: Rob Austein <sra@hactrn.net> 2015-10-26 06:29:00 +0000
committer: Rob Austein <sra@hactrn.net> 2015-10-26 06:29:00 +0000
commit: b46deb1417dc3596e9ac9fe2fe8cc0b7f42457e7 (patch)
tree: ca0dc0276d1adc168bc3337ce0564c4ec4957c1b /rpki/adns.py
parent: 397beaf6d9900dc3b3cb612c89ebf1d57b1d16f6 (diff)
1 files changed, 297 insertions, 297 deletions
diff --git a/rpki/adns.py b/rpki/adns.py
index c5af3549..b0f235e7 100644
--- a/rpki/adns.py
+++ b/rpki/adns.py
@@ -31,14 +31,14 @@ import rpki.sundial
 import rpki.log
 
 try:
-  import dns.resolver, dns.rdatatype, dns.rdataclass, dns.name, dns.message
-  import dns.inet, dns.exception, dns.query, dns.rcode, dns.ipv4, dns.ipv6
+    import dns.resolver, dns.rdatatype, dns.rdataclass, dns.name, dns.message
+    import dns.inet, dns.exception, dns.query, dns.rcode, dns.ipv4, dns.ipv6
 except ImportError:
-  if __name__ == "__main__":
-    sys.stderr.write("DNSPython not available, skipping rpki.adns unit test\n")
-    sys.exit(0)
-  else:
-    raise
+    if __name__ == "__main__":
+        sys.stderr.write("DNSPython not available, skipping rpki.adns unit test\n")
+        sys.exit(0)
+    else:
+        raise
 
 logger = logging.getLogger(__name__)
 
@@ -47,7 +47,7 @@ logger = logging.getLogger(__name__)
 
 resolver = dns.resolver.Resolver()
 if resolver.cache is None:
-  resolver.cache = dns.resolver.Cache()
+    resolver.cache = dns.resolver.Cache()
 
 ## @var nameservers
 # Nameservers from resolver.nameservers converted to (af, address)
@@ -58,327 +58,327 @@ if resolver.cache is None:
 nameservers = []
 
 for ns in resolver.nameservers:
-  try:
-    nameservers.append((socket.AF_INET, dns.ipv4.inet_aton(ns)))
-    continue
-  except:
-    pass
-  try:
-    nameservers.append((socket.AF_INET6, dns.ipv6.inet_aton(ns)))
-    continue
-  except:
-    pass
-  logger.error("Couldn't parse nameserver address %r", ns)
+    try:
+        nameservers.append((socket.AF_INET, dns.ipv4.inet_aton(ns)))
+        continue
+    except:
+        pass
+    try:
+        nameservers.append((socket.AF_INET6, dns.ipv6.inet_aton(ns)))
+        continue
+    except:
+        pass
+    logger.error("Couldn't parse nameserver address %r", ns)
 
 class dispatcher(asyncore.dispatcher):
-  """
-  Basic UDP socket reader for use with asyncore.
-  """
-
-  def __init__(self, cb, eb, af, bufsize = 65535):
-    asyncore.dispatcher.__init__(self)
-    self.cb = cb
-    self.eb = eb
-    self.af = af
-    self.bufsize = bufsize
-    self.create_socket(af, socket.SOCK_DGRAM)
-
-  def handle_read(self):
-    """
-    Receive a packet, hand it off to query class callback.
-    """
-
-    wire, from_address = self.recvfrom(self.bufsize)
-    self.cb(self.af, from_address[0], from_address[1], wire)
-
-  def handle_error(self):
-    """
-    Pass errors to query class errback.
-    """
-
-    self.eb(sys.exc_info()[1])
-
-  def handle_connect(self):
-    """
-    Quietly ignore UDP "connection" events.
-    """
-
-    pass
-
-  def writable(self):
     """
-    We don't need to hear about UDP socket becoming writable.
+    Basic UDP socket reader for use with asyncore.
     """
 
-    return False
+    def __init__(self, cb, eb, af, bufsize = 65535):
+        asyncore.dispatcher.__init__(self)
+        self.cb = cb
+        self.eb = eb
+        self.af = af
+        self.bufsize = bufsize
+        self.create_socket(af, socket.SOCK_DGRAM)
 
+    def handle_read(self):
+        """
+        Receive a packet, hand it off to query class callback.
+        """
 
-class query(object):
-  """
-  Simplified (no search paths) asynchronous adaptation of
-  dns.resolver.Resolver.query() (q.v.).
-  """
-
-  def __init__(self, cb, eb, qname, qtype = dns.rdatatype.A, qclass = dns.rdataclass.IN):
-    if isinstance(qname, (str, unicode)):
-      qname = dns.name.from_text(qname)
-    if isinstance(qtype, str):
-      qtype = dns.rdatatype.from_text(qtype)
-    if isinstance(qclass, str):
-      qclass = dns.rdataclass.from_text(qclass)
-    assert qname.is_absolute()
-    self.cb = cb
-    self.eb = eb
-    self.qname = qname
-    self.qtype = qtype
-    self.qclass = qclass
-    self.start = time.time()
-    rpki.async.event_defer(self.go)
-
-  def go(self):
-    """
-    Start running the query.  Check our cache before doing network
-    query; if we find an answer there, just return it.  Otherwise
-    start the network query.
-    """
-
-    if resolver.cache:
-      answer = resolver.cache.get((self.qname, self.qtype, self.qclass))
-    else:
-      answer = None
-    if answer:
-      self.cb(self, answer)
-    else:
-      self.timer = rpki.async.timer()
-      self.sockets = {}
-      self.request = dns.message.make_query(self.qname, self.qtype, self.qclass)
-      if resolver.keyname is not None:
-        self.request.use_tsig(resolver.keyring, resolver.keyname, resolver.keyalgorithm)
-      self.request.use_edns(resolver.edns, resolver.ednsflags, resolver.payload)
-      self.response = None
-      self.backoff = 0.10
-      self.nameservers = nameservers[:]
-      self.loop1()
-
-  def loop1(self):
-    """
-    Outer loop.  If we haven't got a response yet and still have
-    nameservers to check, start inner loop.  Otherwise, we're done.
-    """
+        wire, from_address = self.recvfrom(self.bufsize)
+        self.cb(self.af, from_address[0], from_address[1], wire)
 
-    self.timer.cancel()
-    if self.response is None and self.nameservers:
-      self.iterator = rpki.async.iterator(self.nameservers[:], self.loop2, self.done2)
-    else:
-      self.done1()
+    def handle_error(self):
+        """
+        Pass errors to query class errback.
+        """
 
-  def loop2(self, iterator, nameserver):
-    """
-    Inner loop.  Send query to next nameserver in our list, unless
-    we've hit the overall timeout for this query.
-    """
+        self.eb(sys.exc_info()[1])
 
-    self.timer.cancel()
-    try:
-      timeout = resolver._compute_timeout(self.start)
-    except dns.resolver.Timeout, e:
-      self.lose(e)
-    else:
-      af, addr = nameserver
-      if af not in self.sockets:
-        self.sockets[af] = dispatcher(self.socket_cb, self.socket_eb, af)
-      self.sockets[af].sendto(self.request.to_wire(),
-                              (dns.inet.inet_ntop(af, addr), resolver.port))
-      self.timer.set_handler(self.socket_timeout)
-      self.timer.set_errback(self.socket_eb)
-      self.timer.set(rpki.sundial.timedelta(seconds = timeout))
-
-  def socket_timeout(self):
-    """
-    No answer from nameserver, move on to next one (inner loop).
-    """
+    def handle_connect(self):
+        """
+        Quietly ignore UDP "connection" events.
+        """
 
-    self.response = None
-    self.iterator()
+        pass
 
-  def socket_eb(self, e):
-    """
-    UDP socket signaled error.  If it really is some kind of socket
-    error, handle as if we've timed out on this nameserver; otherwise,
-    pass error back to caller.
-    """
+    def writable(self):
+        """
+        We don't need to hear about UDP socket becoming writable.
+        """
 
-    self.timer.cancel()
-    if isinstance(e, socket.error):
-      self.response = None
-      self.iterator()
-    else:
-      self.lose(e)
+        return False
 
-  def socket_cb(self, af, from_host, from_port, wire):
-    """
-    Received a packet that might be a DNS message.  If it doesn't look
-    like it came from one of our nameservers, just drop it and leave
-    the timer running.  Otherwise, try parsing it: if it's an answer,
-    we're done, otherwise handle error appropriately and move on to
-    next nameserver.
-    """
 
-    sender = (af, dns.inet.inet_pton(af, from_host))
-    if from_port != resolver.port or sender not in self.nameservers:
-      return
-    self.timer.cancel()
-    try:
-      self.response = dns.message.from_wire(wire, keyring = self.request.keyring, request_mac = self.request.mac, one_rr_per_rrset = False)
-    except dns.exception.FormError:
-      self.nameservers.remove(sender)
-    else:
-      rcode = self.response.rcode()
-      if rcode in (dns.rcode.NOERROR, dns.rcode.NXDOMAIN):
-        self.done1()
-        return
-      if rcode != dns.rcode.SERVFAIL:
-        self.nameservers.remove(sender)
-    self.response = None
-    self.iterator()
-
-  def done2(self):
+class query(object):
     """
-    Done with inner loop.  If we still haven't got an answer and
-    haven't (yet?) eliminated all of our nameservers, wait a little
-    while before starting the cycle again, unless we've hit the
-    timeout threshold for the whole query.
+    Simplified (no search paths) asynchronous adaptation of
+    dns.resolver.Resolver.query() (q.v.).
     """
 
-    if self.response is None and self.nameservers:
-      try:
-        delay = rpki.sundial.timedelta(seconds = min(resolver._compute_timeout(self.start), self.backoff))
-        self.backoff *= 2
-        self.timer.set_handler(self.loop1)
-        self.timer.set_errback(self.lose)
-        self.timer.set(delay)
-      except dns.resolver.Timeout, e:
-        self.lose(e)
-    else:
-      self.loop1()
-
-  def cleanup(self):
-    """
-    Shut down our timer and sockets.
-    """
+    def __init__(self, cb, eb, qname, qtype = dns.rdatatype.A, qclass = dns.rdataclass.IN):
+        if isinstance(qname, (str, unicode)):
+            qname = dns.name.from_text(qname)
+        if isinstance(qtype, str):
+            qtype = dns.rdatatype.from_text(qtype)
+        if isinstance(qclass, str):
+            qclass = dns.rdataclass.from_text(qclass)
+        assert qname.is_absolute()
+        self.cb = cb
+        self.eb = eb
+        self.qname = qname
+        self.qtype = qtype
+        self.qclass = qclass
+        self.start = time.time()
+        rpki.async.event_defer(self.go)
+
+    def go(self):
+        """
+        Start running the query.  Check our cache before doing network
+        query; if we find an answer there, just return it.  Otherwise
+        start the network query.
+        """
+
+        if resolver.cache:
+            answer = resolver.cache.get((self.qname, self.qtype, self.qclass))
+        else:
+            answer = None
+        if answer:
+            self.cb(self, answer)
+        else:
+            self.timer = rpki.async.timer()
+            self.sockets = {}
+            self.request = dns.message.make_query(self.qname, self.qtype, self.qclass)
+            if resolver.keyname is not None:
+                self.request.use_tsig(resolver.keyring, resolver.keyname, resolver.keyalgorithm)
+            self.request.use_edns(resolver.edns, resolver.ednsflags, resolver.payload)
+            self.response = None
+            self.backoff = 0.10
+            self.nameservers = nameservers[:]
+            self.loop1()
+
+    def loop1(self):
+        """
+        Outer loop.  If we haven't got a response yet and still have
+        nameservers to check, start inner loop.  Otherwise, we're done.
+        """
+
+        self.timer.cancel()
+        if self.response is None and self.nameservers:
+            self.iterator = rpki.async.iterator(self.nameservers[:], self.loop2, self.done2)
+        else:
+            self.done1()
+
+    def loop2(self, iterator, nameserver):
+        """
+        Inner loop.  Send query to next nameserver in our list, unless
+        we've hit the overall timeout for this query.
+        """
+
+        self.timer.cancel()
+        try:
+            timeout = resolver._compute_timeout(self.start)
+        except dns.resolver.Timeout, e:
+            self.lose(e)
+        else:
+            af, addr = nameserver
+            if af not in self.sockets:
+                self.sockets[af] = dispatcher(self.socket_cb, self.socket_eb, af)
+            self.sockets[af].sendto(self.request.to_wire(),
+                                    (dns.inet.inet_ntop(af, addr), resolver.port))
+            self.timer.set_handler(self.socket_timeout)
+            self.timer.set_errback(self.socket_eb)
+            self.timer.set(rpki.sundial.timedelta(seconds = timeout))
+
+    def socket_timeout(self):
+        """
+        No answer from nameserver, move on to next one (inner loop).
+        """
+
+        self.response = None
+        self.iterator()
+
+    def socket_eb(self, e):
+        """
+        UDP socket signaled error.  If it really is some kind of socket
+        error, handle as if we've timed out on this nameserver; otherwise,
+        pass error back to caller.
+        """
+
+        self.timer.cancel()
+        if isinstance(e, socket.error):
+            self.response = None
+            self.iterator()
+        else:
+            self.lose(e)
+
+    def socket_cb(self, af, from_host, from_port, wire):
+        """
+        Received a packet that might be a DNS message.  If it doesn't look
+        like it came from one of our nameservers, just drop it and leave
+        the timer running.  Otherwise, try parsing it: if it's an answer,
+        we're done, otherwise handle error appropriately and move on to
+        next nameserver.
+        """
+
+        sender = (af, dns.inet.inet_pton(af, from_host))
+        if from_port != resolver.port or sender not in self.nameservers:
+            return
+        self.timer.cancel()
+        try:
+            self.response = dns.message.from_wire(wire, keyring = self.request.keyring, request_mac = self.request.mac, one_rr_per_rrset = False)
+        except dns.exception.FormError:
+            self.nameservers.remove(sender)
+        else:
+            rcode = self.response.rcode()
+            if rcode in (dns.rcode.NOERROR, dns.rcode.NXDOMAIN):
+                self.done1()
+                return
+            if rcode != dns.rcode.SERVFAIL:
+                self.nameservers.remove(sender)
+        self.response = None
+        self.iterator()
+
+    def done2(self):
+        """
+        Done with inner loop.  If we still haven't got an answer and
+        haven't (yet?) eliminated all of our nameservers, wait a little
+        while before starting the cycle again, unless we've hit the
+        timeout threshold for the whole query.
+        """
+
+        if self.response is None and self.nameservers:
+            try:
+                delay = rpki.sundial.timedelta(seconds = min(resolver._compute_timeout(self.start), self.backoff))
+                self.backoff *= 2
+                self.timer.set_handler(self.loop1)
+                self.timer.set_errback(self.lose)
+                self.timer.set(delay)
+            except dns.resolver.Timeout, e:
+                self.lose(e)
+        else:
+            self.loop1()
+
+    def cleanup(self):
+        """
+        Shut down our timer and sockets.
+        """
+
+        self.timer.cancel()
+        for s in self.sockets.itervalues():
+            s.close()
 
-    self.timer.cancel()
-    for s in self.sockets.itervalues():
-      s.close()
+    def lose(self, e):
+        """
+        Something bad happened.  Clean up, then pass error back to caller.
+        """
+
+        self.cleanup()
+        self.eb(self, e)
+
+    def done1(self):
+        """
+        Done with outer loop.  If we got a useful answer, cache it, then
+        pass it back to caller; if we got an error, pass the appropriate
+        exception back to caller.
+        """
+
+        self.cleanup()
+        try:
+            if not self.nameservers:
+                raise dns.resolver.NoNameservers
+            if self.response.rcode() == dns.rcode.NXDOMAIN:
+                raise dns.resolver.NXDOMAIN
+            answer = dns.resolver.Answer(self.qname, self.qtype, self.qclass, self.response)
+            if resolver.cache:
+                resolver.cache.put((self.qname, self.qtype, self.qclass), answer)
+            self.cb(self, answer)
+        except (rpki.async.ExitNow, SystemExit):
+            raise
+        except Exception, e:
+            self.lose(e)
 
-  def lose(self, e):
-    """
-    Something bad happened.  Clean up, then pass error back to caller.
-    """
+class getaddrinfo(object):
 
-    self.cleanup()
-    self.eb(self, e)
+    typemap = { dns.rdatatype.A    : socket.AF_INET,
+                dns.rdatatype.AAAA : socket.AF_INET6 }
+
+    def __init__(self, cb, eb, host, address_families = typemap.values()):
+        self.cb = cb
+        self.eb = eb
+        self.host = host
+        self.result = []
+        self.queries = [query(self.done, self.lose, host, qtype)
+                        for qtype in self.typemap
+                        if self.typemap[qtype] in address_families]
+
+    def done(self, q, answer):
+        if answer is not None:
+            for a in answer:
+                self.result.append((self.typemap[a.rdtype], a.address))
+        self.queries.remove(q)
+        if not self.queries:
+            self.cb(self.result)
 
-  def done1(self):
-    """
-    Done with outer loop.  If we got a useful answer, cache it, then
-    pass it back to caller; if we got an error, pass the appropriate
-    exception back to caller.
-    """
+    def lose(self, q, e):
+        if isinstance(e, dns.resolver.NoAnswer):
+            self.done(q, None)
+        else:
+            for q in self.queries:
+                q.cleanup()
+            self.eb(e)
 
-    self.cleanup()
-    try:
-      if not self.nameservers:
-        raise dns.resolver.NoNameservers
-      if self.response.rcode() == dns.rcode.NXDOMAIN:
-        raise dns.resolver.NXDOMAIN
-      answer = dns.resolver.Answer(self.qname, self.qtype, self.qclass, self.response)
-      if resolver.cache:
-        resolver.cache.put((self.qname, self.qtype, self.qclass), answer)
-      self.cb(self, answer)
-    except (rpki.async.ExitNow, SystemExit):
-      raise
-    except Exception, e:
-      self.lose(e)
+if __name__ == "__main__":
 
-class getaddrinfo(object):
+    rpki.log.init("test-adns")
+    print "Some adns tests may take a minute or two, please be patient"
 
-  typemap = { dns.rdatatype.A    : socket.AF_INET,
-              dns.rdatatype.AAAA : socket.AF_INET6 }
-
-  def __init__(self, cb, eb, host, address_families = typemap.values()):
-    self.cb = cb
-    self.eb = eb
-    self.host = host
-    self.result = []
-    self.queries = [query(self.done, self.lose, host, qtype)
-                    for qtype in self.typemap
-                    if self.typemap[qtype] in address_families]
-
-  def done(self, q, answer):
-    if answer is not None:
-      for a in answer:
-        self.result.append((self.typemap[a.rdtype], a.address))
-    self.queries.remove(q)
-    if not self.queries:
-      self.cb(self.result)
-
-  def lose(self, q, e):
-    if isinstance(e, dns.resolver.NoAnswer):
-      self.done(q, None)
-    else:
-      for q in self.queries:
-        q.cleanup()
-      self.eb(e)
+    class test_getaddrinfo(object):
 
-if __name__ == "__main__":
+        def __init__(self, qname):
+            self.qname = qname
+            getaddrinfo(self.done, self.lose, qname)
 
-  rpki.log.init("test-adns")
-  print "Some adns tests may take a minute or two, please be patient"
+        def done(self, result):
+            print "getaddrinfo(%s) returned: %s" % (
+                self.qname,
+                ", ".join(str(r) for r in result))
 
-  class test_getaddrinfo(object):
+        def lose(self, e):
+            print "getaddrinfo(%s) failed: %r" % (self.qname, e)
 
-    def __init__(self, qname):
-      self.qname = qname
-      getaddrinfo(self.done, self.lose, qname)
+    class test_query(object):
 
-    def done(self, result):
-      print "getaddrinfo(%s) returned: %s" % (
-        self.qname,
-        ", ".join(str(r) for r in result))
+        def __init__(self, qname, qtype = dns.rdatatype.A, qclass = dns.rdataclass.IN):
+            self.qname = qname
+            self.qtype = qtype
+            self.qclass = qclass
+            query(self.done, self.lose, qname, qtype = qtype, qclass = qclass)
 
-    def lose(self, e):
-      print "getaddrinfo(%s) failed: %r" % (self.qname, e)
+        def done(self, q, result):
+            print "query(%s, %s, %s) returned: %s" % (
+                self.qname,
+                dns.rdatatype.to_text(self.qtype),
+                dns.rdataclass.to_text(self.qclass),
+                ", ".join(str(r) for r in result))
 
-  class test_query(object):
+        def lose(self, q, e):
+            print "getaddrinfo(%s, %s, %s) failed: %r" % (
+                self.qname,
+                dns.rdatatype.to_text(self.qtype),
+                dns.rdataclass.to_text(self.qclass),
+                e)
 
-    def __init__(self, qname, qtype = dns.rdatatype.A, qclass = dns.rdataclass.IN):
-      self.qname = qname
-      self.qtype = qtype
-      self.qclass = qclass
-      query(self.done, self.lose, qname, qtype = qtype, qclass = qclass)
+    if True:
+        for t in (dns.rdatatype.A, dns.rdatatype.AAAA, dns.rdatatype.HINFO):
+            test_query("subvert-rpki.hactrn.net", t)
+        test_query("nonexistant.rpki.net")
+        test_query("subvert-rpki.hactrn.net", qclass = dns.rdataclass.CH)
 
-    def done(self, q, result):
-      print "query(%s, %s, %s) returned: %s" % (
-        self.qname,
-        dns.rdatatype.to_text(self.qtype),
-        dns.rdataclass.to_text(self.qclass),
-        ", ".join(str(r) for r in result))
+    for h in ("subvert-rpki.hactrn.net", "nonexistant.rpki.net"):
+        test_getaddrinfo(h)
 
-    def lose(self, q, e):
-      print "getaddrinfo(%s, %s, %s) failed: %r" % (
-        self.qname,
-        dns.rdatatype.to_text(self.qtype),
-        dns.rdataclass.to_text(self.qclass),
-        e)
-
-  if True:
-    for t in (dns.rdatatype.A, dns.rdatatype.AAAA, dns.rdatatype.HINFO):
-      test_query("subvert-rpki.hactrn.net", t)
-    test_query("nonexistant.rpki.net")
-    test_query("subvert-rpki.hactrn.net", qclass = dns.rdataclass.CH)
-
-  for h in ("subvert-rpki.hactrn.net", "nonexistant.rpki.net"):
-    test_getaddrinfo(h)
-
-  rpki.async.event_loop()
+    rpki.async.event_loop()
author	Rob Austein <sra@hactrn.net>	2015-10-26 06:29:00 +0000
committer	Rob Austein <sra@hactrn.net>	2015-10-26 06:29:00 +0000
commit	b46deb1417dc3596e9ac9fe2fe8cc0b7f42457e7 (patch)
tree	ca0dc0276d1adc168bc3337ce0564c4ec4957c1b /rpki/adns.py
parent	397beaf6d9900dc3b3cb612c89ebf1d57b1d16f6 (diff)