dnsruby 1.2 → 1.23

data/demo/axfr.rb

@@ -0,0 +1,176 @@
+#= NAME
+#
+#axfr - Perform a DNS zone transfer
+#
+#= SYNOPSIS
+#
+#axfr [ -fqs ] [ -D directory ] [ @nameserver ] zone
+#
+#= DESCRIPTION
+#
+#axfr performs a DNS zone transfer, prints each record to the standard
+#output, and stores the zone to a file.  If the zone has already been
+#stored in a file, axfr will read the file instead of performing a
+#zone transfer.
+#
+#Zones will be stored in a directory hierarchy.  For example, the
+#zone transfer for foo.bar.com will be stored in the file
+#  HOME/.dns-zones/com/bar/foo/axfr.  The directory can be changed
+#  with the B<-D> option.
+#  
+#  This programs requires that the Storable module be installed.
+#    
+#= OPTIONS
+#    
+#    * -f     Force a zone transfer, even if the zone has already been stored
+#    in a file.
+#    
+#    * -q    Be quiet -- don't print the records from the zone.
+#    
+#    * -s    Perform a zone transfer if the SOA serial number on the nameserver
+#    is different than the serial number in the zone file.
+#    
+#    * -D directory   Store zone files under I<directory> instead of the default directory (see "FILES")
+#    
+#    * nameserver    Query nameserver instead of the default nameserver.
+#    
+#= FILES
+#    
+#  * ${HOME}/.dns-zones   Default directory for storing zone files.
+#      
+#= AUTHOR
+#      
+#      Michael Fuhr <mike@fuhr.org>
+#      
+
+require 'GetoptLong'
+require 'Dnsruby'
+
+#------------------------------------------------------------------------------
+# Read any command-line options and check syntax.
+#------------------------------------------------------------------------------
+
+#getopts("fqsD:");
+opts = GetoptLong.new(["-f", GetoptLong::NO_ARGUMENT],
+  ["-q", GetoptLong::NO_ARGUMENT],
+  ["-D", GetoptLong::REQUIRED_ARGUMENT],
+  ["-s", GetoptLong::NO_ARGUMENT])
+
+opt_q = false
+opt_f = false 
+opt_s = false 
+opt_d = nil
+opts.each do |opt, arg|
+  case opt
+  when '-q'
+    opt_q=true
+  when '-f'
+    opt_f = true
+  when '-s'
+    opt_s = true
+  when '-D'
+    opt_d = arg
+  end
+end
+
+if (ARGV.length < 1) || (ARGV.length > 2)
+  print "Usage: #{$0} [ -fqs ] [ -D directory ] [ @nameserver ] zone\n" 
+else
+  #------------------------------------------------------------------------------
+  # Get the nameserver (if specified) and set up the zone transfer directory
+  # hierarchy.
+  #------------------------------------------------------------------------------
+  
+  nameserver = (ARGV[0] =~ /^@/) ? ARGV.shift : ""
+  nameserver = nameserver.sub(/^@/, "")
+  
+  zone = ARGV.shift 
+  basedir = opt_d!=nil ? opt_d : (ENV["HOME"]!=nil ? ENV["HOME"] : "") + "/.dns-zones"
+  zonedir = zone.split(/\./).reverse.join("/")
+  zonefile = basedir + "/" + zonedir + "/axfr"
+  
+  # Don't worry about the 0777 permissions here - the current umask setting
+  # will be applied.
+  if !(FileTest.directory?basedir) 
+    Dir.mkdir(basedir, 0777) or raise RuntimeError, "can't mkdir #{basedir}: #{$!}\n"
+  end
+  
+  dir = basedir
+  zonedir.split("/").each do |subdir|
+    dir += "/" + subdir
+    if (!FileTest.directory?dir)
+      Dir.mkdir(dir, 0777) or raise RuntimeError, "can't mkdir #{dir}: #{$!}\n"
+    end
+  end
+  
+  #------------------------------------------------------------------------------
+  # Get the zone.
+  #------------------------------------------------------------------------------
+  
+  zonearray = nil
+  
+  if (FileTest.exist?(zonefile) && !opt_f)
+    zoneref = Marshal.load(File.open(zonefile))
+    if (zoneref==nil)
+      raise RuntimeError, "couldn't retrieve zone from #{zonefile}: #{$!}\n"
+    end
+    
+    #----------------------------------------------------------------------
+    # Check the SOA serial number if desired.
+    #----------------------------------------------------------------------
+    
+    if (opt_s)
+      serial_file, serial_zone = nil
+      
+      zoneref.each do |rr|
+        if (rr.type == "SOA")
+          serial_file = rr.serial
+          break
+        end
+      end
+      if serial_file==nil
+        raise RuntimeError,  "no SOA in #{zonefile}\n" 
+      end
+      
+      soa = res.query(zone, "SOA")
+      if soa==nil
+        raise RuntimeError, "couldn't get SOA for #{zone}: " + res.errorstring + "\n" 
+      end
+      
+      soa.answer.each do |rr|
+        if (rr.type == "SOA")
+          serial_zone = rr.serial
+          break
+        end
+      end
+      
+      if (serial_zone != serial_file)
+        opt_f = true
+      end
+    end 
+  else
+    opt_f = true
+  end
+  
+  if (opt_f)
+    print "nameserver = #{nameserver}, zone=#{zone}"
+    zt = Dnsruby::ZoneTransfer.new
+    zt.server=(nameserver) if nameserver!=""
+    
+    zoneref = zt.transfer(zone)
+    if zoneref==nil
+      raise RuntimeError,  "couldn't transfer zone: " + res.errorstring + "\n"
+    end
+    Marshal.dump(zoneref, File.open(zonefile, File::CREAT|File::RDWR))
+  end
+  
+  #------------------------------------------------------------------------------
+  # Print the records in the zone.
+  #------------------------------------------------------------------------------
+  
+  if (!opt_q) 
+    zoneref.each do |z|
+      print z.to_s + "\n"
+    end
+  end  
+end  

data/demo/check_soa.rb

@@ -0,0 +1,141 @@
+#= NAME
+#
+#check_soa - Check a domain's nameservers
+#
+#= SYNOPSIS
+#
+#check_soa domain
+#
+#= DESCRIPTION
+#
+#check_soa queries each of a domain's nameservers for the Start
+#of Authority (SOA) record and prints the serial number.  Errors
+#are printed for nameservers that couldn't be reached or didn't
+#answer authoritatively.
+#
+#= AUTHOR
+#
+#The original Bourne Shell and C versions were printed in
+#"DNS and BIND" by Paul Albitz & Cricket Liu.
+#
+#This Perl version was written by Michael Fuhr <mike@fuhr.org>.
+#
+#= SEE ALSO
+#
+#axfr, check_zone, mresolv, mx, perldig, Net::DNS
+
+require 'Dnsruby'
+
+#------------------------------------------------------------------------------
+# Get the domain from the command line.
+#------------------------------------------------------------------------------
+
+if ARGV.length ==1 
+  domain = ARGV[0]
+  
+  #------------------------------------------------------------------------------
+  # Find all the nameservers for the domain.
+  #------------------------------------------------------------------------------
+  
+  res = Dnsruby::Resolver.new
+  
+  #  res.defnames=(0)
+  res.retry_times=(2)
+  ns_req = nil
+  begin
+    ns_req = res.query(domain, "NS")
+  rescue Exception => e
+    print "Error : #{e}"
+    return
+  end
+  if (ns_req.header.ancount == 0)
+    print "No nameservers found for #{domain}\n"
+    return
+  end 
+  
+  # Send out non-recursive queries
+  res.recurse=(0)
+  
+  
+  #------------------------------------------------------------------------------
+  # Check the SOA record on each nameserver.
+  #------------------------------------------------------------------------------
+  
+   (ns_req.answer.select {|r| r.type == "NS"}).each do |nsrr|
+    
+    #----------------------------------------------------------------------
+    # Set the resolver to query this nameserver.
+    #----------------------------------------------------------------------
+    ns = nsrr.domainname
+    
+    # In order to lookup the IP(s) of the nameserver, we need a Resolver
+    # object that is set to our local, recursive nameserver.  So we create
+    # a new object just to do that.
+    
+    local_res = Dnsruby::Resolver.new
+    a_req=nil
+    begin
+      a_req = local_res.query(ns, 'A')
+    rescue Exception => e
+      print "Can not find address for #{ns}: #{e}\n"
+      next
+    end
+    
+     (a_req.answer.select {|r| r.type == 'A'}).each do |r|
+      ip = r.address
+      #----------------------------------------------------------------------
+      # Ask this IP.
+      #----------------------------------------------------------------------
+      
+      res.nameserver=(ip.to_s)
+      
+      print "#{ns} (#{ip}): "
+      
+      #----------------------------------------------------------------------
+      # Get the SOA record.
+      #----------------------------------------------------------------------
+      soa_req=nil
+      begin
+        soa_req = res.query(domain, 'SOA', 'IN')
+      rescue Exception => e
+        print "Error : #{e}\n"
+        next
+      end
+      
+      #----------------------------------------------------------------------
+      # Is this nameserver authoritative for the domain?
+      #----------------------------------------------------------------------
+      
+      unless (soa_req.header.aa)
+        print "isn't authoritative for #{domain}\n"
+        next
+      end
+      
+      #----------------------------------------------------------------------
+      # We should have received exactly one answer.
+      #----------------------------------------------------------------------
+      
+      unless (soa_req.header.ancount == 1)
+        print "expected 1 answer, got ", soa_req.header.ancount, "\n"
+        next
+      end
+      
+      #----------------------------------------------------------------------
+      # Did we receive an SOA record?
+      #----------------------------------------------------------------------
+      
+      unless ((soa_req.answer)[0].type == "SOA")
+        print "expected SOA, got ", (soa_req.answer)[0].type, "\n"
+        next
+      end
+      
+      #----------------------------------------------------------------------
+      # Print the serial number.
+      #----------------------------------------------------------------------
+      
+      print "has serial number ", (soa_req.answer)[0].serial, "\n"
+    end
+  end
+else
+  print "Usage: #{$0} domain\n"
+end

data/demo/check_zone.rb

@@ -0,0 +1,157 @@
+#= NAME
+#
+#check_zone - Check a DNS zone for errors
+#
+#= SYNOPSIS
+#
+#check_zone [ -r ] <domain>
+#
+#= DESCRIPTION
+#
+#Checks a DNS zone for errors.  Current checks are:
+#
+#* Checks that all A records have corresponding PTR records.
+#
+#* Checks that hosts listed in NS, MX, and CNAME records have
+#A records.
+#
+#= OPTIONS
+#
+#* -r Perform a recursive check on subdomains.
+#
+#= AUTHOR
+#
+#Michael Fuhr <mike@fuhr.org>
+#(Ruby version AlexD, Nominet UK)
+#
+
+
+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)
+  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"
+  
+  res.nameserver= (nspack.answer.select {|i| i.type == "NS"}).collect {|i| i.domainname.to_s}
+  
+  zt = Dnsruby::ZoneTransfer.new
+  zt.server=(nspack.answer.select {|i| i.type == "NS"}).collect {|i| i.domainname.to_s}
+  zone = zt.transfer(domain) # , klass)
+  unless (zone)
+    print "Zone transfer failed: ", res.errorstring, "\n"
+    return
+  end
+  
+  print "checking PTR records\n"
+  check_ptr(domain, klass, zone)
+  print "\n"
+  
+  print "checking NS records\n"
+  check_ns(domain, klass, zone)
+  print "\n"
+  
+  print "checking MX records\n"
+  check_mx(domain, klass, zone)
+  print "\n"
+  
+  print "checking CNAME records\n"
+  check_cname(domain, klass, zone)
+  print "\n"
+  
+  if (@recurse)
+    print "checking subdomains\n\n"
+    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|
+      subdomains[z.name] = 1
+    end
+    #          foreach (sort keys %subdomains) {
+    subdomains.keys.sort.each do |k|
+      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|
+    host = rr.name
+    addr = rr.address
+    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)
+    rescue Dnsruby::NXDomain
+      print "\t#{host} (#{addr}) returns NXDomain\n"
+    end
+  end
+end
+
+def check_ns(domain, klass, zone)
+  res = 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)
+  end
+end
+
+def check_mx(domain, klass, zone)
+  res = 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)
+    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
+  #  foreach $rr (grep { $_->type eq "CNAME" } @zone)
+  zone.select {|z| z.type == "CNAME"}.each do |rr|
+    ans = res.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
+  end
+end
+
+if (ARGV.length >=1 && ARGV.length <=2)
+  
+  check_domain(ARGV)
+  exit
+else 
+  print "Usage: #{$0} [ -r ] domain [ class ]\n"
+end