dnsruby 1.1

data/lib/Dnsruby/resource/MX.rb

@@ -0,0 +1,66 @@
+#--
+#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 Mail Exchanger (MX) resource records.
+    #RFC 1035 Section 3.3.9
+    class MX < RR
+      ClassValue = nil #:nodoc: all
+      TypeValue= Types::MX #:nodoc: all
+      
+      #The preference for this mail exchange.
+      attr_accessor :preference
+      #The name of this mail exchange.
+      attr_accessor :exchange
+      
+      def from_hash(hash) #:nodoc: all
+        @preference = hash[:preference]
+        @exchange = Name.create(hash[:exchange])
+      end
+      
+      def from_data(data) #:nodoc: all
+        @preference, @exchange = data
+      end
+      
+      def from_string(input) #:nodoc: all
+        if (input.length > 0)
+          names = input.split(" ")
+          @preference = names[0].to_i
+          @exchange = Name.create(names[1])
+        end
+      end
+      
+      def rdata_to_string #:nodoc: all
+        if (@preference!=nil)
+          return "#{@preference} #{@exchange}"
+        else
+          return ""
+        end
+      end
+      
+      def encode_rdata(msg, canonical=false) #:nodoc: all
+        msg.put_pack('n', @preference, canonical)
+        msg.put_name(@exchange, canonical)
+      end
+      
+      def self.decode_rdata(msg) #:nodoc: all
+        preference, = msg.get_unpack('n')
+        exchange = msg.get_name
+        return self.new([preference, exchange])
+      end
+    end 
+  end
+end

data/lib/Dnsruby/resource/NAPTR.rb

@@ -0,0 +1,90 @@
+#--
+#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 Naming Authority Pointer (NAPTR) resource records.
+    #RFC 2168
+    class NAPTR < RR
+      ClassValue = nil #:nodoc: all
+      TypeValue= Types::NAPTR #:nodoc: all
+      
+      # The NAPTR RR order field      
+      attr_accessor :order
+      # The NAPTR RR preference field      
+      attr_accessor :preference
+      # The NAPTR RR flags field      
+      attr_accessor :flags
+      # The NAPTR RR service field      
+      attr_accessor :service
+      # The NAPTR RR regexp field      
+      attr_accessor :regexp
+      # The NAPTR RR replacement field      
+      attr_accessor :replacement
+      
+      def from_hash(hash) #:nodoc: all
+        @order = hash[:order]
+        @preference = hash[:preference]
+        @flags  = hash[:flags]
+        @service = hash[:service]
+        @regexp = hash[:regexp]
+        @replacement = Name.create(hash[:replacement])
+      end
+      
+      def from_data(data) #:nodoc: all
+        @order,  @preference, @flags, @service, @regexp, @replacement = data
+      end
+      
+      def from_string(input) #:nodoc: all
+        if (input.length > 0)
+          values = input.split(" ")
+          @order = values [0]
+          @preference = values [1]
+          @flags = values [2]
+          @service = values [3]
+          @regexp = values [4]
+          @replacement = Name.create(values[5])
+        end
+      end
+      
+      def rdata_to_string #:nodoc: all
+        if (@order!=nil)
+          return "#{@order} #{@preference} #{@flags} #{@service} #{@regexp} #{@replacement}"
+        else
+          return ""
+        end
+      end
+      
+      def encode_rdata(msg, canonical=false) #:nodoc: all
+        msg.put_pack('n', @order)
+        msg.put_pack('n', @preference)
+        msg.put_string(@flags)
+        msg.put_string(@service)
+        msg.put_string(@regexp)
+        msg.put_name(@replacement, canonical)
+      end
+      
+      def self.decode_rdata(msg) #:nodoc: all
+        order, = msg.get_unpack('n')
+        preference, = msg.get_unpack('n')
+        flags, = msg.get_string
+        service, = msg.get_string
+        regexp, = msg.get_string
+        replacement = msg.get_name
+        return self.new([order, preference, flags, service, regexp, replacement])
+      end
+    end 
+  end
+end	    

data/lib/Dnsruby/resource/NSAP.rb

@@ -0,0 +1,172 @@
+#--
+#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 Network Service Access Point (NSAP) resource records.
+    #RFC 1706.
+    class NSAP < RR
+      ClassValue = nil #:nodoc: all
+      TypeValue= Types::NSAP #:nodoc: all
+      #The RR's authority and format identifier.  Dnsruby 
+      #currently supports only AFI 47 (GOSIP Version 2).
+      attr_accessor :afi
+      #The RR's initial domain identifier.
+      attr_accessor :idi
+      #The RR's DSP format identifier.
+      attr_accessor :dfi
+      #The RR's administrative authority.
+      attr_accessor :aa
+      #The RR's routing domain identifier.
+      attr_accessor :rd
+      #The RR's area identifier.
+      attr_accessor :area
+      #The RR's system identifier.
+      attr_accessor :id
+      #The RR's NSAP selector.
+      attr_accessor :sel
+      
+      #The RR's reserved field.
+      attr_writer :rsvd
+      
+      #The RR's initial domain part (the AFI and IDI fields).
+      def idp
+        ret = [@afi, @idi].join('')
+        return ret
+      end
+      
+      #The RR's domain specific part (the DFI, AA, Rsvd, RD, Area,
+      #ID, and SEL fields).
+      def dsp
+        ret = [@dfi,@aa,rsvd,@rd,@area,@id,@sel].join('')
+        return ret
+      end
+      
+      def rsvd
+        if (@rsvd==nil)
+          return "0000"
+        else
+          return @rsvd
+        end
+      end
+      
+      #------------------------------------------------------------------------------
+      # Usage:  str2bcd(STRING, NUM_BYTES)
+      #
+      # Takes a string representing a hex number of arbitrary length and
+      # returns an equivalent BCD string of NUM_BYTES length (with
+      # NUM_BYTES * 2 digits), adding leading zeros if necessary.
+      #------------------------------------------------------------------------------
+      def str2bcd(s, bytes)
+        retval = "";
+        
+        digits = bytes * 2;
+        string = sprintf("%#{digits}s", s);
+        string.tr!(" ","0");
+        
+        i=0;
+        bytes.times do
+          bcd = string[i*2, 2];
+          retval += [bcd.to_i(16)].pack("C");
+          i+=1
+        end
+        
+        return retval;
+      end
+      
+      
+      def from_data(data) #:nodoc: all
+        @afi, @idi, @dfi, @aa, @rsvd, @rd, @area, @id, @sel = data
+      end
+      
+      def from_string(s) #:nodoc: all
+        if (s)
+          string = s.gsub(/\./, "");  # remove all dots.
+          string.gsub!(/^0x/,"");  # remove leading 0x
+          
+          if (string =~ /^[a-zA-Z0-9]{40}$/)
+           (@afi, @idi, @dfi, @aa, @rsvd, @rd, @area, @id, @sel) = string.unpack("A2A4A2A6A4A4A4A12A2")
+          end
+        end
+        
+      end
+      
+      def rdata_to_string #:nodoc: all
+        rdatastr=""
+        
+        if (defined?@afi)
+          if (@afi == "47")
+            rdatastr = [idp, dsp].join('')
+          else
+            rdatastr = "; AFI #{@afi} not supported"
+          end
+        else
+          rdatastr = ''
+        end
+        
+        return rdatastr
+      end
+      
+      def encode_rdata(msg, canonical=false) #:nodoc: all
+        if (defined?@afi)
+          msg.put_pack("C", @afi.to_i(16))
+          
+          if (@afi == "47")
+            msg.put_bytes(str2bcd(@idi,  2))
+            msg.put_bytes(str2bcd(@dfi,  1))
+            msg.put_bytes(str2bcd(@aa,   3))
+            msg.put_bytes(str2bcd(0,               2))	# rsvd)
+            msg.put_bytes(str2bcd(@rd,   2))
+            msg.put_bytes(str2bcd(@area, 2))
+            msg.put_bytes(str2bcd(@id,   6))
+            msg.put_bytes(str2bcd(@sel,  1))
+          end            
+          # Checks for other versions would go here.
+        end
+        
+        return rdata
+      end
+      
+      def self.decode_rdata(msg) #:nodoc: all
+        afi = msg.get_unpack("C")[0]
+        afi = sprintf("%02x", afi)
+        
+        if (afi == "47")
+          idi = msg.get_unpack("CC")
+          dfi = msg.get_unpack("C")[0]
+          aa = msg.get_unpack("CCC")
+          rsvd = msg.get_unpack("CC")
+          rd = msg.get_unpack("CC")
+          area = msg.get_unpack("CC")
+          id = msg.get_unpack("CCCCCC")
+          sel = msg.get_unpack("C")[0]
+          
+          idi  = sprintf("%02x%02x", idi[0], idi[1])
+          dfi  = sprintf("%02x", dfi)
+          aa   = sprintf("%02x%02x%02x", aa[0], aa[1], aa[2])
+          rsvd = sprintf("%02x%02x", rsvd[0],rsvd[1])
+          rd   = sprintf("%02x%02x", rd[0],rd[1])
+          area = sprintf("%02x%02x", area[0],area[1])
+          id   = sprintf("%02x%02x%02x%02x%02x%02x", id[0],id[1],id[2],id[3],id[4],id[5])
+          sel  = sprintf("%02x", sel)
+          
+        else
+          # What to do for unsupported versions?
+        end
+        return self.new([afi, idi, dfi, aa, rsvd, rd, area, id, sel])
+      end
+    end
+  end
+end

data/lib/Dnsruby/resource/NSEC.rb

@@ -0,0 +1,243 @@
+#--
+#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
+    #RFC4034, section 4
+    #The NSEC resource record lists two separate things: the next owner
+    #name (in the canonical ordering of the zone) that contains
+    #authoritative data or a delegation point NS RRset, and the set of RR
+    #types present at the NSEC RR's owner name [RFC3845].  The complete
+    #set of NSEC RRs in a zone indicates which authoritative RRsets exist
+    #in a zone and also form a chain of authoritative owner names in the
+    #zone.  This information is used to provide authenticated denial of
+    #existence for DNS data, as described in [RFC4035].    
+    class NSEC < RR
+      ClassValue = nil #:nodoc: all
+      TypeValue = Types::NSEC #:nodoc: all
+      
+      #The next name which exists after this NSEC
+      #The Next Domain field contains the next owner name (in the canonical
+      #ordering of the zone) that has authoritative data or contains a
+      #delegation point NS RRset
+      attr_reader :next_domain
+      #The Type Bit Maps field identifies the RRset types that exist at the
+      #NSEC RR's owner name
+      attr_reader :types
+      
+      def next_domain=(n)
+        nxt = Name.create(n)
+        @next_domain = nxt
+      end
+      
+      def types=(t)
+        @types = NSEC.get_types(t)
+      end
+      
+      def self.get_types(t)
+        types = nil
+        if (t.instance_of?Array)
+          # from the wire, already decoded
+          types =t
+        elsif (t.instance_of?String)
+          # List of mnemonics
+          types=[]
+          mnemonics = t.split(" ")
+          mnemonics.pop
+          mnemonics.each do |m|
+            type = Types.new(m)
+            types.push(type)
+          end
+        else
+          raise DecodeError.new("Unknown format of types for Dnsruby::RR::NSEC")
+        end
+        return types
+      end
+      
+      def add_type(t)
+        self.types=(@types + [t])
+      end
+      
+      def self.decode_types(bytes)
+        types = []
+        #RFC4034 section 4.1.2
+        #The RR type space is split into 256 window blocks, each representing
+        #the low-order 8 bits of the 16-bit RR type space.  Each block that
+        #has at least one active RR type is encoded using a single octet
+        #window number (from 0 to 255), a single octet bitmap length (from 1
+        #to 32) indicating the number of octets used for the window block's
+        #bitmap, and up to 32 octets (256 bits) of bitmap.
+
+        #Blocks are present in the NSEC RR RDATA in increasing numerical
+        #order.
+
+        #  Type Bit Maps Field = ( Window Block # | Bitmap Length | Bitmap )+
+
+        #  where "|" denotes concatenation.
+       
+        pos = 0
+        while (pos < bytes.length)
+          #So, read the first two octets
+          if (bytes.length-pos < 2)
+            raise DecodeError.new("NSEC : Expected window number and bitmap length octets")
+          end
+          window_number = bytes[pos]
+          bitmap_length = bytes[pos+1]
+          pos += 2
+          bitmap = bytes[pos,bitmap_length]
+          pos += bitmap_length
+          #Each bitmap encodes the low-order 8 bits of RR types within the
+          #window block, in network bit order.  The first bit is bit 0.  For
+          #window block 0, bit 1 corresponds to RR type 1 (A), bit 2 corresponds
+          #to RR type 2 (NS), and so forth.  For window block 1, bit 1
+          #corresponds to RR type 257, and bit 2 to RR type 258.  If a bit is
+          #set, it indicates that an RRset of that type is present for the NSEC
+          #RR's owner name.  If a bit is clear, it indicates that no RRset of
+          #that type is present for the NSEC RR's owner name.
+          index = 0
+          bitmap.each_byte do |char|
+            if char.to_i != 0
+              # decode these RR types
+              0..8.times do |i|
+                if (((1 << (7-i)) & char) == (1 << (7-i)))
+                  type = Types.new((256 * window_number) + (8 * index) + i)
+                  #Bits representing pseudo-types MUST be clear, as they do not appear
+                  #in zone data.  If encountered, they MUST be ignored upon being read.
+                  if (!([Types.OPT, Types.TSIG].include?(type)))
+                    types.push(type)
+                  end
+                end               
+              end
+            end
+            index += 1
+          end
+        end
+        return types
+      end
+      
+      def encode_types
+        NSEC.encode_types(self)
+      end
+      
+      def self.encode_types(nsec)
+        output=""
+        #types represents all 65536 possible RR types.
+        #Split up types into sets of 256 different types.
+        type_codes = []
+        nsec.types.each do |type|
+          type_codes.push(type.code)
+        end
+        type_codes.sort!
+        window = -1
+        0.step(65536,256) { |step|
+          # Gather up the RR types for this set of 256
+          types_to_go = []
+          while (type_codes[0] < step)
+            types_to_go.push(type_codes[0])
+            # And delete them from type_codes
+            type_codes=type_codes.last(type_codes.length-1)
+            break if (type_codes.empty?)
+          end
+          
+          if (!types_to_go.empty?)
+            # Then create the bitmap for them
+            bitmap=""
+            # keep on adding them until there's none left
+            pos = 0
+            bitmap_pos = 0
+            while (!types_to_go.empty?)
+              
+              # Check the next eight
+              byte = 0
+              pos += 8
+              while (types_to_go[0] < pos + step-256)
+                byte = byte | (1 << (pos-1-(types_to_go[0] - (step-256) )))
+                # Add it to the list
+                # And remove it from the to_go queue
+                types_to_go =types_to_go.last(types_to_go.length-1)
+                break if (types_to_go.empty?)
+              end
+              bitmap += " "
+              bitmap[bitmap_pos]=byte
+              bitmap_pos+=1
+            end
+            
+            # Now add data to output bytes
+            start = output.length
+            (2+bitmap.length).times do 
+              output += " "
+            end
+          
+            output[start] = window
+            output[start+1] = bitmap.length
+            bitmap.length.times do |i|
+              output[start+2+i] = bitmap[i]
+            end
+          end
+          window += 1
+          
+          # Are there any more types after this?
+          if (type_codes.empty?)
+            # If not, then break (so we don't add more zeros)
+            break
+          end
+        }
+        return output
+      end
+
+      def from_data(data) #:nodoc: all
+        next_domain, types = data
+        self.next_domain=(next_domain)
+        self.types=(types)
+      end
+      
+      def from_string(input)
+        if (input.length > 0)
+          data = input.split(" ")
+          self.next_domain=(data[0])
+          len = data[0].length + data[1].length + 1
+          self.types=(input[len, input.length-len])
+        end
+      end
+      
+      def rdata_to_string #:nodoc: all
+        if (@next_domain!=nil)
+          type_strings = []
+          @types.each do |t|
+            type_strings.push(t.string)
+          end
+          types = type_strings.join(" ")
+          return "#{@next_domain} ( #{types} )"
+        else
+          return ""
+        end
+      end
+      
+      def encode_rdata(msg, canonical=false) #:nodoc: all
+        # Canonical
+        msg.put_name(@next_domain, true)
+        types = encode_types
+        msg.put_bytes(types)
+      end
+      
+      def self.decode_rdata(msg) #:nodoc: all
+        next_domain = msg.get_name
+        types = decode_types(msg.get_bytes)
+        return self.new(
+          [next_domain, types])
+      end
+    end 
+  end
+end