dnsruby 1.55 → 1.56.0

data/lib/{Dnsruby → dnsruby}/ipv4.rb

@@ -1,23 +1,23 @@
-#--
-#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.
-#++
+# --
+# 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 IPv4
-    # Regular expression IPv4 addresses must match
+    #  Regular expression IPv4 addresses must match
     Regex = /\A(\d\d?\d?)\.(\d\d?\d?)\.(\d\d?\d?)\.(\d\d?\d?)\z/
-    
+
     def self.create(arg)
       case arg
       when IPv4
@@ -35,38 +35,38 @@ module Dnsruby
         raise ArgumentError.new("cannot interpret as IPv4 address: #{arg.inspect}")
       end
     end
-    
+
     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 the IPv4 address.
+
+    #  A String representation of the IPv4 address.
     attr_reader :address
-    
+
     def to_s #:nodoc:
       return sprintf("%d.%d.%d.%d", *@address.unpack("CCCC"))
     end
-    
+
     def inspect #:nodoc:
       return "#<#{self.class} #{self.to_s}>"
     end
-    
+
     def to_name
       return Name.create(
         '%d.%d.%d.%d.in-addr.arpa.' % @address.unpack('CCCC').reverse)
     end
-    
+
     def ==(other)
       return @address == other.address
     end
-    
+
     def eql?(other)
       return self == other
     end
-    
+
     def hash
       return @address.hash
     end

data/lib/{Dnsruby → dnsruby}/ipv6.rb

@@ -1,57 +1,57 @@
-#--
-#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.
-#++
+# --
+# 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
-  #Dnsruby::IPv6 class
+  # Dnsruby::IPv6 class
   class IPv6
-    #IPv6 address format a:b:c:d:e:f:g:h
+    # 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
+
+    # 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
+
+    #  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
+
+    #  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
+
+    #  A composite IPv6 address RegExp
     Regex = /
      (?:#{Regex_8Hex}) |
      (?:#{Regex_CompressedHex}) |
      (?:#{Regex_6Hex4Dec}) |
      (?:#{Regex_CompressedHex4Dec})/x
-     
-    # Created a new IPv6 address from +arg+ which may be:
-    #
-    #* IPv6:: returns +arg+
-    #* String:: +arg+ must match one of the IPv6::Regex* constants
+
+    #  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
@@ -97,17 +97,17 @@ module Dnsruby
         raise ArgumentError.new("cannot interpret as IPv6 address: #{arg.inspect}")
       end
     end
-    
+
     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
+
+    #  The raw IPv6 address as a String
     attr_reader :address
-    
+
     def to_s
       address = sprintf("%X:%X:%X:%X:%X:%X:%X:%X", *@address.unpack("nnnnnnnn"))
       unless address.sub!(/(^|:)0(:0)+(:|$)/, '::')
@@ -115,28 +115,28 @@ module Dnsruby
       end
       return address
     end
-    
+
     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]
+    # Turns this IPv6 address into a Dnsruby::Name
+    # --
+    #  ip6.arpa should be searched too. [RFC3152]
     def to_name
       return Name.create(
-        #                           @address.unpack("H32")[0].split(//).reverse + ['ip6', 'arpa'])
+        #                            @address.unpack("H32")[0].split(//).reverse + ['ip6', 'arpa'])
         @address.unpack("H32")[0].split(//).reverse.join(".") + ".ip6.arpa")
     end
-    
+
     def ==(other) #:nodoc:
       return @address == other.address
     end
-    
+
     def eql?(other) #:nodoc:
       return self == other
     end
-    
+
     def hash
       return @address.hash
     end

data/lib/{Dnsruby → dnsruby}/key_cache.rb

@@ -1,25 +1,25 @@
-#--
-#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
-#
+# --
+# 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.
-#++
+# 
+# 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 KeyCache #:nodoc: all
-    # Cache includes expiration time for keys
-    # Cache removes expired records
+    #  Cache includes expiration time for keys
+    #  Cache removes expired records
     def initialize(keys = nil)
-      # Store key tag against [expiry, key]
+      #  Store key tag against [expiry, key]
       @keys = {}
       add(keys)
     end
@@ -34,7 +34,7 @@ module Dnsruby
       elsif (k.kind_of?KeyCache)
         kaes = k.keys_and_expirations
         kaes.keys.each { |keykey|
-          #            priv_add_key(keykey, kaes[keykey])
+          #             priv_add_key(keykey, kaes[keykey])
           priv_add_key(keykey[1], keykey[0])
         }
       else
@@ -44,17 +44,17 @@ module Dnsruby
     end
 
     def add_rrset(k)
-      # Get expiration from the RRSIG
-      # There can be several RRSIGs here, one for each key which has signed the RRSet
-      # We want to choose the one with the most secure signing algorithm, key length,
-      # and the longest expiration time - not easy!
-      # for now, we simply accept all signed keys
+      #  Get expiration from the RRSIG
+      #  There can be several RRSIGs here, one for each key which has signed the RRSet
+      #  We want to choose the one with the most secure signing algorithm, key length,
+      #  and the longest expiration time - not easy!
+      #  for now, we simply accept all signed keys
       k.sigs.each { |sig|
         if (sig.type_covered = Types.DNSKEY)
           if (sig.inception <= Time.now.to_i)
-            # Check sig.expiration, sig.algorithm
+            #  Check sig.expiration, sig.algorithm
             if (sig.expiration > Time.now.to_i)
-              # add the keys to the store
+              #  add the keys to the store
               k.rrs.each {|rr| priv_add_key(rr, sig.expiration)}
             end
           end
@@ -63,7 +63,7 @@ module Dnsruby
     end
 
     def priv_add_key(k, exp)
-      # Check that the key does not already exist with a longer expiration!
+      #  Check that the key does not already exist with a longer expiration!
       if (@keys[k] == nil)
         @keys[k.key_tag] = [exp,k]
       elsif ((@keys[k])[0] < exp)
@@ -72,17 +72,17 @@ module Dnsruby
     end
 
     def each
-      # Only offer currently-valid keys here
+      #  Only offer currently-valid keys here
       remove_expired_keys
       @keys.values.each {|v| yield v[1]}
     end
     def keys
-      # Only offer currently-valid keys here
+      #  Only offer currently-valid keys here
       remove_expired_keys
       ks = []
       @keys.values.each {|a| ks.push(a[1])}
       return ks
-      #        return @keys.keys
+      #         return @keys.keys
     end
     def keys_and_expirations
       remove_expired_keys

data/lib/dnsruby/message/decoder.rb

@@ -0,0 +1,164 @@
+module Dnsruby
+class MessageDecoder #:nodoc: all
+  attr_reader :index
+  def initialize(data)
+    @data = data
+    @index = 0
+    @limit = data.length
+    yield self if block_given?
+  end
+
+  def has_remaining
+    @limit - @index > 0
+  end
+
+  def get_length16
+    len, = self.get_unpack('n')
+    save_limit = @limit
+    @limit = @index + len
+    d = yield(len)
+    if @index < @limit
+      raise DecodeError.new('junk exists')
+    elsif @limit < @index
+      raise DecodeError.new('limit exceeded')
+    end
+    @limit = save_limit
+    d
+  end
+
+  def get_bytes(len = @limit - @index)
+    d = @data[@index, len]
+    @index += len
+    d
+  end
+
+  def get_unpack(template)
+    len = 0
+    littlec = ?c
+    bigc = ?C
+    littleh = ?h
+    bigh = ?H
+    littlen = ?n
+    bign = ?N
+    star = ?*
+
+    if (littlec.class != Fixnum)
+      #  We're using Ruby 1.9 - convert the codes
+      littlec = littlec.getbyte(0)
+      bigc = bigc.getbyte(0)
+      littleh = littleh.getbyte(0)
+      bigh = bigh.getbyte(0)
+      littlen = littlen.getbyte(0)
+      bign = bign.getbyte(0)
+      star = star.getbyte(0)
+    end
+
+    template.each_byte {|byte|
+      case byte
+        when littlec, bigc
+          len += 1
+        when littleh, bigh
+          len += 1
+        when littlen
+          len += 2
+        when bign
+          len += 4
+        when star
+          len = @limit - @index
+        else
+          raise StandardError.new("unsupported template: '#{byte.chr}' in '#{template}'")
+      end
+    }
+    raise DecodeError.new('limit exceeded') if @limit < @index + len
+    arr = @data.unpack("@#{@index}#{template}")
+    @index += len
+    arr
+  end
+
+  def get_string
+    len = @data[@index]
+    if len.class == String
+      len = len.getbyte(0)
+    end
+    raise DecodeError.new("limit exceeded\nlimit = #{@limit}, index = #{@index}, len = #{len}\n") if @limit < @index + 1 + (len ? len : 0)
+    d = @data[@index + 1, len]
+    @index += 1 + len
+    d
+  end
+
+  def get_string_list
+    strings = []
+    while @index < @limit
+      strings << self.get_string
+    end
+    strings
+  end
+
+  def get_name
+    Name.new(self.get_labels)
+  end
+
+  def get_labels(limit=nil)
+    limit = @index if !limit || @index < limit
+    d = []
+    while true
+      temp = @data[@index]
+      if temp.class == String
+        temp = temp.getbyte(0)
+      end
+      case temp # @data[@index]
+        when 0
+          @index += 1
+          return d
+        when 192..255
+          idx = self.get_unpack('n')[0] & 0x3fff
+          if limit <= idx
+            raise DecodeError.new('non-backward name pointer')
+          end
+          save_index = @index
+          @index = idx
+          d += self.get_labels(limit)
+          @index = save_index
+          return d
+        else
+          d << self.get_label
+      end
+    end
+    d
+  end
+
+  def get_label
+    begin
+      #         label = Name::Label.new(Name::decode(self.get_string))
+      label = Name::Label.new(self.get_string)
+      return label
+        #          return Name::Label::Str.new(self.get_string)
+    rescue ResolvError => e
+      raise DecodeError.new(e) # Turn it into something more suitable
+    end
+  end
+
+  def get_question
+    name = self.get_name
+    type, klass = self.get_unpack('nn')
+    q = Question.new(name, type, klass)
+    q
+  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
+    rec = self.get_length16 { typeclass.decode_rdata(self) }
+    rec.name = name
+    rec.ttl = ttl
+    rec.type = type
+    rec.klass = klass
+    rec
+  end
+end
+
+end