Dnsruby 0.5.0

data/lib/Dnsruby/name.rb

@@ -0,0 +1,325 @@
+#--
+#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::Name class
+  #
+  #(RFC1035, section 3.1)
+  #
+  #== methods
+  #
+  #* Name::create(namestring)
+  #* Name#absolute?
+  #* Name#wild?
+  #* Name#subdomain_of?(other)
+  #* Name#labels
+  #
+  class Name
+    MaxNameLength=255
+    #--
+    # A Name is a collection of Labels. Each label is presentation-formatted
+    # When a Name is wire-encoded, the label array is walked, and each label is wire-encoded.
+    # When a Name is unencoded, each label is unencoded, and added to the Name collection of labels.
+    # When a Name is made from a string, the Name is split into Labels.
+    #++
+    def self.create(arg)
+      case arg
+      when Name
+        return arg
+      when String
+#        arg.gsub!(/\.$/o, "")
+        return Name.new(split_escaped(arg), /\.\z/ =~ arg ? true : false)
+      when Array
+        return Name.new(arg, /\.\z/ =~ ((arg.last.kind_of?String)?arg.last : arg.last.string) ? true : false)
+      else        
+        raise ArgumentError.new("cannot interpret as DNS name: #{arg.inspect}")
+      end
+    end
+    
+    def self.split_escaped(arg) #:nodoc: all
+      encodedlabels = name2encodedlabels(arg)
+      return encodedlabels2name(encodedlabels).labels
+    end
+    
+    attr_reader :labels
+    
+    #This method should only be called internally.
+    #Use Name::create to create a new Name
+    def initialize(labels, absolute=true) #:nodoc: all
+      total_length=labels.length-1
+      labels.each do |l| 
+        if (!l.kind_of?Label)
+          raise ArgumentError.new("Name::new called with non-labels. Use Name::create instead?")
+        end
+        total_length+=l.length 
+      end
+      if (total_length > MaxNameLength) 
+        raise ResolvError.new("Name length is #{total_length}, greater than max of #{MaxNameLength} octets!")
+      end
+      @labels = labels
+      @absolute = absolute
+    end
+    
+    def downcase
+      labels = []
+      @labels.each do |label| labels << Label.new(label.downcase) end
+      return Name.create(labels)
+    end
+    
+    def inspect
+      "#<#{self.class}: #{self.to_s}#{@absolute ? '.' : ''}>"
+    end
+    
+    def absolute?
+      return @absolute
+    end
+    
+    #Is this name a wildcard?
+    def wild?
+      if (labels.length == 0)
+        return false
+      end
+      return (labels[0].string == '*')
+    end
+
+    def ==(other)
+      return false unless Name === other
+      return @labels == other.labels && @absolute == other.absolute?
+    end
+    alias eql? ==
+    
+    # tests subdomain-of relation.
+    #
+    #   domain = Resolv::Name.create("y.z")
+    #   p Resolv::Name.create("w.x.y.z").subdomain_of?(domain) #=> true
+    #   p Resolv::Name.create("x.y.z").subdomain_of?(domain) #=> true
+    #   p Resolv::Name.create("y.z").subdomain_of?(domain) #=> false
+    #   p Resolv::Name.create("z").subdomain_of?(domain) #=> false
+    #   p Resolv::Name.create("x.y.z.").subdomain_of?(domain) #=> false
+    #   p Resolv::Name.create("w.z").subdomain_of?(domain) #=> false
+    #
+    def subdomain_of?(other)
+      raise ArgumentError, "not a domain name: #{other.inspect}" unless Name === other
+      return false if @absolute != other.absolute?
+      other_len = other.length
+      return false if @labels.length <= other_len
+      return @labels[-other_len, other_len] == other.to_a
+    end
+    
+    def hash
+      return @labels.hash ^ @absolute.hash
+    end
+    
+    def to_a #:nodoc: all
+      return @labels
+    end
+    
+    def length #:nodoc: all
+      return @labels.length
+    end
+    
+    def [](i) #:nodoc: all
+      return @labels[i]
+    end
+    
+    # returns the domain name as a string.
+    #
+    # The domain name doesn't have a trailing dot even if the name object is
+    # absolute.
+    #
+    #   p Resolv::Name.create("x.y.z.").to_s #=> "x.y.z"
+    #   p Resolv::Name.create("x.y.z").to_s #=> "x.y.z"
+    #
+    def to_s
+      # @todo@ Need to think about escaped characters here?
+      return @labels.collect{|l| (l.kind_of?String) ? l : l.string}.join('.')
+      
+    end
+    
+    # Utility function
+    #
+    # name2labels to translate names from presentation format into an
+    # array of "wire-format" labels.        
+    # in: dName a string with a domain name in presentation format (1035
+    # sect 5.1)
+    # out: an array of labels in wire format.        
+    def self.name2encodedlabels (dName) #:nodoc: all
+      names=[]
+      j=0;
+      while (dName && dName.length > 0)
+        names[j],dName = encode(dName)
+        j+=1
+      end
+      
+      return names
+    end
+    
+    def self.encodedlabels2name(labels) #:nodoc: all
+      ls = []
+      labels.each do |l|
+        ls.push(Name.decode(l.string))
+      end
+      return Name.new(ls)
+    end    
+    
+    def self.decode(wire) #:nodoc: all
+      presentation=""
+      length=wire.length
+      # There must be a nice regexp to do this.. but since I failed to
+      # find one I scan the name string until I find a '\', at that time
+      # I start looking forward and do the magic.
+      
+      i=0;
+      
+      while (i < length )
+        c=wire.unpack("x#{i}C1") [0]
+        if ( c < 33 || c > 126 )
+          presentation=presentation + sprintf("\\%03u" ,c)
+        elsif ( c.chr ==  "\"" )
+          presentation=presentation +  "\\\""
+        elsif ( c.chr ==  "\$")
+          presentation=presentation +  "\\\$"
+        elsif ( c.chr == "(" )
+          presentation=presentation + "\\("
+        elsif ( c.chr == ")" )
+          presentation=presentation +  "\\)"
+        elsif ( c.chr == ";" )
+          presentation=presentation +  "\\;"
+        elsif ( c.chr == "@" )
+          presentation=presentation +  "\\@"
+        elsif ( c.chr == "\\" )
+          presentation=presentation + "\\\\" 
+        elsif ( c.chr == ".")
+          presentation=presentation +  "\\."
+        else
+          presentation=presentation + c.chr()
+        end
+        i=i+1
+      end
+      
+      return Label.new(presentation)
+    end
+    
+    
+    
+    # wire,leftover=presentation2wire(leftover)    
+    # Will parse the input presentation format and return everything before
+    # the first non-escaped "." in the first element of the return array and
+    # all that has not been parsed yet in the 2nd argument.        
+    def self.encode(presentation) #:nodoc: all
+      presentation=presentation.to_s
+      wire="";
+      length=presentation.length;
+      
+      i=0;
+      
+      while (i < length )
+        c=presentation.unpack("x#{i}C1") [0]
+        if (c == 46) # ord('.')
+          endstring = presentation[i+1, presentation.length-(i+1)]
+          return Label.new(wire),endstring
+        end
+        if (c == 92) # ord'\\'
+          #backslash found
+          pos = i+1
+          # pos sets where next pattern matching should start
+          if (presentation.index(/\G(\d\d\d)/o, pos))
+            wire=wire+[$1.to_i].pack("C")
+            i=i+3
+          elsif(presentation.index(/\Gx([0..9a..fA..F][0..9a..fA..F])/o, pos))
+            wire=wire+[$1].pack("H*")
+            i=i+3
+          elsif(presentation.index(/\G\./o, pos))
+            wire=wire+"\."
+            i=i+1
+          elsif(presentation.index(/\G@/o,pos))
+            wire=wire+"@"
+            i=i+1
+          elsif(presentation.index(/\G\(/o, pos))
+            wire=wire+"("
+            i=i+1
+          elsif(presentation.index(/\G\)/o, pos))
+            wire=wire+")"
+            i=i+1
+          elsif(presentation.index(/\G\\/o, pos))
+            wire=wire+"\\"
+            i+=1
+          end
+        else
+          wire = wire + [c].pack("C")
+        end
+        i=i+1
+      end
+      
+      return Label.new(wire)
+    end
+    
+    #  end
+    
+    
+    #== Dnsruby::Label class
+    #
+    #(RFC1035, section 3.1)
+    #
+    class Label
+      MaxLabelLength = 63
+      @@max_length=MaxLabelLength
+      # Split a Name into its component Labels
+      def self.split(arg)
+        labels = []
+        #        arg.scan(/[^\.]+/) {labels << Str.new($&)}
+        arg.scan(/[^\.]+/) {labels << new($&)}
+        return labels
+      end
+      
+      def self.set_max_length(l)
+        @@max_length=l
+      end
+      
+      def initialize(string)
+        if (string.length > @@max_length)
+          raise ResolvError.new("Label too long (#{string.length}, max length=#{MaxLabelLength}). Label = #{string}")
+        end
+        @downcase = string.downcase
+        @string = string
+      end
+      attr_reader :string, :downcase
+      
+      def to_s
+        return @string.to_s # + "."
+      end
+      
+      def length
+        return @string.length
+      end
+      
+      def inspect
+        return "#<#{self.class} #{self.to_s}>"
+      end
+      
+      def ==(other)
+        return @downcase == other.downcase
+      end
+      
+      def eql?(other)
+        return self == other
+      end
+      
+      def hash
+        return @downcase.hash
+      end
+    end
+  end
+end

data/lib/Dnsruby/resource/A.rb

@@ -0,0 +1,56 @@
+#--
+#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
+    module IN
+      #Class for DNS Address (A) resource records.
+      #
+      #RFC 1035 Section 3.4.1
+      class A < RR
+        ClassHash[[TypeValue = Types::A, ClassValue = ClassValue]] = self #:nodoc: all
+        
+        #The RR's address field.
+        attr_accessor :address
+        
+        def from_data(data) #:nodoc: all
+          @address = IPv4.create(data)
+        end
+        
+        #Create the RR from a hash
+        def from_hash(hash)
+          @address = IPv4.create(hash[:address])
+        end
+        
+        # Create the RR from a standard string
+        def from_string(input)
+          @address = IPv4.create(input)
+        end
+        
+        def rdata_to_string
+          return @address.to_s
+        end
+        
+        def encode_rdata(msg) #:nodoc: all
+          msg.put_bytes(@address.address)
+        end
+        
+        def self.decode_rdata(msg) #:nodoc: all
+          return self.new(IPv4.new(msg.get_bytes(4)))
+        end
+      end
+    end   
+  end
+end

data/lib/Dnsruby/resource/AAAA.rb

@@ -0,0 +1,54 @@
+#--
+#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
+    module IN
+      #Class for DNS IPv6 Address (AAAA) resource records.
+      #
+      #RFC 1886 Section 2, RFC 1884 Sections 2.2 & 2.4.4
+      class AAAA < RR
+        ClassHash[[TypeValue = Types::AAAA, ClassValue = ClassValue]] = self #:nodoc: all
+        
+        #  The RR's address field
+        attr_accessor :address
+        
+        def from_data(data) #:nodoc: all
+          @address = IPv6.create(data)
+        end
+        
+        def from_hash(hash) #:nodoc: all
+          @address = IPv6.create(hash[:address])
+        end
+        
+        def from_string(input) #:nodoc: all
+          @address = IPv6.create(input)
+        end
+        
+        def rdata_to_string #:nodoc: all
+          return @address.to_s
+        end
+        
+        def encode_rdata(msg) #:nodoc: all
+          msg.put_bytes(@address.address)
+        end
+        
+        def self.decode_rdata(msg) #:nodoc: all
+          return self.new(IPv6.new(msg.get_bytes(16)))
+        end
+      end
+    end   
+  end
+end

data/lib/Dnsruby/resource/AFSDB.rb

@@ -0,0 +1,68 @@
+#--
+#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
+    module IN
+      #Class for DNS AFS Data Base (AFSDB) resource records.
+      #
+      #RFC 1183 Section 1
+      class AFSDB < RR
+        ClassHash[[TypeValue = Types::AFSDB, ClassValue = ClassValue]] = self #:nodoc: all
+        
+        #The RR's subtype field.  See RFC 1183.
+        attr_accessor :subtype
+        
+        #The RR's hostname field.  See RFC 1183.
+        attr_accessor :hostname
+        
+        def from_hash(hash) #:nodoc: all
+          @subtype = hash[:subtype]
+          @hostname = Name.create(hash[:hostname])
+        end
+        
+        def from_data(data) #:nodoc: all
+          @subtype, @hostname = data
+        end
+        
+        def from_string(input) #:nodoc: all
+          if (input!=nil && (input =~ /^(\d+)\s+(\S+)$/o))
+            @subtype  = $1;
+            @hostname = Name.create($2)
+          end
+        end
+        
+        def rdata_to_string #:nodoc: all
+          if defined?@subtype
+            return "#{@subtype} #{@hostname}." 
+          else
+            return '';
+          end
+        end
+        
+        def encode_rdata(msg, canonical=false) #:nodoc: all
+          msg.put_pack("n", @subtype)
+          msg.put_name(@hostname, canonical)
+        end
+        
+        def self.decode_rdata(msg) #:nodoc: all
+          subtype,     = msg.get_unpack("n")
+          hostname    = msg.get_name
+          return self.new([subtype, hostname])
+        end
+      end
+    end   
+  end
+end

data/lib/Dnsruby/resource/CERT.rb

@@ -0,0 +1,89 @@
+#--
+#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 Certificate (CERT) resource records. (see RFC 2538)
+    #
+    #RFC 2782
+    class CERT < RR
+      ClassValue = nil #:nodoc: all
+      TypeValue = Types::CERT #:nodoc: all
+      
+      #Returns the format code for the certificate
+      attr_accessor :certtype
+      #Returns the key tag for the public key in the certificate
+      attr_accessor :keytag
+      #Returns the algorithm used by the certificate
+      attr_accessor :alg
+      #Returns the data comprising the certificate itself (in raw binary form)
+      attr_accessor :cert
+      
+      class CertificateTypes < CodeMapper
+        PKIX = 1 # PKIX (X.509v3)
+        SPKI = 2 # Simple Public Key Infrastructure
+        PGP = 3 # Pretty Good Privacy
+        IPKIX = 4 # URL of an X.509 data object
+        ISPKI = 5 # URL of an SPKI certificate
+        IPGP = 6 # Fingerprint and URL of an OpenPGP packet
+        ACPKIX = 7 # Attribute Certificate 
+        IACPKIX = 8 # URL of an Attribute Certificate       
+        URI = 253 # Certificate format defined by URI         
+        OID = 254 # Certificate format defined by OID
+        
+        update()
+      end
+      
+      def from_data(data) #:nodoc: all
+        @certtype = CertificateTypes::new(data[0])
+        @keytag = data[1]
+        @alg = DNSSEC::Algorithms.new(data[2])
+        @cert= data[3]
+      end
+      
+      def from_hash(hash) #:nodoc: all
+        @certtype = CertificateTypes::new(hash[:certtype])
+        @keytag = hash[:keytag]
+        @alg = DNSSEC::Algorithms.new(hash[:alg])
+        @cert= hash[:cert]
+      end
+      
+      def from_string(input) #:nodoc: all
+        if (input != "")
+          names = input.split(" ")
+          @certtype = CertificateTypes::new(names[0])
+          @keytag = names[1]
+          @alg = DNSSEC::Algorithms.new(names[2])
+          @cert = names[3]
+        end
+      end
+      
+      def rdata_to_string #:nodoc: all
+        return "#{@certtype.string} #{@keytag} #{@alg.string} #{@cert}"
+      end
+      
+      def encode_rdata(msg) #:nodoc: all
+        msg.put_pack('nnn', @certtype.code, @keytag, @alg.code)
+        msg.put_string(@cert)
+      end
+      
+      def self.decode_rdata(msg) #:nodoc: all
+        certtype, keytag, alg = msg.get_unpack('nnn')
+        cert = msg.get_string
+        return self.new([certtype, keytag, alg, cert])
+      end
+    end
+  end
+end	

data/lib/Dnsruby/resource/HINFO.rb

@@ -0,0 +1,52 @@
+#--
+#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 Host Information (HINFO) resource records.
+    class HINFO < RR
+      ClassValue = nil #:nodoc: all
+      TypeValue = Types::HINFO #:nodoc: all
+      
+      #The CPU type for this RR.
+      attr_accessor :cpu
+      #The operating system type for this RR.
+      attr_accessor :os
+      
+      def from_data(data) #:nodoc: all
+        @cpu, @os= data
+      end
+      
+      def from_string(input) #:nodoc: all
+        @cpu, @os = input.split(" ")
+      end
+      
+      def rdata_to_string #:nodoc: all
+        return "#{@cpu} #{@os}"
+      end
+      
+      def encode_rdata(msg) #:nodoc: all
+        msg.put_string(@cpu)
+        msg.put_string(@os)
+      end
+      
+      def self.decode_rdata(msg) #:nodoc: all
+        cpu = msg.get_string
+        os = msg.get_string
+        return self.new([cpu, os])
+      end
+    end
+  end
+end