dnsruby 1.40 → 1.41

data/lib/Dnsruby/SingleResolver.rb

@@ -72,6 +72,7 @@ module Dnsruby
       @retry_delay = 0
       @single_resolvers = []
       @configured = false
+      @do_caching = true
         @config = Config.new
 
       if (arg==nil)

data/lib/Dnsruby/dnssec.rb

@@ -286,14 +286,14 @@ module Dnsruby
       return @@dlv_verifier.validate(msg, query)
     end
 
-    def self.verify(msg)
+    def self.verify(msg, keys=nil)
       begin
-        return true if @@anchor_verifier.verify(msg)
+        return true if @@anchor_verifier.verify(msg, keys=nil)
       rescue VerifyError
         begin
-          return true if @@root_verifier.verify(msg)
+          return true if @@root_verifier.verify(msg, keys=nil)
         rescue VerifyError
-          return true if @@dlv_verifier.verify(msg) # Will carry error to client
+          return true if @@dlv_verifier.verify(msg, keys=nil) # Will carry error to client
         end
       end
     end

data/lib/Dnsruby/resource/DNSKEY.rb

@@ -49,10 +49,13 @@ module Dnsruby
       attr_reader :key
       
       def init_defaults
+        @make_new_key_tag = false
         self.protocol=3
         self.flags=ZONE_KEY
         @algorithm=Algorithms.RSASHA1
         @public_key = nil
+        @key_tag = nil
+        @make_new_key_tag = true
       end
       
       def protocol=(p)
@@ -60,6 +63,7 @@ module Dnsruby
           raise DecodeError.new("DNSKEY protocol field set to #{p}, contrary to RFC4034 section 2.1.2")
         else @protocol = p
         end
+        get_new_key_tag
       end
       
       def algorithm=(a)
@@ -74,6 +78,7 @@ module Dnsruby
         rescue ArgumentError => e
           raise DecodeError.new(e)
         end        
+        get_new_key_tag
       end
       
       def revoked=(on)
@@ -82,6 +87,7 @@ module Dnsruby
         else
           @flags &= (~REVOKED_KEY)
         end
+        get_new_key_tag
       end
       
       def revoked?
@@ -94,6 +100,7 @@ module Dnsruby
         else
           @flags &= (~ZONE_KEY)
         end
+        get_new_key_tag
       end
       
       def zone_key?
@@ -106,6 +113,7 @@ module Dnsruby
         else
           @flags &= (~SEP_KEY)
         end
+        get_new_key_tag
       end
       
       def sep_key?
@@ -123,6 +131,7 @@ module Dnsruby
         end
 
         @flags = f
+        get_new_key_tag
       end
       
       #      def bad_flags?
@@ -134,13 +143,26 @@ module Dnsruby
       #
       def from_data(data) #:nodoc: all
         flags, protocol, algorithm, @key = data
+        @make_new_key_tag = false
         self.flags=(flags)
         self.protocol=(protocol)
         self.algorithm=(algorithm)
+        @make_new_key_tag = true
+        get_new_key_tag
       end
       
-      def from_string(input)
+    def from_hash(hash) #:nodoc: all
+      @make_new_key_tag = false
+      hash.keys.each do |param|
+        send(param.to_s+"=", hash[param])
+      end
+      @make_new_key_tag = true
+      get_new_key_tag
+    end
+
+    def from_string(input)
         if (input.length > 0)
+          @make_new_key_tag = false
           data = input.split(" ")
           self.flags=(data[0].to_i)
           self.protocol=(data[1].to_i)
@@ -167,13 +189,15 @@ module Dnsruby
             end
           }
           self.key=(buf)
+          @make_new_key_tag = true
+          get_new_key_tag
         end
       end
       
       def rdata_to_string #:nodoc: all
         if (@flags!=nil)
           #          return "#{@flags} #{@protocol} #{@algorithm.string} ( #{Base64.encode64(@key.to_s)} )"
-          return "#{@flags} #{@protocol} #{@algorithm.string} ( #{[@key.to_s].pack("m*").gsub("\n", "")} )"
+          return "#{@flags} #{@protocol} #{@algorithm.string} ( #{[@key.to_s].pack("m*").gsub("\n", "")} ) ; key_tag=#{key_tag}"
         else
           return ""
         end
@@ -204,13 +228,23 @@ module Dnsruby
         return new_key.key_tag
       end
 
+      def get_new_key_tag
+        if (@make_new_key_tag)
+          rdata = MessageEncoder.new {|msg|
+            encode_rdata(msg)
+          }.to_s
+          tag = generate_key_tag(rdata, @algorithm)
+          @key_tag = tag
+        end
+      end
+
       # Return the tag for this key
       def key_tag
-        rdata = MessageEncoder.new {|msg|
-          encode_rdata(msg)
-        }.to_s
-        tag = generate_key_tag(rdata, @algorithm)
-        return tag
+        if (!@key_tag)
+          @make_new_key_tag = true
+          get_new_key_tag
+        end
+        return @key_tag
       end
 
       def generate_key_tag(rdata, algorithm)
@@ -259,6 +293,7 @@ module Dnsruby
         key_text.gsub!(/ /, "")
         #        @key=Base64.decode64(key_text)        
         @key=key_text.unpack("m*")[0]
+        get_new_key_tag
       end
       
       def public_key

data/lib/Dnsruby/resource/IN.rb

@@ -15,18 +15,51 @@
 #++
 module Dnsruby
   class RR
-    ClassInsensitiveTypes = [
-      NS, CNAME, DNAME, DNSKEY, SOA, PTR, HINFO, MINFO, MX, TXT,
-      ISDN, MB, MG, MR, NAPTR, NSAP, OPT, RP, RT, X25, KX,
-      SPF, CERT, LOC, TSIG, TKEY, ANY, RRSIG, NSEC, DS, NSEC3,
-      NSEC3PARAM, DLV, SSHFP, IPSECKEY, HIP, DHCID
-    ] #:nodoc: all
+    ClassInsensitiveTypes = {
+      Types::NS => NS,
+      Types::CNAME => CNAME,
+      Types::DNAME => DNAME,
+      Types::DNSKEY => DNSKEY,
+      Types::SOA => SOA,
+      Types::PTR => PTR,
+      Types::HINFO => HINFO,
+      Types::MINFO => MINFO,
+      Types::MX => MX,
+      Types::TXT => TXT,
+      Types::ISDN => ISDN,
+      Types::MB => MB,
+      Types::MG => MG,
+      Types::MR => MR,
+      Types::NAPTR => NAPTR,
+      Types::NSAP => NSAP,
+      Types::OPT => OPT,
+      Types::RP => RP,
+      Types::RT => RT,
+      Types::X25 => X25,
+      Types::KX => KX,
+      Types::SPF => SPF,
+      Types::CERT => CERT,
+      Types::LOC => LOC,
+      Types::TSIG => TSIG,
+      Types::TKEY => TKEY,
+      Types::ANY => ANY,
+      Types::RRSIG => RRSIG,
+      Types::NSEC => NSEC,
+      Types::DS => DS,
+      Types::NSEC3 => NSEC3,
+      Types::NSEC3PARAM => NSEC3PARAM,
+      Types::DLV => DLV,
+      Types::SSHFP => SSHFP,
+      Types::IPSECKEY => IPSECKEY,
+      Types::HIP => HIP,
+      Types::DHCID => DHCID
+    } #:nodoc: all
     
     # module IN contains ARPA Internet specific RRs
     module IN
       ClassValue = Classes::IN
       
-      ClassInsensitiveTypes::each {|s|
+      ClassInsensitiveTypes::values::each {|s|
         c = Class.new(s)
         #          c < Record
         c.const_set(:TypeValue, s::TypeValue)

data/lib/Dnsruby/resource/NSEC3.rb

@@ -230,7 +230,7 @@ module Dnsruby
 
       def NSEC3.decode_salt(input)
         if (input == "-")
-          return []
+          return ""
         end
         return [input].pack("H*")
       end

data/lib/Dnsruby/resource/generic.rb

@@ -122,6 +122,14 @@ module Dnsruby
     class ANY < RR
       ClassValue = nil #:nodoc: all
       TypeValue = Types::ANY #:nodoc: all
+      def encode_rdata(msg, canonical=false) #:nodoc: all
+        return ""
+      end
+      def self.decode_rdata(msg) #:nodoc: all
+        return self.new([])
+      end
+      def from_data(data)
+      end
     end
   end  
 end

data/lib/Dnsruby/resource/resource.rb

@@ -569,6 +569,20 @@ module Dnsruby
       }
       return h
     end
+
+    def self.find_class(type_value, class_value) # :nodoc: all
+      klass = nil
+      if (ret = ClassHash[[type_value, class_value]])
+        return ret
+      elsif (val = ClassInsensitiveTypes[type_value])
+        klass = Class.new(val)
+        klass.const_set(:TypeValue, type_value)
+        klass.const_set(:ClassValue, class_value)
+        return klass
+      else
+        return Generic.create(type_value, class_value)
+      end
+    end
     
     #Get an RR of the specified type and class
     def self.get_class(type_value, class_value) #:nodoc: all
@@ -577,8 +591,7 @@ module Dnsruby
       end
       if (type_value.class == Class)
         type_value = type_value.const_get(:TypeValue)
-        return ClassHash[[type_value, Classes.to_code(class_value)]] ||
-          Generic.create(type_value, Classes.to_code(class_value))
+        return find_class(type_value, Classes.to_code(class_value))
       else
         if (type_value.class == Types)
           type_value = type_value.code
@@ -590,8 +603,7 @@ module Dnsruby
         else
           class_value = Classes.new(class_value).code
         end
-        return ClassHash[[type_value, class_value]] ||
-          Generic.create(type_value, class_value)
+        return find_class(type_value, class_value)
       end
       return ret
     end
@@ -629,7 +641,7 @@ module Dnsruby
       return ret
     end
   end
-end  
+end
 require 'Dnsruby/resource/domain_name'
 require 'Dnsruby/resource/generic'
 require 'Dnsruby/resource/IN'

data/lib/Dnsruby/single_verifier.rb

@@ -647,7 +647,8 @@ module Dnsruby
       if ((keys == nil) || (sigrecs == nil))
         return nil, nil
       end
-      if (RR::DNSKEY === keys)
+      if ((RR::DNSKEY === keys) || (RR::DS === keys) ||
+            ((RR::DLV === keys) && (@verifier_type == VerifierType::DLV)))
         keys = [keys]
       end
       enumerator = keys
@@ -677,7 +678,7 @@ module Dnsruby
       #      print "Verify_rrset #{rrset.name}, #{rrset.type}\n"
       sigrecs = rrset.sigs
       if (rrset.rrs.length == 0)
-        raise VerifyError.new("No RRSet to veryify")
+        raise VerifyError.new("No RRSet to verify")
       end
       if (rrset.num_sigs == 0)
         raise VerifyError.new("No signatures in the RRSet : #{rrset.name}, #{rrset.type}")

data/lib/Dnsruby/zone_reader.rb

@@ -25,10 +25,10 @@ module Dnsruby
     # Create a new ZoneReader. The zone origin is required. If the desired SOA minimum
     # and TTL are passed in, then they are used as default values.
     def initialize(origin, soa_minimum = nil, soa_ttl = nil)
-      @origin = origin
+      @origin = origin.to_s
 
       if (!Name.create(@origin).absolute?)
-        @origin = @origin + "."
+        @origin = @origin.to_s + "."
       end
       @soa_ttl = soa_ttl
       if (soa_minimum && !@last_explicit_ttl)

data/test/tc_cache.rb

@@ -20,35 +20,34 @@ include Dnsruby
 
 class TestCache < Test::Unit::TestCase
   def test_cache
-    Dnsruby::PacketSender.clear_caches
+    cache = Cache.new
     m1 = Message.new("example.com.", Types.A, Classes.IN)
     rr1 = RR.create("example.com.		3	IN	A	208.77.188.166")
     m1.add_answer(rr1)
     m1.header.aa = true
     assert(!m1.cached)
-    Cache.add(m1)
-    ret = Cache.find("example.com", "A")
+    cache.add(m1)
+    ret = cache.find("example.com", "A")
     assert(ret.cached)
-    assert(ret.answer == m1.answer, "#{m1.answer}end\n#{ret.answer}end" )
-    assert(ret.answer.to_s == m1.answer.to_s, "#{m1.answer.to_s}end\n#{ret.answer.to_s}end" )
+    assert(ret.answer.rrset("example.com", "A").to_s == m1.answer.rrset("example.com", "A").to_s, "#{m1.answer.rrset("example.com", "A").to_s}end\n#{ret.answer.rrset("example.com", "A").to_s}end" )
     assert(ret.header.aa == false)
     assert(ret.answer.rrsets()[0].ttl == 3)
     sleep(1)
-    ret = Cache.find("example.com", "A")
+    ret = cache.find("example.com", "A")
     assert(ret.cached)
     assert((ret.answer.rrsets()[0].ttl == 2) || (ret.answer.rrsets()[0].ttl == 1), "ttl = #{ret.answer.rrsets()[0].ttl}")
     assert(ret.answer != m1.answer, "ret.answer=#{ret.answer}\nm1.answer=#{m1.answer}" )
     assert(ret.header.aa == false)
     sleep(2) # TTL of 3 should have timed out now
-    ret = Cache.find("example.com", "A")
+    ret = cache.find("example.com", "A")
     assert(!ret)
-    Cache.add(m1)
+    cache.add(m1)
     m2 = Message.new("example.com.", Types.A, Classes.IN)
     rr2 = RR.create("example.com.		200	IN	A	208.77.188.166")
     m2.add_answer(rr2)
     m2.header.aa = true
-    Cache.add(m2)
-    ret = Cache.find("example.com", "A")
+    cache.add(m2)
+    ret = cache.find("example.com", "A")
     assert(ret.cached)
     assert(ret.answer.rrsets()[0].ttl == 200)
   end
@@ -64,8 +63,31 @@ class TestCache < Test::Unit::TestCase
 
   end
 
+  def test_resolver_do_caching
+    # Get the records back from the test zone
+    Dnsruby::PacketSender.clear_caches
+    res = Resolver.new("ns0.validation-test-servers.nominet.org.uk.")
+    res.do_caching = false
+    assert(!res.do_caching)
+    res.udp_size = 4096
+    ret = res.query("overflow.dnsruby.validation-test-servers.nominet.org.uk", Types.TXT)
+#    print "#{ret}\n"
+    assert(!ret.cached)
+    assert(ret.rcode == RCode.NoError)
+    assert(ret.header.aa)
+    # Store the ttls
+    first_ttls = ret.answer.rrset(
+      "overflow.dnsruby.validation-test-servers.nominet.org.uk", Types.TXT).ttl
+    # Wait a while
+    sleep(1)
+    # Ask for the same records
+    ret = res.query("overflow.dnsruby.validation-test-servers.nominet.org.uk", Types.TXT)
+#    print "#{ret}\n"
+    assert(ret.rcode == RCode.NoError)
+    assert(!ret.cached)
+  end
+
   def test_online
-    # @TODO@ !!!
     # Get the records back from the test zone
     Dnsruby::PacketSender.clear_caches
     res = SingleResolver.new("ns0.validation-test-servers.nominet.org.uk.")

data/test/tc_ipseckey.rb

@@ -62,6 +62,7 @@ class TestIPSECKEY < Test::Unit::TestCase
       assert(ipseckey.gateway_type == ipseckey2.gateway_type)
       assert(ipseckey.algorithm == ipseckey2.algorithm)
       assert(ipseckey.gateway == ipseckey2.gateway)
+      assert(ipseckey.klass == ipseckey2.klass)
       assert(ipseckey == ipseckey2)
     }
     }

data/test/tc_naptr.rb

@@ -0,0 +1,48 @@
+#--
+#Copyright 2007 Nominet UK
+#
+#Licensed under the Apache License, Version 2.0 (the "License");
+#you may not use this file except in compliance with the License.
+#You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#Unless required by applicable law or agreed to in writing, software
+#distributed under the License is distributed on an "AS IS" BASIS,
+#WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#See the License for the specific language governing permissions and
+#limitations under the License.
+#++
+require 'rubygems'
+require 'test/unit'
+require 'dnsruby'
+include Dnsruby
+class TestNAPTR < Test::Unit::TestCase
+  def test_naptr
+    txt = "example.com. IN NAPTR 100  50  \"s\"  \"z3950+I2L+I2C\"     \"\"  _z3950._tcp.gatech.edu."
+    naptr = RR.create(txt)
+    assert(naptr.type == Types.NAPTR)
+    assert(naptr.order == 100)
+    assert(naptr.preference == 50)
+    assert(naptr.flags == 's')
+    assert(naptr.service == "z3950+I2L+I2C")
+    assert(naptr.regexp == "")
+    assert(naptr.replacement == Name.create('_z3950._tcp.gatech.edu.'))
+
+    m = Dnsruby::Message.new
+    m.add_additional(naptr)
+    data = m.encode
+    m2 = Dnsruby::Message.decode(data)
+    naptr2 = m2.additional()[0]
+    assert(naptr2.type == Types.NAPTR)
+    assert(naptr2.order == 100)
+    assert(naptr2.preference == 50)
+    assert(naptr2.flags == "s")
+    assert(naptr2.service == "z3950+I2L+I2C")
+    assert(naptr2.regexp == "")
+    assert(naptr2.replacement == Name.create('_z3950._tcp.gatech.edu.'))
+
+    naptr.flags = "u"
+  end
+
+end