rubydns 0.1.8

data/README.rdoc

@@ -0,0 +1,62 @@
+= RubyDNS
+
+Author::    Samuel Williams (http://www.oriontransfer.co.nz/)
+Copyright:: Copyright (C) 2009 Samuel Williams
+License::   GPLv3
+
+RubyDNS is a simple programmatic DSL (domain specific language) for configuring and running a DNS server. RubyDNS provides a daemon that runs a DNS server which can process DNS requests depending on specific policy. Rule selection is based on pattern matching, and results can be hard-coded, computed, fetched from a remote DNS server, fetched from a local cache, etc.
+
+RubyDNS provides a full daemon server using RExec. You can either use the built in daemon, customize it to your needs, or specify a full daemon implementation.
+
+RubyDNS is not designed to be high-performance and uses a thread-per-request model. This is designed to make it as easy as possible to achieve concurrent performance. This is also due to the fact that many other APIs work best this way (unfortunately).
+
+== Basic Example
+
+This is copied from <tt>test/example1.rb</tt>. It has been simplified slightly.
+
+  require 'rubygems'
+  require 'rubydns'
+
+  $R = Resolv::DNS.new
+
+  RubyDNS::run_server do
+  	# For this exact address record, return an IP address
+  	match("dev.mydomain.org", :A) do |transaction|
+  		transaction.respond!("10.0.0.80")
+  	end
+	
+  	match(/^test([0-9]+).mydomain.org$/, :A) do |match_data, transaction|
+  		offset = match_data[1].to_i
+		
+  		if offset > 0 && offset < 10
+  			logger.info "Responding with address #{"10.0.0." + (90 + offset).to_s}..."
+  			transaction.respond!("10.0.0." + (90 + offset).to_s)
+  		else
+  			logger.info "Address out of range: #{offset}!"
+  			false
+  		end
+  	end
+
+  	# Default DNS handler
+  	otherwise do |transaction|
+  		logger.info "Passing DNS request upstream..."
+  		transaction.passthrough!($R)
+  	end
+  end
+
+After starting this server you can test it using dig:
+
+  dig @localhost test1.mydomain.org
+  dig @localhost dev.mydomain.org
+  dig @localhost google.com
+
+
+== Todo
+
+* Better support for logging output
+* Support for TCP connections
+* Support for more features of DNS such as zone transfer
+* Support reverse records more easily?
+
+
+

data/bin/rd-dns-check

@@ -0,0 +1,370 @@
+#!/usr/bin/env ruby
+# Copyright (c) 2009 Samuel Williams. Released under the GNU GPLv3.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+# Pulls down DNS data from old-dns
+# rd-dns-check -s old-dns.mydomain.com -d mydomain.com. -f old-dns.yml
+
+# Check data against old-dns
+# rd-dns-check -s old-dns.mydomain.com -d mydomain.com. -c old-dns.yml
+
+# Check data against new DNS server
+# rd-dns-check -s 10.0.0.36 -d mydomain.com. -c old-dns.yml
+
+require 'yaml'
+require 'optparse'
+require 'set'
+
+class DNSRecord
+  def initialize(arr)
+    @record = arr
+    normalize
+  end
+  
+  def normalize
+    @record[0] = @record[0].downcase
+    @record[1] = @record[1].upcase
+    @record[2] = @record[2].upcase
+    @record[3] = @record[3].downcase
+  end
+  
+  def hostname
+    @record[0]
+  end
+  
+  def klass
+    @record[1]
+  end
+  
+  def type
+    @record[2]
+  end
+  
+  def value
+    @record[3]
+  end
+  
+  def is_address?
+    ["A", "AAAA"].include?(type)
+  end
+  
+  def is_cname?
+    return type == "CNAME"
+  end
+  
+  def to_s
+    "#{hostname.ljust(50)} #{klass.rjust(4)} #{type.rjust(5)} #{value}"
+  end
+  
+  def key
+    "#{hostname}:#{klass}:#{type}".downcase
+  end
+  
+  def to_a
+    @record
+  end
+  
+  def == other
+    return @record == other.to_a
+  end
+end
+
+def dig(dns_server, cmd, exclude = ["TXT", "HINFO", "SOA", "NS"])
+	records = []
+	
+	IO.popen("dig @#{dns_server} +nottlid +nocmd +noall +answer " + cmd) do |p|
+		p.each do |line|
+			r = line.chomp.split(/\s/, 4)
+			
+			next if exclude.include?(r[2])
+      
+			records << DNSRecord.new(r)
+		end
+	end
+	
+	return records
+end
+
+def retrieve_records(dns_server, dns_root)
+	return dig(dns_server, "#{dns_root} AXFR")
+end
+
+def resolve_hostname(dns_server, hostname)
+  return dig(dns_server, "#{hostname} A").first
+end
+
+def resolve_address(dns_server, address)
+  return dig(dns_server, "-x #{address}").first
+end
+
+def print_summary(records, errors, okay, &block)
+  puts "[ Summary ]".center(72, "=")
+  puts "Checked #{records.size} record(s). #{errors} errors."
+  if errors == 0
+    puts "Everything seemed okay."
+  else
+    puts "The following records are okay:"
+    okay.each do |r|
+      if block_given?
+        yield r
+      else
+        puts "".rjust(12) + r.to_s
+      end
+    end
+  end
+end
+
+# Resolve hostnames to IP address "A" or "AAAA" records.
+# Works through CNAME records in order to find out the final
+# address if possible. Checks for loops in CNAME records.
+def resolve_addresses(records)
+  addresses = {}
+  cnames = {}
+  
+  # Extract all hostname -> ip address mappings
+  records.each do |r|
+    if r.is_address?
+      addresses[r.hostname] = r
+    elsif r.is_cname?
+      cnames[r.hostname] = r
+    end
+  end
+  
+  cnames.each do |hostname, r|
+    q = r
+    trail = []
+    failed = false
+    
+    # Keep track of CNAME records to avoid loops
+    while q.is_cname?
+      trail << q
+      q = cnames[q.value] || addresses[q.value]
+      
+      # Q could be nil at this point, which means there was no address record
+      # Q could be already part of the trail, which means there was a loop
+      if q == nil || trail.include?(q)
+        failed = true
+        break
+      end
+    end
+    
+    if failed
+      q = trail.last
+      puts "*** Warning: CNAME record #{hostname} does not point to actual address!"
+      trail.each_with_index do |r, idx|
+        puts idx.to_s.rjust(10) + ": " + r.to_s
+      end
+    end
+    
+    addresses[r.hostname] = q
+  end
+  
+  return addresses, cnames
+end
+
+def check_reverse(records, dns_server)
+  errors = 0
+  okay = []
+  
+  puts "[ Checking Reverse Lookups ]".center(72, "=")
+  
+  records.each do |r|
+    next unless r.is_address?
+    
+    sr = resolve_address(dns_server, r.value)
+    
+    if sr == nil
+      puts "*** Could not resolve host"
+      puts "".rjust(12) + r.to_s
+      errors += 1
+    elsif r.hostname != sr.value
+      puts "*** Hostname does not match"
+      puts "Primary: ".rjust(12) + r.to_s
+      puts "Secondary: ".rjust(12) + sr.to_s
+      errors += 1
+    else
+      okay << [r, sr]
+    end
+  end
+  
+  print_summary(records, errors, okay) do |r|
+    puts "Primary:".rjust(12) + r[0].to_s
+    puts "Secondary:".rjust(12) + r[1].to_s
+  end
+end
+
+def ping_records(records)
+  addresses, cnames = resolve_addresses(records)
+
+  errors = 0
+  okay = []
+
+  puts "[ Pinging Records ]".center(72, "=")
+  
+  addresses.each do |hostname, r|
+    ping = "ping -c 5 -t 5 -i 1 -o #{r.value} > /dev/null"
+    
+    system(ping)
+    
+    if $?.exitstatus == 0
+      okay << r
+    else
+      puts "*** Could not ping host #{hostname.dump}: #{ping.dump}"
+      puts "".rjust(12) + r.to_s
+      errors += 1
+    end
+  end
+  
+  print_summary(records, errors, okay)
+end
+
+def query_records(primary, secondary_server)
+  addresses, cnames = resolve_addresses(primary)
+  
+  okay = []
+  errors = 0
+  
+  primary.each do |r|
+    sr = resolve_hostname(secondary_server, r.hostname)
+    
+    if sr == nil
+      puts "*** Could not resolve hostname #{r.hostname.dump}"
+      puts "Primary: ".rjust(12) + r.to_s
+      
+      rsr = resolve_address(secondary_server, (addresses[r.value] || r).value)
+      puts "Address: ".rjust(12) + rsr.to_s if rsr
+      
+      errors += 1
+    elsif sr.value != r.value
+      ra = addresses[r.value] if r.is_cname?
+      sra = addresses[sr.value] if sr.is_cname?
+      
+      if (sra || sr).value != (ra || r).value
+        puts "*** IP Address does not match"
+        puts "Primary: ".rjust(12) + r.to_s
+        puts "Resolved: ".rjust(12) + ra.to_s if ra
+        puts "Secondary: ".rjust(12) + sr.to_s
+        puts "Resolved: ".rjust(12) + sra.to_s if sra
+        errors += 1
+      end
+    else
+      okay << r
+    end
+  end
+  
+  print_summary(primary, errors, okay)
+end
+
+def check_records(primary, secondary)
+  s = {}
+  okay = []
+  errors = 0
+  
+  secondary.each do |r|
+    s[r.key] = r
+  end
+
+  puts "[ Checking Records ]".center(72, "=")
+
+  primary.each do |r|
+    sr = s[r.key]
+    
+    if sr == nil
+      puts "*** Could not find record"
+      puts "Primary: ".rjust(12) + r.to_s
+      errors += 1
+    elsif sr != r
+      puts "*** Records are different"
+      puts "Primary: ".rjust(12) + r.to_s
+      puts "Secondary: ".rjust(12) + sr.to_s
+      errors += 1
+    else
+      okay << r
+    end
+  end
+  
+  print_summary(primary, errors, okay)
+end
+
+OPTIONS = {
+	:DNSServer => nil,
+	:DNSRoot => ".",
+}
+
+ARGV.options do |o|
+  script_name = File.basename($0)
+  
+  o.set_summary_indent('  ')
+  o.banner = "Usage: #{script_name} [options]"
+  o.define_head "This script is designed to test and check DNS servers."
+  
+  o.on("-s ns.my.domain.", "--server ns.my.domain.", String, "The DNS server to query.") { |host| OPTIONS[:DNSServer] = host }
+  o.on("-d my.domain.", "--domain my.domain.", String, "The DNS zone to transfer/test.") { |host| OPTIONS[:DNSRoot] = host }
+  
+  o.on("-f output.yml", "--fetch output.yml", String, "Pull down a list of hosts. Filters TXT and HINFO records. DNS transfers must be enabled.") { |f|
+    records = retrieve_records(OPTIONS[:DNSServer], OPTIONS[:DNSRoot])
+    
+    output = (f ? File.open(f, "w") : STDOUT)
+    
+    output.write(YAML::dump(records))
+    
+    puts "#{records.size} record(s) retrieved."
+  }
+  
+  o.on("-c input.yml", "--check input.yml", String, "Check that the DNS server returns results as specified by the file.") { |f|
+    input = (f ? File.open(f) : STDIN)
+    
+    master_records = YAML::load(input.read)
+    secondary_records = retrieve_records(OPTIONS[:DNSServer], OPTIONS[:DNSRoot])
+    
+    check_records(master_records, secondary_records)
+  }
+  
+  o.on("-q input.yml", "--query input.yml", String, "Query the remote DNS server with all hostnames in the given file, and checks the IP addresses are consistent.") { |f|
+    input = (f ? File.open(f) : STDIN)
+    
+    master_records = YAML::load(input.read)
+    
+    query_records(master_records, OPTIONS[:DNSServer])
+  }
+  
+  o.on("-p input.yml", "--ping input.yml", String, "Ping all hosts to check if they are available or not.") { |f|
+    input = (f ? File.open(f) : STDIN)
+    
+    master_records = YAML::load(input.read)
+    
+    ping_records(master_records)
+  }
+  
+  o.on("-r input.yml", "--reverse input.yml", String, "Check that all address records have appropriate reverse entries.") { |f|
+    input = (f ? File.open(f) : STDIN)
+    
+    master_records = YAML::load(input.read)
+    
+    check_reverse(master_records, OPTIONS[:DNSServer])
+  }
+  
+  o.separator ""
+  o.separator "Help and Copyright information"
+  
+  o.on_tail("--copy", "Display copyright information") {
+    puts "#{script_name}. Copyright (c) 2008 Samuel Williams. Released under the GPLv3."
+    puts "See http://www.oriontransfer.co.nz/ for more information."
+    exit
+  }
+  
+  o.on_tail("-h", "--help", "Show this help message.") { puts o; exit }
+end.parse!

data/bin/rd-resolve-test

@@ -0,0 +1,155 @@
+#!/usr/bin/env ruby
+# Copyright (c) 2009 Samuel Williams. Released under the GNU GPLv3.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'rubydns/version'
+
+require 'resolv'
+require 'optparse'
+
+OPTIONS = {
+	:Domains => [],
+	:Nameservers => [],
+	:Timeout => 0.5,
+
+	:Threads => 10,
+	:Requests => 20
+}
+
+ARGV.options do |o|
+	script_name = File.basename($0)
+
+	o.banner = "Usage: #{script_name} [options] nameserver [nameserver]"
+
+	o.on("-d [path]", String, "Specify a file that contains a list of domains") do |path|
+		OPTIONS[:Domains] += File.readlines(path).collect { |name| name.strip.downcase }
+	end
+
+	o.on("-t [timeout]", Float, "Queries that take longer than this will be printed") do |timeout|
+		OPTIONS[:Timeout] = timeout.to_f
+	end
+
+	o.on("--threads [count]", Integer, "Number of threads to resolve names concurrently") do |count|
+		OPTIONS[:Threads] = count.to_i
+	end
+
+	o.on("--requests [count]", Integer, "Number of requests to perform per thread") do |count|
+		OPTIONS[:Requests] = count.to_i
+	end
+
+	o.on_tail("--copy", "Display copyright information") do
+		puts "#{script_name} v#{RubyDNS::VERSION::STRING}. Copyright (c) 2009 Samuel Williams. Released under the GPLv3."
+		puts "See http://www.oriontransfer.co.nz/ for more information."
+
+		exit
+	end
+
+	o.on_tail("-h", "--help", "Show this help message.") { puts o; exit }
+end.parse!
+
+OPTIONS[:Nameservers] = ARGV
+
+if OPTIONS[:Nameservers].size > 0
+	$R = Resolv::DNS.new(:nameserver => ARGV)
+else
+	$R = Resolv::DNS.new
+end
+
+$TG = ThreadGroup.new
+$M = Mutex.new
+$STATUS = {}
+$TOTAL = [0.0, 0]
+
+if OPTIONS[:Domains].size == 0
+	OPTIONS[:Domains] += ["www.google.com", "www.amazon.com", "www.apple.com", "www.microsoft.com"]
+	OPTIONS[:Domains] += ["www.rubygems.org", "www.ruby-lang.org", "www.slashdot.org", "www.lucidsystems.org"]
+	OPTIONS[:Domains] += ["www.facebook.com", "www.twitter.com", "www.myspace.com", "www.youtube.com"]
+	OPTIONS[:Domains] += ["www.oriontransfer.co.nz", "www.digg.com"]
+end
+
+def random_domain
+	d = OPTIONS[:Domains]
+
+	d[rand(d.size - 1)]
+end
+
+puts "Starting test with #{OPTIONS[:Domains].size} domains..."
+puts "Using nameservers: " + OPTIONS[:Nameservers].join(", ")
+puts "Only long running queries will be printed..."
+
+def resolve_domain
+	s = Time.now
+	result = nil
+	name = random_domain
+
+	begin
+		result = [$R.getaddress(name)]
+	rescue Resolv::ResolvError
+		$M.synchronize do
+			puts "Name #{name} failed to resolve!"
+			$STATUS[name] ||= []
+			$STATUS[name] << :failure
+
+			if $STATUS[name].include?(:success)
+				puts "Name #{name} has had previous successes!"
+			end
+		end
+
+		return
+	end
+
+	result.unshift(name)
+	result.unshift(Time.now - s)
+
+	$M.synchronize do	
+		$TOTAL[0] += result[0]
+		$TOTAL[1] += 1
+
+		if result[0] > OPTIONS[:Timeout]
+			puts "\t\t%0.2fs: %s => %s" % result
+		end
+
+		$STATUS[name] ||= []
+		$STATUS[name] << :success
+
+		if $STATUS[name].include?(:failure)
+			puts "Name #{name} has had previous failures!"
+		end
+	end
+end
+
+puts "Starting threads..."
+Thread.abort_on_exception = true
+
+OPTIONS[:Threads].times do
+	th = Thread.new do
+		OPTIONS[:Requests].times do
+			resolve_domain
+		end
+	end
+
+	$TG.add th
+end
+
+$TG.list.each { |thr| thr.join }
+
+$STATUS.each do |name, results|
+	if results.include?(:failure)
+		puts "Name #{name} failed at least once!"
+	end
+end
+
+puts
+puts "Requests: #{$TOTAL[1]} Average time: #{$TOTAL[0] / $TOTAL[1]}"