Dnsruby 0.5.0 → 0.6.0

data/lib/Dnsruby/SingleResolver.rb

@@ -176,7 +176,12 @@ module Dnsruby
     end
     
     
-    # Asynchronously send a Message to the server. A client_queue is supplied by the client, 
+    # Asynchronously send a Message to the server. The send can be done using just
+    # Dnsruby, or using EventMachine.
+    # 
+    #= If the pure Ruby event loop supplied weith Dnsruby is being used, then :
+    # 
+    # A client_queue is supplied by the client, 
     # along with a client_query_id to identify the response. When the response is known, the tuple
     # (query_id, response_message, response_exception) is put in the queue for the client to process. 
     # 
@@ -187,11 +192,31 @@ module Dnsruby
     # Takes :
     # 
     # * msg - the message to send
-    # * client_query_id - an ID to identify the query to the client
     # * client_queue - a Queue to push the response to, when it arrives
+    # * client_query_id - an ID to identify the query to the client
     # * use_tcp - whether to use TCP (defaults to SingleResolver.use_tcp)
-    def send_async(msg, client_query_id, client_queue, use_tcp=@use_tcp)
-      st = SelectThread.instance
+    #
+    # If the native Dsnruby networking layer is being used, then this method returns the client_query_id
+    # 
+    #    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)
+    #
+    #= If EventMachine is being used :
+    # 
+    # If EventMachine is being used (see Dnsruby::Resolver::use_eventmachine, then this method returns
+    # an EM::Deferrable object. If a queue (and ID) is passed in, then the response will also be 
+    # pushed to the Queue (as well as the deferrable completing).
+    #
+    #    deferrable = res.send_async(msg)
+    #    deferrable = res.send_async(msg, use_tcp)
+    #    deferrable = res.send_async(msg, q, id, use_tcp)
+    def send_async(*args) # msg, client_queue, client_query_id, use_tcp=@use_tcp)
+      msg = args[0]
+      client_query_id = nil
+      client_queue = nil
+      use_tcp = @use_tcp
       if (msg.kind_of?String)
         msg = Message.new(msg)
       end
@@ -199,9 +224,68 @@ module Dnsruby
       if (udp_packet_size < query_packet.length)
         use_tcp = true
       end
+      if (args.length > 1)
+        if (args[1].class==Queue)
+          client_queue = args[1]
+        elsif (args.length == 2)
+          use_tcp = args[1]
+        end
+        if (args.length > 2)
+          client_query_id = args[2]
+          if (args.length > 3)
+            use_tcp = args[3]
+          end
+        end
+      end
+      #Are we using EventMachine or native Dnsruby?
+      if (Resolver.eventmachine?)
+        return send_eventmachine(query_packet, msg.header.id, client_query_id, client_queue, use_tcp)
+      else
+        if (!client_query_id)
+          client_query_id = msg
+        end
+        send_dnsruby(query_packet, msg.header.id, client_query_id, client_queue, use_tcp)
+        return client_query_id
+      end
+    end
+
+    # This method sends the packet using EventMachine
+    def send_eventmachine(msg, header_id, client_query_id, client_queue, use_tcp, client_deferrable=nil) #:nodoc: all
+      if (!client_deferrable)
+        client_deferrable = EventMachine::DefaultDeferrable.new
+      end
+      packet_deferrable = EventMachineInterface.send(:msg=>msg, :header_id=>header_id, :timeout=>@packet_timeout, :server=>@server, :port=>@port, :src_addr=>@src_addr, :src_port=>@src_port, :tsig_key=>@tsig_key, :ignore_truncation=>@ignore_truncation, :use_tcp=>use_tcp)
+      packet_deferrable.callback { |response|
+        TheLog.debug("EM callback #{response}")
+        # @TODO@ Check TSIG!
+        ret = true
+        if (response.header.tc && !use_tcp)
+          # Try to resend over tcp
+          TheLog.debug("Truncated - resending over TCP")
+          send_eventmachine(msg, header_id, client_query_id, client_queue, true, client_deferrable)
+        else
+          client_deferrable.set_deferred_status :succeeded, response
+          if (client_queue)
+            client_queue.push([client_query_id, response, nil])
+          end
+        end
+      }
+      packet_deferrable.errback { |response, error|
+        TheLog.debug("EM errback #{error}, #{response}")
+        client_deferrable.set_deferred_status :failed, response, error
+        if (client_queue)
+          client_queue.push([client_query_id, response, error])
+        end
+      }
+      return client_deferrable
+    end
+
+    # This method sends the packet using the built-in pure Ruby event loop, with no dependencies.
+    def send_dnsruby(query_packet, header_id, client_query_id, client_queue, use_tcp) #:nodoc: all
+      endtime = Time.now + @packet_timeout
       # First send the query (synchronously)
       # @TODO@ persisent sockets
-      endtime = Time.now + @packet_timeout
+      st = SelectThread.instance
       socket = nil
       begin
         #@TODO@ Different OSes have different interpretations of "random port" here.
@@ -210,7 +294,6 @@ module Dnsruby
         #We need to determine an actual (random) number here, then ask the OS for it, and
         #continue until we get one.
         if (use_tcp) 
-          print "Setting src_port to #{@src_port}"
           socket = TCPSocket.new(@server, @port, @src_addr, @src_port)
         else
           socket = UDPSocket.new()
@@ -223,13 +306,13 @@ module Dnsruby
         end
         err=IOError.new("dnsruby can't connect to #{@server}:#{@port} from #{@src_addr}:#{@src_port}, use_tcp=#{use_tcp}, exception = #{e.class}, #{e}")
         TheLog.error("#{err}")
-        st.push_exception_to_select(client_query_id, client_queue, err, nil)
+        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
       if (socket==nil)
         err=IOError.new("dnsruby can't connect to #{@server}:#{port} from #{@src_addr}:#{@src_port}, use_tcp=#{use_tcp}")
         TheLog.error("#{err}")
-        st.push_exception_to_select(client_query_id, client_queue, err, nil)
+        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
       TheLog.debug("Sending packet to #{@server}:#{@port} from #{@src_addr}:#{@src_port}, use_tcp=#{use_tcp}")
@@ -248,12 +331,24 @@ module Dnsruby
       end
       
       # Then listen for the response
-      query_settings = SelectThread::QuerySettings.new(query_packet, msg.header.id, @tsig_key, @ignore_truncation, client_queue, client_query_id, socket, @server, @port, endtime)
+      query_settings = SelectThread::QuerySettings.new(query_packet, header_id, @tsig_key, @ignore_truncation, client_queue, client_query_id, socket, @server, @port, endtime, self)
       # The select thread will now wait for the response and send that or a timeout
-      # back to the client_queue
+      # back to the client_queue.
       st.add_to_select(query_settings)
     end
     
+    def check_response(response, query, client_queue, client_query_id, tcp)
+      # @TODO@ Check TSIG!
+      ret = true
+      if (response.header.tc && !tcp)
+        # Try to resend over tcp
+        TheLog.debug("Truncated - resending over TCP")
+        send_async(Message.decode(query), client_queue, client_query_id, true)
+        ret=false
+      end
+      return ret
+    end
+    
     # Prepare the packet for sending
     def make_query_packet(packet) #:nodoc: all
       if (packet.header.opcode == OpCode.QUERY || @recurse)

data/lib/Dnsruby/event_machine_interface.rb

@@ -0,0 +1,265 @@
+require 'eventmachine'
+module Dnsruby
+  class EventMachineInterface#:nodoc: all
+    @@started_em_here = false
+    @@running_clients=[]
+    @@outstanding_sends = []
+    @@em_thread=nil
+    # We want to have one EM loop running continuously in this class.
+    # Remember to use stop_event_loop inside of EM callback in order to stop the event machine
+    
+    # Timers - can't use EM timers as they max out at 1000.
+    # Instead, while queries are outstanding, call next_tick to manage our own list of timers.
+    
+    @@timer_procs={} # timeout=>[proc
+    @@timer_keys_sorted=[]
+    TIMER_PERIOD = 0.1
+    
+    def EventMachineInterface::process_timers
+      # Go through list of timers
+      now = Time.now
+      @@timer_keys_sorted.each do |timeout|
+        if (timeout > now) 
+          break
+        end
+        c, proc = @@timer_procs[timeout]
+        proc.call
+        @@timer_procs.delete(timeout)
+        @@timer_keys_sorted.delete(timeout)
+      end
+        
+      if (!@@outstanding_sends.empty?)
+        EventMachine::add_timer(TIMER_PERIOD) {process_timers}
+      end
+    end
+    
+    def EventMachineInterface::remove_timer(c)
+      # Remove from timer structures - if still there!
+      @@timer_procs.each do |timeout, value|
+        conn, proc = value
+        if (c==conn)
+          @@timer_procs.delete(timeout)
+          @@timer_keys_sorted.delete(timeout)
+        end
+      end
+    end
+    
+    def EventMachineInterface::add_to_outstanding(c, timeout)
+      # Add to timer structures
+      @@timer_procs[Time.now+timeout]=[c, Proc.new {
+          # Cancel the send
+          c.closing=true
+          c.close_connection
+          c.send_timeout
+        }]
+      @@timer_keys_sorted=@@timer_procs.keys.sort
+      @@outstanding_sends.push(c)
+#      puts "#{@@outstanding_sends.length} outstanding connections"
+      if (@@outstanding_sends.length==1)
+        EventMachine::add_timer(0) {process_timers}
+      end
+    end
+    
+    def EventMachineInterface::remove_from_outstanding(c)
+      @@outstanding_sends.delete(c)
+#      puts "#{@@outstanding_sends.length} outstanding connections"
+      remove_timer(c)
+      # If we explicitly started the EM loop, and there are no more outstanding sends, then stop the EM loop
+      stop_eventmachine
+    end
+    
+    def EventMachineInterface::start_eventmachine
+      if (!eventmachine_running?)
+        if Resolver.start_eventmachine_loop?
+          TheLog.debug("Starting EventMachine")
+          @@started_em_here = true
+          @@em_thread = Thread.new {
+            EM.run {
+              EventMachine::add_periodic_timer(0.1) {EventMachineInterface::process_timers}
+              @@df = EventMachine::DefaultDeferrable.new
+              @@df.callback{
+                TheLog.debug("Stopping EventMachine")
+                EM.stop              
+                @@em_thread=nil
+              }
+            }
+          }
+        else
+          TheLog.debug("Not trying to start event loop")
+        end
+      end
+    end
+    
+    def EventMachineInterface::start_em_for_resolver(res)
+      @@running_clients.push(res)
+      start_eventmachine
+    end
+    
+    def EventMachineInterface::stop_em_for_resolver(res)
+      @@running_clients.each_index do |i|
+        if (@@running_clients[i]==res)
+          @@running_clients.delete_at(i)
+        end
+      end
+      stop_eventmachine
+    end
+    
+    def EventMachineInterface::eventmachine_running?
+      return (@@em_thread!=nil)
+    end
+    
+    def EventMachineInterface::stop_eventmachine
+      if (@@started_em_here)
+        if (@@outstanding_sends.size==0)
+          if (@@running_clients.length == 0)
+            if (@@em_thread)
+              @@df.set_deferred_status :succeeded
+              @@started_em_here = false
+              #              @@em_thread = nil
+            end
+          end
+        end
+      end
+    end
+
+    def EventMachineInterface::send(args={})#msg, timeout, server, port, src_add, src_port, tsig_key, ignore_truncation, use_tcp)
+      # Is the EventMachine loop running? If not, we need to start it (and mark that we started it)
+      begin
+        if (!EventMachine.reactor_running?)
+          start_eventmachine
+        end
+      rescue Exception
+        #@TODO@ EM::reactor_running? only introduced in EM v0.9.0 - if it's not there, we simply don't know what to do...
+        TheLog.error("EventMachine::reactor_running? not available.")
+        #        if Resolver.start_eventmachine_loop?
+        #          TheLog.debug("Trying to start event loop - may prove fatal...")
+        start_eventmachine
+        #        else
+        #          TheLog.debug("Not trying to start event loop.")
+        #        end
+      end
+      df = nil
+      if (args[:use_tcp])
+        df = send_tcp(args)
+      else
+        df = send_udp(args)
+      end 
+      # Need to add this send to the list of outstanding sends
+      add_to_outstanding(df, args[:timeout])
+      return df
+    end
+
+    def EventMachineInterface::send_tcp(args={})#msg, timeout, server, port, src_add, src_port, tsig_key, ignore_truncation, use_tcp)
+      connection = EventMachine::connect(args[:server], args[:port], EmTcpHandler) { |c|
+        #@TODO SRC_PORT FOR TCP!!!
+        c.timeout_time=Time.now + args[:timeout]
+        c.instance_eval {@args = args}
+        lenmsg = [args[:msg].length].pack('n')
+        c.send_data(lenmsg)
+        c.send_data args[:msg] # , args[:server], args[:port]
+        TheLog.debug"EventMachine : Sent TCP packet to #{args[:server]}:#{args[:port]}" + # from #{args[:src_addr]}:#{args[:src_port]}, timeout=#{args[:timeout]}"
+        ", timeout=#{args[:timeout]}"
+      }
+      return connection # allows clients to set callback, errback, etc., if desired
+    end
+    
+    def EventMachineInterface::send_udp(args={})# msg, timeout, server, port, src_add, src_port, tsig_key, ignore_truncation, use_cp)
+      connection = EventMachine::open_datagram_socket(args[:src_addr], args[:src_port], EmUdpHandler) { |c|
+        c.timeout_time=Time.now + args[:timeout]
+        c.instance_eval {@args = args}
+        c.send_datagram args[:msg], args[:server], args[:port]
+        TheLog.debug"EventMachine : Sent datagram to #{args[:server]}:#{args[:port]} from #{args[:src_addr]}:#{args[:src_port]}, timeout=#{args[:timeout]}"
+      }
+      return connection # allows clients to set callback, errback, etc., if desired
+    end
+    
+    
+    class EmUdpHandler < EventMachine::Connection #:nodoc: all
+      include EM::Deferrable
+      attr_accessor :closing, :timeout_time
+      def post_init
+        @closing=false
+      end
+      def receive_data(dgm)
+        TheLog.debug("UDP receive_data called")
+        process_incoming_message(dgm)
+      end
+      
+      def process_incoming_message(data)
+        TheLog.debug("Processing incoming message, #{data.length} bytes")
+        ans=nil
+        begin
+          ans = Message.decode(data)
+        rescue Exception => e
+          TheLog.error("Decode error! #{e.class}, #{e}\nfor msg (length=#{data.length}) : #{data}")
+          @closing=true
+          close_connection
+          send_to_client(nil, e)
+          return
+        end
+        TheLog.debug("#{ans}")
+        ans.answerfrom=(@args[:server])
+        ans.answersize=(data.length)
+        exception = ans.header.get_exception
+        @closing=true
+        close_connection
+        send_to_client(ans, exception)
+      end
+        
+      def unbind
+        TheLog.debug("Unbind called")
+        if (!@closing)
+          if (@timeout_time <= Time.now + 1)
+            send_timeout
+          else
+            #@TODO@ RAISE OTHER NETWORK ERROR!
+            TheLog.debug("Sending IOError to client")
+            send_to_client(nil, IOError.new("Network error"))
+          end
+        end
+        @closing=false
+        # Take the last send off the list of outstanding sends
+        EventMachineInterface.remove_from_outstanding(self)
+      end
+      def send_timeout
+        TheLog.debug("Sending timeout to client")
+        send_to_client(nil, ResolvTimeout.new("Query timed out"))
+      end
+      def send_to_client(msg, err)
+        #  We call set_defered_status when done
+        if (err != nil)
+          set_deferred_status :failed, msg, err
+        else
+          set_deferred_status :succeeded, msg
+        end
+      end
+    end
+
+
+    class EmTcpHandler < EmUdpHandler #:nodoc: all
+      def post_init
+        super
+        @data=""
+        @answersize = 0
+      end
+      def receive_data(data)
+        TheLog.debug("TCP receive_data called")
+        #Buffer up the incoming data until we have a complete packet
+        @data << data
+        if (@data.length >= 2)
+          if (@answersize == 0)
+            @answersize = @data[0..1].unpack('n')[0]
+            TheLog.debug("TCP - expecting #{@answersize} bytes")
+          end
+          if (@answersize == @data.length - 2)
+            TheLog.debug("TCP - got all #{@answersize} bytes ")
+            process_incoming_message(@data[2..@data.length])
+          else
+            TheLog.debug("TCP - got #{@data.length-2} message bytes")
+          end
+        end
+      end      
+    end
+    
+  end
+end

data/lib/Dnsruby/message.rb

@@ -520,7 +520,7 @@ module Dnsruby
       @opcode = OpCode.new(newcode)
     end
     
-    def getException
+    def get_exception
       exception = nil
       if (@rcode==RCode.NXDOMAIN)
         exception = NXDomain.new

data/lib/Dnsruby/select_thread.rb

@@ -42,17 +42,7 @@ module Dnsruby
     # and socket->[client_id]
     # 
     # @todo@ should we implement some of cancel function?
-    # 
-    # @todo@ How do we ensure that sockets all get closed?
-    # 
-    # @todo@ Should the thread be killed when no queries are active?
     
-    # For each query to monitor, we need to know : 
-    # |a) The socket the query was sent on
-    # |b) The query header ID
-    #  c) The query response queue
-    # So we could have a hash which maps <socket, headerID> to <queue>
-    # Note that multiple values of <queue> could refer to the same Queue
     def initialize
       @@mutex = Mutex.new
       @@mutex.synchronize {
@@ -76,9 +66,9 @@ module Dnsruby
     
     class QuerySettings
       attr_accessor :query, :query_header_id, :tsig, :ignore_truncation, :client_queue, 
-      :client_query_id, :socket, :dest_server, :dest_port, :endtime
+        :client_query_id, :socket, :dest_server, :dest_port, :endtime, :single_resolver
       # new(query, query_header_id, tsig, ignore_truncation, client_queue, client_query_id,
-      #     socket, dest_server, dest_port, endtime)
+      #     socket, dest_server, dest_port, endtime, single_resolver)
       def initialize(*args)
         @query = args[0]
         @query_header_id = args[1]
@@ -89,7 +79,8 @@ module Dnsruby
         @socket = args[6]
         @dest_server = args[7]
         @dest_port=args[8]
-        @endtime = args[9]        
+        @endtime = args[9]  
+        @single_resolver = args[10]        
       end
     end
     
@@ -101,14 +92,6 @@ module Dnsruby
         @@socket_hash[query_settings.socket]=[query_settings.client_query_id] # @todo@ If we use persistent sockets then we need to update this array
         @@timeouts[query_settings.client_query_id]=query_settings.endtime
         @@sockets.push(query_settings.socket)
-        
-        #        # Only do this if we're currently in select
-        #        if @@in_select
-        #          @@in_select=false
-        #          p "in_select now false - sending signal"
-        #          @@select_thread.raise SelectWakeup # Wake up the select thread so it listens to socket too
-        #          #        # @todo@ This would probably be more elegant if we send a signal through select
-        #        end
       }
     end
     
@@ -157,21 +140,11 @@ module Dnsruby
           timeout = tick_time
         end
         begin
-          #          @@mutex.synchronize{
-          #            @@in_select=true
-          ##          p "in_select now true"
-          #          }
           ready, write, errors = IO.select(sockets, nil, nil, timeout)
-          #          @@mutex.synchronize{
-          #            @@in_select=false
-          ##          p "in_select now false"
-          #          }
         rescue SelectWakeup
           # If SelectWakeup, then just restart this loop - the select call will be made with the new data
-          #          p "signal received!"
           next
         end
-        #              @@mutex.synchronize{
         if (ready == nil)
           # proces the timeouts
           process_timeouts
@@ -197,25 +170,14 @@ module Dnsruby
     end
     
     def process_ready(ready)
-      #      while (ready.length > 0) do
-      #      @@mutex.synchronize{
       ready.each do |socket|
-        #        if (socket==@@notified)
-        #          @@notified.getc
-        #          ##          @@notified.close
-        #          next
-        #        end
-        #        socket = ready.pop
-        packet_size = 512 # @todo@ Sort out per-query packet sizes
-        #        @@mutex.synchronize{
+        packet_size = 512 # @TODO@ Sort out per-query packet sizes!!!
         msg = get_incoming_data(socket, packet_size)
         if (msg!=nil)
           send_response_to_client(msg, socket)
         end
-        #        }
         ready.delete(socket)
       end
-      #      }
     end
     
     def send_response_to_client(msg, socket)
@@ -233,14 +195,24 @@ module Dnsruby
         if (query_header_id == msg.header.id)
           # process the response
           client_queue = nil
+          res = nil
+          query=nil
           @@mutex.synchronize{
             client_queue = @@query_hash[id].client_queue
+            res = @@query_hash[id].single_resolver
+            query = @@query_hash[id].query
           }
-          remove_id(id)
-          exception = msg.header.getException
-          TheLog.debug("Pushing response to client queue")
-          client_queue.push([id, msg, exception])
-          notify_queue_observers(client_queue, id)
+          tcp = (socket.class == TCPSocket)
+          # At this point, we should check if the response is OK
+          if (res.check_response(msg, query, client_queue, id, tcp))
+            remove_id(id)
+            exception = msg.header.get_exception
+            TheLog.debug("Pushing response to client queue")
+            client_queue.push([id, msg, exception])
+            notify_queue_observers(client_queue, id)
+          else
+            # Sending query again - don't return response
+          end
           return
         end
       end
@@ -254,16 +226,14 @@ module Dnsruby
         socket = @@query_hash[id].socket
         @@timeouts.delete(id)
         @@query_hash.delete(id)      
-        @@sockets.delete(socket) # @todo@ Not if persistent!
+        @@sockets.delete(socket) # @TODO@ Not if persistent!
       }
       TheLog.debug("Closing socket #{socket}")
-      socket.close # @todo@ Not if persistent!
+      socket.close # @TODO@ Not if persistent!
     end
     
     def process_timeouts
       time_now = Time.now
-      #      timeouts = @@timeouts.values
-      #     timeouts.sort!
       timeouts={}
       @@mutex.synchronize {
         timeouts = @@timeouts
@@ -271,8 +241,6 @@ module Dnsruby
       timeouts.each do |client_id, timeout|
         if (timeout < time_now)
           send_exception_to_client(ResolvTimeout.new("Query timed out"), nil, client_id)
-          #        else
-          #          return # @@timeouts is sorted, so all others will be later than this one
         end
       end
     end
@@ -294,7 +262,7 @@ module Dnsruby
           # We'd like to do a socket.recvfrom, but that raises an Exception
           # on Windows for TCPSocket for Ruby 1.8.5 (and 1.8.6).
           # So, we need to do something different for TCP than UDP. *sigh*
-          # @todo@ This workaround will only work if there is exactly one socket per query
+          # @TODO@ This workaround will only work if there is exactly one socket per query
           #    - *not* ideal TCP use!
           @@mutex.synchronize{
             client_id = @@socket_hash[socket][0]
@@ -348,7 +316,7 @@ module Dnsruby
     end
     
     def handle_recvfrom_failure(socket)
-      #          @todo@ No way to notify the client about this error, unless there was only one connection on the socket
+      #  @TODO@ No way to notify the client about this error, unless there was only one connection on the socket
       ids_for_socket = []
       @@mutex.synchronize{
         ids_for_socket = @@socket_hash[socket]
@@ -375,7 +343,7 @@ module Dnsruby
           query_settings = @@query_hash[id]
           if (answerip == query_settings.dest_server && answerport == query_settings.dest_port)
             # We have a match
-            # - @todo@ as long as we're not speaking to the same server on two ports!
+            # - @TODO@ as long as we're not speaking to the same server on two ports!
             client_id = id
             break
           end
@@ -385,8 +353,6 @@ module Dnsruby
     end
     
     def send_exception_to_client(err, socket, client_id, msg=nil)
-      # first ensure the error is of the right type
-      # @TODO@ What about FORMERR, and other RCode errors?
       if ((!err.kind_of?ResolvError) && (!err.kind_of?ResolvTimeout))
         TheLog.error("INCORRECT ERROR TYPE BEING RETURNED TO CLIENT")
         raise RuntimeError.new("INCORRECT ERROR TYPE BEING RETURNED TO CLIENT")
@@ -428,7 +394,7 @@ module Dnsruby
     def add_observer(client_queue, observer)
       @@mutex.synchronize {
         @@observers[client_queue]=observer
-        check_select_thread_synchronized # @TODO@ Is this really necessary? The client should start the thread by sending a query, really...        
+        check_select_thread_synchronized # Is this really necessary? The client should start the thread by sending a query, really...        
         if (!@@tick_observers.include?observer)
           @@tick_observers.push(observer)
         end

data/lib/Dnsruby/zone_transfer.rb

@@ -75,7 +75,7 @@ module Dnsruby
         # Send an initial query
         msg = Message.new(zone, @transfer_type, @klass)
         if @transfer_type == Types.IXFR
-          rr = RR.create("#{zone} 0 IN SOA" + '. . %u 0 0 0 0' % @serial)
+          rr = RR.create("#{zone} 0 IN SOA" + '0 0 %u 0 0 0 0' % @serial)
           msg.add_authority(rr)
         end
         # @TODO@ TSIG?
@@ -269,6 +269,8 @@ module Dnsruby
       end
     end
     
+    
+    # @TODO@ Do all this with EventMachine?
     def send_message(socket, msg) #:nodoc: all
       query_packet = msg.encode
       lenmsg = [query_packet.length].pack('n')

data/lib/dnsruby.rb

@@ -68,6 +68,14 @@ require 'timeout'
 #  
 #  * NXDomain < ResolvError
 #  
+#  * FormErr < ResolvError
+#  
+#  * ServFail < ResolvError
+#  
+#  * NotImp < ResolvError
+#  
+#  * Refused < ResolvError
+#  
 #  * OtherResolvError < ResolvError
 #  
 #