Dnsruby 0.5.0

data/lib/Dnsruby/resource/X25.rb

@@ -0,0 +1,53 @@
+#--
+#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 X25 resource records.
+    #RFC 1183 Section 3.1
+    class X25 < RR
+      ClassValue = nil #:nodoc: all
+      TypeValue = Types::X25 #:nodoc: all
+      
+      #The PSDN address
+      attr_accessor :address
+      
+      def from_data(data)
+        @address = data
+      end
+      
+      def from_string(input)
+        @address = input
+      end
+      
+      def rdata_to_string
+        if (@address!=nil)
+          return @address
+        else
+          return ""
+        end
+      end
+      
+      def encode_rdata(msg) #:nodoc: all
+        msg.put_string(@address)
+      end
+      
+      def self.decode_rdata(msg) #:nodoc: all
+        address = msg.get_string
+        return self.new(*address)
+      end
+    end
+  end
+end

data/lib/Dnsruby/resource/domain_name.rb

@@ -0,0 +1,58 @@
+#--
+#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
+    # Superclass for RR's which have an additional domain name in the data section.
+    class DomainName < RR
+      # The domain name in the RR data section.
+      attr_reader :domainname
+      
+      def set_domain_name(newname)
+        #        if (!(newname.kind_of?Name))
+        @domainname=Name.create(newname)
+        #       else
+        #        @domainname = newname
+        #     end
+      end
+      
+      alias domainname= set_domain_name
+      
+      def from_hash(hash) #:nodoc: all
+        set_domain_name(hash[:domainname])
+      end
+      
+      def from_data(data) #:nodoc: all
+        @domainname = data
+      end
+      
+      def from_string(input) #:nodoc: all
+        set_domain_name(input)
+      end
+      
+      def rdata_to_string #:nodoc: all
+        return @domainname.to_s
+      end
+      
+      def encode_rdata(msg, canonical=false) #:nodoc: all
+        msg.put_name(@domainname, canonical)
+      end
+      
+      def self.decode_rdata(msg) #:nodoc: all
+        return self.new(msg.get_name)
+      end
+    end
+  end
+end

data/lib/Dnsruby/resource/generic.rb

@@ -0,0 +1,142 @@
+#--
+#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 to store generic RRs (RFC 3597)
+    class Generic < RR # RFC 3597
+      attr_reader :data
+      
+      def from_data(data) #:nodoc: all
+        @data = data[0]
+      end
+      
+      def rdata_to_string #:nodoc: all
+        if (@data!=nil)
+          return  "\\# " +  @data.length.to_s +  " " + @data.unpack("H*")[0]
+        end
+        return "#NO DATA"
+      end
+      
+      def from_string(data) #:nodoc: all
+        @data = data
+      end
+      
+      def encode_rdata(msg) #:nodoc: all
+        msg.put_bytes(data)
+      end
+      
+      def self.decode_rdata(msg) #:nodoc: all
+        return self.new(msg.get_bytes)
+      end
+      
+      def self.create(type_value, class_value)
+        c = Class.new(Generic)
+        #          c.type = type_value
+        #          c.klass = class_value
+        c.const_set(:TypeValue, type_value)
+        c.const_set(:ClassValue, class_value)
+        Generic.const_set("Type#{type_value}_Class#{class_value}", c)
+        ClassHash[[type_value, class_value]] = c
+        return c
+      end
+    end
+    
+    #--
+    # Standard (class generic) RRs
+    #++
+    #NS RR
+    class NS < DomainName
+      ClassValue = nil #:nodoc: all
+      TypeValue = Types::NS #:nodoc: all
+      
+      alias nsdname domainname
+      alias nsdname= domainname=
+    end
+    
+    #CNAME RR
+    class CNAME < DomainName
+      ClassValue = nil #:nodoc: all
+      TypeValue = Types::CNAME #:nodoc: all
+
+      alias cname domainname
+      alias cname= domainname=
+    end
+    
+    #DNAME RR
+    class DNAME < DomainName
+      ClassValue = nil #:nodoc: all
+      TypeValue = Types::DNAME #:nodoc: all
+      
+      alias dname domainname
+      alias dname= domainname=
+    end
+    
+    #MB RR
+    class MB < DomainName
+      ClassValue = nil #:nodoc: all
+      TypeValue = Types::MB #:nodoc: all
+      alias madname domainname
+      alias madname= domainname=
+    end
+    
+    #MG RR
+    class MG < DomainName
+      ClassValue = nil #:nodoc: all
+      TypeValue = Types::MG #:nodoc: all
+      alias mgmname domainname
+      alias mgmname= domainname=
+    end
+    
+    #MR RR
+    class MR < DomainName
+      ClassValue = nil #:nodoc: all
+      TypeValue = Types::MR #:nodoc: all
+      alias newname domainname
+      alias newname= domainname=
+    end
+    
+    #PTR RR
+    class PTR < DomainName
+      ClassValue = nil #:nodoc: all
+      TypeValue = Types::PTR #:nodoc: all
+    end
+    
+    #ANY RR
+#    class ANY < Query
+    class ANY < RR
+      ClassValue = nil #:nodoc: all
+      TypeValue = Types::ANY #:nodoc: all
+    end
+  end  
+end
+require 'Dnsruby/resource/HINFO'
+require 'Dnsruby/resource/MINFO'
+require 'Dnsruby/resource/ISDN'
+require 'Dnsruby/resource/MX'
+require 'Dnsruby/resource/NAPTR'
+require 'Dnsruby/resource/NSAP'
+require 'Dnsruby/resource/PX'
+require 'Dnsruby/resource/RP'
+require 'Dnsruby/resource/RT'
+require 'Dnsruby/resource/SOA'
+require 'Dnsruby/resource/TXT'
+require 'Dnsruby/resource/X25'
+require 'Dnsruby/resource/SPF'
+require 'Dnsruby/resource/CERT'
+require 'Dnsruby/resource/LOC'
+require 'Dnsruby/resource/OPT'
+require 'Dnsruby/resource/TSIG'
+require 'Dnsruby/resource/TKEY'

data/lib/Dnsruby/resource/resource.rb

@@ -0,0 +1,444 @@
+#--
+#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
+  ClassHash = {} #:nodoc: all
+  
+  # RFC2181, section 5
+  # "It is however possible for most record types to exist
+  # with the same label, class and type, but with different data.  Such a
+  # group of records is hereby defined to be a Resource Record Set
+  # (RRSet)."
+  class RRSet
+    def initialize()
+      @rrs = []
+    end
+    #Add the RR to this RRSet
+    def add(r)
+      if @rrs.include?r
+        return false
+      end
+      if (rrs.size() == 0)
+        @rrs.push(r)
+        return;
+      end
+      # Check the type, klass and ttl are correct
+      first = @rrs[0]
+      if (!r.sameRRset(first))
+        raise ArgumentError.new("record does not match rrset")
+      end
+      
+      if (r.ttl != first.ttl) # RFC2181, section 5.2
+        if (r.ttl > first.ttl)
+          #          r = r.cloneRecord();
+          r.ttl=(first.ttl);
+        else
+          @rrs.each do |rr|
+            rr.ttl = r.ttl
+          end
+        end
+      end
+      
+      if (!rrs.contains(r))
+        @rrs.push(r)
+      end
+    end
+    
+    #Delete the RR from this RRSet
+    def delete(rr)
+      @rrs.delete(rr)
+    end
+    def each
+      @rrs.each do |rr|
+        yield rr
+      end
+    end
+    #Return the type of this RRSet
+    def type
+      return @rrs[0].type
+    end
+    #Return the klass of this RRSet
+    def klass
+      return @rrs[0].klass
+    end
+    #Return the ttl of this RRSet
+    def ttl
+      return @rrs[0].ttl
+    end
+  end
+  
+  #Superclass for all Dnsruby resource records.
+  # 
+  #Represents a DNS RR (resource record) [RFC1035, section 3.2]
+  # 
+  #Use Dnsruby::RR::create(...) to create a new RR record. 
+  # 
+  #   mx = Dnsruby::RR.create("example.com. 7200 MX 10 mailhost.example.com.")
+  #   
+  #   rr = Dnsruby::RR.create({:name => "example.com", :type => "MX", :ttl => 7200, 
+  #                                  :preference => 10, :exchange => "mailhost.example.com"})
+  #                                  
+  #   s = rr.to_s # Get a String representation of the RR (in zone file format)
+  #   rr_again = Dnsruby::RR.create(s)
+  # 
+  class RR
+    
+    # A regular expression which catches any valid resource record.
+    @@RR_REGEX = Regexp.new("^\\s*(\\S+)\\s*(\\d+)?\\s*(#{Classes.regexp + "|CLASS\\d+"})?\\s*(#{Types.regexp + '|TYPE\\d+'})?\\s*([\\s\\S]*)\$") #:nodoc: all
+    
+    #The Resource's domain name
+    attr_accessor :name
+    #The Resource type
+    attr_accessor :type
+    #The Resource class
+    attr_accessor :klass
+    #The Resource Time-To-Live
+    attr_accessor :ttl
+    #The Resource data section
+    attr_accessor :rdata
+    
+    def rdlength
+      return rdata.length
+    end
+    
+    def name=(newname)
+      if (!(newname.kind_of?Name))
+        @name=Name.create(newname)
+      else
+        @name = newname
+      end
+    end
+    
+    def type=(type)
+      @type = Types.new(type)
+    end
+    
+    def klass=(klass)
+      @klass= Classes.new(klass)
+    end
+    
+    # Determines if two Records could be part of the same RRset.
+    # This compares the name, type, and class of the Records; the ttl and
+    # rdata are not compared.
+    def sameRRset(rec)
+      return (@type == rec.type && @klass == rec.klass && @name== rec.name)
+    end
+    
+    private
+    def initialize(*args) #:nodoc: all
+      if (args.length > 0)
+        if (args[0].class == Hash)
+          from_hash(args[0])
+          return
+        else
+          @rdata = args[0]
+          if (args[0].class == String)
+            from_string(args[0])
+            return
+          else
+            from_data(args[0])
+            return
+          end
+        end
+      end
+#      raise ArgumentError.new("Don't call new! Use Dnsruby::RR::create() instead")
+    end
+    public
+    
+    def from_hash(hash) #:nodoc: all
+      hash.keys.each do |param|
+        send(param.to_s+"=", hash[param])
+      end
+    end
+    
+    #Create a new RR from the hash. The name is required; all other fields are optional.
+    #Type defaults to ANY and the Class defaults to IN. The TTL defaults to 0.
+    #
+    #If the type is specified, then it is necessary to provide ALL of the resource record fields which 
+    #are specific to that record; i.e. for
+    #an MX record, you would need to specify the exchange and the preference
+    #
+    #   require 'Dnsruby'
+    #   rr = Dnsruby::RR.new_from_hash({:name => "example.com"})
+    #   rr = Dnsruby::RR.new_from_hash({:name => "example.com", :type => Types.MX, :ttl => 10, :preference => 5, :exchange => "mx1.example.com"})
+    def RR.new_from_hash(inhash)
+      hash = inhash.clone        
+      type = hash[:type] || Types::ANY
+      klass = hash[:class] || Classes::IN
+      ttl = hash[:ttl] || 0
+      recordclass = get_class(type, klass)
+      record = recordclass.new
+      record.name=hash[:name]
+      if !(record.name.kind_of?Name)
+        record.name = Name.create(record.name)
+      end
+      record.ttl=ttl
+      record.type = type
+      record.klass = klass
+      hash.delete(:name)
+      hash.delete(:type)
+      hash.delete(:ttl)
+      hash.delete(:class)
+      record.from_hash(hash)
+      return record
+    end
+    
+    #Returns a Dnsruby::RR object of the appropriate type and
+    #initialized from the string passed by the user.  The format of the
+    #string is that used in zone files, and is compatible with the string
+    #returned by Net::DNS::RR.inspect
+    #
+    #The name and RR type are required; all other information is optional.
+    #If omitted, the TTL defaults to 0 and the RR class defaults to IN.
+    #
+    #All names must be fully qualified.  The trailing dot (.) is optional.
+    #
+    # 
+    #   a     = Dnsruby::RR.new_from_string("foo.example.com. 86400 A 10.1.2.3")
+    #   mx    = Dnsruby::RR.new_from_string("example.com. 7200 MX 10 mailhost.example.com.")
+    #   cname = Dnsruby::RR.new_from_string("www.example.com 300 IN CNAME www1.example.com")
+    #   txt   = Dnsruby::RR.new_from_string('baz.example.com 3600 HS TXT "text record"')
+    #
+    #
+    def RR.new_from_string(rrstring)
+      # strip out comments
+      # Test for non escaped ";" by means of the look-behind assertion
+      # (the backslash is escaped)
+      rrstring.gsub!(/(\?<!\\);.*/o, "");
+      
+      if ((rrstring =~/#{@@RR_REGEX}/xo) == nil)
+        raise Exception, "#{rrstring} did not match RR pat.\nPlease report this to the author!\n"
+      end
+      
+      name    = $1;
+      ttl     = $2.to_i || 0;
+      rrclass = $3 || '';
+      
+      
+      rrtype  = $4 || '';
+      rdata   = $5 || '';
+      
+      if rdata 
+        rdata.gsub!(/\s+$/o, "")
+      end
+      if name 
+        name.gsub!(/\.$/o, "");
+      end
+      
+      
+      # RFC3597 tweaks
+      # This converts to known class and type if specified as TYPE###
+      if rrtype  =~/^TYPE\d+/o
+        rrtype  = Dnsruby::Types.typesbyval(Dnsruby::Types::typesbyname(rrtype))
+      end
+      if rrclass =~/^CLASS\d+/o
+        rrclass = Dnsruby::Classes.classesbyval(Dnsruby::Classes::classesbyname(rrclass))
+      end
+      
+      
+      if (rrtype=='' && rrclass && rrclass == 'ANY')
+        rrtype  = 'ANY';
+        rrclass = 'IN';
+      elsif (rrclass=='')
+        rrclass = 'IN';
+      end
+      
+      if (rrtype == '')
+        rrtype = 'ANY';
+      end
+      
+      if (implemented_rrs.include?(rrtype) && rdata !~/^\s*\\#/o )
+        subclass = _get_subclass(name, rrtype, rrclass, ttl, rdata)
+        return subclass
+      elsif (implemented_rrs.include?(rrtype))   # A known RR type starting with \#
+        rdata =~ /\\\#\s+(\d+)\s+(.*)$/o;
+        
+        rdlength = $1.to_i;
+        hexdump  = $2;		
+        hexdump.gsub!(/\s*/, "");
+        
+        if hexdump.length() != rdlength*2
+          raise Exception, "#{rdata} is inconsistent; length does not match content"
+        end
+        
+        rdata = [hexdump].pack('H*');
+        
+        return new_from_data(name, rrtype, rrclass, ttl, rdlength, rdata, 0) # rdata.length() - rdlength);
+      elsif (rdata=~/\s*\\\#\s+\d+\s+/o)
+        #We are now dealing with the truly unknown.
+        raise Exception, 'Expected RFC3597 representation of RDATA' unless rdata =~/\\\#\s+(\d+)\s+(.*)$/o;
+        
+        rdlength = $1.to_i;
+        hexdump  = $2;		
+        hexdump.gsub!(/\s*/o, "");
+        
+        if hexdump.length() != rdlength*2
+          raise Exception, "#{rdata} is inconsistent; length does not match content" ;
+        end
+        
+        rdata = [hexdump].pack('H*');
+        
+        return new_from_data(name,rrtype,rrclass,ttl,rdlength,rdata,0) # rdata.length() - rdlength);
+      else
+        #God knows how to handle these...
+        subclass = _get_subclass(name, rrtype, rrclass, ttl, "")
+        return subclass
+      end
+    end
+    
+    def RR.new_from_data(*args) #:nodoc: all
+      name = args[0]
+      rrtype = args[1]
+      rrclass = args[2]
+      ttl = args[3]
+      rdlength = args[4]
+      data = args[5]
+      offset = args[6]
+      rdata = data[offset, rdlength]
+      
+      record = nil
+      MessageDecoder.new(rdata) {|msg|
+        record = get_class(rrtype, rrclass).decode_rdata(msg)
+      }
+      record.name = name
+      record.ttl = ttl
+      record.type = rrtype
+      record.klass = rrclass        
+      
+      return record
+    end
+    
+    #Return an array of all the currently implemented RR types
+    def RR.implemented_rrs
+      return ClassHash.keys.map {|k| Dnsruby::Types.to_string(k[0])}
+    end
+    
+    private
+    def RR._get_subclass(name, rrtype, rrclass, ttl, rdata) #:nodoc: all
+      return unless (rrtype!=nil)        
+      record = get_class(rrtype, rrclass).new(rdata)        
+      record.name = name
+      record.ttl = ttl
+      record.type = rrtype
+      record.klass = rrclass   
+      return record
+    end	
+    public
+    
+    #Returns a string representation of the RR in zone file format
+    def to_s
+      return (@name?@name.to_s():"") + ".\t" +(@ttl?@ttl.to_s():"") + "\t" + (klass()?klass.string():"") + "\t" + (type()?type.string():"") + "\t" + rdata_to_string
+    end
+    
+    #Get a string representation of the data section of the RR (in zone file format)
+    def rdata_to_string
+      if (@rdata && @rdata.length > 0)
+        return @rdata
+      else 
+        return "no rdata"
+      end
+    end
+    
+    def from_data(data) #:nodoc: all
+      # to be implemented by subclasses
+      raise NotImplementedError.new
+    end
+    
+    def from_string(input) #:nodoc: all
+      # to be implemented by subclasses
+      #      raise NotImplementedError.new
+    end
+    
+    def encode_rdata(msg) #:nodoc: all
+      # to be implemented by subclasses
+      raise EncodeError.new("#{self.class} is RR.") 
+    end
+    
+    def self.decode_rdata(msg) #:nodoc: all
+      # to be implemented by subclasses
+      raise DecodeError.new("#{self.class} is RR.") 
+    end
+    
+    def ==(other)
+      # @TODO@ TTL should not be compared for Updates! (RFC 2136, 1.1.1)
+      return self.class == other.class &&
+        self.instance_variables == other.instance_variables &&
+        self.instance_variables.collect {|name| self.instance_eval name} ==
+        other.instance_variables.collect {|name| other.instance_eval name}
+    end
+    
+    def eql?(other)
+      return self == other
+    end
+    
+    def hash
+      h = 0
+      self.instance_variables.each {|name|
+        h ^= self.instance_eval("#{name}.hash")
+      }
+      return h
+    end
+    
+    #Get an RR of the specified type and class
+    def self.get_class(type_value, class_value) #:nodoc: all
+      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))
+      else
+        if (type_value.class == Types)
+          type_value = type_value.code
+        else
+          type_value = Types.new(type_value).code
+        end
+        if (class_value.class == Classes)
+          class_value = class_value.code
+        else
+          class_value = Classes.new(class_value).code
+        end
+        return ClassHash[[type_value, class_value]] ||
+          Generic.create(type_value, class_value)
+      end
+      return ret
+    end  
+    
+    
+    #Create a new RR from the arguments, which can be either a String or a Hash.
+    #See new_from_string and new_from_hash for details
+    #
+    #   a     = Dnsruby::RR.create("foo.example.com. 86400 A 10.1.2.3")
+    #   mx    = Dnsruby::RR.create("example.com. 7200 MX 10 mailhost.example.com.")
+    #   cname = Dnsruby::RR.create("www.example.com 300 IN CNAME www1.example.com")
+    #   txt   = Dnsruby::RR.create('baz.example.com 3600 HS TXT "text record"')
+    #   
+    #   rr = Dnsruby::RR.create({:name => "example.com"})
+    #   rr = Dnsruby::RR.create({:name => "example.com", :type => "MX", :ttl => 10, 
+    #                                  :preference => 5, :exchange => "mx1.example.com"})
+    #   
+    def RR.create(*args)
+      if (args.length == 1) && (args[0].class == String) 
+        return new_from_string(args[0])
+      elsif (args.length == 1) && (args[0].class == Hash) 
+        return new_from_hash(args[0])
+      else 
+        return new_from_data(args)
+      end
+    end
+    
+  end
+end  
+require 'Dnsruby/resource/domain_name'
+require 'Dnsruby/resource/generic'
+require 'Dnsruby/resource/IN'