dnsruby 1.33 → 1.34

data/lib/Dnsruby/Resolver.rb

@@ -365,6 +365,8 @@ module Dnsruby
                 @config.set_config_info(args[0][:config_info])
               elsif (key==:nameserver)
                 set_config_nameserver(args[0][:nameserver])
+              elsif (key==:nameservers)
+                set_config_nameserver(args[0][:nameservers])
               else
                 send(key.to_s+"=", args[0][key])
               end
@@ -479,7 +481,10 @@ module Dnsruby
         res.send(param.to_s+"=", instance_variable_get("@"+param.to_s))
       end
     end
-    
+
+    def nameservers=(ns)
+      self.nameserver=(n)
+    end
     def nameserver=(n)
       @configured = true
             @single_res_mutex.synchronize {

data/lib/Dnsruby/code_mapper.rb

@@ -26,16 +26,23 @@ module Dnsruby
   class CodeMapper # :nodoc: all
     include Comparable
     
-    @@strings = {}
-    @@stringsdown = {}
-    @@values = {}
-    @@maxcode = {}
+    @@arrays = {}
     
     attr_accessor :string, :code
     alias to_code code
     alias to_i code
     alias to_string string
     alias to_s string
+
+    class Arrays
+      attr_accessor :strings, :stringsdown, :values, :maxcode
+      def initialize
+        @strings = {}
+        @stringsdown = {}
+        @values = {}
+        @maxcode = 0
+      end
+    end
     
     def CodeMapper.maxcode
       return @maxcode
@@ -43,30 +50,28 @@ module Dnsruby
     
     # Creates the CodeMapper from the defined constants
     def CodeMapper.update
-      
-      @@strings[self] = {}
-      @@stringsdown[self] = {}
-      @@values[self] = {}
-      @@maxcode[self] = 0
+
+      @@arrays[self] = Arrays.new
       
       constants = self.constants - CodeMapper.constants
       constants.each do |i|
-        @@strings[self].store(i.to_s, const_get(i))
+        @@arrays[self].strings.store(i.to_s, const_get(i))
       end 
-      @@maxcode[self] = constants.length
-      @@values[self] = @@strings[self].invert
-      @@stringsdown[self] = Hash.new
-      @@strings[self].keys.each do |s|
-        @@stringsdown[self].store(s.downcase, @@strings[self][s])    
+      @@arrays[self].maxcode = constants.length
+      @@arrays[self].values = @@arrays[self].strings.invert
+      @@arrays[self].stringsdown = Hash.new
+      @@arrays[self].strings.keys.each do |s|
+        @@arrays[self].stringsdown.store(s.downcase, @@arrays[self].strings[s])
       end
     end
     
     # Add new a code to the CodeMapper
     def CodeMapper.add_pair(string, code)
-      @@strings[self].store(string, code)
-      @@values[self]=@@strings[self].invert
-      @@stringsdown[self].store(string.downcase, code)
-      @@maxcode[self]+=1
+      array = @@arrays[self]
+      array.strings.store(string, code)
+      array.values=array.strings.invert
+      array.stringsdown.store(string.downcase, code)
+      array.maxcode+=1
     end
     
     def unknown_string(arg) #:nodoc: all
@@ -75,7 +80,7 @@ module Dnsruby
     
     def unknown_code(arg) #:nodoc: all
       # Be liberal in what you accept...
-#      raise ArgumentError.new("Code #{arg} not a member of #{self.class}")
+      #      raise ArgumentError.new("Code #{arg} not a member of #{self.class}")
       Classes.add_pair(arg.to_s, arg)
       set_code(arg)
     end
@@ -86,36 +91,42 @@ module Dnsruby
     end
     
     def initialize(arg) #:nodoc: all
+      array = @@arrays[self.class]
       if (arg.kind_of?String)
         arg.gsub!("_", "-")
-        if (@@stringsdown[self.class][arg.downcase] != nil)
-          set_string(arg)
+        code = array.stringsdown[arg.downcase]
+        if (code != nil)
+          @code = code
+          @string = array.strings.invert[@code]
         else 
           unknown_string(arg)
         end
       elsif (arg.kind_of?Fixnum)
-        if (@@values[self.class][arg] != nil)
-          set_code(arg)
+        if (array.values[arg] != nil)
+          @code = arg
+          @string = array.values[@code]
         else 
           unknown_code(arg)
         end
       elsif (arg.kind_of?self.class)
-        set_code(arg.code)
+        @code = arg.code
+        @string = array.values[@code]
       else
         raise ArgumentError.new("Unknown argument #{arg} for #{self.class}")
       end
     end
     
+    def set_string(arg)
+      array = @@arrays[self.class]
+      @code = array.stringsdown[arg.downcase]
+      @string = array.strings.invert[@code]
+    end
+
     def set_code(arg)
       @code = arg
-      @string = @@values[self.class][@code]
+      @string = @@arrays[self.class].values[@code]
     end
-    
-    def set_string(arg)
-      @code = @@stringsdown[self.class][arg.downcase]
-      @string = @@strings[self.class].invert[@code]
-    end
-    
+        
     def inspect
       return @string
     end    
@@ -124,7 +135,7 @@ module Dnsruby
       if (arg.kind_of?String) 
         return arg
       else
-        return @@values[self][arg]
+        return @@arrays[self].values[arg]
       end
     end
     
@@ -132,7 +143,7 @@ module Dnsruby
       if (arg.kind_of?Fixnum)
         return arg
       else
-        return @@stringsdown[self][arg.downcase]
+        return @@arrays[self].stringsdown[arg.downcase]
       end
     end
     
@@ -145,16 +156,16 @@ module Dnsruby
     end
     
     def ==(other)
-      if other.kind_of?CodeMapper
-        if other.string == @string && other.code == @code
-          return true 
+      if Fixnum === other
+        if other == @code
+          return true
         end
-      elsif other.kind_of?String
+      elsif String === other
         if other == @string
           return true
         end
-      elsif other.kind_of?Fixnum
-        if other == @code
+      elsif CodeMapper === other
+        if other.string == @string && other.code == @code
           return true
         end
       end
@@ -165,7 +176,7 @@ module Dnsruby
     # Return a regular expression which matches any codes or strings from the CodeMapper.
     def self.regexp
       # Longest ones go first, so the regex engine will match AAAA before A, etc.
-      return @@strings[self].keys.sort { |a, b| b.length <=> a.length }.join('|')
+      return @@arrays[self].strings.keys.sort { |a, b| b.length <=> a.length }.join('|')
     end
     
   end

data/lib/Dnsruby/dnssec.rb

@@ -138,7 +138,7 @@ module Dnsruby
             line = lastname.to_s + ((lastname.absolute?)?".":"") + " " + line
           end
           ds = RR.create(line)
-          if ((ds.type == Types.DS) || (ds.type == Types.DNSKEY))
+          if ((ds.type == Types::DS) || (ds.type == Types::DNSKEY))
             #            assert(ds.name.absolute?)
             Dnssec.add_trust_anchor(ds)
           end
@@ -189,7 +189,7 @@ module Dnsruby
       # First, just check there is something to validate!
       found_sigs = false
       msg.each_resource {|rr|
-        if (rr.type == Types.RRSIG)
+        if (rr.type == Types::RRSIG)
           found_sigs = true
         end
       }

data/lib/Dnsruby/message.rb

@@ -96,7 +96,7 @@ module Dnsruby
       def rrset(name, type=Types.A, klass=Classes::IN)
         rrs = select{|rr| 
           type_ok = (rr.type==type)
-          if (rr.type == Types.RRSIG)
+          if (rr.type == Types::RRSIG)
             type_ok = (rr.type_covered == type)
           end
           type_ok && (rr.klass == klass) && (rr.name.to_s.downcase == name.to_s.downcase)
@@ -115,7 +115,7 @@ module Dnsruby
         end
         ret = []
         each do |rr|
-          next if (!include_opt && (rr.type == Types.OPT))
+          next if (!include_opt && (rr.type == Types::OPT))
           #          if (type)
           #            next if ((rr.type == Types.RRSIG) && (type != Types.RRSIG) && (rr.type_covered != type))
           #            next if (rr.type != type)
@@ -124,8 +124,8 @@ module Dnsruby
             # if this is an rrsig type, then :
             #    only include it if the type_covered is the type requested,
             #    OR if the type requested is an RRSIG
-            if (rr.type == Types.RRSIG)
-              if ((rr.type_covered == type) || (type == Types.RRSIG))
+            if (rr.type == Types::RRSIG)
+              if ((rr.type_covered == type) || (type == Types::RRSIG))
               else
                 next
               end
@@ -162,10 +162,10 @@ module Dnsruby
         # update the counts itself, rather than the section worrying about it?
         rrs_to_delete = []
         each do |rr|
-          next if rr.rr_type == Types.OPT
+          next if rr.rr_type == Types::OPT
           if ((rr.name.to_s.downcase == name.to_s.downcase) &&
                 ((rr.type == type) ||
-                  ((rr.type == Types.RRSIG) && (rr.type_covered == type)) ))
+                  ((rr.type == Types::RRSIG) && (rr.type_covered == type)) ))
             rrs_to_delete.push(rr)
           end
         end
@@ -200,8 +200,8 @@ module Dnsruby
       @security_level = SecurityLevel.UNCHECKED
       @security_error = nil
       @cached = false
-      type = Types.A
-      klass = Classes.IN
+      type = Types::A
+      klass = Classes::IN
       if (args.length > 0)
         name = args[0]
         if (args.length > 1)
@@ -463,7 +463,7 @@ module Dnsruby
     
     def get_opt
       each_additional do |r|
-        if (r.type == Types.OPT)
+        if (r.type == Types::OPT)
           return r
         end
       end
@@ -531,7 +531,7 @@ module Dnsruby
         retval = retval + "\n";
         retval = retval + ";; ADDITIONAL SECTION (#{@header.arcount}  record#{@header.arcount == 1 ? '' : 's'})\n";
         each_additional { |rr|
-          if (rr.type != Types.OPT)
+          if (rr.type != Types::OPT)
             retval = retval + rr.to_s+ "\n"
           end
         }
@@ -602,7 +602,7 @@ module Dnsruby
         o.header.arcount.times { |count|
           start = msg.index
           rr = msg.get_rr
-          if (rr.type == Types.TSIG)
+          if (rr.type == Types::TSIG)
             if (count!=o.header.arcount-1)
               Dnsruby.log.Error("Incoming message has TSIG record before last record")
               raise DecodeError.new("TSIG record present before last record")
@@ -1109,8 +1109,8 @@ module Dnsruby
     #
     #If an IPv4 or IPv6 object is used then the type is set to PTR.
     def initialize(*args)
-      @qtype = Types.A
-      @qclass = Classes.IN
+      @qtype = Types::A
+      @qclass = Classes::IN
       if (args.length > 0)
         if (args.length > 1)
           @qtype = Types.new(args[1])

data/lib/Dnsruby/resource/NSEC.rb

@@ -145,7 +145,7 @@ module Dnsruby
                   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)))
+                  if (!([Types::OPT, Types::TSIG].include?(type)))
                     types.push(type)
                   end
                 end               

data/lib/Dnsruby/resource/RRSIG.rb

@@ -89,7 +89,7 @@ module Dnsruby
       
       def init_defaults
         @algorithm=Algorithms.RSASHA1
-        @type_covered = Types.A
+        @type_covered = Types::A
         @original_ttl = 3600
         @inception = Time.now.to_i
         @expiration = Time.now.to_i

data/lib/Dnsruby/resource/resource.rb

@@ -52,7 +52,7 @@ module Dnsruby
           return false
         end
       end
-      if (r.type == Types.RRSIG)
+      if (r.type == Types::RRSIG)
         new_pos = @rrs.length
         @num_sigs += 1
       end
@@ -61,13 +61,24 @@ module Dnsruby
     end
 
     #Add the RR to this RRSet
-    def add(r)
-      if (r.instance_of?RRSet)
+    #Takes a copy of the RR by default. To suppress this, pass false
+    #as the second parameter.
+    def add(rin, do_clone = true)
+      if (rin.instance_of?RRSet)
         ret = false
-        [r.rrs, r.sigs].each {|rr| ret = add(rr)}
+        [rin.rrs, rin.sigs].each {|rr| ret = add(rr)}
         return ret
       end
-      r = RR.create(r.to_s) # clone the record
+      #      r = RR.create(r.to_s) # clone the record
+      r = nil
+      if do_clone
+        Message::MessageDecoder.new(MessageEncoder.new {|msg|
+            msg.put_rr(rin, true)}.to_s) {|msg|
+          r = msg.get_rr
+        }
+      else
+        r = rin
+      end
       if (@rrs.size() == 0) #  && !(r.type == Types.RRSIG))
         return privateAdd(r)
       end
@@ -75,10 +86,10 @@ module Dnsruby
       first = @rrs[0]
       if (!r.sameRRset(first))
         return false
-#        raise ArgumentError.new("record does not match rrset")
+        #        raise ArgumentError.new("record does not match rrset")
       end
       
-      if (!(r.type == Types.RRSIG) && (!(first.type == Types.RRSIG)))
+      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)
@@ -90,13 +101,13 @@ module Dnsruby
         end
       end
       
-        return privateAdd(r)
-#      return true
+      return privateAdd(r)
+      #      return true
     end
 
     def <=>(other)
-#      return 1 if ((!other) || !(other.name) || !(other.type))
-#      return -1 if (!@name)
+      #      return 1 if ((!other) || !(other.name) || !(other.type))
+      #      return -1 if (!@name)
       if (@name.canonical == other.name.canonical)
         return @type.code <=> other.type.code
       else
@@ -117,7 +128,7 @@ module Dnsruby
 
       return_rrs = RRSet.new
       canonical_rrs.keys.sort.each { |rdata|
-        return_rrs.add(canonical_rrs[rdata])
+        return_rrs.add(canonical_rrs[rdata], false)
       }
       return return_rrs
     end
@@ -152,7 +163,7 @@ module Dnsruby
     #Return the type of this RRSet
     def type
       if (@rrs[0])
-      return @rrs[0].type
+        return @rrs[0].type
       end
       return nil
     end
@@ -173,7 +184,7 @@ module Dnsruby
     end
     def name
       if (@rrs[0])
-      return @rrs[0].name
+        return @rrs[0].name
       else
         return nil
       end
@@ -191,25 +202,27 @@ module Dnsruby
   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. 
-  # 
+  #
+  #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, 
+  #
+  #   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 + 
+    @@RR_REGEX = Regexp.new("^\\s*(\\S+)\\s*(\\d+)?\\s*(#{Classes.regexp +
       "|CLASS\\d+"})?\\s*(#{Types.regexp + '|TYPE\\d+'})?\\s*([\\s\\S]*)\$") #:nodoc: all
     
+    @@implemented_rr_map = nil
+
     #The Resource's domain name
     attr_reader :name
     #The Resource type
@@ -239,13 +252,13 @@ module Dnsruby
     alias :rr_type :type
     
     def klass=(klass)
-      if (@type != Types.OPT) 
+      if (@type != Types::OPT)
         @klass= Classes.new(klass)
       else
-         if (klass.class == Classes)
-            @klass = klass
+        if (klass.class == Classes)
+          @klass = klass
         else
-            @klass = Classes.new("CLASS#{klass}")
+          @klass = Classes.new("CLASS#{klass}")
         end
       end
     end
@@ -258,7 +271,7 @@ module Dnsruby
         return false
       end
       [rec, self].each { |rr|
-        if (rr.type == Types.RRSIG)
+        if (rr.type == Types::RRSIG)
           return ((@type == rr.type_covered) || (rec.type == rr.type_covered))
         end
       }
@@ -278,7 +291,7 @@ module Dnsruby
           return
         else
           @rdata = args[0]
-#          print "Loading RR from #{args[0]}, class : #{args[0].class}\n"
+          #          print "Loading RR from #{args[0]}, class : #{args[0].class}\n"
           if (args[0].class == String)
             from_string(args[0])
             return
@@ -301,7 +314,7 @@ module Dnsruby
     #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 
+    #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
     #
@@ -309,7 +322,7 @@ module 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        
+      hash = inhash.clone
       type = hash[:type] || Types::ANY
       klass = hash[:klass] || Classes::IN
       ttl = hash[:ttl] || 0
@@ -340,7 +353,7 @@ module Dnsruby
     #
     #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")
@@ -365,7 +378,7 @@ module Dnsruby
       rrtype  = $4 || '';
       rdata   = $5 || '';
       
-      if rdata 
+      if rdata
         rdata.gsub!(/\s+$/o, "")
       end
       
@@ -397,7 +410,7 @@ module Dnsruby
         rdata =~ /\\\#\s+(\d+)\s+(.*)$/o;
         
         rdlength = $1.to_i;
-        hexdump  = $2;		
+        hexdump  = $2;
         hexdump.gsub!(/\s*/, "");
         
         if hexdump.length() != rdlength*2
@@ -412,7 +425,7 @@ module Dnsruby
         raise Exception, 'Expected RFC3597 representation of RDATA' unless rdata =~/\\\#\s+(\d+)\s+(.*)$/o;
         
         rdlength = $1.to_i;
-        hexdump  = $2;		
+        hexdump  = $2;
         hexdump.gsub!(/\s*/o, "");
         
         if hexdump.length() != rdlength*2
@@ -439,7 +452,7 @@ module Dnsruby
       offset = args[6]
       rdata = []
       if (data != nil)
-         rdata = data[offset, rdlength]
+        rdata = data[offset, rdlength]
       end
       
       record = nil
@@ -449,26 +462,29 @@ module Dnsruby
       record.name = Name.create(name)
       record.ttl = ttl
       record.type = rrtype
-      record.klass = rrclass        
+      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])}
+      if (!@@implemented_rr_map)
+        @@implemented_rr_map = ClassHash.keys.map {|k| Dnsruby::Types.to_string(k[0])}
+      end
+      return @@implemented_rr_map
     end
     
     private
     def RR._get_subclass(name, rrtype, rrclass, ttl, rdata) #:nodoc: all
-      return unless (rrtype!=nil)        
-      record = get_class(rrtype, rrclass).new(rdata)        
+      return unless (rrtype!=nil)
+      record = get_class(rrtype, rrclass).new(rdata)
       record.name = Name.create(name)
       record.ttl = ttl
       record.type = rrtype
-      record.klass = rrclass   
+      record.klass = rrclass
       return record
-    end	
+    end
     public
     
     #Returns a string representation of the RR in zone file format
@@ -480,7 +496,7 @@ module Dnsruby
     def rdata_to_string
       if (@rdata && @rdata.length > 0)
         return @rdata
-      else 
+      else
         return "no rdata"
       end
     end
@@ -497,12 +513,12 @@ module Dnsruby
     
     def encode_rdata(msg, canonical=false) #:nodoc: all
       # to be implemented by subclasses
-      raise EncodeError.new("#{self.class} is RR.") 
+      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.") 
+      raise DecodeError.new("#{self.class} is RR.")
     end
     
     def ==(other)
@@ -520,7 +536,7 @@ module Dnsruby
       o_ivars.delete "@ttl" # RFC 2136 section 1.1
       
       return s_ivars == o_ivars &&
-        s_ivars.collect {|name| self.instance_variable_get name} == 
+        s_ivars.collect {|name| self.instance_variable_get name} ==
         o_ivars.collect {|name| other.instance_variable_get name}
     end
     
@@ -529,7 +545,7 @@ module Dnsruby
     end
     
     def hash # :nodoc:
-      h = 0      
+      h = 0
       vars = self.instance_variables
       vars.delete "@ttl"
       vars.each {|name|
@@ -540,8 +556,8 @@ module Dnsruby
     
     #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)
+      if (type_value == Types::OPT)
+        return Class.new(OPT)
       end
       if (type_value.class == Class)
         type_value = type_value.const_get(:TypeValue)
@@ -559,10 +575,10 @@ module Dnsruby
           class_value = Classes.new(class_value).code
         end
         return ClassHash[[type_value, class_value]] ||
-           Generic.create(type_value, class_value)
+          Generic.create(type_value, class_value)
       end
       return ret
-    end  
+    end
     
     
     #Create a new RR from the arguments, which can be either a String or a Hash.
@@ -572,17 +588,17 @@ module Dnsruby
     #   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, 
+    #   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) 
+      if (args.length == 1) && (args[0].class == String)
         return new_from_string(args[0])
-      elsif (args.length == 1) && (args[0].class == Hash) 
+      elsif (args.length == 1) && (args[0].class == Hash)
         return new_from_hash(args[0])
-      else 
+      else
         return new_from_data(args)
       end
     end