rubydns 0.1.8 → 0.2.0

data/lib/rubydns/extensions/hexdump.rb

@@ -0,0 +1,19 @@
+
+require 'stringio'
+
+class String
+	def hexdump
+		i = 1
+		out = StringIO.new
+		
+		out.puts "Size: #{self.size}"
+		while (self.length > 16*(i-1))
+			a = self.slice(16*(i-1)..(16*i)-1)
+			out.printf("%06x: %4.4x %4.4x %4.4x %4.4x   %4.4x %4.4x %4.4x %4.4x ", (i-1)*16,  *a.unpack("n16"))
+			out.printf("|%s|\n", a.tr("^\040-\176","."))
+			i += 1
+		end
+		
+		return out.string
+	end
+end

data/lib/rubydns/handler.rb

@@ -0,0 +1,86 @@
+
+require 'eventmachine'
+require 'stringio'
+
+require 'rubydns/extensions/hexdump'
+
+module RubyDNS
+	
+	UDP_TRUNCATION_SIZE = 512
+	
+	module UDPHandler
+		def initialize(server)
+			@server = server
+		end
+		
+		def self.process(server, data, &block)
+			server.logger.debug "Receiving incoming query..."
+			
+			server.logger.debug data.hexdump
+			
+			begin
+				server.receive_data(data) do |answer|
+					yield answer.encode
+				end
+			rescue
+				server.logger.error "Error processing request!"
+				server.logger.error "#{$!.class}: #{$!.message}"
+
+				$!.backtrace.each { |at| server.logger.error at }
+			end
+		end
+		
+		def receive_data(data)
+			UDPHandler.process(@server, data) do |result|
+				self.send_data(result)
+			end
+		end
+	end
+	
+	class LengthError < StandardError
+	end
+	
+	module TCPHandler
+		def initialize(server)
+			@server = server
+			@buffer = nil
+			@length = nil
+			@processed = 0
+		end
+		
+		def receive_data(data)
+			@buffer ||= StringIO.new
+			@buffer.write(data)
+			
+			# Message includes a 16-bit length field
+			if @length == nil
+				if (@buffer.size - @processed) < 2
+					raise LengthError.new("Malformed message smaller than two bytes received")
+				end
+				
+				@length = @buffer.string[@processed, 2].unpack('n')[0]
+				@processed += 2
+			end
+			
+			
+			if (@buffer.size - @processed) >= @length
+				data = @buffer.string[@processed, @length]
+				
+				UDPHandler.process(@server, data) do |result|
+					self.send_data([result.size].pack('n'))
+					self.send_data(result)
+				end
+				
+				@processed += @length
+				@length = nil
+			end
+		end
+		
+		def unbind
+			if @processed != @buffer.size
+				raise LengthError.new("Unprocessed data remaining (#{@buffer.size - @processed} bytes unprocessed)")
+			end
+		end
+	end
+	
+end

data/lib/rubydns/server.rb

@@ -31,6 +31,7 @@ module RubyDNS
 		#   end
 		#
 		def initialize(&block)
+			@events = {}
 			@rules = []
 			@otherwise = nil
 
@@ -68,6 +69,23 @@ module RubyDNS
 			@rules << [pattern, Proc.new(&block)]
 		end
 
+		# Register a named event which may be invoked later using #fire
+		#   on(:start) do |server|
+		#     RExec.change_user(RUN_AS)
+		#   end
+		def on(event_name, &block)
+			@events[event_name] = Proc.new(&block)
+		end
+		
+		# Fire the named event, which must have been registered using on.
+		def fire(event_name)
+			callback = @events[event_name]
+			
+			if callback
+				callback.call(self)
+			end
+		end
+		
 		# Specify a default block to execute if all other rules fail to match.
 		# This block is typially used to pass the request on to another server
 		# (i.e. recursive request).
@@ -138,7 +156,7 @@ module RubyDNS
 
 		# Process an incoming DNS message. Returns a serialized message to be
 		# sent back to the client.
-		def receive_data(data)
+		def receive_data(data, &block)
 			query = Resolv::DNS::Message::decode(data)
 
 			# Setup answer
@@ -164,7 +182,11 @@ module RubyDNS
 				end
 			end
 
-			return answer.encode
+			if block_given?
+				yield answer
+			else
+				return answer
+			end
 		end
 	end
 end

data/lib/rubydns/transaction.rb

@@ -44,7 +44,7 @@ module RubyDNS
 			@question = question
 			@resource_class = resource_class
 			@answer = answer
-
+			
 			@question_appended = false
 		end
 

data/lib/rubydns/version.rb

@@ -16,8 +16,8 @@
 module RubyDNS
   module VERSION #:nodoc:
     MAJOR = 0
-    MINOR = 1
-    TINY  = 8
+    MINOR = 2
+    TINY  = 0
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/lib/rubydns.rb

@@ -25,6 +25,8 @@ require 'logger'
 require 'rexec'
 require 'rexec/daemon'
 
+require 'rubydns/handler'
+
 module RubyDNS
 	
 	# Run a server with the given rules. A number of options can be supplied:
@@ -51,58 +53,26 @@ module RubyDNS
 	#
 	def self.run_server (options = {}, &block)
 		server = RubyDNS::Server.new(&block)
-		threads = ThreadGroup.new
-
 		server.logger.info "Starting server..."
-
-		options[:listen] ||= [[:udp, "0.0.0.0", 53]]
-
-		sockets = []
 		
-		# Setup server sockets
-		options[:listen].each do |spec|
-			if spec.kind_of?(BasicSocket)
-				sockets << spec
-			elsif spec[0] == :udp
-				socket = UDPSocket.new
-				socket.bind(spec[1], spec[2])
-
-				sockets << socket
-			elsif spec[0] == :tcp
-				server.logger.warn "Sorry, TCP is not currently supported!"
-			end
-		end
+		options[:listen] ||= [[:udp, "0.0.0.0", 53], [:tcp, "0.0.0.0", 53]]
 		
-		begin
-			# Listen for incoming packets
-			while true
-				ready = IO.select(sockets)
-
-				ready[0].each do |socket|
-					packet, sender = socket.recvfrom(1024*5)
-					server.logger.debug "Receiving incoming query..."
-
-					thr = Thread.new do
-						begin
-							result = server.receive_data(packet)
-
-							server.logger.debug "Sending result to #{sender.inspect}:"
-							server.logger.debug "#{result.inspect}"
-							socket.send(result, 0, sender[2], sender[1])
-						rescue
-							server.logger.error "Error processing request!"
-							server.logger.error "#{$!.class}: #{$!.message}"
-							$!.backtrace.each { |at| server.logger.error at }
-						end
-					end
-					
-					threads.add thr
+		EventMachine.run do
+			server.fire(:setup)
+			
+			# Setup server sockets
+			options[:listen].each do |spec|
+				if spec[0] == :udp
+					EventMachine.open_datagram_socket(spec[1], spec[2], UDPHandler, server)
+				elsif spec[0] == :tcp
+					EventMachine.start_server(spec[1], spec[2], TCPHandler, server)
 				end
 			end
-		rescue Interrupt
-			server.logger.info "Server interrupted - stopping #{threads.list.size} request(s)."
-			threads.list.each { |thr| thr.join }
+			
+			server.fire(:start)
 		end
+		
+		server.fire(:stop)
 	end
 end
 

data/test/daemon2.rb

@@ -36,46 +36,45 @@ require 'rubydns'
 # You might need to change the user name "daemon". This can be a user name or a user id.
 RUN_AS = "daemon"
 
-# UDP Socket does per packet reverse lookups unless this is set.
-UDPSocket.do_not_reverse_lookup = true
+INTERFACES = [
+	[:udp, "0.0.0.0", 53],
+	[:tcp, "0.0.0.0", 53]
+]
 
 # We need to be root in order to bind to privileged port
 if RExec.current_user != "root"
-  $stderr.puts "Sorry, this command needs to be run as root!"
-  exit 1
+	$stderr.puts "Sorry, this command needs to be run as root!"
+	exit 1
 end
 
 # The Daemon itself
 class Server < RExec::Daemon::Base
-  @@var_directory = File.dirname(__FILE__)
-
-  def self.run
-    # Bind to port 53 (UDP)
-    socket = UDPSocket.new
-    socket.bind("0.0.0.0", 53)
-
-    # Drop priviledges
-    RExec.change_user(RUN_AS)
-
-    # Don't buffer output (for debug purposes)
-    $stderr.sync = true
-
-    # Use upstream DNS for name resolution (These ones are Orcon DNS in NZ)
-    $R = Resolv::DNS.new(:nameserver => ["60.234.1.1", "60.234.2.2"])
-
-    # Start the RubyDNS server
-    RubyDNS::run_server(:listen => [socket]) do
-      match("test.mydomain.org", :A) do |transaction|
-        transaction.respond!("10.0.0.80")
-      end
-
-      # Default DNS handler
-      otherwise do |transaction|
-        logger.info "Passthrough: #{transaction}"
-        transaction.passthrough!($R)
-      end
-    end
-  end
+	@@var_directory = File.dirname(__FILE__)
+
+	def self.run
+		# Don't buffer output (for debug purposes)
+		$stderr.sync = true
+
+		# Use upstream DNS for name resolution (These ones are Orcon DNS in NZ)
+		$R = Resolv::DNS.new(:nameserver => ["60.234.1.1", "60.234.2.2"])
+
+		# Start the RubyDNS server
+		RubyDNS::run_server(:listen => INTERFACES) do
+			on(:start) do
+				RExec.change_user(RUN_AS)
+			end
+
+			match("test.mydomain.org", :A) do |transaction|
+				transaction.respond!("10.0.0.80")
+			end
+
+			# Default DNS handler
+			otherwise do |transaction|
+				logger.info "Passthrough: #{transaction}"
+				transaction.passthrough!($R)
+			end
+		end
+	end
 end
 
 # RExec daemon runner