rubydns 0.1.8

data/lib/rubydns.rb

@@ -0,0 +1,108 @@
+# Copyright (c) 2009 Samuel Williams. Released under the GNU GPLv3.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+# Thanks to "jmorgan" who provided some basic ideas for how to do this
+# using Ruby: http://half-penny.org/computing/simple-ruby-dns-server
+
+require 'rubydns/version'
+require 'rubydns/resolv'
+require 'rubydns/server'
+
+require 'logger'
+
+require 'rexec'
+require 'rexec/daemon'
+
+module RubyDNS
+	
+	# Run a server with the given rules. A number of options can be supplied:
+	#
+	# <tt>:interfaces</tt>:: A set of sockets or addresses as defined below.
+	#
+	# One important feature of DNS is the port it runs on. The <tt>options[:listen]</tt>
+	# allows you to specify a set of network interfaces and ports to run the server on. This
+	# must be a list of <tt>[protocol, interface address, port]</tt>.
+	# 
+	#   INTERFACES = [[:udp, "0.0.0.0", 5300]]
+	#   RubyDNS::run_server(:listen => INTERFACES) do
+	#     ...
+	#   end
+	#
+	# You can specify already connected sockets if need be:
+	#
+	#   socket = UDPSocket.new; socket.bind("0.0.0.0", 53)
+	#   Process::Sys.setuid(server_uid)
+	#   INTERFACES = [socket]
+	#
+	# The default interface is <tt>[[:udp, "0.0.0.0", 53]]</tt>. The server typically needs
+	# to run as root for this to work, since port 53 is privileged.
+	#
+	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
+		
+		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
+				end
+			end
+		rescue Interrupt
+			server.logger.info "Server interrupted - stopping #{threads.list.size} request(s)."
+			threads.list.each { |thr| thr.join }
+		end
+	end
+end
+

data/lib/rubydns/resolv.rb

@@ -0,0 +1,76 @@
+# Copyright (c) 2009 Samuel Williams. Released under the GNU GPLv3.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+# Resolv rdoc
+# http://www.ruby-doc.org/stdlib/libdoc/resolv/rdoc/index.html
+
+require 'resolv'
+
+class Resolv
+	class DNS
+		# Queries the given DNS server and returns its response in its entirety. 
+		# This allows such responses to be passed upstream with little or no
+		# modification/reinterpretation.
+		def query(name, typeclass)
+			lazy_initialize
+			requester = make_requester
+			senders = {}
+			begin
+				@config.resolv(name) {|candidate, tout, nameserver|
+					msg = Message.new
+					msg.rd = 1
+					msg.add_question(candidate, typeclass)
+					unless sender = senders[[candidate, nameserver]]
+						sender = senders[[candidate, nameserver]] =
+						requester.sender(msg, candidate, nameserver)
+					end
+					reply, reply_name = requester.request(sender, tout)
+
+					return reply, reply_name
+				}
+			ensure
+				requester.close
+			end
+		end
+
+		class Message
+			# Merge the given message with this message. A number of heuristics are
+			# applied in order to ensure that the result makes sense. For example,
+			# If the current message is not recursive but is being merged with a
+			# message that was recursive, this bit is maintained. If either message
+			# is authoritive, then the result is also authoritive.
+			#
+			# Modifies the current message in place.
+			def merge! (other)
+				# Authoritive Answer
+				@aa = @aa && other.aa
+
+				@additional += other.additional
+				@answer += other.answer
+				@authority += other.authority
+				@question += other.question
+
+				# Recursion Available
+				@ra = @ra || other.ra
+
+				# Result Code (Error Code)
+				@rcode = other.rcode unless other.rcode == 0
+
+				# Recursion Desired
+				@rd = @rd || other.rd
+			end
+		end
+	end
+end

data/lib/rubydns/server.rb

@@ -0,0 +1,170 @@
+# Copyright (c) 2009 Samuel Williams. Released under the GNU GPLv3.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'rubydns/transaction'
+
+module RubyDNS
+	
+	# This class provides the core of the DSL. It contains a list of rules which
+	# are used to match against incoming DNS questions. These rules are used to
+	# generate responses which are either DNS resource records or failures.
+	class Server
+		
+		# Instantiate a server with a block
+		#
+		#   server = Server.new do
+		#     match(/server.mydomain.com/, :A) do |transaction|
+		#       transaction.respond!("1.2.3.4")
+		#     end
+		#   end
+		#
+		def initialize(&block)
+			@rules = []
+			@otherwise = nil
+
+			@logger = Logger.new($stderr)
+
+			if block_given?
+				instance_eval &block
+			end
+		end
+
+		attr :logger, true
+
+		# This function connects a pattern with a block. A pattern is either
+		# a String or a Regex instance. Optionally, a second argument can be
+		# provided which is either a String, Symbol or Array of resource record
+		# types which the rule matches against.
+		# 
+		#   match("www.google.com")
+		#   match("gmail.com", :MX)
+		#   match(/g?mail.(com|org|net)/, [:MX, :A])
+		#
+		def match (*pattern, &block)
+			# Normalize pattern
+			case pattern[1]
+			when nil
+				# Do nothing
+			when String
+				pattern[1] = pattern[1].upcase
+			when Symbol
+				pattern[1] = pattern[1].to_s.upcase
+			when Array
+				pattern[1] = pattern[1].collect { |v| v.to_s.upcase }
+			end
+
+			@rules << [pattern, Proc.new(&block)]
+		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).
+		#
+		#   otherwise do |transaction|
+		#     transaction.passthrough!($R)
+		#   end
+		#
+		def otherwise(&block)
+			@otherwise = Proc.new(&block)
+		end
+
+		# Give a name and a record type, try to match a rule and use it for
+		# processing the given arguments.
+		#
+		# If a rule returns false, it is considered that the rule failed and
+		# futher matching is carried out.
+		def process(name, record_type, *args)
+			@logger.debug "Searching for #{name} #{record_type}"
+
+			@rules.each do |rule|
+				@logger.debug "Checking rule #{rule[0].inspect}..."
+				
+				pattern = rule[0]
+
+				# Match failed against record_type?
+				case pattern[1]
+				when String
+					next if pattern[1] != record_type
+					@logger.debug "Resource type #{record_type} matched"
+				when Array
+					next if pattern[1].include?(record_type)
+					@logger.debug "Resource type #{record_type} matched #{pattern[1].inspect}"
+				end
+
+				# Match succeeded against name?
+				case pattern[0]
+				when Regexp
+					match_data = pattern[0].match(name)
+					if match_data
+						@logger.debug "Query #{name} matched #{pattern[0].to_s} with result #{match_data.inspect}"
+						if rule[1].call(match_data, *args)
+							@logger.debug "Rule returned successfully"
+							return
+						end
+					else
+						@logger.debug "Query #{name} failed to match against #{pattern[0].to_s}"
+					end
+				when String
+					if pattern[0] == name
+						@logger.debug "Query #{name} matched #{pattern[0]}"
+						if rule[1].call(*args)
+							@logger.debug "Rule returned successfully"
+							return
+						end
+					else
+						@logger.debug "Query #{name} failed to match against #{pattern[0]}"
+					end
+				end
+			end
+
+			if @otherwise
+				@otherwise.call(*args)
+			else
+				@logger.warn "Failed to handle #{name} #{record_type}!"
+			end
+		end
+
+		# Process an incoming DNS message. Returns a serialized message to be
+		# sent back to the client.
+		def receive_data(data)
+			query = Resolv::DNS::Message::decode(data)
+
+			# Setup answer
+			answer = Resolv::DNS::Message::new(query.id)
+			answer.qr = 1                 # 0 = Query, 1 = Response
+			answer.opcode = query.opcode  # Type of Query; copy from query
+			answer.aa = 1                 # Is this an authoritative response: 0 = No, 1 = Yes
+			answer.rd = query.rd          # Is Recursion Desired, copied from query
+			answer.ra = 0                 # Does name server support recursion: 0 = No, 1 = Yes
+			answer.rcode = 0              # Response code: 0 = No errors
+
+			query.each_question do |question, resource_class|    # There may be multiple questions per query
+				transaction = Transaction.new(self, query, question, resource_class, answer)
+
+				begin
+					transaction.process
+				rescue
+					@logger.error "Exception thrown while processing #{transaction}!"
+					@logger.error "#{$!.class}: #{$!.message}"
+					$!.backtrace.each { |at| @logger.error at }
+
+					answer.rcode = Resolv::DNS::RCode::ServFail
+				end
+			end
+
+			return answer.encode
+		end
+	end
+end

data/lib/rubydns/transaction.rb

@@ -0,0 +1,208 @@
+# Copyright (c) 2009 Samuel Williams. Released under the GNU GPLv3.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+module RubyDNS
+	
+	# Turn a symbol or string name into a resource class. For example,
+	# convert <tt>:A</tt> into <tt>Resolv::DNS::Resource::IN::A</tt>
+	def self.lookup_resource_class(klass)
+		return nil if klass == nil
+		
+		if Symbol === klass
+			klass = klass.to_s
+		end
+		
+		if String === klass
+			if Resolv::DNS::Resource.const_defined?(klass)
+				return Resolv::DNS::Resource.const_get(klass)
+			elsif Resolv::DNS::Resource::IN.const_defined?(klass)
+				return Resolv::DNS::Resource::IN.const_get(klass)
+			end
+		end
+		
+		return klass
+	end
+	
+	# This class provides all details of a single DNS question and answer. This
+	# is used by the DSL to provide DNS related functionality.
+	class Transaction
+		def initialize(server, query, question, resource_class, answer)
+			@server = server
+			@query = query
+			@question = question
+			@resource_class = resource_class
+			@answer = answer
+
+			@question_appended = false
+		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 answer to the incoming query.
+		attr :answer
+
+		# Return the type of record (eg. <tt>A</tt>, <tt>MX</tt>) as a <tt>String</tt>.
+		def record_type
+			@resource_class.name.split("::").last
+		end
+
+		# Return the name of the question, which is typically the requested hostname.
+		def name
+			@question.to_s
+		end
+
+		# Suitable for debugging purposes
+		def to_s
+			"#{name} #{record_type}"
+		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 transactions <tt>answer</tt>.
+		def append_query!(name, resource_type = nil)
+			Transaction.new(@server, @query, name, RubyDNS.lookup_resource_class(resource_type) || @resource_class, @answer).process
+		end
+
+		def process
+			@server.process(name, record_type, self)
+		end
+
+		# Use the given resolver to respond to the question. This will <tt>query</tt>
+		# the resolver and <tt>merge!</tt> the answer if one is received. If recursion is
+		# not requested, the result is <tt>failure!(:Refused)</tt>. If the resolver does
+		# not respond, the result is <tt>failure!(:NXDomain)</tt>
+		#
+		# If a block is supplied, this function yields with the reply and reply_name if
+		# successful. This could be used, for example, to update a cache.
+		def passthrough! (resolver, &block)
+			# Were we asked to recursively find this name?
+			if @query.rd
+				reply, reply_name = resolver.query(name, resource_class)
+
+				if reply
+					if block_given?
+						yield(reply, reply_name)
+					end
+
+					@answer.merge!(reply)
+				else
+					failure!(:NXDomain)
+				end
+			else
+				failure!(:Refused)
+			end
+
+			true
+		end
+
+		# Respond to the given query with a resource record. The arguments to this
+		# function depend on the <tt>resource_class</tt> requested. The last argument
+		# can optionally be a hash of options.
+		#
+		# <tt>options[:resource_class]</tt>:: Override the default <tt>resource_class</tt>
+		# <tt>options[:ttl]</tt>:: Specify the TTL for the resource
+		# <tt>options[:name]</tt>:: Override the name (question) of the response.
+		#
+		# for A records:: <tt>respond!("1.2.3.4")</tt>
+		# for MX records::  <tt>respond!("mail.blah.com", 10)</tt>
+		#
+		# This function instantiates the resource class with the supplied arguments, and
+		# then passes it to <tt>append!</tt>.
+		#
+		# See <tt>Resolv::DNS::Resource</tt> for more information about the various 
+		# <tt>resource_class</tt>s available. 
+		# http://www.ruby-doc.org/stdlib/libdoc/resolv/rdoc/index.html
+		def respond! (*data)
+			options = data.last.kind_of?(Hash) ? data.pop : {}
+			
+			case options[:resource_class]
+			when nil
+				append!(@resource_class.new(*data), options)
+			when Class
+				append!(options[:resource_class].new(*data), options)
+			else
+				raise ArgumentError, "Could not instantiate resource!"
+			end
+		end
+
+		# Append a given set of resources to the answer. The last argument can 
+		# optionally be a hash of options.
+		# 
+		# <tt>options[:ttl]</tt>:: Specify the TTL for the resource
+		# <tt>options[:name]</tt>:: Override the name (question) of the response.
+		# 
+		# This function can be used to supply multiple responses to a given question.
+		# For example, each argument is expected to be an instantiated resource from
+		# <tt>Resolv::DNS::Resource</tt> module.
+		def append! (*resources)
+			append_question!
+
+			options = resources.last.kind_of?(Hash) ? resources.pop.dup : {}
+			options[:ttl] ||= 16000
+			options[:name] ||= @question.to_s + "."
+
+			resources.each do |resource|
+				@answer.add_answer(options[:name], options[:ttl], resource)
+			end
+
+			@answer.encode
+
+			true
+		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 <tt>Resolv::DNS::RCode</tt>.
+		#
+		# The easiest way to use this function it to simply supply a symbol. Here is
+		# a list of the most commonly used ones:
+		#
+		# <tt>:NoError</tt>:: No error occurred.
+		# <tt>:FormErr</tt>::	The incoming data was not formatted correctly.
+		# <tt>:ServFail</tt>:: The operation caused a server failure (internal error, etc).
+		# <tt>:NXDomain</tt>:: Non-eXistant Domain (domain record does not exist).
+		# <tt>:NotImp</tt>:: The operation requested is not implemented.
+		# <tt>:Refused</tt>:: The operation was refused by the server.
+		# <tt>:NotAuth</tt>:: The server is not authoritive for the zone.
+		#
+		# See http://www.rfc-editor.org/rfc/rfc2929.txt for more information
+		# about DNS error codes (specifically, page 3).
+		def failure! (rcode)
+			append_question!
+
+			if rcode.kind_of? Symbol
+				@answer.rcode = Resolv::DNS::RCode.const_get(rcode)
+			else
+				@answer.rcode = rcode.to_i
+			end
+
+			true
+		end
+
+		protected
+		def append_question!
+			if @answer.question.size == 0
+				@answer.add_question(@question, @resource_class) unless @question_appended
+			end
+		end
+	end
+end