dnsruby 1.57.0 → 1.58.0

data/lib/dnsruby/message/message.rb

@@ -290,14 +290,27 @@ module Dnsruby
       @header.nscount = @authority.length
     end
 
-
-    def add_answer(rr) #:nodoc: all
-      unless @answer.include?(rr)
+    def _add_answer(rr, force = false)
+      if force || (! @answer.include?(rr))
         @answer << rr
         update_counts
       end
+    end; private :_add_answer
+
+    # Adds an RR to the answer section unless it already occurs.
+    def add_answer(rr) #:nodoc: all
+      _add_answer(rr)
     end
 
+    # When adding an RR to a Dnsruby::Message, add_answer checks to see if it already occurs,
+    # and, if so, does not add it again. This method adds the record whether or not
+    # it already occurs.  This is needed in order to add
+    # a SOA record twice for an AXFR response.
+    def add_answer!(rr)
+      _add_answer(rr, true)
+    end
+
+
     def each_answer
       @answer.each {|rec|
         yield rec

data/lib/dnsruby/message/section.rb

@@ -65,11 +65,11 @@ class Section < Array
   end
 
   def ==(other)
-    return false unless (other.instance_of?(Message::Section))
+    return false unless self.class == other.class
     return false if other.rrsets(nil, true).length != self.rrsets(nil, true).length
 
-    otherrrsets = other.rrsets(nil, true)
-    self.rrsets(nil, true).each {|rrset|
+    otherrrsets = other.rrsets(nil)
+    self.rrsets(nil).each {|rrset|
       return false unless otherrrsets.include?(rrset)
     }
 

data/lib/dnsruby/name.rb

@@ -329,7 +329,7 @@ module Dnsruby
           if (presentation.index(/\G(\d\d\d)/o, pos))
             wire=wire+[$1.to_i].pack("C")
             i=i+3
-          elsif(presentation.index(/\Gx([0..9a..fA..F][0..9a..fA..F])/o, pos))
+          elsif(presentation.index(/\Gx(\h\h)/o, pos))
             wire=wire+[$1].pack("H*")
             i=i+3
           elsif(presentation.index(/\G\./o, pos))
@@ -418,4 +418,4 @@ module Dnsruby
 
     end
   end
-end
+end

data/lib/dnsruby/packet_sender.rb

@@ -16,6 +16,7 @@
 require 'dnsruby/select_thread'
 require 'ipaddr'
 # require 'dnsruby/iana_ports'
+include Socket::Constants
 module Dnsruby
   class PacketSender # :nodoc: all
     @@authoritative_cache = Cache.new
@@ -70,6 +71,14 @@ module Dnsruby
     #  Defaults to false
     attr_accessor :use_tcp
 
+    # Reuse tcp connection
+    #
+    # Defaults to false
+    attr_accessor :tcp_pipelining
+
+    # Limit the number of queries per pipeline
+    attr_accessor :tcp_pipelining_max_queries
+
     #  Use UDP only - don't use TCP
     #  For test/debug purposes only
     #  Defaults to false
@@ -158,6 +167,8 @@ module Dnsruby
     #  * :server
     #  * :port
     #  * :use_tcp
+    #  * :tcp_pipelining
+    #  * :tcp_pipelining_max_queries
     #  * :no_tcp
     #  * :ignore_truncation
     #  * :src_address
@@ -182,6 +193,9 @@ module Dnsruby
       @src_address6 = '::'
       @src_port = [0]
       @recurse = true
+      @tcp_pipelining = false
+      @tcp_pipelining_max_queries = :infinite
+      @use_counts = {}
 
       if (arg==nil)
         #  Get default config
@@ -348,6 +362,57 @@ module Dnsruby
       #       end
     end
 
+    #  This method returns the current tcp socket for pipelining
+    #  If this is the first time the method is called then the socket is bound to
+    #  @src_address:@src_port and connected to the remote dns server @server:@port.
+    #  If the connection has been closed because of an EOF on recv_nonblock (closed by server)
+    #  the function will recreate of the socket (since @pipeline_socket.connect will result in a IOError
+    #  exception)
+    #  In general, every subsequent call the function will either return the current tcp
+    #  pipeline socket or a new connected socket if the current one was closed by the server
+    def tcp_pipeline_socket(src_port)
+      Dnsruby.log.debug("Using tcp_pipeline_socket")
+      sockaddr = Socket.sockaddr_in(@port, @server)
+
+      reuse_pipeline_socket = -> do
+        begin
+          max = @tcp_pipelining_max_queries
+          use_count = @use_counts[@pipeline_socket]
+          if use_count && max != :infinite && use_count >= max
+             #we can't reuse the socket since max is reached
+            @use_counts.delete(@pipeline_socket)
+            @pipeline_socket = nil
+            Dnsruby.log.debug("Max queries per connection attained - creating new socket")
+          else
+            @pipeline_socket.connect(sockaddr)
+          end
+        rescue Errno::EISCONN
+          #already connected, do nothing and reuse!
+        rescue IOError #close by remote host, reconnect
+          @pipeline_socket = nil
+          Dnsruby.log.debug("Connection closed - recreating socket")
+        end
+      end
+
+      create_pipeline_socket = -> do
+        @tcp_pipeline_local_port = src_port
+        src_address = @ipv6 ? @src_address6 : @src_address
+
+        @pipeline_socket = Socket.new(AF_INET, SOCK_STREAM, 0)
+        @pipeline_socket.bind(Addrinfo.tcp(src_address, src_port))
+        @pipeline_socket.connect(sockaddr)
+        @use_counts[@pipeline_socket] = 0
+      end
+
+      # Don't combine the following 2 statements; the reuse lambda can set the
+      # socket to nil and if so we'd want to call the create lambda to recreate it.
+      reuse_pipeline_socket.() if @pipeline_socket
+      create_pipeline_socket.() unless @pipeline_socket
+
+      @use_counts[@pipeline_socket] += 1
+
+      @pipeline_socket
+    end
 
     #  This method sends the packet using the built-in pure Ruby event loop, with no dependencies.
     def send_dnsruby(query_bytes, query, client_query_id, client_queue, use_tcp) #:nodoc: all
@@ -367,7 +432,12 @@ module Dnsruby
           src_port = get_next_src_port
           if (use_tcp)
             begin
-              socket = TCPSocket.new(@server, @port, src_address, src_port)
+              if (@tcp_pipelining)
+                socket = tcp_pipeline_socket(src_port)
+                src_port = @tcp_pipeline_local_port
+              else
+                socket = TCPSocket.new(@server, @port, src_address, src_port)
+              end
             rescue Errno::EBADF, Errno::ENETUNREACH => e
               #  Can't create a connection
               err=IOError.new("TCP connection error to #{@server}:#{@port} from #{src_address}:#{src_port}, use_tcp=#{use_tcp}, exception = #{e.class}, #{e}")
@@ -416,6 +486,8 @@ module Dnsruby
       #             print "#{Time.now} : Sending packet to #{@server} : #{query.question()[0].qname}, #{query.question()[0].qtype}\n"
       #  Listen for the response before we send the packet (to avoid any race conditions)
       query_settings = SelectThread::QuerySettings.new(query_bytes, query, @ignore_truncation, client_queue, client_query_id, socket, @server, @port, endtime, udp_packet_size, self)
+      query_settings.is_persistent_socket = @tcp_pipelining if use_tcp
+      query_settings.tcp_pipelining_max_queries = @tcp_pipelining_max_queries if @tcp_pipelining
       begin
         if (use_tcp)
           lenmsg = [query_bytes.length].pack('n')

data/lib/dnsruby/resolv.rb

@@ -3,38 +3,60 @@
 # The DNS class may be used to perform more queries. If greater control over the sending
 # of packets is required, then the Resolver or SingleResolver classes may be used.
 module Dnsruby
+
+
+# NOTE!  Beware, there is a Ruby library class named Resolv, and you may need to
+# explicitly specify Dnsruby::Resolv to use the Dnsruby Resolv class,
+# even if you have include'd Dnsruby.
+
 class Resolv
 
+  # Address RegExp to use for matching IP addresses
+  ADDRESS_REGEX = /(?:#{IPv4::Regex})|(?:#{IPv6::Regex})/
+
+
+  # Some class methods require the use of an instance to compute their result.
+  # For this purpose we create a single instance that can be reused.
+  def self.instance
+    @instance ||= self.new
+  end
+
+
+  # Class methods that delegate to instance methods:
+
   # Looks up the first IP address for +name+
   def self.getaddress(name)
-    DefaultResolver.getaddress(name)
+    instance.getaddress(name)
   end
 
   # Looks up all IP addresses for +name+
   def self.getaddresses(name)
-    DefaultResolver.getaddresses(name)
+    instance.getaddresses(name)
   end
 
   # Iterates over all IP addresses for +name+
   def self.each_address(name, &block)
-    DefaultResolver.each_address(name, &block)
+    instance.each_address(name, &block)
   end
 
   # Looks up the first hostname of +address+
   def self.getname(address)
-    DefaultResolver.getname(address)
+    instance.getname(address)
   end
 
   # Looks up all hostnames of +address+
   def self.getnames(address)
-    DefaultResolver.getnames(address)
+    instance.getnames(address)
   end
 
   # Iterates over all hostnames of +address+
   def self.each_name(address, &proc)
-    DefaultResolver.each_name(address, &proc)
+    instance.each_name(address, &proc)
   end
 
+
+  # Instance Methods:
+
   # Creates a new Resolv using +resolvers+
   def initialize(resolvers=[Hosts.new, DNS.new])
     @resolvers = resolvers
@@ -42,72 +64,64 @@ class Resolv
 
   # Looks up the first IP address for +name+
   def getaddress(name)
-    each_address(name) {|address| return address}
-    raise ResolvError.new("no address for #{name}")
+    addresses = getaddresses(name)
+    if addresses.empty?
+      raise ResolvError.new("no address for #{name}")
+    else
+      addresses.first
+    end
   end
 
   # Looks up all IP addresses for +name+
   def getaddresses(name)
-    ret = []
-    each_address(name) {|address| ret << address}
-    return ret
+    return [name] if ADDRESS_REGEX.match(name)
+    @resolvers.each do |resolver|
+      addresses = []
+      resolver.each_address(name) { |address| addresses << address }
+      return addresses unless addresses.empty?
+    end
+    []
   end
 
   # Iterates over all IP addresses for +name+
   def each_address(name)
-    if AddressRegex =~ name
-      yield name
-      return
-    end
-    yielded = false
-    @resolvers.each {|r|
-      r.each_address(name) {|address|
-        yield address.to_s
-        yielded = true
-      }
-      return if yielded
-    }
+    getaddresses(name).each { |address| yield(address)}
   end
 
   # Looks up the first hostname of +address+
   def getname(address)
-    each_name(address) {|name| return name}
-    raise ResolvError.new("no name for #{address}")
+    names = getnames(address)
+    if names.empty?
+      raise ResolvError.new("no name for #{address}")
+    else
+      names.first
+    end
   end
 
   # Looks up all hostnames of +address+
   def getnames(address)
-    ret = []
-    each_name(address) {|name| ret << name}
-    return ret
+    @resolvers.each do |resolver|
+      names = []
+      resolver.each_name(address) { |name| names << name }
+      return names unless names.empty?
+    end
+    []
   end
 
   # Iterates over all hostnames of +address+
   def each_name(address)
-    yielded = false
-    @resolvers.each {|r|
-      r.each_name(address) {|name|
-        yield name.to_s
-        yielded = true
-      }
-      return if yielded
-    }
+    getnames(address).each { |address| yield(address) }
   end
 
 
   require 'dnsruby/cache'
   require 'dnsruby/DNS'
   require 'dnsruby/hosts'
-  require 'dnsruby/message'
+  require 'dnsruby/message/message'
   require 'dnsruby/update'
   require 'dnsruby/zone_transfer'
   require 'dnsruby/dnssec'
   require 'dnsruby/zone_reader'
 
-  # Default Resolver to use for Dnsruby class methods
-  DefaultResolver = self.new
-
-  # Address RegExp to use for matching IP addresses
-  AddressRegex = /(?:#{IPv4::Regex})|(?:#{IPv6::Regex})/
 end
 end

data/lib/dnsruby/resolver.rb

@@ -1,12 +1,12 @@
 # --
 # 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.
@@ -23,18 +23,18 @@ module Dnsruby
   #  Dnsruby::Resolver is a DNS stub resolver.
   #  This class performs queries with retries across multiple nameservers.
   #  The system configured resolvers are used by default.
-  #  
+  #
   #  The retry policy is a combination of the Net::DNS and dnsjava approach, and has the option of :
   #  * A total timeout for the query (defaults to 0, meaning "no total timeout")
   #  * A retransmission system that targets the namervers concurrently once the first query round is
   #   complete, but in which the total time per query round is split between the number of nameservers
   #   targetted for the first round. and total time for query round is doubled for each query round
-  #  
+  #
   #  Note that, if a total timeout is specified, then that will apply regardless of the retry policy
   #  (i.e. it may cut retries short).
-  #  
+  #
   #  Note also that these timeouts are distinct from the SingleResolver's packet_timeout
-  #  
+  #
   #  Timeouts apply to the initial query and response. If DNSSEC validation is to
   #  be performed, then additional queries may be required (these are performed automatically
   #  by Dnsruby). Each additional query will be performed with its own timeouts.
@@ -42,31 +42,31 @@ module Dnsruby
   #  validation may take several times that long.
   #  (Future versions of Dnsruby may expose finer-grained events for client tracking of
   #  responses and validation)
-  #  
+  #
   #  == Methods
-  #  
+  #
   #  === Synchronous
   #  These methods raise an exception or return a response message with rcode==NOERROR
-  #  
+  #
   #  *  Dnsruby::Resolver#send_message(msg)
   #  *  Dnsruby::Resolver#query(name [, type [, klass]])
-  #  
+  #
   #    There are "!" versions of these two methods that return an array [response, error]
   #    instead of raising an error on failure.  They can be called as follows:
-  #  
+  #
   #    response, error = resolver.send_message!(...)
   #    response, error = resolver.query!(...)
-  #  
+  #
   #    If the request succeeds, response will contain the Dnsruby::Message response
   #    and error will be nil.
-  #  
+  #
   #    If the request fails, response will be nil and error will contain the error raised.
-  #  
+  #
   #  === Asynchronous
   #  These methods use a response queue to return the response and the error
-  #  
+  #
   #  *  Dnsruby::Resolver#send_async(msg, response_queue, query_id)
-  #  
+  #
   #  == Event Loop
   #  Dnsruby runs a pure Ruby event loop to handle I/O in a single thread.
   #  Support for EventMachine has been deprecated.
@@ -75,6 +75,7 @@ module Dnsruby
     DefaultPacketTimeout = 5
     DefaultRetryTimes = 1
     DefaultRetryDelay = 5
+    DefaultPipeLiningMaxQueries = 5
     DefaultPort = 53
     DefaultDnssec = true
     AbsoluteMinDnssecUdpSize = 1220
@@ -94,6 +95,13 @@ module Dnsruby
     #  If use_tcp==true, then ONLY TCP will be used as a transport.
     attr_reader :use_tcp
 
+    #  If tcp_pipelining==true, then we reuse the TCP connection
+    attr_reader :tcp_pipelining
+
+    # How many times (number of messages) to reuse the pipelining connection
+    # before closing, :infinite for infinite number of requests per connection
+    attr_reader :tcp_pipelining_max_queries
+
     #  If no_tcp==true, then ONLY UDP will be used as a transport.
     #  This should not generally be used, but is provided as a debugging aid.
     attr_reader :no_tcp
@@ -171,12 +179,12 @@ module Dnsruby
     #  --
     #  @TODO@ add load_balance? i.e. Target nameservers in a random, rather than pre-determined, order?
     #  This is best done when configuring the Resolver, as it will re-order servers based on their response times.
-    #  
+    #
     #  ++
 
     #  Query for a name. If a valid Message is received, then it is returned
     #  to the caller. Otherwise an exception (a Dnsruby::ResolvError or Dnsruby::ResolvTimeout) is raised.
-    #  
+    #
     #    require 'dnsruby'
     #    res = Dnsruby::Resolver.new
     #    response = res.query('example.com') # defaults to Types.A, Classes.IN
@@ -222,11 +230,11 @@ module Dnsruby
 
     #  Send a message, and wait for the response. If a valid Message is received, then it is returned
     #  to the caller. Otherwise an exception (a Dnsruby::ResolvError or Dnsruby::ResolvTimeout) is raised.
-    #  
+    #
     #  send_async is called internally.
-    #  
+    #
     #  example :
-    #  
+    #
     #    require 'dnsruby'
     #    include Dnsruby
     #    res = Dnsruby::Resolver.new
@@ -302,9 +310,9 @@ module Dnsruby
     #  Dnsruby::PacketSender#add_opt_rr(msg)
     #  The return value from this method is the [response, error] tuple. Either of
     #  these values may be nil - it is up to the client to check.
-    #  
+    #
     #  example :
-    #  
+    #
     #    require 'dnsruby'
     #    include Dnsruby
     #    res = Dnsruby::Resolver.new
@@ -328,40 +336,40 @@ module Dnsruby
 
     #  Asynchronously send a Message to the server. The send can be done using just
     #  Dnsruby. Support for EventMachine has been deprecated.
-    #  
+    #
     #  == Dnsruby pure Ruby event loop :
-    #  
+    #
     #  A client_queue is supplied by the client,
     #  along with an optional client_query_id to identify the response. The client_query_id
     #  is generated, if not supplied, and returned to the client.
     #  When the response is known,
     #  a tuple of (query_id, response_message, exception) will be added to the client_queue.
-    #  
+    #
     #  The query is sent synchronously in the caller's thread. The select thread is then used to
     #  listen for and process the response (up to pushing it to the client_queue). The client thread
     #  is then used to retrieve the response and deal with it.
-    #  
+    #
     #  Takes :
-    #  
+    #
     #  * msg - the message to send
     #  * client_queue - a Queue to push the response to, when it arrives
     #  * client_query_id - an optional ID to identify the query to the client
     #  * use_tcp - whether to use only TCP (defaults to SingleResolver.use_tcp)
-    #  
+    #
     #  Returns :
-    #  
+    #
     #  * client_query_id - to identify the query response to the client. This ID is
     #  generated if it is not passed in by the client
-    #  
+    #
     #  === Example invocations :
-    #  
+    #
     #     id = res.send_async(msg, queue)
     #     NOT SUPPORTED : id = res.send_async(msg, queue, use_tcp)
     #     id = res.send_async(msg, queue, id)
     #     id = res.send_async(msg, queue, id, use_tcp)
-    #  
+    #
     #  === Example code :
-    #  
+    #
     #    require 'dnsruby'
     #    res = Dnsruby::Resolver.newsend
     #    query_id = 10 # can be any object you like
@@ -378,7 +386,7 @@ module Dnsruby
     #          # deal with problem
     #      end
     #    end
-    #  
+    #
     def send_async(msg, client_queue, client_query_id = nil)
       unless @configured
         add_config_nameservers
@@ -406,8 +414,8 @@ module Dnsruby
     #  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 :
-    #  
-    #  
+    #
+    #
     #  * :port
     #  * :use_tcp
     #  * :tsig
@@ -424,6 +432,8 @@ module Dnsruby
     #  * :retry_times
     #  * :retry_delay
     #  * :do_caching
+    #  * :tcp_pipelining
+    #  * :tcp_pipelining_max_queries - can be a number or :infinite symbol
     def initialize(*args)
       #  @TODO@ Should we allow :namesver to be an RRSet of NS records? Would then need to randomly order them?
       @resolver_ruby = nil
@@ -478,6 +488,8 @@ module Dnsruby
               dnssec:             @dnssec,
               use_tcp:            @use_tcp,
               no_tcp:             @no_tcp,
+              tcp_pipelining:     @tcp_pipelining,
+              tcp_pipelining_max_queries: @tcp_pipelining_max_queries,
               packet_timeout:     @packet_timeout,
               tsig:               @tsig,
               ignore_truncation:  @ignore_truncation,
@@ -520,6 +532,8 @@ module Dnsruby
       @do_caching= true
       @use_tcp = false
       @no_tcp = false
+      @tcp_pipelining = false
+      @tcp_pipelining_max_queries = DefaultPipeLiningMaxQueries
       @tsig = nil
       @ignore_truncation = false
       @config = Config.new()
@@ -557,7 +571,7 @@ module Dnsruby
     end
 
     def update_internal_res(res)
-      [:port, :use_tcp, :no_tcp, :tsig, :ignore_truncation, :packet_timeout,
+      [:port, :use_tcp, :no_tcp, :tcp_pipelining, :tcp_pipelining_max_queries, :tsig, :ignore_truncation, :packet_timeout,
         :src_address, :src_address6, :src_port, :recurse,
         :udp_size, :dnssec].each do |param|
 
@@ -589,7 +603,7 @@ module Dnsruby
     #  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
       @src_port.length == 1 ? @src_port[0] : @src_port
@@ -598,11 +612,11 @@ module Dnsruby
     #  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 Resolver.check_port(p)
         @src_port = Resolver.get_ports_from(p)
@@ -617,11 +631,11 @@ module Dnsruby
     #  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 Resolver.check_port(p, @src_port)
         a = Resolver.get_ports_from(p)
@@ -671,6 +685,16 @@ module Dnsruby
       a
     end
 
+    def tcp_pipelining=(on)
+      @tcp_pipelining = on
+      update
+    end
+
+    def tcp_pipelining_max_queries=(max)
+      @tcp_pipelining_max_queries = max
+      update
+    end
+
     def use_tcp=(on)
       @use_tcp = on
       update
@@ -693,23 +717,21 @@ module Dnsruby
       update
     end
 
-    def create_tsig_options(args)
-      if args.size > 3
-        log_and_raise("Illegal number of arguments (#{args.size}; must be 1, 2, or 3.")
-      end
-
-      options = { type: Types.TSIG, klass: Classes.ANY }
-      if args.length >= 2
-        options.merge!({ name: args[0], key: args[1] })
-      end
-      if args.length == 3
-        options[:algorithm] == args[2]
-      end
 
+    protected
+    def Resolver.create_tsig_options(name, key, algorithm = nil)
+        options = {
+          type:  Types.TSIG,
+          klass: Classes.ANY,
+          name:  name,
+          key:   key
+      }
+      options[:algorithm] = algorithm if algorithm
       options
-    end; private :create_tsig_options
+    end
 
 
+    public
     def Resolver.get_tsig(args)
 
       tsig = nil
@@ -719,7 +741,7 @@ module Dnsruby
           if args[0].instance_of?(RR::TSIG)
             tsig = args[0]
           elsif args[0].instance_of?(Array)
-            tsig = RR.new_from_hash(create_tsig_options(args))
+            tsig = RR.new_from_hash(create_tsig_options(*args[0]))
           end
         else
           #           Dnsruby.log.debug{'TSIG signing switched off'}
@@ -898,7 +920,7 @@ module Dnsruby
     def generate_timeouts # :nodoc: all
       #  Create the timeouts for the query from the retry_times and retry_delay attributes.
       #  These are created at the same time in case the parameters change during the life of the query.
-      #  
+      #
       #  These should be absolute, rather than relative
       #  The first value should be Time.now[
       @parent.generate_timeouts(Time.now)
@@ -917,7 +939,7 @@ module Dnsruby
     end
 
     #  MUST BE CALLED IN A SYNCHRONIZED BLOCK!
-    #  
+    #
     #  Send the result back to the client, and close the socket for that query by removing
     #  the query from the select thread.
     def send_result_and_stop_querying(client_queue, client_query_id, select_queue, msg, error) # :nodoc: all
@@ -926,14 +948,14 @@ module Dnsruby
     end
 
     #  MUST BE CALLED IN A SYNCHRONIZED BLOCK!
-    #  
+    #
     #  Stops send any more packets for a client-level query
     def stop_querying(client_query_id) # :nodoc: all
       @timeouts.delete(client_query_id)
     end
 
     #  MUST BE CALLED IN A SYNCHRONIZED BLOCK!
-    #  
+    #
     #  Sends the result to the client's queue, and removes the queue observer from the select thread
     def send_result(client_queue, client_query_id, select_queue, msg, error) # :nodoc: all
       stop_querying(client_query_id)  # @TODO@ !
@@ -996,35 +1018,35 @@ module Dnsruby
     #  The queue interface is used to separate producer/consumer threads, but we're using it here in one thread.
     #  It's probably a good idea to create a new "worker thread" to take items from the select thread queue and
     #  call this method in the worker thread.
-    #  
+    #
     def handle_queue_event(queue, id) # :nodoc: all
       #  Time to process a new queue event.
       #  If we get a callback for an ID we don't know about, don't worry -
       #  just ignore it. It may be for a query we've already completed.
-      #  
+      #
       #  So, get the next response from the queue (presuming there is one!)
-      #  
+      #
       #  @TODO@ Tick could poll the queue and then call this method if needed - no need for observer interface.
       #  @TODO@ Currently, tick and handle_queue_event called from select_thread - could have thread chuck events in to tick_queue. But then, clients would have to call in on other thread!
-      #  
+      #
       #  So - two types of response :
       #  1) we've got a coherent response (or error) - stop sending more packets for that query!
       #  2) we've validated the response - it's ready to be sent to the client
-      #  
+      #
       #  so need two more methods :
       #   handleValidationResponse : basically calls send_result_and_stop_querying and
       #   handleValidationError : does the same as handleValidationResponse, but for errors
       #  can leave handleError alone
       #  but need to change handleResponse to stop sending, rather than send_result_and_stop_querying.
-      #  
+      #
       #  @TODO@ Also, we could really do with a MaxValidationTimeout - if validation not OK within
       #  this time, then raise Timeout (and stop validation)?
-      #  
+      #
       #  @TODO@ Also, should there be some facility to stop validator following same chain
       #  concurrently?
-      #  
+      #
       #  @TODO@ Also, should have option to speak only to configured resolvers (not follow authoritative chain)
-      #  
+      #
       if queue.empty?
         log_and_raise('Severe internal error - Queue empty in handle_queue_event')
       end
@@ -1208,8 +1230,8 @@ module Dnsruby
       #                 handle_error_response(queue, event_id, error, response)
       #                 Or:
       send_result(client_queue, client_query_id, select_queue, response, error)
-      #  
-      #  
+      #
+      #
     end
   end
 end