dnsruby 1.1

data/lib/Dnsruby/select_thread.rb

@@ -0,0 +1,449 @@
+#--
+#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. 
+#See the License for the specific language governing permissions and 
+#limitations under the License.
+#++
+require 'socket'
+#require 'thread'
+begin
+  require 'fastthread'
+rescue LoadError
+  require 'thread'
+end
+require 'singleton'
+module Dnsruby
+  Thread::abort_on_exception = true
+  class SelectThread #:nodoc: all
+    class SelectWakeup < RuntimeError; end
+    include Singleton
+    # This singleton class runs a continuous select loop which 
+    # listens for responses on all of the in-use sockets.
+    # When a new query is sent, the thread is woken up, and
+    # the socket is added to the select loop (and the new timeout
+    # 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]
+    # and socket->[client_id]
+    # 
+    # @todo@ should we implement some of cancel function?
+    
+    def initialize
+      @@mutex = Mutex.new
+      @@mutex.synchronize {
+        @@in_select=false
+        #        @@notifier,@@notified=IO.pipe
+        @@sockets = [] # @@notified]
+        @@timeouts = Hash.new
+        #    @@mutex.synchronize do
+        @@query_hash = Hash.new
+        @@socket_hash = Hash.new
+        @@observers = Hash.new
+        @@tick_observers = []
+        @@queued_exceptions=[]
+        #    end
+        # Now start the select thread
+        @@select_thread = Thread.new {
+          do_select
+        }
+      }
+    end
+    
+    class QuerySettings
+      attr_accessor :query_bytes, :query, :ignore_truncation, :client_queue, 
+        :client_query_id, :socket, :dest_server, :dest_port, :endtime, :udp_packet_size,
+        :single_resolver
+      # new(query_bytes, query, ignore_truncation, client_queue, client_query_id,
+      #     socket, dest_server, dest_port, endtime, , udp_packet_size, single_resolver)
+      def initialize(*args)
+        @query_bytes = args[0]
+        @query = args[1]
+        @ignore_truncation=args[2]
+        @client_queue = args[3]
+        @client_query_id = args[4]
+        @socket = args[5]
+        @dest_server = args[6]
+        @dest_port=args[7]
+        @endtime = args[8]  
+        @udp_packet_size = args[9]
+        @single_resolver = args[10]
+      end
+    end
+    
+    def add_to_select(query_settings)
+      # Add the query to sockets, and then wake the select thread up
+      @@mutex.synchronize {
+        check_select_thread_synchronized
+        # @TODO@ This assumes that all client_query_ids are unique!
+        # Would be a good idea at least to check this...
+        @@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
+        @@timeouts[query_settings.client_query_id]=query_settings.endtime
+        @@sockets.push(query_settings.socket)
+      }
+    end
+    
+    def check_select_thread_synchronized
+      if (!@@select_thread.alive?)
+        TheLog.debug("Restarting select thread")
+        @@select_thread = Thread.new {
+          do_select
+        }
+      end
+    end
+    
+    def select_thread_alive?
+      ret=true
+      @@mutex.synchronize{
+        ret = @@select_thread.alive?
+      }
+      return ret
+    end
+    
+    def do_select
+      unused_loop_count = 0
+      while true do
+        send_tick_to_observers
+        send_queued_exceptions
+        timeout = tick_time = (Time.now+0.1) - Time.now # We provide a timer service to various Dnsruby classes
+        sockets=[]
+        timeouts=[]
+        has_observer = false
+        @@mutex.synchronize {                
+          sockets = @@sockets 
+          timeouts = @@timeouts.values
+          has_observer = !@@observers.empty?
+        }
+        if (timeouts.length > 0)
+          timeouts.sort!
+          timeout = timeouts[0] - Time.now
+          if (timeout <= 0)
+            process_timeouts
+            timeout = 0
+            next
+          end
+        end
+        ready=nil
+        if (has_observer && (timeout > tick_time))
+          timeout = tick_time
+        end
+#        next if (timeout < 0)
+        begin
+          ready, write, errors = IO.select(sockets, nil, nil, timeout)
+        rescue SelectWakeup
+          # If SelectWakeup, then just restart this loop - the select call will be made with the new data
+          next
+        end
+        if (ready == nil)
+          # proces the timeouts
+          process_timeouts
+          unused_loop_count+=1
+        else
+          process_ready(ready)
+          unused_loop_count=0
+          #                  process_error(errors)
+        end
+        @@mutex.synchronize{
+          if (unused_loop_count > 10 && @@query_hash.empty? && @@observers.empty?)
+            TheLog.debug("Stopping select loop")
+            return
+          end
+        }
+        #              }
+      end
+    end
+    
+    def process_error(errors)
+      TheLog.debug("Error! #{errors.inspect}")
+      # @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
+    def process_ready(ready)
+      ready.each do |socket|
+        query_settings = nil
+        @@mutex.synchronize{
+          # Can do this if we have a query per socket, but not otherwise...
+          c_q_id = @@socket_hash[socket][0] # @todo@ If we use persistent sockets then this won't work
+          query_settings = @@query_hash[c_q_id]
+        }
+        next if !query_settings
+        udp_packet_size = query_settings.udp_packet_size
+        msg, bytes = get_incoming_data(socket, udp_packet_size)
+        if (msg!=nil)
+          send_response_to_client(msg, bytes, socket)
+        end
+        ready.delete(socket)
+      end
+    end
+    
+    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
+      client_ids=[]
+      @@mutex.synchronize{
+        client_ids = @@socket_hash[socket]
+      }
+      # get the queries associated with them
+      client_ids.each do |id|
+        query_header_id=nil
+        @@mutex.synchronize{
+          query_header_id = @@query_hash[id].query.header.id
+        }
+        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
+          }
+          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))
+            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
+      # If not, then we have an error
+      TheLog.error("Stray packet - " + msg.inspect + "\n from " + socket.inspect)
+    end
+    
+    def remove_id(id)
+      socket=nil
+      @@mutex.synchronize{
+        socket = @@query_hash[id].socket
+        @@timeouts.delete(id)
+        @@query_hash.delete(id)      
+        @@sockets.delete(socket) # @TODO@ Not if persistent!
+      }
+      TheLog.debug("Closing socket #{socket}")
+      socket.close # @TODO@ Not if persistent!
+    end
+    
+    def process_timeouts
+      time_now = Time.now
+      timeouts={}
+      @@mutex.synchronize {
+        timeouts = @@timeouts
+      }
+      timeouts.each do |client_id, timeout|
+        if (timeout < time_now)
+          send_exception_to_client(ResolvTimeout.new("Query timed out"), nil, client_id)
+        end
+      end
+    end
+    
+    def tcp_read(socket, len)
+      buf=""
+      while (buf.length < len) do
+        buf += socket.recv(len-buf.length)
+      end
+      return buf
+    end
+    
+    def get_incoming_data(socket, packet_size)
+      answerfrom,answerip,answerport,answersize=nil
+      ans,buf = nil
+      begin
+        if (socket.class == TCPSocket)
+          # @todo@ Ruby Bug #9061 stops this working right
+          # 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
+          #    - *not* ideal TCP use!
+          @@mutex.synchronize{
+            client_id = @@socket_hash[socket][0]
+            answerfrom = @@query_hash[client_id].dest_server
+            answerip = answerfrom
+            answerport = @@query_hash[client_id].dest_port
+          }
+          buf = tcp_read(socket, 2)
+          answersize = buf.unpack('n')[0]
+          buf = tcp_read(socket,answersize)
+        else
+          if (ret = socket.recvfrom(packet_size))
+            buf = ret[0]
+            answerport=ret[1][1]
+            answerfrom=ret[1][2]
+            answerip=ret[1][3]
+            answersize=(buf.length)
+          else
+            # recvfrom failed - why?
+            TheLog.error("Error - recvfrom failed from #{socket}")
+            handle_recvfrom_failure(socket)          
+            return
+          end        
+        end
+      rescue Exception => e
+        TheLog.error("Error - recvfrom failed from #{socket}, exception : #{e}")
+        handle_recvfrom_failure(socket)          
+        return
+      end
+      TheLog.debug(";; answer from #{answerfrom} : #{answersize} bytes\n")
+      
+      begin
+        ans = Message.decode(buf)
+      rescue Exception => e
+        TheLog.error("Decode error! #{e.class}, #{e}\nfor msg (length=#{buf.length}) : #{buf}")
+        client_id=get_client_id_from_answerfrom(socket, answerip, answerport)
+        if (client_id != nil) 
+          send_exception_to_client(e, socket, client_id)
+        else
+          TheLog.error("Decode error from #{answerfrom} but can't determine packet id")
+        end
+        return
+      end
+      
+      if (ans!= nil)
+        TheLog.debug("#{ans}")
+        ans.answerfrom=(answerfrom)
+        ans.answersize=(answersize)
+      end
+      return ans, buf
+    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
+      ids_for_socket = []
+      @@mutex.synchronize{
+        ids_for_socket = @@socket_hash[socket]
+      }
+      if (ids_for_socket.length == 1)
+        answerfrom=nil
+        @@mutex.synchronize{
+          query_settings = @@query_hash[ids_for_socket[0]]
+          answerfrom=query_settings.dest_server
+        }
+        send_exception_to_client(OtherResolvError.new("recvfrom failed from #{answerfrom}"), socket, ids_for_socket[0])
+      else
+        TheLog.fatal("Recvfrom failed from #{socket}, no way to tell query id")
+      end
+    end
+    
+    def get_client_id_from_answerfrom(socket, answerip, answerport)
+      client_id=nil
+      # Figure out client id from answerfrom
+      @@mutex.synchronize{
+        ids = @@socket_hash[socket]
+        ids.each do |id|
+          # Does this id speak to this dest_server?
+          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!
+            client_id = id
+            break
+          end
+        end
+      }
+      return client_id
+    end
+    
+    def send_exception_to_client(err, socket, client_id, msg=nil)
+      # find the client response queue
+      client_queue = nil
+      @@mutex.synchronize {
+        client_queue = @@query_hash[client_id].client_queue
+      }
+      remove_id(client_id)
+      push_exception_to_client(client_id, client_queue, err, msg)
+    end
+    
+    def push_exception_to_select(client_id, client_queue, err, msg)
+      @@mutex.synchronize{
+        @@queued_exceptions.push([client_id, client_queue, err, msg])
+      }
+    end
+    
+    def send_queued_exceptions
+      exceptions = []
+      @@mutex.synchronize{
+        exceptions = @@queued_exceptions
+        @@queued_exceptions = []
+      }
+      
+      exceptions.each do |item|
+        client_id, client_queue, err, msg = item
+        push_exception_to_client(client_id, client_queue, err, msg)
+      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])
+      notify_queue_observers(client_queue, client_id)
+    end
+    
+    def add_observer(client_queue, observer)
+      @@mutex.synchronize {
+        @@observers[client_queue]=observer
+        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
+      }
+    end
+    
+    def remove_observer(client_queue, observer)
+      @@mutex.synchronize {
+        if (@@observers[client_queue]==observer)
+          @@observers.delete(observer)
+        else
+          TheLog.error("remove_observer called with wrong observer for queue")
+          raise ArgumentError.new("remove_observer called with wrong observer for queue")
+        end
+        if (!@@observers.values.include?observer)
+          @@tick_observers.delete(observer)
+        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
+      @@mutex.synchronize {
+        observer = @@observers[client_queue]
+      }
+      if (observer)
+        observer.handle_queue_event(client_queue, client_query_id)
+      end      
+    end
+    
+    def send_tick_to_observers
+      # If any observers are known then send them a tick
+      tick_observers=nil
+      @@mutex.synchronize {
+        tick_observers = @@tick_observers
+      }
+      tick_observers.each do |observer|
+        observer.tick
+      end
+    end
+  end
+end

data/lib/Dnsruby/update.rb

@@ -0,0 +1,262 @@
+#--
+#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. 
+#See the License for the specific language governing permissions and 
+#limitations under the License.
+#++
+module Dnsruby
+  #Dnsruby::Update is a subclass of Dnsruby::Packet,
+  #to be used for making DNS dynamic updates.  Programmers
+  #should refer to RFC 2136 for the semantics of dynamic updates.
+  
+  #The first example below shows a complete program; subsequent examples
+  #show only the creation of the update packet.
+  #
+  #== Add a new host
+  #
+  # require 'Dnsruby'
+  # 
+  # # Create the update packet.
+  # update = Dnsruby::Update.new('example.com')
+  # 
+  # # Prerequisite is that no A records exist for the name.
+  # update.absent('foo.example.com.', 'A')
+  # 
+  # # Add two A records for the name.
+  # update.add('foo.example.com.', 'A', 86400, '192.168.1.2')
+  # update.add('foo.example.com.', 'A', 86400, '172.16.3.4')
+  # 
+  # # Send the update to the zone's primary master.
+  # res = Dnsruby::Resolver.new({:nameserver => 'primary-master.example.com'})
+  # 
+  # begin
+  #     reply = res.send_message(update)
+  #     print "Update succeeded\n"
+  #  rescue Exception => e
+  #     print 'Update failed: #{e}\n'
+  #  end
+  #
+  #== Add an MX record for a name that already exists
+  #
+  #    update = Dnsruby::Update.new('example.com')
+  #    update.present('example.com')
+  #    update.add('example.com', Dnsruby::Types.MX, 10, 'mailhost.example.com')
+  #
+  #== Add a TXT record for a name that doesn't exist
+  #
+  #    update = Dnsruby::Update.new('example.com')
+  #    update.absent('info.example.com')
+  #    update.add('info.example.com', Types.TXT, 86400, "yabba dabba doo"')
+  #
+  #== Delete all A records for a name
+  #
+  #    update = Dnsruby::Update.new('example.com')
+  #    update.present('foo.example.com', 'A')
+  #    update.delete('foo.example.com', 'A')
+  #
+  #== Delete all RRs for a name
+  #
+  #    update = Dnsruby::Update.new('example.com')
+  #    update.present('byebye.example.com')
+  #    update.delete('byebye.example.com')
+  #
+  #== Perform a signed update
+  #
+  #    key_name = 'tsig-key'
+  #    key      = 'awwLOtRfpGE+rRKF2+DEiw=='
+  #
+  #    update = Dnsruby::Update.new('example.com')
+  #    update.add('foo.example.com', 'A', 86400, 10.1.2.3'))
+  #    update.add('bar.example.com', 'A', 86400, 10.4.5.6'))
+  #    res.tsig=(key_name,key)
+  #
+  class Update < Message
+    #Returns a Dnsruby::Update object suitable for performing a DNS
+    #dynamic update.  Specifically, it creates a message with the header
+    #opcode set to UPDATE and the zone record type to SOA (per RFC 2136,
+    #Section 2.3).
+    #
+    #Programs must use the push method to add RRs to the prerequisite,
+    #update, and additional sections before performing the update.
+    #
+    #Arguments are the zone name and the class.  If the zone is omitted,
+    #the default domain will be taken from the resolver configuration.
+    #If the class is omitted, it defaults to IN.
+    #    packet = Dnsruby::Update.new
+    #    packet = Dnsruby::Update.new('example.com')
+    #    packet = Dnsruby::Update.new('example.com', 'HS')
+    #
+    def initialize(zone=nil, klass=nil)
+      
+      # sort out the zone section (RFC2136, section 2.3)
+      if (zone==nil)
+        config = Config.new
+        zone = (config.search)[0]
+        return unless zone
+      end
+      
+      type  = 'SOA'
+      klass  ||= 'IN'
+      
+      super(zone, type, klass) || return
+      
+      @header.opcode=('UPDATE')
+      @header.rd=(0)
+    end
+    
+    #Ways to create the prerequisite records (exists, notexists, inuse, etc. - RFC2136, section 2.4)
+    #
+    #      (1)  RRset exists (value independent).  At least one RR with a
+    #           specified NAME and TYPE (in the zone and class specified by
+    #           the Zone Section) must exist.
+    #           
+    #           update.present(name, type)
+    #
+    #      (2)  RRset exists (value dependent).  A set of RRs with a
+    #           specified NAME and TYPE exists and has the same members
+    #           with the same RDATAs as the RRset specified here in this
+    #           Section.
+    #           
+    #           update.present(name, type, rdata)
+    #
+    #      (4)  Name is in use.  At least one RR with a specified NAME (in
+    #           the zone and class specified by the Zone Section) must exist.
+    #           Note that this prerequisite is NOT satisfied by empty
+    #           nonterminals.
+    #           
+    #           update.present(name)
+    def present(*args)
+      ttl = 0
+      rdata = []
+      klass = Classes.ANY
+      if (args.length>=1) # domain (RFC2136, Section 2.4.4)
+        name = args[0]
+        type = Types.ANY
+        if (args.length>=2) # RRSET (RFC2136, Section 2.4.1)
+          type = args[1]
+        end
+        if (args.length > 2) # RRSET (RFC2136, Section 2.4.2)
+          klass = zone()[0].zclass
+          rdata=args[2]
+        end
+        rec = RR.create("#{name} #{ttl} #{klass} #{type} #{rdata}")
+        add_pre(rec)
+        return rec
+      else
+        raise ArgumentError.new("Wrong number of arguments (#{args.length} for 1 or 2) for Update#absent")
+      end
+    end
+    
+    #Ways to create the prerequisite records (exists, notexists, inuse, etc. - RFC2136, section 2.4)
+    #Can be called with one arg : 
+    #
+    #   update.absent(name)
+    #      (5)  Name is not in use.  No RR of any type is owned by a
+    #           specified NAME.  Note that this prerequisite IS satisfied by
+    #           empty nonterminals.
+    #
+    #Or with two :
+    #
+    #   update.absent(name, type)
+    #      (3)  RRset does not exist.  No RRs with a specified NAME and TYPE
+    #          (in the zone and class denoted by the Zone Section) can exist.
+    #
+    def absent(*args)
+      ttl = 0
+      rdata = []
+      klass = Classes.NONE
+      if (args.length>=1) # domain (RFC2136, Section 2.4.5)
+        name = args[0]
+        type = Types.ANY
+        if (args.length==2) # RRSET (RFC2136, Section 2.4.3)
+          type = args[1]
+        end
+        rec = RR.create("#{name} #{ttl} #{klass} #{type} #{rdata}")
+        add_pre(rec)
+        return rec
+      else
+        raise ArgumentError.new("Wrong number of arguments (#{args.length} for 1 or 2) for Update#absent")
+      end
+    end
+    
+    #Ways to create the update records (add, delete, RFC2136, section 2.5)
+    #  " 2.5.1 - Add To An RRset
+    #
+    #   RRs are added to the Update Section whose NAME, TYPE, TTL, RDLENGTH
+    #   and RDATA are those being added, and CLASS is the same as the zone
+    #   class.  Any duplicate RRs will be silently ignored by the primary
+    #   master."
+    #   
+    #   update.add(rr)
+    #   update.add([rr1, rr2])
+    #   update.add(name, type, ttl, rdata)
+    #
+    def add(*args)
+      zoneclass=zone()[0].zclass
+      case args[0]
+      when Array
+        args[0].each do |resource|
+          add(resource)
+        end
+      when RR
+        # Make sure that the Class is the same as the zone
+        resource = args[0]
+        if (resource.klass != zoneclass)
+          raise ArgumentError.new("Wrong class #{resource.klass} for update (should be #{zoneclass})!")
+        end
+        add_update(resource)
+        return resource
+      else
+        name=args[0]
+        type=args[1]
+        ttl=args[2]
+        rdata=args[3]
+        resource = RR.create("#{name} #{ttl} #{zoneclass} #{type} #{rdata}")
+        add_update(resource)
+        return resource
+      end
+      # @TODO@ Should be able to take RRSet!
+    end
+    
+    #Ways to create the update records (add, delete, RFC2136, section 2.5)
+    #
+    #2.5.2 - Delete An RRset
+    #   update.delete(name, type)
+    #   
+    #
+    #2.5.3 - Delete All RRsets From A Name
+    #   update.delete(name)
+    #   
+    #2.5.4 - Delete An RR From An RRset
+    #  update.delete(name, type, rdata)
+    #  
+    def delete(*args)
+      ttl = 0
+      klass = Classes.ANY
+      rdata=[]
+      resource = nil
+      case args.length
+      when 1 # name
+        resource = RR.create("#{args[0]} #{ttl} #{klass} #{Types.ANY} #{rdata}")
+        add_update(resource)      
+      when 2 # name, type
+        resource = RR.create("#{args[0]} #{ttl} #{klass} #{args[1]} #{rdata}")
+        add_update(resource)      
+      when 3 # name, type, rdata
+        klass = Classes.NONE
+        resource = RR.create("#{args[0]} #{ttl} #{klass} #{args[1]} #{args[2]}")
+        add_update(resource)      
+      end
+      return resource
+    end
+  end
+end