Dnsruby 0.6.0 → 1.0

data/lib/Dnsruby/ipv4.rb

@@ -14,19 +14,8 @@
 #limitations under the License.
 #++
 module Dnsruby
-#== Dnsruby::IPv4 class
-#=== class methods
-#* Dnsruby::IPv4.create(address)
-#
-#=== methods
-#* Dnsruby::IPv4#to_s
-#* Dnsruby::IPv4#to_name
-#
-#=== constants
-#* Dnsruby::IPv4::Regex
-#    regular expression for IPv4 address.
-#
   class IPv4
+    # Regular expression IPv4 addresses must match
     Regex = /\A(\d+)\.(\d+)\.(\d+)\.(\d+)\z/
     
     def self.create(arg)
@@ -47,19 +36,21 @@ module Dnsruby
       end
     end
     
-    def initialize(address)
+    def initialize(address) #:nodoc:
       unless address.kind_of?(String) && address.length == 4
         raise ArgumentError.new('IPv4 address must be 4 bytes')
       end
       @address = address
     end
+    
+    # A String representation of thi IPv4 address.
     attr_reader :address
     
-    def to_s
+    def to_s #:nodoc:
       return sprintf("%d.%d.%d.%d", *@address.unpack("CCCC"))
     end
     
-    def inspect
+    def inspect #:nodoc:
       return "#<#{self.class} #{self.to_s}>"
     end
     

data/lib/Dnsruby/ipv6.rb

@@ -14,47 +14,45 @@
 #limitations under the License.
 #++
 module Dnsruby
-#== Dnsruby::IPv6 class
-#=== class methods
-#* Dnsruby::IPv6.create(address)
-#
-#=== methods
-#* Dnsruby::IPv6#to_s
-#* Dnsruby::IPv6#to_name
-#
-#=== constants
-#* Dnsruby::IPv6::Regex
-#    regular expression for IPv6 address.
-#    
+  #Dnsruby::IPv6 class
   class IPv6
+    #IPv6 address format a:b:c:d:e:f:g:h
     Regex_8Hex = /\A
      (?:[0-9A-Fa-f]{1,4}:){7}
     [0-9A-Fa-f]{1,4}
     \z/x
     
+    #Compresses IPv6 format a::b
     Regex_CompressedHex = /\A
      ((?:[0-9A-Fa-f]{1,4}(?::[0-9A-Fa-f]{1,4})*)?) ::
      ((?:[0-9A-Fa-f]{1,4}(?::[0-9A-Fa-f]{1,4})*)?)
     \z/x
     
+    # IPv4 mapped IPv6 address format a:b:c:d:e:f:w.x.y.z
     Regex_6Hex4Dec = /\A
      ((?:[0-9A-Fa-f]{1,4}:){6,6})
      (\d+)\.(\d+)\.(\d+)\.(\d+)
     \z/x
     
+    # Compressed IPv4 mapped IPv6 address format a::b:w.x.y.z
     Regex_CompressedHex4Dec = /\A
      ((?:[0-9A-Fa-f]{1,4}(?::[0-9A-Fa-f]{1,4})*)?) ::
      ((?:[0-9A-Fa-f]{1,4}:)*)
      (\d+)\.(\d+)\.(\d+)\.(\d+)
     \z/x
     
+    # A composite IPv6 address RegExp
     Regex = /
      (?:#{Regex_8Hex}) |
      (?:#{Regex_CompressedHex}) |
      (?:#{Regex_6Hex4Dec}) |
      (?:#{Regex_CompressedHex4Dec})/x
      
-     def self.create(arg)
+    # Created a new IPv6 address from +arg+ which may be:
+    #
+    #* IPv6:: returns +arg+
+    #* String:: +arg+ must match one of the IPv6::Regex* constants
+    def self.create(arg)
       case arg
       when IPv6
         return arg
@@ -100,12 +98,14 @@ module Dnsruby
       end
     end
     
-    def initialize(address)
+    def initialize(address) #:nodoc:
       unless address.kind_of?(String) && address.length == 16
         raise ArgumentError.new('IPv6 address must be 16 bytes')
       end
       @address = address
     end
+    
+    # The raw IPv6 address as a String
     attr_reader :address
     
     def to_s
@@ -116,22 +116,24 @@ module Dnsruby
       return address
     end
     
-    def inspect
+    def inspect #:nodoc:
       return "#<#{self.class} #{self.to_s}>"
     end
-    
+
+    #Turns this IPv6 address into a Dnsruby::Name
+    #--    
+    # ip6.arpa should be searched too. [RFC3152]
     def to_name
-      # ip6.arpa should be searched too. [RFC3152]
       return Name.create(
-#                           @address.unpack("H32")[0].split(//).reverse + ['ip6', 'arpa'])
-                           @address.unpack("H32")[0].split(//).reverse.join(".") + ".ip6.arpa")
+        #                           @address.unpack("H32")[0].split(//).reverse + ['ip6', 'arpa'])
+        @address.unpack("H32")[0].split(//).reverse.join(".") + ".ip6.arpa")
     end
     
-    def ==(other)
+    def ==(other) #:nodoc:
       return @address == other.address
     end
     
-    def eql?(other)
+    def eql?(other) #:nodoc:
       return self == other
     end
     

data/lib/Dnsruby/message.rb

@@ -59,13 +59,13 @@ module Dnsruby
   #      Dnsruby::Message#encode
   #      Dnsruby::Message::decode(data)
   class Message
-    # Create a new Message. Takes optional name, type and class
+    #Create a new Message. Takes optional name, type and class
     # 
-    # type defaults to A, and klass defaults to IN
+    #type defaults to A, and klass defaults to IN
     # 
-    #    Dnsruby::Message.new("example.com") # defaults to A, IN
-    #    Dnsruby::Message.new("example.com", 'AAAA')
-    #    Dnsruby::Message.new("example.com", Dnsruby::Types.PTR, "HS")
+    #*  Dnsruby::Message.new("example.com") # defaults to A, IN
+    #*  Dnsruby::Message.new("example.com", 'AAAA')
+    #*  Dnsruby::Message.new("example.com", Dnsruby::Types.PTR, "HS")
     #    
     def initialize(*args)
       @header = Header.new()
@@ -73,6 +73,10 @@ module Dnsruby
       @answer = []
       @authority = []
       @additional = []
+      @tsigstate = :Unsigned
+      @signing = false
+      @tsigkey = nil
+      @answerfrom = nil
       type = Types.A
       klass = Classes.IN
       if (args.length > 0)
@@ -87,31 +91,41 @@ module Dnsruby
       end
     end
     
-    # The question section, an array of Dnsruby::Question objects.
+    #The question section, an array of Dnsruby::Question objects.
     attr_reader :question
     
-    # The answer section, an array of Dnsruby::RR objects.
+    #The answer section, an array of Dnsruby::RR objects.
     attr_reader :answer
-    # The authority section, an array of Dnsruby::RR objects.
+    #The authority section, an array of Dnsruby::RR objects.
     attr_reader :authority
-    # The additional section, an array of Dnsruby::RR objects.
+    #The additional section, an array of Dnsruby::RR objects.
     attr_reader :additional
-    # The header section, a Dnsruby::Header object.
+    #The header section, a Dnsruby::Header object.
     attr_accessor :header
     
-    # If this Message is a response from a server, then answerfrom contains the address of the server
+    #If this Message is a response from a server, then answerfrom contains the address of the server
     attr_accessor :answerfrom
     
-    # If this Message is a response from a server, then answersize contains the size of the response
+    #If this Message is a response from a server, then answersize contains the size of the response
     attr_accessor :answersize
     
-    attr_accessor :tsigkey
-    attr_reader :querytsig
-    attr_reader :tsigerror
-    
-    attr_accessor :tsigstart
+    #If this message has been verified using a TSIG RR then tsigerror contains 
+    #the error code returned by the TSIG verification. The error will be an RCode
+    attr_accessor :tsigerror
+    
+    #Can be
+    #* :Unsigned - the default state
+    #* :Signed - the outgoing message has been signed
+    #* :Verified - the incoming message has been verified
+    #* :Intermediate - the incoming message is an intermediate envelope in a TCP session
+    #in which only every 100th envelope must be signed
+    #* :Failed - the incoming response failed verification
     attr_accessor :tsigstate
     
+    #--
+    attr_accessor :tsigstart
+    #++
+
     def ==(other)
       ret = false
       if (other.kind_of?Message)
@@ -124,12 +138,12 @@ module Dnsruby
       return ret
     end
     
-    # Add a new Question to the Message. Takes either a Question, 
-    # or a name, and an optional type and class.
+    #Add a new Question to the Message. Takes either a Question, 
+    #or a name, and an optional type and class.
     # 
-    # msg.add_question(Question.new("example.com", 'MX'))
-    # msg.add_question("example.com") # defaults to Types.A, Classes.IN
-    # msg.add_question("example.com", Types.LOC)
+    #* msg.add_question(Question.new("example.com", 'MX'))
+    #* msg.add_question("example.com") # defaults to Types.A, Classes.IN
+    #* msg.add_question("example.com", Types.LOC)
     def add_question(question, type=Types.A, klass=Classes.IN)
       if (!question.kind_of?Question) 
         question = Question.new(question, type, klass)
@@ -193,22 +207,43 @@ module Dnsruby
     
     # Returns the TSIG record from the ADDITIONAL section, if one is present.
     def tsig
-      if (@additional.last.type == Types.TSIG)
-        return @additional.last
+      if (@additional.last)
+        if (@additional.last.rr_type == Types.TSIG)
+          return @additional.last
+        end
       end
       return nil
     end
     
-    # Was this message signed by a TSIG?
-    def is_signed
-      return (tsigstate == :Signed ||
-          tsigstate == :Verified ||
-          tsigstate == :Failed)
+    #Sets the TSIG to sign this message with. Can either be a Dnsruby::RR::TSIG
+    #object, or it can be a (name, key) tuple, or it can be a hash which takes
+    #Dnsruby::RR::TSIG attributes (e.g. name, key, fudge, etc.)
+    def set_tsig(*args)
+      if (args.length == 1)
+        if (args[0].instance_of?RR::TSIG)
+          @tsigkey = args[0]
+        elsif (args[0].instance_of?Hash)
+          @tsigkey = RR.create({:type=>'TSIG', :klass=>'ANY'}.merge(args[0]))
+        else
+          raise ArgumentError.new("Wrong type of argument to Dnsruby::Message#set_tsig - should be TSIG or Hash")
+        end
+      elsif (args.length == 2)
+        @tsigkey = RR.create({:type=>'TSIG', :klass=>'ANY', :name=>args[0], :key=>args[1]})
+      else
+        raise ArgumentError.new("Wrong number of arguments to Dnsruby::Message#set_tsig")
+      end
     end
     
-    # If this message was signed by a TSIG, was the TSIG verified?
-    def is_verified
-      return (tsigstate == :Verified)
+    #Was this message signed by a TSIG?
+    def signed?
+      return (@tsigstate == :Signed ||
+          @tsigstate == :Verified ||
+          @tsigstate == :Failed)
+    end
+    
+    #If this message was signed by a TSIG, was the TSIG verified?
+    def verified?
+      return (@tsigstate == :Verified)
     end
     
     def to_s
@@ -251,13 +286,32 @@ module Dnsruby
       return retval;
     end
     
+    #Signs the message. If used with no arguments, then the message must have already 
+    #been set (set_tsig). Otherwise, the arguments can either be a Dnsruby::RR::TSIG
+    #object, or a (name, key) tuple, or a hash which takes
+    #Dnsruby::RR::TSIG attributes (e.g. name, key, fudge, etc.)
+    def sign!(*args)
+      if (args.length > 0)
+        set_tsig(*args)
+        sign!
+      else
+        if ((@tsigkey) && @tsigstate == :Unsigned)
+          @tsigkey.apply(self)
+        end      
+      end
+    end
+    
     #Return the encoded form of the message
+    # If there is a TSIG record present and the record has not been signed 
+    # then sign it
     def encode
+      if ((@tsigkey) && @tsigstate == :Unsigned && !@signing)
+        @signing = true
+        sign!
+        @signing = false
+      end
       return MessageEncoder.new {|msg|
         header = @header
-        if (@tsigkey)
-          header.arcount += 1
-        end
         header.encode(msg)
         @question.each {|q|
           msg.put_name(q.qname)
@@ -265,18 +319,17 @@ module Dnsruby
         }
         [@answer, @authority, @additional].each {|rr|
           rr.each {|r|
-            # name, ttl, data = r
             name = r.name
             ttl = r.ttl
-            msg.put_name(name)
+            if (r.type == Types.TSIG)
+              msg.put_name(name, true)
+            else
+              msg.put_name(name)
+            end
             msg.put_pack('nnN', r.type.code, r.klass.code, ttl)
             msg.put_length16 {r.encode_rdata(msg)}
           }
         }
-        if (@tsigkey)
-          tsigrec = @tsigkey.generate(this, msg, tsigerror, querytsig)
-          tsigrec.encode(msg, Section.ADDITIONAL, c)
-        end
       }.to_s
     end
     
@@ -298,13 +351,14 @@ module Dnsruby
           o.authority << rr
         }
         o.header.arcount.times { |count|
+          start = msg.index
           rr = msg.get_rr
           if (rr.type == Types.TSIG)
             if (count!=o.header.arcount-1)
               TheLog.Error("Incoming message has TSIG record before last record")
+              raise DecodeError.new("TSIG record present before last record")
             end
-            # @TODO@ Sort TSIG stuff out!
-            # o.tsigstart = pos
+            o.tsigstart = start # needed for TSIG verification
           end
           o.additional << rr
         }
@@ -341,7 +395,6 @@ module Dnsruby
   #
   #RFC 1035 Section 4.1.1
   class Header
-    @@identifier = -1
     MAX_ID = 65535
     
     # The header ID
@@ -415,7 +468,7 @@ module Dnsruby
     end
     
     def opcode=(op)
-      @opcode = Opcode.new(op)
+      @opcode = OpCode.new(op)
     end
     
     def rcode=(rcode)
@@ -453,6 +506,19 @@ module Dnsruby
         @arcount)
     end
     
+    def Header.decrement_arcount_encoded(bytes)
+      header = Header.new
+      header_end = 0
+      MessageDecoder.new(bytes) {|msg|
+        header.decode(msg)
+        header_end = msg.index
+      }
+      header.arcount = header.arcount - 1
+      bytes[0,header_end]=MessageEncoder.new {|msg|
+        header.encode(msg)}.to_s
+      return bytes
+    end
+    
     def ==(other)
       return @qr == other.qr &&
         @opcode == other.opcode &&
@@ -512,14 +578,6 @@ module Dnsruby
       @rcode = RCode.new(flag & 15)
     end
     
-    def rcode=(newcode)
-      @rcode = RCode.new(newcode)
-    end
-    
-    def opcode=(newcode)
-      @opcode = OpCode.new(newcode)
-    end
-    
     def get_exception
       exception = nil
       if (@rcode==RCode.NXDOMAIN)
@@ -551,6 +609,7 @@ module Dnsruby
   end
   
   class MessageDecoder #:nodoc: all
+    attr_reader :index
     def initialize(data)
       @data = data
       @index = 0
@@ -660,12 +719,12 @@ module Dnsruby
       type, klass = self.get_unpack("nn")
       q = Question.new(name, type, klass)
       return q
-      #      return name, RR.get_class(type, klass)
     end
     
     def get_rr
       name = self.get_name
       type, klass, ttl = self.get_unpack('nnN')
+      klass = Classes.new(klass)
       typeclass = RR.get_class(type, klass)
       # @TODO@ Trap decode errors here, and somehow mark the record as bad.
       # Need some way to represent raw data only
@@ -745,7 +804,7 @@ module Dnsruby
     
     def put_label(d)
       s, = Name.encode(d)
-      raise RuntimeError, "length of #{s} is #{s.string.length} (larger than 63 octets)" if s.string.length > 63 # @todo@ Error type
+      raise RuntimeError, "length of #{s} is #{s.string.length} (larger than 63 octets)" if s.string.length > 63
       self.put_string(s.string)
     end
   end
@@ -753,7 +812,7 @@ module Dnsruby
   class EncodeError < StandardError
   end
   
-  #A Net::DNS::Question object represents a record in the
+  #A Dnsruby::Question object represents a record in the
   #question section of a DNS packet.
   #
   #RFC 1035 Section 4.1.2
@@ -804,6 +863,32 @@ module Dnsruby
       end
     end
     
+    def qtype=(qtype)
+      @qtype = Types.new(qtype)
+    end
+    
+    def qclass=(qclass)
+      @qclass = Classes.new(qclass)
+    end
+    
+    def qname=(qname)
+      case qname
+      when IPv4::Regex
+        @qname = IPv4.create(qname).to_name
+        @qtype = Types.PTR
+      when IPv6::Regex
+        @qname = IPv6.create(qname).to_name
+        @qtype = Types.PTR
+      when Name
+      when IPv6
+        @qtype = Types.PTR
+      when IPv4
+        @qtype = Types.PTR
+      else
+        @qname = Name.create(qname)
+      end
+    end  
+    
     #Returns a string representation of the question record.
     def to_s
       return "#{@qname}.\t#{@qclass.string}\t#{@qtype.string}";