dnsruby 1.24 → 1.26

data/lib/Dnsruby/Resolver.rb

@@ -14,6 +14,7 @@
 #limitations under the License.
 #++
 require "Dnsruby/SingleResolver"
+require "Dnsruby/Recursor"
 module Dnsruby
   #== Description
   #Dnsruby::Resolver is a DNS stub resolver.
@@ -83,8 +84,6 @@ module Dnsruby
     
     # The source address to send queries from
     attr_reader :src_address
-    # The source port to send queries from
-    attr_reader :src_port
     
     # Should TCP queries be sent on a persistent socket?
     attr_reader :persistent_tcp
@@ -137,10 +136,13 @@ module Dnsruby
     #   response = res.query("example.com", Types.MX)
     #   response = res.query("208.77.188.166") # IPv4 address so PTR query will be made
     #   response = res.query("208.77.188.166", Types.PTR)
-    def query(name, type=Types.A, klass=Classes.IN)
+    def query(name, type=Types.A, klass=Classes.IN, set_cd=@dnssec)
       msg = Message.new
       msg.header.rd = 1
       msg.add_question(name, type, klass)
+      if (@dnssec)
+        msg.header.cd = set_cd # We do our own validation by default
+      end
       return send_message(msg)
     end
     
@@ -211,7 +213,7 @@ module Dnsruby
     #=== Example code :
     #
     #   require 'Dnsruby'
-    #   res = Dnsruby::Resolver.new
+    #   res = Dnsruby::Resolver.newsend
     #   query_id = 10 # can be any object you like
     #   query_queue = Queue.new
     #   res.send_async(Message.new("example.com", Types.MX),  query_queue, query_id)
@@ -287,7 +289,15 @@ module Dnsruby
     def close
       [@resolver_em, @resolver_ruby].each do |r| r.close if r end
     end
-
+    
+#    def make_query(*args)
+#      return @single_resolvers[0].make_query(*args)
+#    end
+#
+#    def make_query_packet(args)
+#      return @single_resolvers[0].make_query_packet(args)
+#    end
+#
     # Create a new Resolver object. If no parameters are passed in, then the default 
     # system configuration will be used. Otherwise, a Hash may be passed in with the 
     # following optional elements : 
@@ -384,13 +394,13 @@ module Dnsruby
       @tsig = nil
       @ignore_truncation = false
       @config = Config.new()
-      @src_addr        = '0.0.0.0'
-      @src_port        = 0
+      @src_address        = '0.0.0.0'
+      @src_port        = [0]
       @recurse = true
       @persistent_udp = false
       @persistent_tcp = false
       @single_resolvers=[]
-      @dnssec = true
+      @dnssec = SingleResolver::DEFAULT_DNSSEC
     end
     
     def update #:nodoc: all
@@ -427,11 +437,58 @@ module Dnsruby
       update
     end
     
-    def port=(p)
-      @port = p
-      update
+    # The source port to send queries from
+    # Returns either a single Fixnum or an Array
+    # e.g. "0", or "[60001, 60002, 60007]"
+    # 
+    # Defaults to 0 - random port
+    def src_port
+      if (@src_port.length == 1) 
+        return @src_port[0]
+      end
+      return @src_port
+    end
+
+    # Can be a single Fixnum or a Range or an Array
+    # If an invalid port is selected (one reserved by
+    # IANA), then an ArgumentError will be raised.
+    # 
+    #        res.src_port=0
+    #        res.src_port=[60001,60005,60010]
+    #        res.src_port=60015..60115
+    #
+    def src_port=(p)
+      if (SingleResolver.check_port(p))
+        @src_port = SingleResolver.get_ports_from(p)
+        update
+      end
     end
     
+    # Can be a single Fixnum or a Range or an Array
+    # If an invalid port is selected (one reserved by
+    # IANA), then an ArgumentError will be raised.
+    # "0" means "any valid port" - this is only a viable
+    # option if it is the only port in the list.
+    # An ArgumentError will be raised if "0" is added to
+    # an existing set of source ports.
+    # 
+    #        res.add_src_port(60000)
+    #        res.add_src_port([60001,60005,60010])
+    #        res.add_src_port(60015..60115)
+    #
+    def add_src_port(p)
+      if (SingleResolver.check_port(p, @src_port))
+        a = SingleResolver.get_ports_from(p)
+        a.each do |x|
+          if ((@src_port.length > 0) && (x == 0))
+            raise ArgumentError.new("src_port of 0 only allowed as only src_port value (currently #{@src_port.length} values")
+          end
+          @src_port.push(x)
+        end
+      end
+      update
+    end
+
     def use_tcp=(on)
       @use_tcp = on
       update
@@ -458,8 +515,8 @@ module Dnsruby
       update
     end
     
-    def src_port=(a)
-      @src_port = a
+    def port=(a)
+      @port = a
       update
     end
     

data/lib/Dnsruby/SingleResolver.rb

@@ -14,6 +14,7 @@
 #limitations under the License.
 #++
 require 'Dnsruby/select_thread'
+require 'Dnsruby/iana_ports'
 module Dnsruby
   #== Dnsruby::SingleResolver
   #
@@ -63,10 +64,6 @@ module Dnsruby
     # 
     # Defaults to localhost
     attr_accessor :src_address
-    # The source port to send queries from
-    # 
-    # Defaults to 0 - random port
-    attr_accessor :src_port
     
     # Should the TCP socket persist between queries?
     # 
@@ -93,6 +90,7 @@ module Dnsruby
     
     # Use DNSSEC for this SingleResolver
     attr_reader :dnssec
+    DEFAULT_DNSSEC = false # @TODO@
     
     #Sets the TSIG to sign outgoing messages with.
     #Pass in either a Dnsruby::RR::TSIG, or a key_name and key (or just a key)
@@ -129,7 +127,7 @@ module Dnsruby
             tsig = RR.new_from_hash({:type => Types.TSIG, :klass => Classes.ANY, :name => args[0][0], :key => args[0][1]})
           end
         else
-          Dnsruby.log.info{"TSIG signing switched off"}
+#          Dnsruby.log.debug{"TSIG signing switched off"}
           return nil
         end
       elsif (args.length ==2)
@@ -156,7 +154,7 @@ module Dnsruby
     # * :port
     # * :use_tcp
     # * :ignore_truncation
-    # * :src_addr
+    # * :src_address
     # * :src_port
     # * :udp_size
     # * :persistent_tcp
@@ -172,12 +170,12 @@ module Dnsruby
       @use_tcp = false
       @tsig = nil
       @ignore_truncation = false
-      @src_addr        = '0.0.0.0'
-      @src_port        = 0
+      @src_address        = '0.0.0.0'
+      @src_port        = [0]
       @recurse = true
       @persistent_udp = false
       @persistent_tcp = false
-      @dnssec = true
+      @dnssec = DEFAULT_DNSSEC
       
       seen_dnssec = false
       
@@ -192,16 +190,16 @@ module Dnsruby
           begin
             send(attr.to_s+"=", arg[attr])
             if (attr.to_s == "dnssec")
-                seen_dnssec = true
+              seen_dnssec = true
             end
           rescue Exception
             Dnsruby.log.error{"Argument #{attr} not valid\n"}
           end
-        #        end
+          #        end
         end
       end
       if (!seen_dnssec) 
-        @dnssec = true
+        @dnssec = DEFAULT_DNSSEC
       end
       #Check server is IP
       @server=Config.resolve_server(@server)
@@ -215,10 +213,8 @@ module Dnsruby
     
     # Synchronously send a query for the given name. The type will default to A, 
     # and the class to IN.
-    def query(name, type=Types.A, klass=Classes.IN)
-      msg = Message.new
-      msg.header.rd = 1
-      msg.add_question(name, type, klass)
+    def query(name, type=Types.A, klass=Classes.IN, set_cd=@dnssec)
+      msg = make_query(name, type, klass, set_cd)
       return send_message(msg)
     end
     
@@ -292,6 +288,9 @@ module Dnsruby
       use_tcp = @use_tcp
       if (msg.kind_of?String)
         msg = Message.new(msg)
+        if (@dnssec)
+          msg.header.cd = @dnssec # we'll do our own validation by default
+        end
       end
       query_packet = make_query_packet(msg, use_tcp)
       if (udp_packet_size < query_packet.length)
@@ -330,7 +329,7 @@ module Dnsruby
       if (!client_deferrable)
         client_deferrable = EventMachine::DefaultDeferrable.new
       end
-      packet_deferrable = EventMachineInterface.send(:msg=>msg_bytes, :timeout=>packet_timeout, :server=>@server, :port=>@port, :src_addr=>@src_addr, :src_port=>get_next_src_port, :use_tcp=>use_tcp)
+      packet_deferrable = EventMachineInterface.send(:msg=>msg_bytes, :timeout=>packet_timeout, :server=>@server, :port=>@port, :src_address=>@src_address, :src_port=>get_next_src_port, :use_tcp=>use_tcp)
       packet_deferrable.callback { |response, response_bytes|
         ret = true
         if (response.header.tc && !use_tcp && !@ignore_truncation)
@@ -369,10 +368,10 @@ module Dnsruby
         begin
           src_port = get_next_src_port
           if (use_tcp) 
-            socket = TCPSocket.new(@server, @port, @src_addr, src_port)
+            socket = TCPSocket.new(@server, @port, @src_address, src_port)
           else
             socket = UDPSocket.new()
-            socket.bind(@src_addr, src_port)
+            socket.bind(@src_address, src_port)
             socket.connect(@server, @port)
           end
           runnextportloop = false
@@ -382,8 +381,8 @@ module Dnsruby
           end          
           # Try again if the error was EADDRINUSE and a random source port is used
           if ((e.class != Errno::EADDRINUSE) || 
-                ((e.class == Errno::EADDRINUSE) && (src_port == get_next_src_port)))
-            err=IOError.new("dnsruby can't connect to #{@server}:#{@port} from #{@src_addr}:#{src_port}, use_tcp=#{use_tcp}, exception = #{e.class}, #{e}")
+                ((e.class == Errno::EADDRINUSE) && (src_port == @src_port)))
+            err=IOError.new("dnsruby can't connect to #{@server}:#{@port} from #{@src_address}:#{src_port}, use_tcp=#{use_tcp}, exception = #{e.class}, #{e}")
             Dnsruby.log.error{"#{err}"}
             st.push_exception_to_select(client_query_id, client_queue, err, nil) # @TODO Do we still need this? Can we not just send it from here?
             return
@@ -391,12 +390,12 @@ module Dnsruby
         end
       end
       if (socket==nil)
-        err=IOError.new("dnsruby can't connect to #{@server}:#{@port} from #{@src_addr}:#{src_port}, use_tcp=#{use_tcp}")
+        err=IOError.new("dnsruby can't connect to #{@server}:#{@port} from #{@src_address}:#{src_port}, use_tcp=#{use_tcp}")
         Dnsruby.log.error{"#{err}"}
         st.push_exception_to_select(client_query_id, client_queue, err, nil) # @TODO Do we still need this? Can we not just send it from here?
         return
       end
-      Dnsruby.log.debug{"Sending packet to #{@server}:#{@port} from #{@src_addr}:#{src_port}, use_tcp=#{use_tcp}"}
+      Dnsruby.log.debug{"Sending packet to #{@server}:#{@port} from #{@src_address}:#{src_port}, use_tcp=#{use_tcp}"}
       begin
         if (use_tcp)
           lenmsg = [query_bytes.length].pack('n')
@@ -405,7 +404,7 @@ module Dnsruby
         socket.send(query_bytes, 0)
       rescue Exception => e
         socket.close
-        err=IOError.new("Send failed to #{@server}:#{@port} from #{@src_addr}:#{src_port}, use_tcp=#{use_tcp}, exception : #{e}")
+        err=IOError.new("Send failed to #{@server}:#{@port} from #{@src_address}:#{src_port}, use_tcp=#{use_tcp}, exception : #{e}")
         Dnsruby.log.error{"#{err}"}
         st.push_exception_to_select(client_query_id, client_queue, err, nil)
         return
@@ -418,23 +417,137 @@ module Dnsruby
       st.add_to_select(query_settings)
     end
     
-    def get_next_src_port
-        #Different OSes have different interpretations of "random port" here.
-        #Apparently, Linux will just give you the same port as last time, unless it is still
-        #open, in which case you get n+1.
-        #We need to determine an actual (random) number here, then ask the OS for it, and
-        #continue until we get one.
-      if (@src_port > 0 && @src_port < 65535)
-        return @src_port
+    # The source port to send queries from
+    # Returns either a single Fixnum or an Array
+    # e.g. "0", or "[60001, 60002, 60007]"
+    # 
+    # Defaults to 0 - random port
+    def src_port
+      if (@src_port.length == 1) 
+        return @src_port[0]
+      end
+      return @src_port
+    end
+
+    # Can be a single Fixnum or a Range or an Array
+    # If an invalid port is selected (one reserved by
+    # IANA), then an ArgumentError will be raised.
+    # 
+    #        res.src_port=0
+    #        res.src_port=[60001,60005,60010]
+    #        res.src_port=60015..60115
+    #
+    def src_port=(p)
+      @src_port=[]
+      add_src_port(p)
+    end
+    
+    def SingleResolver.get_ports_from(p) 
+      a = []
+      if (p.class == Fixnum)
+        a = [p]
+      else
+        p.each do |x|
+          a.push(x)
+        end
+      end
+      return a      
+    end
+    
+    # Can be a single Fixnum or a Range or an Array
+    # If an invalid port is selected (one reserved by
+    # IANA), then an ArgumentError will be raised.
+    # "0" means "any valid port" - this is only a viable
+    # option if it is the only port in the list.
+    # An ArgumentError will be raised if "0" is added to
+    # an existing set of source ports.
+    # 
+    #        res.add_src_port(60000)
+    #        res.add_src_port([60001,60005,60010])
+    #        res.add_src_port(60015..60115)
+    #
+    def add_src_port(p)
+      if (SingleResolver.check_port(p, @src_port))
+        a = SingleResolver.get_ports_from(p)
+        a.each do |x|
+          if ((@src_port.length > 0) && (x == 0))
+            raise ArgumentError.new("src_port of 0 only allowed as only src_port value (currently #{@src_port.length} values")
+          end
+          @src_port.push(x)
+        end
+      end
+    end
+    
+    def SingleResolver.check_port(p, src_port=[])
+      if (p.class != Fixnum)
+        tmp_src_ports = Array.new(src_port)
+        p.each do |x|
+          if (!SingleResolver.check_port(x, tmp_src_ports))
+            return false
+          end
+          tmp_src_ports.push(x)
+        end
+        return true
+      end
+      if (SingleResolver.port_in_range(p))
+        if ((p == 0) && (src_port.length > 0))
+          return false
+        end
+        return true
       else
-        return (rand(65535-1024) + 1024)
+        Dnsruby.log.error("Illegal port (#{p})")
+        raise ArgumentError.new("Illegal port #{p}")
+      end
+    end
+    
+    def SingleResolver.port_in_range(p) 
+      if ((p == 0) || ((IANA_PORTS.index(p)) == nil && (p > 1024) && (p < 65535))) 
+        return true
+      end
+      return false
+    end
+    
+    def get_next_src_port
+      #Different OSes have different interpretations of "random port" here.
+      #Apparently, Linux will just give you the same port as last time, unless it is still
+      #open, in which case you get n+1.
+      #We need to determine an actual (random) number here, then ask the OS for it, and
+      #continue until we get one.
+      if (@src_port[0] == 0)
+        candidate = -1
+        while (!(SingleResolver.port_in_range(candidate)))
+          candidate = (rand(65535-1024) + 1024)
+        end
+        return candidate        
       end
+      pos = rand(@src_port.length)
+      return @src_port[pos]
     end
     
     def check_response(response, response_bytes, query, client_queue, client_query_id, tcp)
       if (!check_tsig(query, response, response_bytes))
         return false
       end
+      if (@dnssec)
+        begin 
+          Dnssec.validate_with_query(query,response)
+        rescue (VerifyError)
+          return false # Send this info back to the client somehow?
+        end
+      end
+      # Should check that question section is same as question that was sent! RFC 5452
+      # If it's not an update...
+      if (query.class == Update)
+        # @TODO@!!
+      else
+        if ((response.question[0].qname.labels != query.question[0].qname.labels) || 
+              (response.question[0].qtype != query.question[0].qtype) ||
+              (response.question[0].qclass != query.question[0].qclass) ||
+              (response.question.length != query.question.length) ||
+              (response.header.id != query.header.id))
+          return false
+        end
+      end
       if (response.header.tc && !tcp && !@ignore_truncation)
         # Try to resend over tcp
         Dnsruby.log.debug{"Truncated - resending over TCP"}
@@ -465,8 +578,18 @@ module Dnsruby
       return true
     end
     
+    def make_query(name, type = Types.A, klass = Classes.IN, set_cd=@set_cd)
+      msg = Message.new
+      msg.header.rd = 1
+      msg.add_question(name, type, klass)
+      if (@set_cd)
+        msg.header.cd = set_cd # We do our own validation by default
+      end
+      return msg
+    end
+    
     # Prepare the packet for sending
-    def make_query_packet(packet, use_tcp) #:nodoc: all
+    def make_query_packet(packet, use_tcp = @use_tcp) #:nodoc: all
       if (packet.header.opcode == OpCode.QUERY || @recurse)
         packet.header.rd=@recurse
       end
@@ -481,8 +604,6 @@ module Dnsruby
         
         packet.header.ad = false # RFC 4035 section 4.6
         
-        packet.header.cd = false # We trust the upstream resolver and the link to it
-              
       elsif ((udp_packet_size > Resolver::DefaultUDPSize) && !use_tcp)
         #      if ((udp_packet_size > Resolver::DefaultUDPSize) && !use_tcp)
         Dnsruby.log.debug{";; Adding EDNS extension with UDP packetsize  #{udp_packet_size}.\n"}