dnsruby 1.1

data/lib/Dnsruby/resource/TXT.rb

@@ -0,0 +1,76 @@
+#--
+#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.
+#++
+require 'shellwords'
+module Dnsruby
+  class RR
+    #Class for DNS Text (TXT) resource records.
+    #RFC 1035 Section 3.3.14
+    class TXT < RR
+      ClassValue = nil #:nodoc: all
+      TypeValue = Types::TXT #:nodoc: all
+      
+      #List of the individual elements
+      attr_accessor :strings
+      
+      def data
+        @strings[0]
+      end
+      
+      def from_data(data)
+        @strings = data
+      end
+      
+      def from_hash(hash)
+        if (hash.has_key?:strings)
+          from_string(hash[:strings])
+        end
+      end
+      
+      def from_string(input)
+        words = Shellwords.shellwords(input)
+        
+        @strings=[]
+        
+        if (words != nil)
+          words.each { |string|
+            string .gsub!(/\\"/, '"')
+            @strings.push(string)
+          }
+        end
+      end
+      
+      def rdata_to_string
+        if (defined?@strings)
+          temp = @strings.map {|str|
+            str.gsub(/"/, '\\"')
+              %<"#{str}">
+          }
+          return temp.join(' ')
+        end          
+        return ''
+      end
+      
+      def encode_rdata(msg, canonical=false) #:nodoc: all
+        msg.put_string_list(@strings)
+      end
+      
+      def self.decode_rdata(msg) #:nodoc: all
+        strings = msg.get_string_list
+        return self.new(strings)
+      end
+    end
+  end
+end

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, canonical=false) #: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,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
+    # Abstract superclass for RR's which have a 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)
+        @domainname=Name.create(newname)
+      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,151 @@
+#--
+#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
+      #data for the generic resource record
+      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, canonical=false) #: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) #:nodoc:
+        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
+    #Nameserver resource record
+    class NS < DomainName
+      ClassValue = nil #:nodoc: all
+      TypeValue = Types::NS #:nodoc: all
+      
+      alias nsdname domainname
+      alias nsdname= domainname=
+    end
+    
+    #CNAME RR
+    #The canonical name for an alias
+    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
+    # A Query type requesting any RR
+    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'
+require 'Dnsruby/resource/DNSKEY'
+require 'Dnsruby/resource/RRSIG'
+require 'Dnsruby/resource/NSEC'
+require 'Dnsruby/resource/DS'
+require 'Dnsruby/resource/NSEC3'
+require 'Dnsruby/resource/NSEC3PARAM'

data/lib/Dnsruby/resource/resource.rb

@@ -0,0 +1,561 @@
+#--
+#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)."
+  # This class also stores the RRSIG records which cover the RRSet
+  class RRSet
+    # The number of RRSIGs stored in this RRSet
+    attr_reader :num_sigs
+    def initialize(rrs = [])
+      if (!rrs.instance_of?Array)
+        rrs = [rrs]
+      end
+      @rrs = []
+      @num_sigs = 0
+      rrs.each {|rr| add(rr)}
+    end
+    # The RRSIGs stored with this RRSet
+    def sigs
+      return @rrs[@rrs.length-@num_sigs, @num_sigs]
+    end
+    # The RRs (not RRSIGs) stored in this RRSet
+    def rrs
+      return @rrs[0, @rrs.length-@num_sigs]
+    end
+    def privateAdd(r) #:nodoc:
+      if @rrs.include?r
+        return true
+      end      
+      new_pos = @rrs.length - @num_sigs
+      if ((@num_sigs == @rrs.length)  && @num_sigs > 0) # if we added RRSIG first
+        if (r.type != @rrs.last.type_covered)
+          return false
+        end
+      end
+      if (r.type == Types.RRSIG)
+        new_pos = @rrs.length
+        @num_sigs += 1
+      end
+      @rrs.insert(new_pos, r)
+      return true
+    end
+
+    #Add the RR to this RRSet
+    def add(r)
+      if (r.instance_of?RRSet)
+        ret = false
+        [r.rrs, r.sigs].each {|rr| ret = add(rr)}
+        return ret
+      end
+      r = RR.create(r.to_s) # clone the record
+      if (@rrs.size() == 0) #  && !(r.type == Types.RRSIG))
+        return privateAdd(r)
+      end
+      # Check the type, klass and ttl are correct
+      first = @rrs[0]
+      if (!r.sameRRset(first))
+        return false
+#        raise ArgumentError.new("record does not match rrset")
+      end
+      
+      if (!(r.type == Types.RRSIG) && (!(first.type == Types.RRSIG)))
+        if (r.ttl != first.ttl) # RFC2181, section 5.2
+          if (r.ttl > first.ttl)
+            r.ttl=(first.ttl)
+          else
+            @rrs.each do |rr|
+              rr.ttl = r.ttl
+            end
+          end
+        end
+      end
+      
+        return privateAdd(r)
+      return true
+    end
+    
+    #Return a new RRset which contains the RRs from this
+    #RRset into canonical order (RFC 4034 section 6)
+    def sort_canonical
+      #Make a list, for all the RRs, where each RR contributes 
+      #the canonical RDATA encoding
+      canonical_rrs = []
+      self.rrs.each do |rr|
+        data = MessageEncoder.new {|msg|
+          msg.put_rr(rr, true)
+        }.to_s
+        canonical_rrs.push(data)
+      end
+      
+      # Check there are no identical records - if there are duplicated entries
+      # then remove them
+      canonical_rrs.uniq!
+      
+      #Sort it (the absence of an octet sorts before a zero octet.)
+      canonical_rrs.sort!
+      
+      return_rrs = RRSet.new
+      canonical_rrs.each {|rr|
+        MessageDecoder.new(rr) {|msg|
+          new_rr = msg.get_rr
+          return_rrs.add(new_rr)
+        }
+      }
+      return return_rrs
+    end
+    
+    #Delete the RR from this RRSet
+    def delete(rr)
+      @rrs.delete(rr)
+    end
+    def each
+      @rrs.each do |rr|
+        yield rr
+      end
+    end
+    def [](index)
+      return @rrs[index]
+    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
+    def ttl=(ttl)
+      [rrs, sigs].each {|rrs|
+        rrs.each {|rr|
+          rr.ttl = ttl
+        }
+      }
+    end
+    def name
+      return @rrs[0].name
+    end
+    def to_s
+      ret = ""
+      each {|rec|
+        ret += rec.to_s + "\n"
+      }
+      return ret
+    end
+    def length
+      return @rrs.length
+    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_reader :name
+    #The Resource type
+    attr_reader :type
+    #The Resource class
+    attr_reader :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
+    alias :rr_type :type
+    
+    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)
+      if (@klass != rec.klass || @name != rec.name)
+        return false
+      end
+      [rec, self].each { |rr|
+        if (rr.type == Types.RRSIG)
+          return ((@type == rr.type_covered) || (rec.type == rr.type_covered))
+        end
+      }
+      return (@type == rec.type)
+    end
+    
+    def init_defaults
+      # Default to do nothing
+    end
+    
+    private
+    def initialize(*args) #:nodoc: all
+      init_defaults
+      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[:klass] || 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(:klass)
+      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.to_s():"") + "\t" + (type() ? type.to_s():"") + "\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, canonical=false) #: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)
+      return false unless self.class == other.class
+      s_ivars = self.instance_variables
+      s_ivars.sort!
+      s_ivars.delete "@ttl" # RFC 2136 section 1.1
+      
+      o_ivars = other.instance_variables
+      o_ivars.sort!
+      o_ivars.delete "@ttl" # RFC 2136 section 1.1
+      
+      return s_ivars == o_ivars &&
+        s_ivars.collect {|name| self.instance_variable_get name} == 
+        o_ivars.collect {|name| other.instance_variable_get name}
+    end
+    
+    def eql?(other) #:nodoc:
+      return self == other
+    end
+    
+    def hash # :nodoc:
+      h = 0      
+      vars = self.instance_variables
+      vars.delete "@ttl"
+      vars.each {|name|
+        h ^= self.instance_variable_get(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 == Types.OPT)
+      #        return Class.new(OPT)
+      #      end
+      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'