dnsruby 1.1

data/lib/Dnsruby/event_machine_interface.rb

@@ -0,0 +1,264 @@
+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, 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, 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, use_tcp)
+      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, 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, data, exception)
+      end
+        
+      def unbind
+        TheLog.debug("Unbind called")
+        if (!@closing)
+          if (@timeout_time <= Time.now + 1)
+            send_timeout
+          else
+            TheLog.debug("Sending IOError to client")
+            send_to_client(nil, 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, nil, ResolvTimeout.new("Query timed out"))
+      end
+      def send_to_client(msg, bytes, err)
+        #  We call set_defered_status when done
+        if (err != nil)
+          set_deferred_status :failed, msg, err
+        else
+          set_deferred_status :succeeded, msg, bytes
+        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/ipv4.rb

@@ -0,0 +1,74 @@
+#--
+#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
+  class IPv4
+    # Regular expression IPv4 addresses must match
+    Regex = /\A(\d+)\.(\d+)\.(\d+)\.(\d+)\z/
+    
+    def self.create(arg)
+      case arg
+      when IPv4
+        return arg
+      when Regex
+        if (0..255) === (a = $1.to_i) &&
+         (0..255) === (b = $2.to_i) &&
+         (0..255) === (c = $3.to_i) &&
+         (0..255) === (d = $4.to_i)
+          return self.new([a, b, c, d].pack("CCCC"))
+        else
+          raise ArgumentError.new("IPv4 address with invalid value: " + arg)
+        end
+      else
+        raise ArgumentError.new("cannot interpret as IPv4 address: #{arg.inspect}")
+      end
+    end
+    
+    def initialize(address) #:nodoc:
+      unless address.kind_of?(String) && address.length == 4
+        raise ArgumentError.new('IPv4 address must be 4 bytes')
+      end
+      @address = address
+    end
+    
+    # A String representation of thi IPv4 address.
+    attr_reader :address
+    
+    def to_s #:nodoc:
+      return sprintf("%d.%d.%d.%d", *@address.unpack("CCCC"))
+    end
+    
+    def inspect #:nodoc:
+      return "#<#{self.class} #{self.to_s}>"
+    end
+    
+    def to_name
+      return Name.create(
+        '%d.%d.%d.%d.in-addr.arpa.' % @address.unpack('CCCC').reverse)
+    end
+    
+    def ==(other)
+      return @address == other.address
+    end
+    
+    def eql?(other)
+      return self == other
+    end
+    
+    def hash
+      return @address.hash
+    end
+  end
+end

data/lib/Dnsruby/ipv6.rb

@@ -0,0 +1,144 @@
+#--
+#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::IPv6 class
+  class IPv6
+    #IPv6 address format a:b:c:d:e:f:g:h
+    Regex_8Hex = /\A
+     (?:[0-9A-Fa-f]{1,4}:){7}
+    [0-9A-Fa-f]{1,4}
+    \z/x
+    
+    #Compresses IPv6 format a::b
+    Regex_CompressedHex = /\A
+     ((?:[0-9A-Fa-f]{1,4}(?::[0-9A-Fa-f]{1,4})*)?) ::
+     ((?:[0-9A-Fa-f]{1,4}(?::[0-9A-Fa-f]{1,4})*)?)
+    \z/x
+    
+    # IPv4 mapped IPv6 address format a:b:c:d:e:f:w.x.y.z
+    Regex_6Hex4Dec = /\A
+     ((?:[0-9A-Fa-f]{1,4}:){6,6})
+     (\d+)\.(\d+)\.(\d+)\.(\d+)
+    \z/x
+    
+    # Compressed IPv4 mapped IPv6 address format a::b:w.x.y.z
+    Regex_CompressedHex4Dec = /\A
+     ((?:[0-9A-Fa-f]{1,4}(?::[0-9A-Fa-f]{1,4})*)?) ::
+     ((?:[0-9A-Fa-f]{1,4}:)*)
+     (\d+)\.(\d+)\.(\d+)\.(\d+)
+    \z/x
+    
+    # A composite IPv6 address RegExp
+    Regex = /
+     (?:#{Regex_8Hex}) |
+     (?:#{Regex_CompressedHex}) |
+     (?:#{Regex_6Hex4Dec}) |
+     (?:#{Regex_CompressedHex4Dec})/x
+     
+    # Created a new IPv6 address from +arg+ which may be:
+    #
+    #* IPv6:: returns +arg+
+    #* String:: +arg+ must match one of the IPv6::Regex* constants
+    def self.create(arg)
+      case arg
+      when IPv6
+        return arg
+      when String
+        address = ''
+        if Regex_8Hex =~ arg
+          arg.scan(/[0-9A-Fa-f]+/) {|hex| address << [hex.hex].pack('n')}
+        elsif Regex_CompressedHex =~ arg
+          prefix = $1
+          suffix = $2
+          a1 = ''
+          a2 = ''
+          prefix.scan(/[0-9A-Fa-f]+/) {|hex| a1 << [hex.hex].pack('n')}
+          suffix.scan(/[0-9A-Fa-f]+/) {|hex| a2 << [hex.hex].pack('n')}
+          omitlen = 16 - a1.length - a2.length
+          address << a1 << "\0" * omitlen << a2
+        elsif Regex_6Hex4Dec =~ arg
+          prefix, a, b, c, d = $1, $2.to_i, $3.to_i, $4.to_i, $5.to_i
+          if (0..255) === a && (0..255) === b && (0..255) === c && (0..255) === d
+            prefix.scan(/[0-9A-Fa-f]+/) {|hex| address << [hex.hex].pack('n')}
+            address << [a, b, c, d].pack('CCCC')
+          else
+            raise ArgumentError.new("not numeric IPv6 address: " + arg)
+          end
+        elsif Regex_CompressedHex4Dec =~ arg
+          prefix, suffix, a, b, c, d = $1, $2, $3.to_i, $4.to_i, $5.to_i, $6.to_i
+          if (0..255) === a && (0..255) === b && (0..255) === c && (0..255) === d
+            a1 = ''
+            a2 = ''
+            prefix.scan(/[0-9A-Fa-f]+/) {|hex| a1 << [hex.hex].pack('n')}
+            suffix.scan(/[0-9A-Fa-f]+/) {|hex| a2 << [hex.hex].pack('n')}
+            omitlen = 12 - a1.length - a2.length
+            address << a1 << "\0" * omitlen << a2 << [a, b, c, d].pack('CCCC')
+          else
+            raise ArgumentError.new("not numeric IPv6 address: " + arg)
+          end
+        else
+          raise ArgumentError.new("not numeric IPv6 address: " + arg)
+        end
+        return IPv6.new(address)
+      else
+        raise ArgumentError.new("cannot interpret as IPv6 address: #{arg.inspect}")
+      end
+    end
+    
+    def initialize(address) #:nodoc:
+      unless address.kind_of?(String) && address.length == 16
+        raise ArgumentError.new('IPv6 address must be 16 bytes')
+      end
+      @address = address
+    end
+    
+    # The raw IPv6 address as a String
+    attr_reader :address
+    
+    def to_s
+      address = sprintf("%X:%X:%X:%X:%X:%X:%X:%X", *@address.unpack("nnnnnnnn"))
+      unless address.sub!(/(^|:)0(:0)+(:|$)/, '::')
+        address.sub!(/(^|:)0(:|$)/, '::')
+      end
+      return address
+    end
+    
+    def inspect #:nodoc:
+      return "#<#{self.class} #{self.to_s}>"
+    end
+
+    #Turns this IPv6 address into a Dnsruby::Name
+    #--    
+    # ip6.arpa should be searched too. [RFC3152]
+    def to_name
+      return Name.create(
+        #                           @address.unpack("H32")[0].split(//).reverse + ['ip6', 'arpa'])
+        @address.unpack("H32")[0].split(//).reverse.join(".") + ".ip6.arpa")
+    end
+    
+    def ==(other) #:nodoc:
+      return @address == other.address
+    end
+    
+    def eql?(other) #:nodoc:
+      return self == other
+    end
+    
+    def hash
+      return @address.hash
+    end
+  end
+end