celluloid-dns 0.0.1 → 0.17.3

data/lib/celluloid/dns/server.rb

@@ -1,27 +1,151 @@
-module Celluloid
-  module DNS
-    class Server
-      # Maximum UDP packet we'll accept
-      MAX_PACKET_SIZE = 512
-      
-      include Celluloid::IO
-      
-      def initialize(addr, port, &block)
-        @block = block
-        
-        # Create a non-blocking Celluloid::IO::UDPSocket
-        @socket = UDPSocket.new
-        @socket.bind(addr, port)
-        
-        async.run
-      end
-      
-      def run
-        loop do
-          data, (_, port, addr) = @socket.recvfrom(MAX_PACKET_SIZE)
-          @block.call Request.new(addr, port, @socket, data)
-        end
-      end
-    end
-  end
-end
+# Copyright, 2009, 2012, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+require 'celluloid/io'
+
+require_relative 'transaction'
+require_relative 'logger'
+
+module Celluloid::DNS
+	class Server
+		include Celluloid::IO
+		
+		# The default server interfaces
+		DEFAULT_INTERFACES = [[:udp, "0.0.0.0", 53], [:tcp, "0.0.0.0", 53]]
+		
+		# Instantiate a server with a block
+		#
+		#	server = Server.new do
+		#		match(/server.mydomain.com/, IN::A) do |transaction|
+		#			transaction.respond!("1.2.3.4")
+		#		end
+		#	end
+		#
+		def initialize(options = {})
+			@logger = options[:logger] || Celluloid.logger
+			@interfaces = options[:listen] || DEFAULT_INTERFACES
+			
+			@origin = options[:origin] || '.'
+		end
+
+		# Records are relative to this origin:
+		attr_accessor :origin
+
+		attr_accessor :logger
+
+		# Fire the named event as part of running the server.
+		def fire(event_name)
+		end
+		
+		finalizer def stop
+			# Celluloid.logger.debug(self.class.name) {"-> Shutdown..."}
+			
+			fire(:stop)
+			
+			# Celluloid.logger.debug(self.class.name) {"<- Shutdown..."}
+		end
+		
+		# Give a name and a record type, try to match a rule and use it for processing the given arguments.
+		def process(name, resource_class, transaction)
+			raise NotImplementedError.new
+		end
+		
+		# Process an incoming DNS message. Returns a serialized message to be sent back to the client.
+		def process_query(query, options = {}, &block)
+			start_time = Time.now
+			
+			# Setup response
+			response = Resolv::DNS::Message::new(query.id)
+			response.qr = 1                 # 0 = Query, 1 = Response
+			response.opcode = query.opcode  # Type of Query; copy from query
+			response.aa = 1                 # Is this an authoritative response: 0 = No, 1 = Yes
+			response.rd = query.rd          # Is Recursion Desired, copied from query
+			response.ra = 0                 # Does name server support recursion: 0 = No, 1 = Yes
+			response.rcode = 0              # Response code: 0 = No errors
+			
+			transaction = nil
+			
+			begin
+				query.question.each do |question, resource_class|
+					begin
+						question = question.without_origin(@origin)
+						
+						@logger.debug {"<#{query.id}> Processing question #{question} #{resource_class}..."}
+						
+						transaction = Transaction.new(self, query, question, resource_class, response, options)
+						
+						transaction.process
+					rescue Resolv::DNS::OriginError
+						# This is triggered if the question is not part of the specified @origin:
+						@logger.debug {"<#{query.id}> Skipping question #{question} #{resource_class} because #{$!}"}
+					end
+				end
+			rescue StandardError => error
+				@logger.error "<#{query.id}> Exception thrown while processing #{transaction}!"
+				Celluloid::DNS.log_exception(@logger, error)
+			
+				response.rcode = Resolv::DNS::RCode::ServFail
+			end
+			
+			end_time = Time.now
+			@logger.debug {"<#{query.id}> Time to process request: #{end_time - start_time}s"}
+			
+			return response
+		end
+		
+		# Setup all specified interfaces and begin accepting incoming connections.
+		def run
+			@logger.info "Starting Celluloid::DNS server (v#{Celluloid::DNS::VERSION})..."
+			
+			fire(:setup)
+			
+			# Setup server sockets
+			@interfaces.each do |spec|
+				if spec.is_a?(BasicSocket)
+					spec.do_not_reverse_lookup
+					protocol = spec.getsockopt(Socket::SOL_SOCKET, Socket::SO_TYPE).unpack("i")[0]
+					ip = spec.local_address.ip_address
+					port = spec.local_address.ip_port
+					
+					case protocol
+					when Socket::SOCK_DGRAM
+						@logger.info "<> Attaching to pre-existing UDP socket #{ip}:#{port}"
+						link UDPSocketHandler.new(self, Celluloid::IO::Socket.try_convert(spec))
+					when Socket::SOCK_STREAM
+						@logger.info "<> Attaching to pre-existing TCP socket #{ip}:#{port}"
+						link TCPSocketHandler.new(self, Celluloid::IO::Socket.try_convert(spec))
+					else
+						raise ArgumentError.new("Unknown socket protocol: #{protocol}")
+					end
+				elsif spec[0] == :udp
+					@logger.info "<> Listening on #{spec.join(':')}"
+					link UDPHandler.new(self, spec[1], spec[2])
+				elsif spec[0] == :tcp
+					@logger.info "<> Listening on #{spec.join(':')}"
+					link TCPHandler.new(self, spec[1], spec[2])
+				else
+					raise ArgumentError.new("Invalid connection specification: #{spec.inspect}")
+				end
+			end
+			
+			fire(:start)
+		end
+	end
+end

data/lib/celluloid/dns/system.rb

@@ -0,0 +1,146 @@
+# Copyright, 2009, 2012, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+begin
+	require 'win32/resolv'
+rescue LoadError
+	# Ignore this - we aren't running on windows.
+end
+
+module Celluloid::DNS
+	# This module encapsulates system dependent name lookup functionality.
+	module System
+		RESOLV_CONF = "/etc/resolv.conf"
+		HOSTS = "/etc/hosts"
+
+		def self.hosts_path
+			if RUBY_PLATFORM =~ /mswin32|mingw|bccwin/
+				Win32::Resolv.get_hosts_path
+			else
+				HOSTS
+			end
+		end
+
+		# This code is very experimental
+		class Hosts
+			def initialize
+				@addresses = {}
+				@names = {}
+			end
+
+			attr :addresses
+			attr :names
+
+			# This is used to match names against the list of known hosts:
+			def call(name)
+				@names.include?(name)
+			end
+
+			def lookup(name)
+				addresses = @names[name]
+
+				if addresses
+					addresses.last
+				else
+					nil
+				end
+			end
+
+			alias [] lookup
+
+			def add(address, names)
+				@addresses[address] ||= []
+				@addresses[address] += names
+
+				names.each do |name|
+					@names[name] ||= []
+					@names[name] << address
+				end
+			end
+
+			def parse_hosts(io)
+				io.each do |line|
+					line.sub!(/#.*/, '')
+					address, hostname, *aliases = line.split(/\s+/)
+
+					add(address, [hostname] + aliases)
+				end
+			end
+
+			def self.local
+				hosts = self.new
+
+				path = System::hosts_path
+
+				if path and File.exist?(path)
+					File.open(path) do |file|
+						hosts.parse_hosts(file)
+					end
+				end
+
+				return hosts
+			end
+		end
+
+		def self.parse_resolv_configuration(path)
+			nameservers = []
+			File.open(path) do |file|
+				file.each do |line|
+					# Remove any comments:
+					line.sub!(/[#;].*/, '')
+
+					# Extract resolv.conf command:
+					keyword, *args = line.split(/\s+/)
+
+					case keyword
+					when 'nameserver'
+						nameservers += args
+					end
+				end
+			end
+
+			return nameservers
+		end
+
+		def self.standard_connections(nameservers)
+			connections = []
+
+			nameservers.each do |host|
+				connections << [:udp, host, 53]
+				connections << [:tcp, host, 53]
+			end
+
+			return connections
+		end
+
+		# Get a list of standard nameserver connections which can be used for querying any standard servers that the system has been configured with. There is no equivalent facility to use the `hosts` file at present.
+		def self.nameservers
+			nameservers = []
+
+			if File.exist? RESOLV_CONF
+				nameservers = parse_resolv_configuration(RESOLV_CONF)
+			elsif defined?(Win32::Resolv) and RUBY_PLATFORM =~ /mswin32|cygwin|mingw|bccwin/
+				search, nameservers = Win32::Resolv.get_resolv_info
+			end
+
+			return standard_connections(nameservers)
+		end
+	end
+end

data/lib/celluloid/dns/transaction.rb

@@ -0,0 +1,202 @@
+# Copyright, 2009, 2012, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+module Celluloid::DNS
+	
+	# This class provides all details of a single DNS question and response. This is used by the DSL to provide DNS related functionality.
+	# 
+	# The main functions to complete the transaction are: {#append!} (evaluate a new query and append the results), {#passthrough!} (pass the query to an upstream server), {#respond!} (compute a specific response) and {#fail!} (fail with an error code).
+	class Transaction
+		# The default time used for responses (24 hours).
+		DEFAULT_TTL = 86400
+		
+		def initialize(server, query, question, resource_class, response, options = {})
+			@server = server
+			@query = query
+			@question = question
+			@resource_class = resource_class
+			@response = response
+
+			@options = options
+		end
+
+		# The resource_class that was requested. This is typically used to generate a response.
+		attr :resource_class
+		
+		# The incoming query which is a set of questions.
+		attr :query
+		
+		# The question that this transaction represents.
+		attr :question
+		
+		# The current full response to the incoming query.
+		attr :response
+		
+		# Any options or configuration associated with the given transaction.
+		attr :options
+		
+		def [] key
+			@options[key]
+		end
+		
+		# The name of the question, which is typically the requested hostname.
+		def name
+			@question.to_s
+		end
+		
+		# Shows the question name and resource class. Suitable for debugging purposes.
+		def to_s
+			"#{name} #{@resource_class.name}"
+		end
+		
+		# Run a new query through the rules with the given name and resource type. The results of this query are appended to the current transaction's `response`.
+		def append!(name, resource_class = nil, options = {})
+			Transaction.new(@server, @query, name, resource_class || @resource_class, @response, options).process
+		end
+		
+		# Use the given resolver to respond to the question. Uses `passthrough` to do the lookup and merges the result.
+		#
+		# If a block is supplied, this function yields with the `response` message if successful. This could be used, for example, to update a cache or modify the reply.
+		#
+		# If recursion is not requested, the result is `fail!(:Refused)`. This check is ignored if an explicit `options[:name]` or `options[:force]` is given.
+		#
+		# If the resolver can't reach upstream servers, `fail!(:ServFail)` is invoked.
+		def passthrough!(resolver, options = {}, &block)
+			if @query.rd || options[:force] || options[:name]
+				response = passthrough(resolver, options)
+				
+				if response
+					yield response if block_given?
+					
+					# Recursion is available and is being used:
+					# See issue #26 for more details.
+					@response.ra = 1
+					@response.merge!(response)
+				else
+					fail!(:ServFail)
+				end
+			else
+				fail!(:Refused)
+			end
+		end
+		
+		# Use the given resolver to respond to the question.
+		# 
+		# A block must be supplied, and provided a valid response is received from the upstream server, this function yields with the reply and reply_name.
+		#
+		# If `options[:name]` is provided, this overrides the default query name sent to the upstream server. The same logic applies to `options[:resource_class]`.
+		def passthrough(resolver, options = {})
+			query_name = options[:name] || name
+			query_resource_class = options[:resource_class] || resource_class
+			
+			resolver.query(query_name, query_resource_class)
+		end
+		
+		# Respond to the given query with a resource record. The arguments to this function depend on the `resource_class` requested. This function instantiates the resource class with the supplied arguments, and then passes it to {#append!}.
+		#
+		# e.g. For A records: `respond!("1.2.3.4")`, For MX records:  `respond!(10, Name.create("mail.blah.com"))`
+		
+		# The last argument can optionally be a hash of `options`. If `options[:resource_class]` is provided, it overrides the default resource class of transaction. Additional `options` are passed to {#append!}.
+		#
+		# See `Resolv::DNS::Resource` for more information about the various `resource_classes` available (http://www.ruby-doc.org/stdlib/libdoc/resolv/rdoc/index.html).
+		def respond!(*args)
+			append_question!
+			
+			options = args.last.kind_of?(Hash) ? args.pop : {}
+			resource_class = options[:resource_class] || @resource_class
+			
+			if resource_class == nil
+				raise ArgumentError.new("Could not instantiate resource #{resource_class}!")
+			end
+			
+			resource = resource_class.new(*args)
+			
+			add([resource], options)
+		end
+		
+		# Append a list of resources.
+		#
+		# By default resources are appended to the `answers` section, but this can be changed by setting `options[:section]` to either `:authority` or `:additional`.
+		#
+		# The time-to-live (TTL) of the resources can be specified using `options[:ttl]` and defaults to `DEFAULT_TTL`.
+		def add(resources, options = {})
+			# Use the default options if provided:
+			options = options.merge(@options)
+			
+			ttl = options[:ttl] || DEFAULT_TTL
+			name = options[:name] || @question.to_s + "."
+			
+			section = (options[:section] || 'answer').to_sym
+			method = "add_#{section}".to_sym
+			
+			resources.each do |resource|
+				@server.logger.debug "#{method}: #{resource.inspect} #{resource.class::TypeValue} #{resource.class::ClassValue}"
+				
+				@response.send(method, name, ttl, resource)
+			end
+		end
+		
+		# This function indicates that there was a failure to resolve the given question. The single argument must be an integer error code, typically given by the constants in {Resolv::DNS::RCode}.
+		#
+		# The easiest way to use this function it to simply supply a symbol. Here is a list of the most commonly used ones:
+		#
+		# - `:NoError`: No error occurred.
+		# - `:FormErr`: The incoming data was not formatted correctly.
+		# - `:ServFail`: The operation caused a server failure (internal error, etc).
+		# - `:NXDomain`: Non-eXistant Domain (domain record does not exist).
+		# - `:NotImp`: The operation requested is not implemented.
+		# - `:Refused`: The operation was refused by the server.
+		# - `:NotAuth`: The server is not authoritive for the zone.
+		#
+		# See [RFC2929](http://www.rfc-editor.org/rfc/rfc2929.txt) for more information about DNS error codes (specifically, page 3).
+		#
+		# **This function will complete deferred transactions.**
+		def fail!(rcode)
+			append_question!
+			
+			if rcode.kind_of? Symbol
+				@response.rcode = Resolv::DNS::RCode.const_get(rcode)
+			else
+				@response.rcode = rcode.to_i
+			end
+		end
+		
+		# @deprecated
+		def failure!(*args)
+			@server.logger.warn "failure! is deprecated, use fail! instead"
+			
+			fail!(*args)
+		end
+		
+		# A helper method to process the transaction on the given server. Unless the transaction is deferred, it will {#succeed} on completion.
+		def process
+			@server.process(name, @resource_class, self)
+		end
+		
+		protected
+		
+		# A typical response to a DNS request includes both the question and response. This helper appends the question unless it looks like the user is already managing that aspect of the response.
+		def append_question!
+			if @response.question.size == 0
+				@response.add_question(@question, @resource_class)
+			end
+		end
+	end
+end