rubydns 0.6.0 → 2.0.0

data/lib/rubydns/resolver.rb

@@ -1,239 +0,0 @@
-# Copyright, 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 'rubydns/message'
-
-module RubyDNS
-	class InvalidProtocolError < StandardError
-	end
-	
-	class ResolutionFailure < StandardError
-	end
-	
-	class Resolver
-		# Servers are specified in the same manor as options[:listen], e.g.
-		#   [:tcp/:udp, address, port]
-		# In the case of multiple servers, they will be checked in sequence.
-		def initialize(servers, options = {})
-			@servers = servers
-			@sequence = 0
-			
-			@options = options
-		end
-
-		# Provides the next sequence identification number which is used to keep track of DNS messages.
-		def next_id!
-			return (@sequence += 1)
-		end
-
-		# Look up a named resource of the given resource_class.
-		def query(name, resource_class = Resolv::DNS::Resource::IN::A, &block)
-			message = Resolv::DNS::Message.new(next_id!)
-			message.rd = 1
-			message.add_question name, resource_class
-			
-			Request.fetch(message, @servers, @options, &block)
-		end
-
-		# Yields a list of `Resolv::IPv4` and `Resolv::IPv6` addresses for the given `name` and `resource_class`.
-		def addresses_for(name, resource_class = Resolv::DNS::Resource::IN::A, &block)
-			query(name, resource_class) do |response|
-				# Resolv::DNS::Name doesn't retain the trailing dot.
-				name = name.sub(/\.$/, '')
-				
-				case response
-				when Message
-					yield response.answer.select{|record| record[0].to_s == name}.collect{|record| record[2].address}
-				else
-					yield []
-				end
-			end
-		end
-
-		# Manages a single DNS question message across one or more servers.
-		class Request
-			include EventMachine::Deferrable
-			
-			def self.fetch(*args)
-				request = self.new(*args)
-				
-				request.callback do |message|
-					yield message
-				end
-				
-				request.errback do |error|
-					yield error
-				end
-				
-				request.run!
-			end
-			
-			def initialize(message, servers, options = {}, &block)
-				@message = message
-				@packet = message.encode
-				
-				@servers = servers.dup
-				
-				# We select the protocol based on the size of the data:
-				if @packet.bytesize > UDP_TRUNCATION_SIZE
-					@servers.delete_if{|server| server[0] == :udp}
-				end
-				
-				# Measured in seconds:
-				@timeout = options[:timeout] || 5
-				
-				@logger = options[:logger]
-			end
-			
-			attr :message
-			attr :packet
-			attr :logger
-			
-			def run!
-				try_next_server!
-			end
-			
-			def process_response!(response)
-				if Exception === response
-					@logger.warn "[#{@message.id}] Failure while processing response #{exception}!" if @logger
-					RubyDNS.log_exception(@logger, response) if @logger
-					
-					try_next_server!
-				elsif response.tc != 0
-					@logger.warn "[#{@message.id}] Received truncated response!" if @logger
-					
-					try_next_server!
-				elsif response.id != @message.id
-					@logger.warn "[#{@message.id}] Received response with incorrect message id: #{response.id}" if @logger
-					
-					try_next_server!
-				else
-					@logger.warn "[#{@message.id}] Received valid response #{response.inspect}" if @logger
-					
-					succeed response
-				end
-			end
-			
-			private
-			
-			def try_next_server!
-				if @request
-					@request.close_connection
-					@request = nil
-				end
-				
-				if @servers.size > 0
-					@server = @servers.shift
-					
-					@logger.debug "[#{@message.id}] Sending request to server #{@server.inspect}" if @logger
-					
-					# We make requests one at a time to the given server, naturally the servers are ordered in terms of priority.
-					case @server[0]
-					when :udp
-						@request = UDPRequestHandler.open(@server[1], @server[2], self)
-					when :tcp
-						@request = TCPRequestHandler.open(@server[1], @server[2], self)
-					else
-						raise InvalidProtocolError.new(@server)
-					end
-					
-					# Setting up the timeout...
-					EventMachine::Timer.new(@timeout) do
-						@logger.debug "[#{@message.id}] Request timed out!" if @logger
-						
-						try_next_server!
-					end
-				else
-					fail ResolutionFailure.new("No available servers responded to the request.")
-				end
-			end
-			
-			module UDPRequestHandler
-				def self.open(host, port, request)
-					# Open a datagram socket... EventMachine doesn't support connected datagram sockets, so we have to cheat a bit:
-					EventMachine::open_datagram_socket('', 0, self, request, host, port)
-				end
-				
-				def initialize(request, host, port)
-					@request = request
-					@host = host
-					@port = port
-				end
-				
-				def post_init
-					# Sending question to remote DNS server...
-					send_datagram(@request.packet, @host, @port)
-				end
-				
-				def receive_data(data)
-					# Receiving response from remote DNS server...
-					message = RubyDNS::decode_message(data)
-						
-					# The message id must match, and it can't be truncated:
-					@request.process_response!(message)
-				rescue Resolv::DNS::DecodeError => error
-					@request.process_response!(error)
-				end
-			end
-			
-			module TCPRequestHandler
-				def self.open(host, port, request)
-					EventMachine::connect(host, port, TCPRequestHandler, request)
-				end
-				
-				def initialize(request)
-					@request = request
-					@buffer = nil
-					@length = nil
-				end
-				
-				def post_init
-					data = @request.packet
-					
-					send_data([data.bytesize].pack('n'))
-					send_data data
-				end
-				
-				def receive_data(data)
-					# We buffer data until we've received the entire packet:
-					@buffer ||= BinaryStringIO.new
-					@buffer.write(data)
-
-					if @length == nil
-						if @buffer.size > 2
-							@length = @buffer.string.byteslice(0, 2).unpack('n')[0]
-						end
-					end
-
-					# If we have received more data than expected, should this be an error?
-					if @buffer.size >= (@length + 2)
-						data = @buffer.string.byteslice(2, @length)
-						
-						message = RubyDNS::decode_message(data)
-						
-						@request.process_response!(message)
-					end
-				rescue Resolv::DNS::DecodeError => error
-					@request.process_response!(error)
-				end
-			end
-		end
-	end
-end

data/lib/rubydns/server.rb

@@ -1,241 +0,0 @@
-# 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 'rubydns/transaction'
-require 'rubydns/extensions/logger'
-
-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
-		class Rule
-			def initialize(pattern, callback)
-				@pattern = pattern
-				@callback = callback
-			end
-			
-			def match(name, resource_class)
-				# If the pattern doesn't specify any resource classes, we implicitly pass this test:
-				return true if @pattern.size < 2
-				
-				# Otherwise, we try to match against some specific resource classes:
-				if Class === @pattern[1]
-					@pattern[1] == resource_class
-				else
-					@pattern[1].include?(resource_class) rescue false
-				end
-			end
-			
-			def call(server, name, resource_class, *args)
-				unless match(name, resource_class)
-					server.logger.debug "Resource class #{resource_class} failed to match #{@pattern[1].inspect}!"
-					
-					return false
-				end
-				
-				# Match succeeded against name?
-				case @pattern[0]
-				when Regexp
-					match_data = @pattern[0].match(name)
-					if match_data
-						server.logger.debug "Regexp pattern matched with #{match_data.inspect}."
-						return @callback[*args, match_data]
-					end
-				when String
-					if @pattern[0] == name
-						server.logger.debug "String pattern matched."
-						return @callback[*args]
-					end
-				else
-					if (@pattern[0].call(name, resource_class) rescue false)
-						server.logger.debug "Callable pattern matched."
-						return @callback[*args]
-					end
-				end
-				
-				server.logger.debug "No pattern matched."
-				# We failed to match the pattern.
-				return false
-			end
-			
-			def to_s
-				@pattern.inspect
-			end
-		end
-		
-		# 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(&block)
-			@events = {}
-			@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", IN::MX)
-		#   match(/g?mail.(com|org|net)/, [IN::MX, IN::A])
-		#
-		def match(*pattern, &block)
-			@rules << Rule.new(pattern, 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] = 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).
-		#
-		#   otherwise do |transaction|
-		#     transaction.passthrough!($R)
-		#   end
-		#
-		def otherwise(&block)
-			@otherwise = block
-		end
-
-		def next!
-			throw :next
-		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, resource_class, *args)
-			@logger.debug "Searching for #{name} #{resource_class.name}"
-
-			@rules.each do |rule|
-				@logger.debug "Checking rule #{rule}..."
-
-				catch (:next) do
-					# If the rule returns true, we assume that it was successful and no further rules need to be evaluated.
-					return true if rule.call(self, name, resource_class, *args)
-				end
-			end
-
-			if @otherwise
-				@otherwise.call(*args)
-			else
-				@logger.warn "Failed to handle #{name} #{resource_class.name}!"
-			end
-		end
-
-		# Process an incoming DNS message. Returns a serialized message to be
-		# sent back to the client.
-		def process_query(query, options = {}, &block)
-			# 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
-
-			# 1/ This chain contains a reverse list of question lambdas.
-			chain = []
-
-			# 4/ Finally, the answer is given back to the calling block:
-			chain << lambda do
-				@logger.debug "Passing answer back to caller..."
-				yield answer
-			end
-
-			# There may be multiple questions per query
-			query.question.reverse.each do |question, resource_class|
-				next_link = chain.last
-
-				chain << lambda do
-					@logger.debug "Processing question #{question} #{resource_class}..."
-
-					transaction = Transaction.new(self, query, question, resource_class, answer, options)
-					
-					# Call the next link in the chain:
-					transaction.callback do
-						# 3/ ... which calls the previous item in the chain, i.e. the next question to be answered:
-						next_link.call
-					end
-
-					# If there was an error, log it and fail:
-					transaction.errback do |response|
-						if Exception === response
-							@logger.error "Exception thrown while processing #{transaction}!"
-							RubyDNS.log_exception(@logger, response)
-						else
-							@logger.error "Failure while processing #{transaction}!"
-							@logger.error "#{response.inspect}"
-						end
-
-						answer.rcode = Resolv::DNS::RCode::ServFail
-
-						chain.first.call
-					end
-					
-					begin
-						# Transaction.process will call succeed if it wasn't deferred:
-						transaction.process
-					rescue
-						transaction.fail($!)
-					end
-				end
-			end
-
-			# 2/ We call the last lambda...
-			chain.last.call
-		end
-	end
-end

data/lib/rubydns/system.rb

@@ -1,146 +0,0 @@
-# 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 RubyDNS
-	# 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