dnsruby 1.26 → 1.30

data/lib/Dnsruby/resource/OPT.rb

@@ -24,6 +24,8 @@ module Dnsruby
       TypeValue = Types::OPT #:nodoc: all
       DO_BIT = 0x8000
 
+      # @TODO@ Add BADVERS to an XRCode CodeMapper object
+
       #Can be called with up to 3 arguments, none of which must be present
       #* OPT.new()
       #* OPT.new(size)
@@ -90,11 +92,12 @@ module Dnsruby
       end
       
       def xrcode
-        return flags_from_ttl[0, 1].unpack("C")[0]
+        return ExtendedRCode.new(flags_from_ttl[0, 1].unpack("C")[0])
       end
       
-      def xrcode=(code)
-        @ttl = (code << 24) + (version() << 16) + flags()
+      def xrcode=(c)
+        code = ExtendedRCode.new(c)
+        @ttl = (code.code << 24) + (version() << 16) + flags()
       end
       
       def version
@@ -102,7 +105,7 @@ module Dnsruby
       end
       
       def version=(code)
-        @ttl = (xrcode() << 24) + (code << 16) + flags()
+        @ttl = (xrcode().code << 24) + (code << 16) + flags()
       end
       
       def flags
@@ -114,7 +117,7 @@ module Dnsruby
       end
       
       def set_flags(code) # Should always be zero
-        @ttl = (xrcode() << 24) + (version() << 16) + code
+        @ttl = (xrcode().code << 24) + (version() << 16) + code
       end
       
       def dnssec_ok
@@ -165,7 +168,7 @@ module Dnsruby
       end
       
       def to_s
-        ret = "OPT pseudo-record : payloadsize #{payloadsize}, xrcode #{xrcode}, version #{version}, flags #{flags}"
+        ret = "OPT pseudo-record : payloadsize #{payloadsize}, xrcode #{xrcode.code}, version #{version}, flags #{flags}"
         if @options
           @options.each do |opt|
             ret = ret + " " + opt.to_s

data/lib/Dnsruby/resource/PX.rb

@@ -39,7 +39,7 @@ module Dnsruby
         def from_string(input) #:nodoc: all
           if (input.length > 0)
             names = input.split(" ")
-            @preference = names[0]
+            @preference = names[0].to_i
             @map822 = Name.create(names[1])
             @mapx400 = Name.create(names[2])
           end

data/lib/Dnsruby/resource/RT.rb

@@ -39,7 +39,7 @@ module Dnsruby
       def from_string(input) #:nodoc: all
         if (input.length > 0)
           names = input.split(" ")
-          @preference = names[0]
+          @preference = names[0].to_i
           @intermediate = Name.create(names[1])
         end
       end

data/lib/Dnsruby/resource/SRV.rb

@@ -75,9 +75,9 @@ module Dnsruby
         def from_string(input)
           if (input.length > 0)
             names = input.split(" ")
-            @priority = names[0]
-            @weight = names[1]
-            @port = names[2]
+            @priority = names[0].to_i
+            @weight = names[1].to_i
+            @port = names[2].to_i
             if (names[3])
               @target = Name.create(names[3])
             end

data/lib/Dnsruby/resource/resource.rb

@@ -111,36 +111,21 @@ module Dnsruby
       return return_rrs
     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
-    
+    def ==(other)
+      return false unless other.instance_of?RRSet
+      return false if (other.sigs.length != self.sigs.length)
+      return false if (other.rrs.length != self.rrs.length)
+      return false if (other.ttl != self.ttl)
+      otherrrs = other.rrs
+      self.rrs.each {|rr|
+        return false if (!otherrrs.include?rr)
+      }
+      othersigs= other.sigs
+      self.sigs.each {|sig|
+        return false if (!othersigs.include?sig)
+      }
+      return true
+    end
     #Delete the RR from this RRSet
     def delete(rr)
       @rrs.delete(rr)
@@ -155,7 +140,10 @@ module Dnsruby
     end
     #Return the type of this RRSet
     def type
+      if (@rrs[0])
       return @rrs[0].type
+      end
+      return nil
     end
     #Return the klass of this RRSet
     def klass
@@ -275,6 +263,7 @@ module Dnsruby
           return
         else
           @rdata = args[0]
+#          print "Loading RR from #{args[0]}, class : #{args[0].class}\n"
           if (args[0].class == String)
             from_string(args[0])
             return
@@ -364,10 +353,6 @@ module Dnsruby
       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###
@@ -446,7 +431,7 @@ module Dnsruby
       MessageDecoder.new(rdata) {|msg|
         record = get_class(rrtype, rrclass).decode_rdata(msg)
       }
-      record.name = name
+      record.name = Name.create(name)
       record.ttl = ttl
       record.type = rrtype
       record.klass = rrclass        
@@ -463,7 +448,7 @@ module Dnsruby
     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.name = Name.create(name)
       record.ttl = ttl
       record.type = rrtype
       record.klass = rrclass   
@@ -587,6 +572,15 @@ module Dnsruby
       end
     end
     
+    def self.get_num(bytes)
+      ret = 0
+      shift = (bytes.length-1) * 8
+      bytes.each_byte {|byte|
+        ret += byte.to_i << shift
+        shift -= 8
+      }
+      return ret
+    end
   end
 end  
 require 'Dnsruby/resource/domain_name'

data/lib/Dnsruby/select_thread.rb

@@ -21,6 +21,7 @@ rescue LoadError
   require 'thread'
 end
 require 'singleton'
+require 'Dnsruby/validator_thread.rb'
 module Dnsruby
   Thread::abort_on_exception = true
   class SelectThread #:nodoc: all
@@ -33,9 +34,6 @@ module Dnsruby
     # calculated).
     # Note that a combination of the socket and the packet ID is
     # sufficient to uniquely identify the query to the select thread.
-    # But how do we identify it to the client thread?
-    # Push [id, response] onto the response queue?
-    # Or [id, timeout]
     # 
     # But how do we find the response queue for a particular query?
     # Hash of client_id->[query, client_queue, socket]
@@ -56,11 +54,15 @@ module Dnsruby
         @@observers = Hash.new
         @@tick_observers = []
         @@queued_exceptions=[]
+        @@queued_responses=[]
+        @@queued_validation_responses=[]
         #    end
         # Now start the select thread
         @@select_thread = Thread.new {
           do_select
         }
+        #        # Start the validator thread
+        #        @@validator = ValidatorThread.instance
       }
     end
     
@@ -117,9 +119,15 @@ module Dnsruby
     
     def do_select
       unused_loop_count = 0
+      last_tick_time = Time.now - 10
       while true do
-        send_tick_to_observers
+        if (last_tick_time < (Time.now - 0.5))
+          send_tick_to_observers # ONLY NEED TO SEND THIS TWICE A SECOND - NOT EVERY SELECT!!!
+          last_tick_time = Time.now
+        end
         send_queued_exceptions
+        send_queued_responses
+        send_queued_validation_responses
         timeout = tick_time = 0.5 # We provide a timer service to various Dnsruby classes
         sockets=[]
         timeouts=[]
@@ -142,7 +150,7 @@ module Dnsruby
         if (has_observer && (timeout > tick_time))
           timeout = tick_time
         end
-#        next if (timeout < 0)
+        #        next if (timeout < 0)
         begin
           ready, write, errors = IO.select(sockets, nil, nil, timeout)
         rescue SelectWakeup
@@ -173,8 +181,8 @@ module Dnsruby
       # @todo@ Process errors [can we do this in single socket environment?]
     end
     
-#        @@query_hash[query_settings.client_query_id]=query_settings
-#        @@socket_hash[query_settings.socket]=[query_settings.client_query_id] # @todo@ If we use persistent sockets then we need to update this array
+    #        @@query_hash[query_settings.client_query_id]=query_settings
+    #        @@socket_hash[query_settings.socket]=[query_settings.client_query_id] # @todo@ If we use persistent sockets then we need to update this array
     def process_ready(ready)
       ready.each do |socket|
         query_settings = nil
@@ -188,9 +196,13 @@ module Dnsruby
         msg, bytes = get_incoming_data(socket, udp_packet_size)
         if (msg!=nil)
           # Check that the IP we received from was the IP we sent to!
-          if ((msg.answerip != query_settings.dest_server) && 
-                (msg.answerfrom != query_settings.dest_server))
-            Dnsruby.log.warn("Unsolicited response received from #{answerip}")
+          answerip = msg.answerip.downcase
+          answerfrom = msg.answerfrom.downcase
+          dest_server = query_settings.dest_server
+          if (dest_server && (dest_server != '0.0.0.0') &&
+              (answerip != query_settings.dest_server.downcase) &&
+                 (answerfrom != query_settings.dest_server.downcase))
+            Dnsruby.log.warn("Unsolicited response received from #{answerip} instead of #{query_settings.dest_server}")
           else 
             send_response_to_client(msg, bytes, socket)
           end
@@ -201,6 +213,7 @@ module Dnsruby
     
     def send_response_to_client(msg, bytes, socket)
       # Figure out which client_ids we were expecting on this socket, then see if any header ids match up
+      # @TODO@ Can get rid of this, as we only have one query per socket.
       client_ids=[]
       @@mutex.synchronize{
         client_ids = @@socket_hash[socket]
@@ -223,12 +236,16 @@ module Dnsruby
           }
           tcp = (socket.class == TCPSocket)
           # At this point, we should check if the response is OK
-          if (res.check_response(msg, bytes, query, client_queue, id, tcp))
+          if (ret = res.check_response(msg, bytes, query, client_queue, id, tcp))
             remove_id(id)
-            exception = msg.header.get_exception
+            exception = msg.get_exception
+            if (ret.instance_of?TsigError)
+              exception = ret
+            end
             Dnsruby.log.debug{"Pushing response to client queue"}
-            client_queue.push([id, msg, exception])
-            notify_queue_observers(client_queue, id)
+            push_to_client(id, client_queue, msg, exception, query, res)
+            #            client_queue.push([id, msg, exception])
+            #            notify_queue_observers(client_queue, id)
           else
             # Sending query again - don't return response
           end
@@ -237,6 +254,7 @@ module Dnsruby
       end
       # If not, then we have an error
       Dnsruby.log.error{"Stray packet - " + msg.inspect + "\n from " + socket.inspect}
+      print("Stray packet - " + msg.question()[0].qname.to_s + " from " + msg.answerip.to_s + ", #{client_ids.length} client_ids\n")
     end
     
     def remove_id(id)
@@ -268,7 +286,12 @@ module Dnsruby
     def tcp_read(socket, len)
       buf=""
       while (buf.length < len) do
-        buf += socket.recv(len-buf.length)
+        input = socket.recv(len-buf.length) 
+        if (input=="")
+          TheLog.info("Bad response from server - no bytes read - ignoring")
+          return false
+        end
+        buf += input
       end
       return buf
     end
@@ -291,8 +314,16 @@ module Dnsruby
             answerport = @@query_hash[client_id].dest_port
           }
           buf = tcp_read(socket, 2)
+          if (!buf)
+            handle_recvfrom_failure(socket, "")          
+            return
+          end
           answersize = buf.unpack('n')[0]
           buf = tcp_read(socket,answersize)
+          if (!buf)
+            handle_recvfrom_failure(socket, "")          
+            return
+          end
         else
           if (ret = socket.recvfrom(packet_size))
             buf = ret[0]
@@ -317,7 +348,9 @@ module Dnsruby
       begin
         ans = Message.decode(buf)
       rescue Exception => e
+#        print "DECODE ERROR\n"
         Dnsruby.log.error{"Decode error! #{e.class}, #{e}\nfor msg (length=#{buf.length}) : #{buf}"}
+        # @TODO@ Should know this from the socket!
         client_id=get_client_id_from_answerfrom(socket, answerip, answerport)
         if (client_id != nil) 
           send_exception_to_client(e, socket, client_id)
@@ -356,6 +389,7 @@ module Dnsruby
     end
     
     def get_client_id_from_answerfrom(socket, answerip, answerport)
+      # @TODO@ Can get rid of this, as there is only one query per socket
       client_id=nil
       # Figure out client id from answerfrom
       @@mutex.synchronize{
@@ -381,15 +415,56 @@ module Dnsruby
         client_queue = @@query_hash[client_id].client_queue
       }
       remove_id(client_id)
-      push_exception_to_client(client_id, client_queue, err, msg)
+      #      push_to_client(client_id, client_queue, msg, err)
+      client_queue.push([client_id, Resolver::EventType::ERROR, msg, err])
+      notify_queue_observers(client_queue, client_id)
     end
     
     def push_exception_to_select(client_id, client_queue, err, msg)
       @@mutex.synchronize{
         @@queued_exceptions.push([client_id, client_queue, err, msg])
       }
+      # Make sure select loop is running!
+      if (@@select_thread && @@select_thread.alive?)
+      else
+        @@select_thread = Thread.new {
+          do_select
+        }      
+      end
+    end
+    
+    def push_response_to_select(client_id, client_queue, msg, query, res)
+      # This needs to queue the response TO THE SELECT THREAD, which then needs
+      # to send it out from its normal loop.
+      Dnsruby.log.debug{"Pushing response to client queue direct from resolver or validator"}
+      @@mutex.synchronize{
+        @@queued_responses.push([client_id, client_queue, msg, nil, query, res])
+      }
+      # Make sure select loop is running!
+      if (@@select_thread && @@select_thread.alive?)
+      else
+        @@select_thread = Thread.new {
+          do_select
+        }
+      end
     end
     
+    def push_validation_response_to_select(client_id, client_queue, msg, err, query, res)
+      # This needs to queue the response TO THE SELECT THREAD, which then needs
+      # to send it out from its normal loop.
+      Dnsruby.log.debug{"Pushing response to client queue direct from resolver or validator"}
+      @@mutex.synchronize{
+        @@queued_validation_responses.push([client_id, client_queue, msg, err, query, res])
+      }
+      # Make sure select loop is running!
+      if (@@select_thread && @@select_thread.alive?)
+      else
+        @@select_thread = Thread.new {
+          do_select
+        }
+      end
+    end
+
     def send_queued_exceptions
       exceptions = []
       @@mutex.synchronize{
@@ -399,16 +474,76 @@ module Dnsruby
       
       exceptions.each do |item|
         client_id, client_queue, err, msg = item
-        push_exception_to_client(client_id, client_queue, err, msg)
+        #        push_to_client(client_id, client_queue, msg, err)
+        client_queue.push([client_id, Resolver::EventType::ERROR, msg, err])
+        notify_queue_observers(client_queue, client_id)
       end
     end
     
-    def push_exception_to_client(client_id, client_queue, err, msg)
-      # Now push the exception on the queue
-      client_queue.push([client_id, msg, err])
+    def send_queued_responses
+      responses = []
+      @@mutex.synchronize{
+        responses = @@queued_responses
+        @@queued_responses = []
+      }
+
+      responses.each do |item|
+        client_id, client_queue, msg, err, query, res = item
+        #        push_to_client(client_id, client_queue, msg, err)
+        client_queue.push([client_id, Resolver::EventType::RECEIVED, msg, err])
+        notify_queue_observers(client_queue, client_id)
+        # @TODO@ Do we need to validate this? The response has come from the cache -
+        # validate it only if it has not been validated already
+        # So, if we need to validate it, send it to the validation thread
+        # Otherwise, send VALIDATED to the requester.
+        # Should we really just be checking (level != SECURE) ?
+        if (((msg.security_level == Message::SecurityLevel::UNCHECKED) ||
+              (msg.security_level == Message::SecurityLevel::INDETERMINATE)) &&
+            (ValidatorThread.requires_validation?(query, msg, err, res)))
+          validator = ValidatorThread.new(client_id, client_queue, msg, err, query ,self, res)
+          validator.run
+        else
+          PacketSender.cache(query, msg) # The validator won't cache it, so we'd better do it now
+          client_queue.push([client_id, Resolver::EventType::VALIDATED, msg, err])
+          notify_queue_observers(client_queue, client_id)
+        end
+      end
+    end
+
+    def send_queued_validation_responses
+      responses = []
+      @@mutex.synchronize{
+        responses = @@queued_validation_responses
+        @@queued_validation_responses = []
+      }
+
+      responses.each do |item|
+        client_id, client_queue, msg, err, query, res = item
+        #        push_to_client(client_id, client_queue, msg, err)
+        client_queue.push([client_id, Resolver::EventType::VALIDATED, msg, err])
+        notify_queue_observers(client_queue, client_id)
+      end
+    end
+
+    def push_to_client(client_id, client_queue, msg, err, query, res)
+      # @TODO@ Really need to let the client know that we have received a valid response!
+      # Can do that by calling notify_observers here, but with an identifier which
+      # defines the response to be a "Response received - validating. Please stop sending"
+      # type of response.
+      client_queue.push([client_id, Resolver::EventType::RECEIVED, msg, err])
       notify_queue_observers(client_queue, client_id)
+
+      if (!err || (err.instance_of?(NXDomain)))
+      #
+      # This method now needs to push the response to the validator,
+      # which will then take responsibility for delivering it to the client.
+      # The validator will need access to the queue observers -
+      validator = ValidatorThread.new(client_id, client_queue, msg, err, query ,self, res)
+      validator.run
+      #      @@validator.add_to_queue([client_id, client_queue, msg, err, query, self, res])
+      end
     end
-    
+
     def add_observer(client_queue, observer)
       @@mutex.synchronize {
         @@observers[client_queue]=observer
@@ -422,9 +557,11 @@ module Dnsruby
     def remove_observer(client_queue, observer)
       @@mutex.synchronize {
         if (@@observers[client_queue]==observer)
-#          @@observers.delete(observer)
+          #          @@observers.delete(observer)
           @@observers.delete(client_queue)
         else
+          if (@@observers[client_queue] == nil)
+          end
           Dnsruby.log.error{"remove_observer called with wrong observer for queue"}
           raise ArgumentError.new("remove_observer called with wrong observer for queue")
         end
@@ -433,7 +570,7 @@ module Dnsruby
         end
       }
     end
-    
+
     def notify_queue_observers(client_queue, client_query_id)
       # If any observers are known for this query queue then notify them
       observer=nil