dnsruby 1.39 → 1.40

data/lib/Dnsruby/Recursor.rb

@@ -384,7 +384,7 @@ module Dnsruby
 
         # Make sure that known_authorities still contains some authorities!
         # If not, remove the zone from zones_cache, and start again
-        if (known_authorities.values.length > 0)
+        if (known_authorities && known_authorities.values.length > 0)
           done = true
         else
           @@mutex.synchronize{

data/lib/Dnsruby/code_mapper.rb

@@ -103,7 +103,7 @@ module Dnsruby
         code = array.stringsdown[arg.downcase]
         if (code != nil)
           @code = code
-          @string = array.strings.invert[@code]
+          @string = array.values[@code]
         else 
           unknown_string(arg)
         end
@@ -125,7 +125,7 @@ module Dnsruby
     def set_string(arg)
       array = @@arrays[self.class]
       @code = array.stringsdown[arg.downcase]
-      @string = array.strings.invert[@code]
+      @string = array.values[@code]
     end
 
     def set_code(arg)
@@ -162,18 +162,9 @@ module Dnsruby
     end
     
     def ==(other)
-      if Fixnum === other
-        if other == @code
-          return true
-        end
-      elsif String === other
-        if other == @string
-          return true
-        end
-      elsif CodeMapper === other
-        if other.string == @string && other.code == @code
-          return true
-        end
+      return true if [@code, @string].include?other
+      if (CodeMapper === other)
+        return true if ((other.code == @code) || (other.string == @string))
       end
       return false
     end

data/lib/Dnsruby/name.rb

@@ -72,7 +72,7 @@ module Dnsruby
       return labels
     end
     
-    attr_reader :labels
+    attr_accessor :labels
     
     #This method should only be called internally.
     #Use Name::create to create a new Name
@@ -172,7 +172,7 @@ module Dnsruby
     end
     
     def ==(other) # :nodoc:
-      return false unless Name === other
+      return false if other.class != Name
       return @labels == other.labels && @absolute == other.absolute?
     end
     alias eql? == # :nodoc:
@@ -267,9 +267,10 @@ module Dnsruby
       # I start looking forward and do the magic.
       
       i=0;
-      
+
+      unpacked = wire.unpack("C*")
       while (i < length )
-        c=wire.unpack("x#{i}C1") [0]
+        c = unpacked[i]
         if ( c < 33 || c > 126 )
           presentation=presentation + sprintf("\\%03u" ,c)
         elsif ( c.chr ==  "\"" )
@@ -378,6 +379,7 @@ module Dnsruby
         end
         @downcase = string.downcase
         @string = string
+        @string_length = string.length
       end
       attr_reader :string, :downcase
       
@@ -386,7 +388,7 @@ module Dnsruby
       end
       
       def length
-        return @string.length
+        return @string_length
       end
       
       def inspect

data/lib/Dnsruby/resource/AFSDB.rb

@@ -53,7 +53,7 @@ module Dnsruby
         end
         
         def encode_rdata(msg, canonical=false) #:nodoc: all
-          msg.put_pack("n", @subtype)
+          msg.put_pack("n", @subtype.to_i)
           msg.put_name(@hostname, canonical)
         end
         

data/lib/Dnsruby/resource/CERT.rb

@@ -63,25 +63,38 @@ module Dnsruby
       def from_string(input) #:nodoc: all
         if (input != "")
           names = input.split(" ")
-          @certtype = CertificateTypes::new(names[0])
+          begin
+            @certtype = CertificateTypes::new(names[0])
+          rescue ArgumentError
+            @certtype = CertificateTypes::new(names[0].to_i)
+          end
           @keytag = names[1].to_i
-          @alg = Dnsruby::Algorithms.new(names[2])
-          @cert = names[3]
+          begin
+            @alg = Dnsruby::Algorithms.new(names[2])
+          rescue ArgumentError
+            @alg = Dnsruby::Algorithms.new(names[2].to_i)
+          end
+          buf = names[3]
+
+
+          buf.gsub!(/\n/, "")
+          buf.gsub!(/ /, "")
+          @cert = buf.unpack("m*").first
         end
       end
       
       def rdata_to_string #:nodoc: all
-        return "#{@certtype.string} #{@keytag} #{@alg.string} #{@cert}"
+        return "#{@certtype.string} #{@keytag} #{@alg.string} #{[@cert.to_s].pack("m*").gsub("\n", "")}"
       end
       
       def encode_rdata(msg, canonical=false) #:nodoc: all
-        msg.put_pack('nnn', @certtype.code, @keytag, @alg.code)
-        msg.put_string(@cert)
+        msg.put_pack('nnc', @certtype.code, @keytag, @alg.code)
+        msg.put_bytes(@cert)
       end
       
       def self.decode_rdata(msg) #:nodoc: all
-        certtype, keytag, alg = msg.get_unpack('nnn')
-        cert = msg.get_string
+        certtype, keytag, alg = msg.get_unpack('nnc')
+        cert = msg.get_bytes
         return self.new([certtype, keytag, alg, cert])
       end
     end

data/lib/Dnsruby/resource/DHCID.rb

@@ -0,0 +1,55 @@
+#--
+#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.
+#++
+module Dnsruby
+  class RR
+    #Class for DNS DHCP ID (DHCID) resource records.
+    #RFC 4701
+    class DHCID < RR
+      ClassValue = nil #:nodoc: all
+      TypeValue= Types::DHCID #:nodoc: all
+      
+      #The opaque rdata for DHCID
+      attr_accessor :dhcid_data
+      
+      def from_hash(hash) #:nodoc: all
+        @dhcid_data = hash[:dhcid_data]
+      end
+      
+      def from_data(data) #:nodoc: all
+        @dhcid_data,  = data
+      end
+      
+      def from_string(input) #:nodoc: all
+        buf = input.gsub(/\n/, "")
+        buf.gsub!(/ /, "")
+        @dhcid_data = buf.unpack("m*").first
+      end
+      
+      def rdata_to_string #:nodoc: all
+        return "#{[@dhcid_data.to_s].pack("m*").gsub("\n", "")}"
+      end
+      
+      def encode_rdata(msg, canonical=false) #:nodoc: all
+        msg.put_bytes(@dhcid_data)
+      end
+      
+      def self.decode_rdata(msg) #:nodoc: all
+        dhcid_data, = msg.get_bytes()
+        return self.new([dhcid_data])
+      end
+    end 
+  end
+end

data/lib/Dnsruby/resource/HINFO.rb

@@ -30,7 +30,11 @@ module Dnsruby
       end
       
       def from_string(input) #:nodoc: all
-        @cpu, @os = input.split(" ")
+        cpu, os = input.split(" ")
+        cpu.sub!(/^\"/, "")
+        @cpu = cpu.sub(/\"$/, "")
+        os.sub!(/^\"/, "")
+        @os = os.sub(/\"$/, "")
       end
       
       def rdata_to_string #:nodoc: all

data/lib/Dnsruby/resource/HIP.rb

@@ -0,0 +1,138 @@
+ 
+#--
+#Copyright 2009 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.
+#++
+module Dnsruby
+  class RR
+    class HIP < RR
+
+      ClassValue = nil #:nodoc: all
+      TypeValue = Types::HIP #:nodoc: all
+
+      #An 8-bit length for the HIT field
+      attr_accessor :hit_length
+      #The PK algorithm used :
+      # 0 - no key present
+      # 1 - DSA key present
+      # 2 - RSA key present
+      attr_accessor :pk_algorithm
+      #An 8-bit length for the Public Key field
+      attr_accessor :pk_length
+
+      #An array of Rendezvous Servers
+      attr_accessor :rsvs
+
+      def from_data(data) #:nodoc: all
+        @rsvs=[]
+        @hit_length = data[0]
+        @pk_algorithm = data[1]
+        @pk_length = data[2]
+        @hit = data[3]
+        @public_key = data[4]
+        @rsvs = data[5]
+      end
+
+      def from_hash(hash)
+        @rsvs=[]
+        @hit_length = hash[:hit_length]
+        @pk_algorithm = hash[:pk_algorithm]
+        @pk_length = hash[:pk_length]
+        @hit = hash[:hit]
+        @public_key = hash[:public_key]
+        if (hash[:rsvs])
+          hash[:rsvs].each {|rsv|
+            @rsvs.push(Name.create(rsv))
+          }
+        end
+      end
+
+      #HIT field - stored in binary : client methods should handle base16(hex) encoding
+      def hit_string
+        # Return hex value
+        [@hit.to_s].pack("H*").gsub("\n", "")
+      end
+      def hit_from_string(hit_text)
+        # Decode the hex value
+        hit_text.gsub!(/\n/, "")
+        hit_text.gsub!(/ /, "")
+        return hit_text.unpack("H*")[0]
+      end
+
+      #Public Key field - presentation format is base64 - public_key methods reused from IPSECKEY
+      def public_key_string
+        [@public_key.to_s].pack("m*").gsub("\n", "")
+      end
+
+      def public_key_from_string(key_text)
+        key_text.gsub!(/\n/, "")
+        key_text.gsub!(/ /, "")
+        return key_text.unpack("m*")[0]
+      end
+
+      def from_string(input)
+        @rsvs=[]
+        if (input.length > 0)
+          split = input.split(" ")
+
+          @pk_algorithm = split[0].to_i
+          @hit = hit_from_string(split[1])
+          @hit_length = @hit.length
+          @public_key = public_key_from_string(split[2])
+          @pk_length = @public_key.length
+
+          # Now load in any RSVs there may be
+          count = 3
+          while (split[count])
+            @rsvs.push(Name.create(split[count]))
+            count += 1
+          end
+
+        end
+      end
+
+      def rdata_to_string #:nodoc: all
+        ret = "#{@pk_algorithm} #{hit_string} #{public_key_string}"
+        @rsvs.each {|rsv|
+          ret += " #{rsv}"
+        }
+        return ret
+      end
+
+      def encode_rdata(msg, canonical=false) #:nodoc: all\
+        msg.put_pack('ccC', @hit_length, @pk_algorithm, @pk_length)
+        msg.put_bytes(@hit)
+        msg.put_bytes(@public_key)
+        @rsvs.each {|rsv|
+          # RSVs MUST NOT be compressed
+          msg.put_name(rsv, true)
+        }
+      end
+
+      def self.decode_rdata(msg) #:nodoc: all
+        hit_length, pk_algorithm, pk_length = msg.get_unpack('ccC')
+        hit = msg.get_bytes(hit_length)
+        public_key = msg.get_bytes(pk_length)
+        rsvs = []
+        # Load in the RSV names, if there are any
+        while (msg.has_remaining)
+          name = msg.get_name
+          rsvs.push(name)
+        end
+        return self.new(
+          [hit_length, pk_algorithm, pk_length, hit, public_key, rsvs])
+      end
+    end
+  end
+end

data/lib/Dnsruby/resource/IN.rb

@@ -17,9 +17,9 @@ 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,
+      ISDN, MB, MG, MR, NAPTR, NSAP, OPT, RP, RT, X25, KX,
       SPF, CERT, LOC, TSIG, TKEY, ANY, RRSIG, NSEC, DS, NSEC3,
-      NSEC3PARAM, DLV, SSHFP
+      NSEC3PARAM, DLV, SSHFP, IPSECKEY, HIP, DHCID
     ] #:nodoc: all
     
     # module IN contains ARPA Internet specific RRs

data/lib/Dnsruby/resource/IPSECKEY.rb

@@ -0,0 +1,143 @@
+#--
+#Copyright 2009 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.
+#++
+module Dnsruby
+  class RR
+    class IPSECKEY < RR
+
+      ClassValue = nil #:nodoc: all
+      TypeValue = Types::IPSECKEY #:nodoc: all
+
+      #An 8-bit precedence for this field. Lower values are preferred.
+      attr_accessor :precedence
+      #Specifies the type of gateway :
+      # 0 - no gateway present
+      # 1 - 4 byte IPv4 address present
+      # 2 - 16 byte IPv6 address present
+      # 3 - wire-encoded domain name present
+      attr_accessor :gateway_type
+      #The algorithm used by this key :
+      # 0 - no key present
+      # 1 - DSA key present
+      # 2 - RSA key present
+      attr_accessor :algorithm
+      #The gateway. May either be a 32-bit network order IPv4 address, or a 
+      #128-bit IPv6 address, or a domain name, or may not be present.
+      attr_accessor :gateway
+
+      def from_data(data) #:nodoc: all
+        @precedence = data[0]
+        @gateway_type = data[1]
+        @algorithm = data[2]
+        @public_key = nil
+        @gateway = load_gateway_from_string(@gateway_type, data[3])
+        if (@gateway)
+          @public_key = data[4]
+        else
+          @public_key = data[3]
+        end
+      end
+
+      def from_hash(hash)
+        @precedence = hash[:precedence]
+        @gateway_type = hash[:gateway_type]
+        @algorithm = hash[:algorithm]
+        @gateway = load_gateway_from_string(@gateway_type, hash[:gateway])
+        @public_key = hash[:public_key]
+      end
+      
+      def load_gateway_from_string(gateway_type, s)
+        gateway = nil
+        if (gateway_type == 0)
+          gateway = nil
+        elsif (gateway_type == 1)
+          # Load IPv4 gateway
+          gateway = IPv4.create(s)
+        elsif (gateway_type == 2)
+          # Load IPv6 gateway
+          gateway = IPv6.create(s)
+        else
+          # Load gateway domain name
+          gateway = Name.create(s)
+        end
+        return gateway        
+      end
+
+      def public_key_string
+        [@public_key.to_s].pack("m*").gsub("\n", "")
+      end
+
+      def public_key_from_string(key_text)
+        key_text.gsub!(/\n/, "")
+        key_text.gsub!(/ /, "")
+        return key_text.unpack("m*")[0]
+      end
+
+      def from_string(input)
+        if (input.length > 0)
+          split = input.split(" ")
+
+          @precedence = split[0].to_i
+          @gateway_type = split[1].to_i
+          @algorithm = split[2].to_i
+
+          @gateway = load_gateway_from_string(@gateway_type, split[3])
+
+          @public_key = public_key_from_string(split[4])
+        end
+      end
+
+      def rdata_to_string #:nodoc: all
+        ret = "#{@precedence} #{@gateway_type} #{@algorithm} "
+        if (@gateway_type > 0)
+          ret += "#{@gateway} "
+        end
+        ret += "#{public_key_string()}"
+        return ret
+      end
+
+      def encode_rdata(msg, canonical=false) #:nodoc: all
+        msg.put_pack('ccc', @precedence, @gateway_type, @algorithm)
+        if ([1,2].include?@gateway_type)
+          msg.put_bytes(@gateway.address)
+        end
+        if (@gateway_type == 3)
+          msg.put_name(@gateway, true) # gateway MUST NOT be compressed
+        end
+        msg.put_bytes(@public_key)
+      end
+
+      def self.decode_rdata(msg) #:nodoc: all
+        precedence, gateway_type, algorithm = msg.get_unpack('ccc')
+        gateway = nil
+        if (gateway_type == 1)
+          gateway = IPv4.new(msg.get_bytes(4))
+        elsif (gateway_type == 2)
+          gateway = IPv6.new(msg.get_bytes(16))
+        elsif (gateway_type == 3)
+          gateway = msg.get_name
+        end
+        public_key = msg.get_bytes
+        if (gateway_type == 0)
+          return self.new(
+            [precedence, gateway_type, algorithm, public_key])
+        else
+          return self.new(
+            [precedence, gateway_type, algorithm, gateway, public_key])
+        end
+      end
+    end
+  end
+end