dnsruby 1.58.0 → 1.59.0

data/demo/check_zone.rb

@@ -1,3 +1,5 @@
+#! /usr/bin/env ruby
+
 # --
 # Copyright 2007 Nominet UK
 # 
@@ -28,6 +30,7 @@
 # 
 # * Checks that all A records have corresponding PTR records.
 # 
+
 # * Checks that hosts listed in NS, MX, and CNAME records have
 # A records.
 # 
@@ -42,132 +45,134 @@
 # 
 
 
+def fatal_error(message)
+  puts message
+  exit(-1)
+end
+
+unless (1..2).include?(ARGV.length)
+  fatal_error("Usage: #{$0}  domain [ class ]")
+end
+
+
 require 'dnsruby'
 require 'getoptLong'
 
+
 def check_domain(args)
   domain = args[0]
-  klass = "IN"
-  if (args.length > 1)
-    klass = args[1]
-  end
-  print "----------------------------------------------------------------------\n"
-  print "#{domain} (class #{klass}\n"
-  print "\n"
-
-  res = Dnsruby::Resolver.new
-  res.retry_times=(2)
-  nspack = nil
-  begin
-    nspack = res.query(domain, "NS", klass)
+  klass = args[1] || 'IN'
+  puts "----------------------------------------------------------------------"
+  puts "#{domain} (class #{klass}\n"
+  puts "----------------------------------------------------------------------"
+
+  resolver = Dnsruby::Resolver.new
+  resolver.retry_times = 2
+  nspack = begin
+    resolver.query(domain, 'NS', klass)
   rescue Exception => e
     print "Couldn't find nameservers for #{domain}: #{e}\n"
     return
   end
 
   print "nameservers (will request zone from first available):\n"
-  ns=""
-  (nspack.answer.select {|r| r.type == "NS"}).each do |ns|
-    print "\t", ns.domainname, "\n"
-  end
-  print "\n"
+  ns_answers = nspack.answer.select {|r| r.type == 'NS' }
+  ns_domain_names = ns_answers.map(&:domainname)
+  ns_domain_names.each { |name| puts "\t#{name}" }
+  puts ''
 
-  res.nameserver= (nspack.answer.select {|i| i.type == "NS"}).collect {|i| i.domainname.to_s}
+  resolver.nameserver = ns_domain_names
 
   zt = Dnsruby::ZoneTransfer.new
-  zt.server=(nspack.answer.select {|i| i.type == "NS"}).collect {|i| i.domainname.to_s}
+  zt.server = ns_domain_names
+
   zone = zt.transfer(domain) # , klass)
-  unless (zone)
-    print "Zone transfer failed: ", res.errorstring, "\n"
-    return
+  unless zone
+    fatal_error("Zone transfer failed: #{resolver.errorstring}")
   end
 
-  print "checking PTR records\n"
+  puts "checking PTR records"
   check_ptr(domain, klass, zone)
-  print "\n"
 
-  print "checking NS records\n"
+  puts "\nchecking NS records"
   check_ns(domain, klass, zone)
-  print "\n"
 
-  print "checking MX records\n"
+  puts "\nchecking MX records"
   check_mx(domain, klass, zone)
-  print "\n"
 
-  print "checking CNAME records\n"
+  puts "\nchecking CNAME records"
   check_cname(domain, klass, zone)
   print "\n"
 
-  if (@recurse)
-    print "checking subdomains\n\n"
+  if @recurse
+    puts 'checking subdomains'
     subdomains = Hash.new
-    #           foreach (grep { $_->type eq "NS" and $_->name ne $domain } @zone) {
-    (zone.select {|i| i.type == "NS" && i.name != domain}).each do |z|
+    #           foreach (grep { $_->type eq 'NS' and $_->name ne $domain } @zone) {
+    zone.select { |i| i.type == 'NS' && i.name != domain }.each do |z|
       subdomains[z.name] = 1
     end
     #           foreach (sort keys %subdomains) {
     subdomains.keys.sort.each do |k|
-      check_domain(k, klass)
+      check_domain([k, klass])
     end
   end
 end
 
 def check_ptr(domain, klass, zone)
-  res = Dnsruby::Resolver.new
-  #   foreach $rr (grep { $_->type eq "A" } @zone) {
-  (zone.select {|z| z.type == "A"}).each do |rr|
+  resolver = Dnsruby::Resolver.new
+  #   foreach $rr (grep { $_->type eq 'A' } @zone) {
+  zone.select { |z| z.type == 'A' }.each do |rr|
     host = rr.name
     addr = rr.address
-    ans= nil
+    ans = nil
     begin
-    ans = res.query(addr.to_s, "A") #, klass)
-    print "\t#{host} (#{addr}) has no PTR record\n" if (ans.header.ancount < 1)
+      ans = resolver.query(addr.to_s, 'A') #, klass)
+      puts "\t#{host} (#{addr}) has no PTR record" if ans.header.ancount < 1
     rescue Dnsruby::NXDomain
-      print "\t#{host} (#{addr}) returns NXDomain\n"
+      puts "\t#{host} (#{addr}) returns NXDomain"
     end
   end
 end
 
 def check_ns(domain, klass, zone)
-  res = Dnsruby::Resolver.new
+  resolver = Dnsruby::Resolver.new
   #   foreach $rr (grep { $_->type eq "NS" } @zone) {
-  (zone.select { |z| z.type == "NS" }).each do |rr|
-    ans = res.query(rr.nsdname, "A", klass)
-    print "\t", rr.nsdname, " has no A record\n" if (ans.header.ancount < 1)
+  zone.select { |z| z.type == 'NS' }.each do |rr|
+    ans = resolver.query(rr.nsdname, 'A', klass)
+    puts "\t", rr.nsdname, ' has no A record' if (ans.header.ancount < 1)
   end
 end
 
 def check_mx(domain, klass, zone)
-  res = Dnsruby::Resolver.new
+  resolver = Dnsruby::Resolver.new
   #   foreach $rr (grep { $_->type eq "MX" } @zone) {
-  zone.select {|z| z.type == "MX"}.each do |rr|
-    ans = res.query(rr.exchange, "A", klass)
+  zone.select { |z| z.type == 'MX' }.each do |rr|
+    ans = resolver.query(rr.exchange, 'A', klass)
     print "\t", rr.exchange, " has no A record\n" if (ans.header.ancount < 1)
   end
 end
 
 def check_cname(domain, klass, zone)
-  res = Dnsruby::Resolver.new
+  resolver = Dnsruby::Resolver.new
   #   foreach $rr (grep { $_->type eq "CNAME" } @zone)
-  zone.select {|z| z.type == "CNAME"}.each do |rr|
-    ans = res.query(rr.cname, "A", klass)
+  zone.select { |z| z.type == 'CNAME' }.each do |rr|
+    ans = resolver.query(rr.cname, 'A', klass)
     print "\t", rr.cname, " has no A record\n" if (ans.header.ancount < 1)
   end
 end
 
-opts = GetoptLong.new(["-r", GetoptLong::NO_ARGUMENT])
-@recurse = false
-opts.each do |opt, arg|
-  case opt
-  when '-r'
-    @recurse=true
+def main
+  opts = GetoptLong.new(['-r', GetoptLong::NO_ARGUMENT])
+  @recurse = false
+  opts.each do |opt, arg|
+    case opt
+    when '-r'
+      @recurse = true
+    end
   end
-end
-
-if (ARGV.length >=1 && ARGV.length <=2)
 
   check_domain(ARGV)
-  exit
-else
-  print "Usage: #{$0} [ -r ] domain [ class ]\n"
 end
+
+
+main

data/demo/digdlv.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 # --
 # Copyright 2007 Nominet UK
 # 
@@ -40,46 +41,43 @@
 # Michael Fuhr <mike@fuhr.org>
 # Alex D <alexd@nominet.org.uk>
 
-begin
-require 'rubygems'
-rescue LoadError
-end
 require 'dnsruby'
-include Dnsruby
 
-raise RuntimeError, "Usage: #{$0}  name [ type [ class ] ]\n" unless (ARGV.length >= 1) && (ARGV.length <= 3)
+def fatal_error(message)
+  puts message
+  exit -1
+end
 
+unless (1..3).include?(ARGV.length)
+  fatal_error("Usage: #{$0}  name [ type [ class ] ]")
+end
 
-res = Dnsruby::Recursor.new
-zt=Dnsruby::ZoneTransfer.new
+resolver = Dnsruby::Recursor.new
+zone_transfer = Dnsruby::ZoneTransfer.new
 
-dlv_key = RR.create("dlv.isc.org. IN DNSKEY 257 3 5 BEAAAAPHMu/5onzrEE7z1egmhg/WPO0+juoZrW3euWEn4MxDCE1+lLy2 brhQv5rN32RKtMzX6Mj70jdzeND4XknW58dnJNPCxn8+jAGl2FZLK8t+ 1uq4W+nnA3qO2+DL+k6BD4mewMLbIYFwe0PG73Te9fZ2kJb56dhgMde5 ymX4BI/oQ+cAK50/xvJv00Frf8kw6ucMTwFlgPe+jnGxPPEmHAte/URk Y62ZfkLoBAADLHQ9IrS2tryAe7mbBZVcOwIeU/Rw/mRx/vwwMCTgNboM QKtUdvNXDrYJDSHZws3xiRXF1Rf+al9UmZfSav/4NWLKjHzpT59k/VSt TDN0YUuWrBNh")
-Dnssec.add_dlv_key(dlv_key)
+dlv_key = Dnsruby::RR.create("dlv.isc.org. IN DNSKEY 257 3 5 BEAAAAPHMu/5onzrEE7z1egmhg/WPO0+juoZrW3euWEn4MxDCE1+lLy2 brhQv5rN32RKtMzX6Mj70jdzeND4XknW58dnJNPCxn8+jAGl2FZLK8t+ 1uq4W+nnA3qO2+DL+k6BD4mewMLbIYFwe0PG73Te9fZ2kJb56dhgMde5 ymX4BI/oQ+cAK50/xvJv00Frf8kw6ucMTwFlgPe+jnGxPPEmHAte/URk Y62ZfkLoBAADLHQ9IrS2tryAe7mbBZVcOwIeU/Rw/mRx/vwwMCTgNboM QKtUdvNXDrYJDSHZws3xiRXF1Rf+al9UmZfSav/4NWLKjHzpT59k/VSt TDN0YUuWrBNh")
+Dnsruby::Dnssec.add_dlv_key(dlv_key)
 
 
 name, type, klass = ARGV
-type  ||= "A"
-klass ||= "IN"
+type  ||= 'A'
+klass ||= 'IN'
 
-if (type.upcase == "AXFR")
-  rrs = zt.transfer(name) # , klass)
+if type.upcase == 'AXFR'
+  rrs = zone_transfer.transfer(name) # , klass)
 
-  if (rrs)
-    rrs.each do |rr|
-      print rr.to_s + "\n"
-    end
+  if rrs
+    rrs.each { |rr| puts rr }
   else
-    raise RuntimeError, "zone transfer failed: ", res.errorstring, "\n"
+    fatal_error("Zone transfer failed: #{resolver.errorstring}.")
   end
 
 else
 
-#  Dnsruby::TheLog.level=Logger::DEBUG
   begin
-    answer = nil
-    answer = res.query(name, type, klass)
-    print answer
+    answer = resolver.query(name, type, klass)
+    puts answer
   rescue Exception => e
-    print "query failed: #{e}\n"
+    fatal_error("query failed: #{e}")
   end
 end

data/demo/digroot.rb

@@ -1,3 +1,5 @@
+#! /usr/bin/env ruby
+
 # --
 # Copyright 2007 Nominet UK
 # 
@@ -35,29 +37,31 @@
 # Michael Fuhr <mike@fuhr.org>
 # Alex D <alexd@nominet.org.uk>
 
-begin
-require 'rubygems'
-rescue LoadError
-end
 require 'dnsruby'
-include Dnsruby
 
-raise RuntimeError, "Usage: #{$0} name [ type [ class ] ]\n" unless (ARGV.length >= 1) && (ARGV.length <= 3)
+def fatal_error(message)
+  puts message
+  exit -1
+end
+
+unless (1..3).include?(ARGV.length)
+  fatal_error("Usage: #{$0}  name [ type [ class ] ]")
+end
+
 
-resolver = Dnsruby::Resolver.new()
-resolver.do_validation = true
-res = Dnsruby::Recursor.new(resolver)
+inner_resolver = Dnsruby::Resolver.new
+inner_resolver.do_validation = true
+resolver = Dnsruby::Recursor.new(inner_resolver)
 
 #    Dnsruby::TheLog.level=Logger::DEBUG
 
 name, type, klass = ARGV
-type  ||= "A"
-klass ||= "IN"
-
-  begin
-    answer = nil
-    answer = res.query(name, type, klass)
-    print answer
-  rescue Exception => e
-    print "query failed: #{e}\n"
-  end
+type  ||= 'A'
+klass ||= 'IN'
+
+begin
+  answer = resolver.query(name, type, klass)
+  print answer
+rescue Exception => e
+  fatal_error("query failed: #{e}")
+end

data/demo/example_recurse.rb

@@ -1,3 +1,5 @@
+#! /usr/bin/env ruby
+
 # --
 # Copyright 2007 Nominet UK
 # 
@@ -19,11 +21,23 @@
 
 require 'dnsruby'
 
-res = Dnsruby::Recursor.new
+unless (1..3).include?(ARGV.length)
+  puts "Usage: #{$0} domain [type [ class ]]"
+  exit(-1)
+end
+
+
+resolver = Dnsruby::Recursor.new
+resolver.hints = '198.41.0.4' # A.ROOT-SERVER.NET.
+
+
 Dnsruby::TheLog.level = Logger::DEBUG
+
+
 name, type, klass = ARGV
-type  ||= "A"
-klass ||= "IN"
-res.hints=("198.41.0.4") # A.ROOT-SERVER.NET.
-packet = res.query(name, type, klass)
-print packet.to_s
+type  ||= 'A'
+klass ||= 'IN'
+
+
+packet = resolver.query(name, type, klass)
+puts packet

data/demo/mresolv.rb

@@ -1,3 +1,5 @@
+#! /usr/bin/env ruby
+
 # --
 # Copyright 2007 Nominet UK
 # 
@@ -29,12 +31,19 @@
 # 
 # *-t timeout : Set the query timeout for each name in seconds.
 
+# Examples for running:
+#
+# echo my-domain.com | ./mresolv.rb
+# or
+# ./mresolv.rb  # then type domain name(s) separated by new lines and then ctrl-D
+
 require 'dnsruby'
 require 'getoptLong'
 
-opts = GetoptLong.new(["-d", GetoptLong::NO_ARGUMENT],
-  ["-n", GetoptLong::REQUIRED_ARGUMENT],
-  ["-t", GetoptLong::REQUIRED_ARGUMENT])
+opts = GetoptLong.new(
+  ['-d', GetoptLong::NO_ARGUMENT],
+  ['-n', GetoptLong::REQUIRED_ARGUMENT],
+  ['-t', GetoptLong::REQUIRED_ARGUMENT])
 
 max_outstanding = 32	# number of requests to have outstanding at any time
 timeout = 15    # timeout (seconds)
@@ -42,7 +51,7 @@ debug = false
 opts.each do |opt, arg|
   case opt
   when '-d'
-    Dnsruby.log.level=Logger::INFO
+    Dnsruby.log.level = Logger::INFO
     debug = true
   when '-n'
     max_outstanding = arg.to_i
@@ -51,31 +60,34 @@ opts.each do |opt, arg|
   end
 end
 
-res = Dnsruby::Resolver.new
-res.query_timeout=timeout
+resolver = Dnsruby::Resolver.new
+resolver.query_timeout = timeout
+
 # We want to have a rolling window of max_outstanding queries.
 in_progress = 0
+
 q = Queue.new
 eof = false
-while (!eof)
-  #  Have the thread loop round, send queries until max_num are outstanding.
-  while (!eof && in_progress < max_outstanding)
-    print("DEBUG: reading...") if debug
+
+until eof
+  # Have the thread loop round, send queries until max_num are outstanding.
+  while !eof && in_progress < max_outstanding
+    print('DEBUG: reading...') if debug
     unless (name = gets)
       print("EOF.\n") if debug
       eof = true
       break
     end
     name.chomp!
-    res.send_async(Dnsruby::Message.new(name), q, name)
+    resolver.send_async(Dnsruby::Message.new(name), q, name)
     in_progress += 1
     print("name = #{name}, outstanding = #{in_progress}\n")   if debug
   end
-  #  Keep receiving while the query pool is full, or the list has been queried
-  while (in_progress >= max_outstanding || (eof && in_progress > 0))
+  # Keep receiving while the query pool is full, or the list has been queried
+  while in_progress >= max_outstanding || (eof && in_progress > 0)
     id, result, error = q.pop
     in_progress -= 1
-    if (error)
+    if error
       print("#{id}:\t#{error}\n")
     else
       print("#{result.answer.join("\n")}\n")