net-dns 0.1

data/AUTHORS

@@ -0,0 +1,10 @@
+#	$Id: AUTHORS,v 1.2 2005/06/17 10:09:57 bluemonk Exp $	
+
+
+AUTHORS
+
+Net::DNS core developement:
+	Marco Ceresa <ceresa@ieee.org>
+
+Beta testing:
+	

data/README

@@ -0,0 +1,55 @@
+Net::DNS README
+============
+
+  This is a port of the Perl Net::DNS module, written by Michael Fuhr
+and now currently maintained by Olaf Kolkman (www.net-dns.org). It
+keeps the same interfaces and function names, although has a bit
+improved OO and some other stuff.
+It can be used to query DNS servers for various kind of records, perform
+zone transfer and dynamic updates. It has even a class for acting as a
+nameserver.
+This version is quite incomplete. You can use it as a resolver.
+
+
+Requirements
+------------
+
+  * Ruby 1.6
+
+
+Install
+-------
+
+  De-compress archive and enter its top directory.
+  Then type:
+
+   ($ su)
+    # ruby setup.rb
+
+  These simple step installs this program under the default
+  location of Ruby libraries.  You can also install files into
+  your favorite directory by supplying setup.rb some options.
+  Try "ruby setup.rb --help".
+
+
+Usage
+-----
+
+  Have a look on the manual pages.
+  In doc/ you will find many useful documents too.
+
+
+License
+-------
+
+  Net::DNS is distributed under the same license Ruby is.
+
+
+Author
+------
+
+  See AUTHORS
+
+
+#	$Id: README,v 1.2 2005/06/17 15:11:18 bluemonk Exp $	
+

data/Rakefile

@@ -0,0 +1,65 @@
+require 'rake/clean'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/contrib/rubyforgepublisher' 
+require 'rake/gempackagetask' 
+
+require 'rubygems'
+
+desc "Run the tests"
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/net/dns/**/test*.rb']
+  t.verbose = true
+end
+
+desc "Install the library"
+task :install do
+  sh "sudo ruby setup.rb"
+end
+
+desc "Build documentation"
+Rake::RDocTask.new do |rd|
+  rd.rdoc_files.include("lib/net/dns/**/*.rb")
+  rd.options << "-S"
+end
+
+#
+# Gem specifications
+#
+SPEC = Gem::Specification.new do |s|
+  s.name      = "net-dns"
+  s.version   = "0.1"
+  s.author    = "Marco Ceresa"
+  s.email     = "ceresa@gmail.com"
+  s.homepage  = "http://net-dns.rubyforge.org/"
+  s.platform  = Gem::Platform::RUBY
+  s.summary   = "Pure Ruby DNS library"
+  candidates  = Dir.glob("**/*")
+  s.files     = candidates.delete_if do |item|
+                  item.include?("CVS") || item.include?("rdoc") || item.include?("pkg")
+                end
+  s.has_rdoc         = true
+  s.extra_rdoc_files = ["README"]
+  s.description = <<EOF
+A pure Ruby DNS library, similar to the Perl Net::DNS library
+EOF
+end
+
+# 
+# Build packages
+#
+desc "Build packages"
+Rake::GemPackageTask.new(SPEC) do |pkg|
+  pkg.need_zip = true
+  pkg.need_tar = true
+end
+
+# 
+# RubyForge publisher
+#
+desc "Upload project on RubyForge"
+task :upload do
+  rubyforge = Rake::RubyForgePublisher.new("net-dns","bluemonk")
+  rubyforge.upload
+end

data/demo/check_soa.rb

@@ -0,0 +1,120 @@
+#!/usr/bin/env ruby 
+
+# 	$Id: check_soa.rb,v 1.7 2006/07/30 16:53:57 bluemonk Exp $	
+
+
+
+require 'net/dns/resolver'
+
+#------------------------------------------------------------------------------
+# Get the domain from the command line.
+#------------------------------------------------------------------------------
+
+raise ArgumentError, "Usage: check_soa.rb domain\n" unless ARGV.size == 1
+
+domain = ARGV[0]
+
+#------------------------------------------------------------------------------
+# Find all the nameservers for the domain.
+#------------------------------------------------------------------------------
+
+res = Net::DNS::Resolver.new(:defname => false, :retry => 2)
+
+#res.defname=false
+#res.retry=2
+
+
+ns_req = res.query(domain, Net::DNS::NS);
+raise ArgumentError, "No nameservers found for domain: " + res.errorstring + 
+  "\n"	unless ns_req and ns_req.header.anCount > 0
+
+
+# Send out non-recursive queries
+res.recurse=false
+# Do not buffer standard out
+#| = 1;
+
+
+#------------------------------------------------------------------------------
+# Check the SOA record on each nameserver.
+#------------------------------------------------------------------------------
+
+ns_req.each_nameserver do |ns|
+  
+  #----------------------------------------------------------------------
+  # Set the resolver to query this nameserver.
+  #----------------------------------------------------------------------
+  
+  # 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 = Net::DNS::Resolver.new
+  
+  a_req = local_res.query(ns, Net::DNS::A)
+  
+  
+  unless a_req 
+    puts "Can not find address for ns: " + res.errorstring + "\n"
+    next
+  end
+  
+  
+  a_req.each_address do |ip|
+
+    #----------------------------------------------------------------------
+    # Ask this IP.
+    #----------------------------------------------------------------------
+    res.nameservers=ip	
+    
+    print "#{ns} (#{ip}): "
+    
+    #----------------------------------------------------------------------
+    # Get the SOA record.
+    #----------------------------------------------------------------------
+    
+    soa_req = res.send(domain, Net::DNS::SOA, Net::DNS::IN)
+    
+    if soa_req == nil
+      puts res.errorstring, "\n"
+      next
+    end
+    
+    #----------------------------------------------------------------------
+    # Is this nameserver authoritative for the domain?
+    #----------------------------------------------------------------------
+    
+    unless soa_req.header.auth? 
+      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.to_s + "\n"
+      next
+    end
+    
+    #----------------------------------------------------------------------
+    # Did we receive an SOA record?
+    #----------------------------------------------------------------------
+    
+    unless soa_req.answer[0].class == Net::DNS::RR::SOA
+      print "expected SOA, got " + Net::DNS::RR::RRTypes.to_str(soa_req.answer[0].type) + "\n"
+      next
+    end
+    
+    #----------------------------------------------------------------------
+    # Print the serial number.
+    #----------------------------------------------------------------------
+    
+    print "has serial number " + soa_req.answer[0].serial.to_s + "\n"
+    
+  end
+end
+
+
+

data/demo/threads.rb

@@ -0,0 +1,21 @@
+require 'net/dns/resolver'
+
+a = ["ibm.com", "sun.com", "redhat.com"]
+
+threads = []
+
+for dom in a
+  threads << Thread.new(dom) do |domain|
+    res = Net::DNS::Resolver.new
+    res.query(domain, Net::DNS::NS).each_nameserver do |ns|
+      puts "Domain #{domain} has nameserver #{ns}"
+    end
+    puts ""
+  end
+end
+
+threads.each do |t|
+  t.join
+end
+
+

data/gemspec

@@ -0,0 +1,16 @@
+require 'rubygems'
+SPEC = Gem::Specification.new do |s|
+  s.name      = "net-dns"
+  s.version   = "0.1"
+  s.author    = "Marco Ceresa"
+  s.email     = "ceresa@gmail.com"
+  s.homepage  = "http://net-dns.rubyforge.org/"
+  s.platform  = Gem::Platform::RUBY
+  s.summary   = "Pure Ruby DNS library"
+  candidates  = Dir.glob("{bin,docs,lib,tests}/**/*")
+  s.files     = candidates.delete_if do |item|
+                  item.include?("CVS") || item.include?("rdoc")
+                end
+  s.has_rdoc         = true
+  s.extra_rdoc_files = ["README"]
+end

data/lib/net/dns/dns.rb

@@ -0,0 +1,117 @@
+##
+#
+# dns.rb
+#
+# $id$
+#
+##
+
+module Net # :nodoc:
+  module DNS
+    
+    # Version of the library
+    VERSION = 0.1
+    
+    # Packet size in bytes
+    PACKETSZ = 512
+    
+    # Size of the header 
+    HFIXEDSZ = 12
+    
+    # Size of the question portion (type and class)
+    QFIXEDSZ = 4
+    
+    # Size of an RR portion (type,class,lenght and ttl)
+    RRFIXEDSZ = 10
+    
+    # Size of an int 32 bit
+    INT32SZ = 4
+    
+    # Size of a short int
+    INT16SZ = 2
+
+    module QueryTypes
+    
+      SIGZERO   = 0
+      A         = 1
+      NS        = 2
+      MD        = 3
+      MF        = 4
+      CNAME     = 5
+      SOA       = 6
+      MB        = 7
+      MG        = 8
+      MR        = 9
+      NULL      = 10
+      WKS       = 11
+      PTR       = 12
+      HINFO     = 13
+      MINFO     = 14
+      MX        = 15
+      TXT       = 16
+      RP        = 17
+      AFSDB     = 18
+      X25       = 19
+      ISDN      = 20
+      RT        = 21
+      NSAP      = 22
+      NSAPPTR   = 23
+      SIG       = 24
+      KEY       = 25
+      PX        = 26
+      GPOS      = 27
+      AAAA      = 28
+      LOC       = 29
+      NXT       = 30
+      EID       = 31
+      NIMLOC    = 32
+      SRV       = 33
+      ATMA      = 34
+      NAPTR     = 35
+      KX        = 36
+      CERT      = 37
+      DNAME     = 39
+      OPT       = 41
+      DS        = 43
+      SSHFP     = 44
+      RRSIG     = 46
+      NSEC      = 47
+      DNSKEY    = 48
+      UINFO     = 100
+      UID       = 101
+      GID       = 102
+      UNSPEC    = 103
+      TKEY      = 249
+      TSIG      = 250
+      IXFR      = 251
+      AXFR      = 252
+      MAILB     = 253
+      MAILA     = 254
+      ANY       = 255
+
+    end
+    
+    module QueryClasses
+    
+      # Internet class
+      IN        = 1
+      
+      # Chaos class
+      CH        = 3
+    
+      # Hesiod class
+      HS        = 4
+      
+      # None class
+      NONE      = 254
+      
+      # Any class
+      ANY       = 255
+      
+    end
+    
+    include QueryTypes
+    include QueryClasses
+
+  end # module DNS
+end # module Net

data/lib/net/dns/header.rb

@@ -0,0 +1,692 @@
+#---
+# $Id: Header.rb,v 1.5 2006/07/30 16:54:28 bluemonk Exp $
+#+++
+
+require 'net/dns/dns'
+
+module Net # :nodoc:
+  module DNS 
+
+    #
+    # =Name
+    #
+    # Net::DNS::Header - DNS packet header class
+    #
+    # =Synopsis
+    # 
+    #   require 'net/dns/header'
+    #
+    # =Description
+    # 
+    # The Net::DNS::Header class represents the header portion of a 
+    # DNS packet. An Header object is created whenever a new packet
+    # is parsed or as user request.
+    # 
+    #   header = Net::DNS::Header.new
+    #     # ;; id = 18123
+    #     # ;; qr = 0       opCode: 0       aa = 0  tc = 0  rd = 1
+    #     # ;; ra = 0       ad = 0  cd = 0  rcode = 0
+    #     # ;; qdCount = 1  anCount = 0     nsCount = 0     arCount = 0
+    #
+    #   header.format
+    #     #  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    #     #  |             18123             |
+    #     #  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    #     #  |0|   0   |0|0|1|0|0| 0 |   0   |
+    #     #  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    #     #  |               1               |
+    #     #  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    #     #  |               0               |
+    #     #  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    #     #  |               0               |
+    #     #  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    #     #  |               0               |
+    #     #  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    #
+    #   # packet is an instance of Net::DNS::Packet
+    #   header = packet.header
+    #   puts "Answer is #{header.auth? ? '' : 'non'} authoritative"
+    #
+    # A lot of methods were written to keep a compatibility layer with
+    # the Perl version of the library, as long as methods name which are
+    # more or less the same. 
+    #
+    # =Error classes
+    #
+    # Some error classes has been defined for the Net::DNS::Header class,
+    # which are listed here to keep a light and browsable main documentation.
+    # We have:
+    #
+    # * HeaderArgumentError:  canonical argument error
+    # * HeaderWrongCount:     a wrong +count+ parameter has been passed
+    # * HeaderWrongRecursive: a wrong +recursive+ parameter has been passed
+    # * HeaderWrongOpcode:    a not valid +opCode+ has been specified
+    # * HeaderDuplicateID:    the requested ID is already in use
+    #
+    # =Copyright
+    # 
+    # Copyright (c) 2006 Marco Ceresa
+    #
+    # All rights reserved. This program is free software; you may redistribute 
+    # it and/or modify it under the same terms as Ruby itself.
+    #
+    class Header
+
+      # Constant for +opCode+ query
+      QUERY   = 0
+      # Constant for +opCode+ iquery
+      IQUERY  = 1
+      # Constant for +opCode+ status
+      STATUS  = 2
+      # Array with given strings
+      OPARR = %w[QUERY IQUERY STATUS]
+
+      # Constant for +rcode+ Response Code No Error
+      NOERROR = 0
+      # Constant for +rcode+ Response Code Format Error
+      FORMAT = 1
+      # Constant for +rcode+ Response Code Server Format Error
+      SERVER = 2
+      # Constant for +rcode+ Response Code Name Error
+      NAME = 3
+      # Constant for +rcode+ Response Code Not Implemented Error
+      NOTIMPLEMENTED = 4
+      # Constant for +rcode+ Response Code Refused Error
+      REFUSED = 5
+      # Array with given strings
+      CODEARR = %w[NOERROR FORMAT SERVER NAME NOTIMPLEMENTED REFUSED]
+      
+      @@id_arr = []
+      
+      # Reader for +id+ attribute  
+      attr_reader :id
+      # Reader for the operational code
+      attr_reader :opCode
+      # Reader for question section entries number
+      attr_reader :qdCount
+      # Reader for answer section entries number
+      attr_reader :anCount
+      # Reader for authority section entries number
+      attr_reader :nsCount
+      # Reader for addictional section entries number
+      attr_reader :arCount
+      
+      # Creates a new Net::DNS::Header object with the desired values,
+      # which can be specified as an Hash argument. When called without
+      # arguments, defaults are used. If a data string is passed, values 
+      # are taken from parsing the string.
+      #
+      # Examples:
+      #
+      #   # Create a new Net::DNS::Header object
+      #   header = Net::DNS::Header.new
+      #
+      #   # Create a new Net::DNS::Header object passing values
+      #   header = Net::DNS::Header.new(:opCode => 1, :rd => 0)
+      #
+      #   # Create a new Net::DNS::Header object with binary data
+      #   header = Net::DNS::Header.new(data)
+      #
+      # Default values are:
+      #
+      #   :id => auto generated
+      #   :qr      => 0 # Query response flag
+      #   :aa      => 0 # Authoritative answer flag
+      #   :tc      => 0 # Truncated packet flag
+      #   :ra      => 0 # Recursiond available flag
+      #   :rCode   => 0 # Response code (status of the query)
+      #   :opCode  => 0 # Operational code (purpose of the query)
+      #   :cd      => 0 # Checking disable flag
+      #   :ad      => 0 # Only relevant in DNSSEC context
+      #   :rd      => 1 # Recursion desired flag
+      #   :qdCount => 1 # Number of questions in the dns packet
+      #   :anCount => 0 # Number of answer RRs in the dns packet
+      #   :nsCount => 0 # Number of authoritative RRs in the dns packet
+      #   :arCount => 0 # Number of additional RRs in the dns packet
+      #
+      # See also each option for a detailed explanation of usage.
+      #
+      def initialize(arg = {})
+        if arg.kind_of? Hash
+          new_from_hash(arg)
+        else
+          raise HeaderArgumentError, "Wrong argument class: #{arg.class}"
+        end
+      end
+
+      # Creates a new Net::DNS::Header object from binary data, which is 
+      # passed as a string object as argument.
+      # The configurations parameters are taken from parsing the string.
+      #
+      # Example:
+      #
+      #   # Create a new Net::DNS::Header object with binary data
+      #   header = Net::DNS::Header.new(data)
+      #
+      #   header.auth? 
+      #     #=> "true" if it comes from authoritative name server 
+      #
+      def self.parse(arg)
+        if arg.kind_of? String
+          o = allocate
+          o.send(:new_from_binary, arg)
+          o
+        else
+          raise HeaderArgumentError, "Wrong argument class: #{arg.class}"
+        end
+      end
+      
+      
+      # Inspect method, prints out all the options and relative values.
+      # 
+      #   p Net::DNS::Header.new
+      #     # ;; id = 18123
+      #     # ;; qr = 0       opCode: 0       aa = 0  tc = 0  rd = 1
+      #     # ;; ra = 0       ad = 0  cd = 0  rcode = 0
+      #     # ;; qdCount = 1  anCount = 0     nsCount = 0     arCount = 0
+      #
+      # This method will maybe be changed in the future to a more pretty
+      # way of display output.
+      #
+      def inspect 
+        ";; id = #@id\n" +
+          if false # @opCode == "UPDATE"
+            #do stuff
+          else
+            ";; qr = #@qr\t" +
+              "opCode: #{opCode_str}\t" +
+              "aa = #@aa\t" +
+              "tc = #@tc\t" +
+              "rd = #@rd\n" +
+              ";; ra = #@ra\t" +
+              "ad = #@ad\t" +
+              "cd = #@cd\t" +
+              "rcode = #{rCode_str[0] || "NOERROR"}\n" +
+              ";; qdCount = #@qdCount\t"+
+              "anCount = #@anCount\t"+
+              "nsCount = #@nsCount\t"+
+              "arCount = #@arCount\n"
+          end
+      end
+      
+      # The Net::DNS::Header#format method prints out the header
+      # in a special ascii representation of data, in a way 
+      # similar to those often found on RFCs. 
+      #   
+      #   p Net::DNS::Header.new.format
+      #     #  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+      #     #  |             18123             |
+      #     #  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+      #     #  |0|   0   |0|0|1|0|0| 0 |   0   |
+      #     #  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+      #     #  |               1               |
+      #     #  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+      #     #  |               0               |
+      #     #  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+      #     #  |               0               |
+      #     #  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+      #     #  |               0               |
+      #     #  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+      #
+      # This can be very usefull for didactical purpouses :)
+      #
+      def format 
+        del = ("+-" * 16) + "+\n"
+        len = del.length
+        str = del + "|" + @id.to_s.center(len-3) + "|\n"
+        str += del + "|" + @qr.to_s
+        str += "|" + @opCode.to_s.center(7)
+        str += "|" + @aa.to_s
+        str += "|" + @tc.to_s
+        str += "|" + @rd.to_s
+        str += "|" + @ra.to_s
+        str += "|" + @ad.to_s
+        str += "|" + @cd.to_s.center(3)
+        str += "|" + @rCode.to_s.center(7) + "|\n"
+        str += del + "|" + @qdCount.to_s.center(len-3) + "|\n"
+        str += del + "|" + @anCount.to_s.center(len-3) + "|\n"
+        str += del + "|" + @nsCount.to_s.center(len-3) + "|\n"
+        str += del + "|" + @arCount.to_s.center(len-3) + "|\n" + del
+        str
+      end
+      
+      # Returns the header data in binary format, appropriate 
+      # for use in a DNS query packet.
+      #
+      #   hdata = header.data
+      #   puts "Header is #{hdata.size} bytes"
+      #
+      def data
+        arr = []
+        arr.push(@id)
+        arr.push((@qr<<7)|(@opCode<<3)|(@aa<<2)|(@tc<<1)|@rd)
+        arr.push((@ra<<7)|(@ad<<5)|(@cd<<4)|@rCode)
+        arr.push(@qdCount)
+        arr.push(@anCount)
+        arr.push(@nsCount)
+        arr.push(@arCount)
+        arr.pack("n C2 n4")
+      end
+
+      # Set the ID for the current header. Useful when
+      # performing security tests.
+      #
+      def id=(val)
+        if @@id_arr.include? val
+          raise HeaderDuplicateID, "ID #{val} already used"
+        end
+        if (1..65535).include? val
+          @id = val
+          @@id_arr.push val
+        else
+          raise HeaderArgumentError, "ID #{val} out of range"
+        end
+      end
+      
+      # Checks whether the header is a query (+qr+ bit set to 0)
+      #
+      def query?
+        @qr == 0
+      end
+
+      # Set the +qr+ query response flag to be either +true+ or 
+      # +false+. You can also use the values 0 and 1. This flag 
+      # indicates if the DNS packet contains a query or an answer,
+      # so it should be set to +true+ in DNS answer packets.
+      # If +qr+ is +true+, the packet is a response.
+      #
+      def qr=(val)
+        case val
+        when true
+          @qr = 1
+        when false
+          @qr = 0
+        when 0,1
+          @qr = val
+        else
+          raise HeaderArgumentError, ":qr must be true(or 1) or false(or 0)"
+        end
+      end
+
+      # Checks whether the header is a response 
+      # (+qr+ bit set to 1)
+      #
+      def response?
+        @qr == 1
+      end
+
+      # Returns a string representation of the +opCode+
+      #
+      #   puts "Packet is a #{header.opCode_str}"
+      #     #=> Packet is a QUERY
+      #
+      def opCode_str
+        OPARR[@opCode]
+      end
+
+      # Set the +opCode+ variable to a new value. This fields indicates
+      # the type of the question present in the DNS packet; +val+ can be 
+      # one of the values QUERY, IQUERY or STATUS. 
+      #
+      # * QUERY is the standard DNS query
+      # * IQUERY is the inverse query
+      # * STATUS is used to query the nameserver for its status
+      #
+      # Example:
+      # 
+      #   include Net::DNS
+      #   header = Header.new
+      #   header.opCode = Header::STATUS
+      #
+      def opCode=(val)
+        if (0..2).include? val
+          @opCode = val
+        else
+          raise HeaderWrongOpcode, "Wrong opCode value (#{val}), must be QUERY, IQUERY or STATUS"
+        end
+      end
+
+      # Checks whether the response is authoritative
+      #
+      #   if header.auth?
+      #     puts "Response is authoritative"
+      #   else
+      #     puts "Answer is NOT authoritative"
+      #   end
+      #
+      def auth?
+        @aa == 1
+      end
+
+      # Set the +aa+ flag (authoritative answer) to either +true+
+      # or +false+. You can also use 0 or 1. 
+      #
+      # This flag indicates whether a DNS answer packet contains
+      # authoritative data, meaning that is was generated by a 
+      # nameserver authoritative for the domain of the question.
+      #
+      # Must only be set to +true+ in DNS answer packets.
+      #
+      def aa=(val)
+        case val
+        when true
+          @aa = 1
+        when false
+          @aa = 0
+        when 0,1
+          @aa = val
+        else
+          raise HeaderArgumentError, ":aa must be true(or 1) or false(or 0)"
+        end
+      end
+      
+      # Checks whether the packet was truncated
+      #
+      #   # Sending packet using UDP
+      #   if header.truncated?
+      #     puts "Warning, packet has been truncated!"
+      #     # Sending packet using TCP
+      #   end
+      #   # Do something with the answer
+      #
+      def truncated?
+        @tc == 1
+      end
+
+      # Set the +tc+ flag (truncated packet) to either +true+ 
+      # ot +false+. You can also use 0 or 1.
+      #
+      # The truncated flag is used in response packets to indicate
+      # that the amount of data to be trasmitted exceedes the 
+      # maximum allowed by the protocol in use, tipically UDP, and 
+      # that the data present in the packet has been truncated. 
+      # A different protocol (such has TCP) need to be used to 
+      # retrieve full data.
+      #
+      # Must only be set in DNS answer packets.
+      #
+      def tc=(val)
+        case val
+        when true
+          @tc = 1
+        when false
+          @tc = 0
+        when 0,1
+          @tc = val
+        else
+          raise HeaderArgumentError, ":tc must be true(or 1) or false(or 0)"
+        end
+      end
+      
+      # Checks whether the packet has a recursion bit
+      # set, meaning that recursion is desired
+      #
+      def recursive?
+        @rd == 1
+      end
+
+      # Sets the recursion desidered bit.
+      # Remember that recursion query support is
+      # optional.
+      #
+      #   header.recursive = true
+      #   hdata = header.data # suitable for sending
+      #
+      # Consult RFC1034 and RFC1035 for a detailed explanation
+      # of how recursion works.
+      #
+      def recursive=(val)
+        case val
+        when true
+          @rd = 1
+        when false
+          @rd = 0
+        when 1
+          @rd = 1
+        when 0
+          @rd = 0
+        else
+          raise HeaderWrongRecursive, "Wrong value (#{val}), please specify true (1) or false (0)"
+        end
+      end
+
+      # Alias for Header#recursive= to keep compatibility
+      # with the Perl version.
+      #
+      def rd=(val)
+        self.recursive = val
+      end
+      
+      # Checks whether recursion is available.
+      # This flag is usually set by nameservers to indicate
+      # that they support recursive-type queries.
+      #
+      def r_available?
+        @ra == 1
+      end
+
+      # Set the +ra+ flag (recursion available) to either +true+ or
+      # +false+. You can also use 0 and 1.
+      #
+      # This flag must only be set in DNS answer packets.
+      #
+      def ra=(val)
+        case val
+        when true
+          @ra = 1
+        when false
+          @ra = 0
+        when 0,1
+          @ra = val
+        else
+          raise HeaderArgumentError, ":ra must be true(or 1) or false(or 0)"
+        end
+      end
+
+      # Checks whether checking is enabled or disabled.
+      #
+      # Checking is enabled by default.
+      #
+      def checking?
+        @cd == 0
+      end
+
+      # Set the +cd+ flag (checking disabled) to either +true+ 
+      # ot +false+. You can also use 0 or 1.
+      #
+      def cd=(val)
+        case val
+        when true
+          @cd = 1
+        when false
+          @cd = 0
+        when 0,1
+          @cd = val
+        else
+          raise HeaderArgumentError, ":cd must be true(or 1) or false(or 0)"
+        end
+      end
+
+      # Checks whether +ad+ flag has been set.
+      #
+      # This flag is only relevant in DNSSEC context.
+      #
+      def verified?
+        @ad == 1
+      end
+
+      # Set the +ad+ flag  to either +true+ 
+      # ot +false+. You can also use 0 or 1.
+      #
+      # The AD bit is only set on answers where signatures have 
+      # been cryptographically verified or the server is 
+      # authoritative for the data and is allowed to set the bit by policy.
+      #
+      def ad=(val)
+        case val
+        when true
+          @ad = 1
+        when false
+          @ad = 0
+        when 0,1
+          @ad = val
+        else
+          raise HeaderArgumentError, ":ad must be true(or 1) or false(or 0)"
+        end
+      end
+      
+      # Returns an error array for the header response code, or
+      # +nil+ if no error is generated.
+      #
+      #   error, cause = header.rcode_str
+      #   puts "Error #{error} cause by: #{cause}" if error
+      #     #=> Error Format Error caused by: The name server
+      #     #=> was unable to interpret the query
+      #
+      def rCode_str
+        case @rCode
+        when NOERROR
+          return nil,nil
+        when FORMAT
+          return "Format Error", "The name server was unable to interpret the query"
+        when SERVER
+          return "Server Failure", 
+          "The name server was unable to process this query due to problem with the name server"
+        when NAME
+          return "Name Error", "Domain name referenced in the query does not exists"
+        when NOTIMPLEMENTED
+          return "Not Implemented", 
+          "The name server does not support the requested kind of query"
+        when REFUSED
+          return "Refused",
+          "The name server refuses to perform the specified operation for policy reasons"
+        end
+      end
+
+      # Return the value of rCode variable
+      #
+      #   if header.rcode == Net::DNS::Header::NOERROR
+      #     puts "No errors in DNS answer packet"
+      #   end
+      #
+      def rCode
+        @rCode
+      end
+      
+      # Set the rCode value. This should only be done in DNS 
+      # answer packets.
+      #
+      def rCode=(val)
+        if (0..5).include? val
+          @rCode = val
+        else
+          raise HeaderArgumentError, ":rCode must be one of #{CODEARR.join(" ")}"
+        end
+      end
+      
+      # Sets the number of entries in a question section
+      #
+      def qdCount=(val)
+        if (0..65535).include? val
+          @qdCount = val
+        else
+          raise HeaderWrongCount, "Wrong number of count (#{val}), must be 0-65535"
+        end
+      end
+
+      # Sets the number of RRs in an answer section
+      #
+      def anCount=(val)
+        if (0..65535).include? val
+          @anCount = val
+        else
+          raise HeaderWrongCount, "Wrong number of count (#{val}), must be 0-65535"
+        end
+      end
+
+      # Sets the number of RRs in an authority section
+      #
+      def nsCount=(val)
+        if (0..65535).include? val
+          @nsCount = val
+        else
+          raise HeaderWrongCount, "Wrong number of count (#{val}), must be 0-65535"
+        end
+      end
+
+      # Sets the number of RRs in an addictional section
+      #
+      def arCount=(val)
+        if (0..65535).include? val
+          @arCount = val
+        else
+          raise HeaderWrongCount, "Wrong number of count (#{val}), must be 0-65535"
+        end
+      end
+
+      private
+      
+      def new_from_scratch
+        @id = genID # generate ad unique id
+        @qr = @aa = @tc = @ra = @ad = @cd = 0
+        @rCode = NOERROR 
+        @anCount = @nsCount = @arCount = 0
+        @rd = @qdCount = 1
+        @opCode = QUERY # standard query, default message 
+      end
+      
+      def new_from_binary(str)
+        unless str.size == Net::DNS::HFIXEDSZ
+          raise HeaderArgumentError, "Header binary data has wrong size: #{str.size} bytes"
+        end
+        arr = str.unpack("n C2 n4")
+        @id          =  arr[0]
+        @qr          = (arr[1] >> 7) & 0x01
+        @opCode      = (arr[1] >> 3) & 0x0F
+        @aa          = (arr[1] >> 2) & 0x01
+        @tc          = (arr[1] >> 1) & 0x01
+        @rd          =  arr[1] & 0x1
+        @ra          = (arr[2] >> 7) & 0x01
+        @ad          = (arr[2] >> 5) & 0x01
+        @cd          = (arr[2] >> 4) & 0x01
+        @rCode       =  arr[2] & 0xf
+        @qdCount     =  arr[3]
+        @anCount     =  arr[4]
+        @nsCount     =  arr[5]
+        @arCount     =  arr[6]
+      end
+        
+      def new_from_hash(hash)
+        new_from_scratch
+        hash.each do |key,val|
+          eval "self.#{key.to_s} = val"
+        end
+      end
+        
+      def genID
+        while (@@id_arr.include?(q = rand(65535)))
+        end
+        @@id_arr.push(q)
+        q
+      end
+
+    end # class Header
+
+  end # class DNS
+end # module Net
+
+
+class HeaderArgumentError < ArgumentError # :nodoc: all
+end
+
+class HeaderWrongCount < ArgumentError # :nodoc: all
+end
+
+class HeaderWrongRecursive < ArgumentError # :nodoc: all
+end
+
+class HeaderWrongOpcode < ArgumentError # :nodoc: all
+end
+
+class HeaderDuplicateID < ArgumentError # :nodoc: all
+end