rubydns 1.0.3 → 2.0.0.pre.rc1

data/lib/rubydns/resolver.rb

@@ -1,294 +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_relative 'handler'
-
-require 'securerandom'
-require 'celluloid/io'
-
-module RubyDNS
-	class InvalidProtocolError < StandardError
-	end
-	
-	class InvalidResponseError < StandardError
-	end
-	
-	class ResolutionFailure < StandardError
-	end
-	
-	class Resolver
-		# Wait for up to 2 seconds for a response. Override with `options[:timeout]`
-		DEFAULT_TIMEOUT = 5.0
-		
-		# 10ms wait between making requests. Override with `options[:delay]`
-		DEFAULT_DELAY = 0.01
-		
-		# Try a given request 5 times before failing. Override with `options[:retries]`.
-		DEFAULT_RETRIES = 10
-		
-		include Celluloid::IO
-		
-		# 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
-			
-			@options = options
-			
-			@origin = options[:origin] || nil
-			
-			@logger = options[:logger] || Celluloid.logger
-		end
-		
-		attr_accessor :origin
-		
-		def fully_qualified_name(name)
-			# If we are passed an existing deconstructed name:
-			if Resolv::DNS::Name === name
-				if name.absolute?
-					return name
-				else
-					return name.with_origin(@origin)
-				end
-			end
-			
-			# ..else if we have a string, we need to do some basic processing:
-			if name.end_with? '.'
-				return Resolv::DNS::Name.create(name)
-			else
-				return Resolv::DNS::Name.create(name).with_origin(@origin)
-			end
-		end
-
-		# Provides the next sequence identification number which is used to keep track of DNS messages.
-		def next_id!
-			# Using sequential numbers for the query ID is generally a bad thing because over UDP they can be spoofed. 16-bits isn't hard to guess either, but over UDP we also use a random port, so this makes effectively 32-bits of entropy to guess per request.
-			SecureRandom.random_number(2**16)
-		end
-
-		# Look up a named resource of the given resource_class.
-		def query(name, resource_class = Resolv::DNS::Resource::IN::A)
-			message = Resolv::DNS::Message.new(next_id!)
-			message.rd = 1
-			message.add_question fully_qualified_name(name), resource_class
-			
-			dispatch_request(message)
-		end
-		
-		# Yields a list of `Resolv::IPv4` and `Resolv::IPv6` addresses for the given `name` and `resource_class`. Raises a ResolutionFailure if no severs respond.
-		def addresses_for(name, resource_class = Resolv::DNS::Resource::IN::A, options = {})
-			name = fully_qualified_name(name)
-			
-			cache = options.fetch(:cache, {})
-			retries = options.fetch(:retries, DEFAULT_RETRIES)
-			delay = options.fetch(:delay, DEFAULT_DELAY)
-			
-			records = lookup(name, resource_class, cache) do |name, resource_class|
-				response = nil
-				
-				retries.times do |i|
-					# Wait 10ms before trying again:
-					sleep delay if delay and i > 0
-					
-					response = query(name, resource_class)
-					
-					break if response
-				end
-				
-				response or abort ResolutionFailure.new("Could not resolve #{name} after #{retries} attempt(s).")
-			end
-			
-			addresses = []
-			
-			if records
-				records.each do |record|
-					if record.respond_to? :address
-						addresses << record.address
-					else
-						# The most common case here is that record.class is IN::CNAME and we need to figure out the address. Usually the upstream DNS server would have replied with this too, and this will be loaded from the response if possible without requesting additional information.
-						addresses += addresses_for(record.name, record.class, options.merge(cache: cache))
-					end
-				end
-			end
-			
-			if addresses.size > 0
-				return addresses
-			else
-				abort ResolutionFailure.new("Could not find any addresses for #{name}.")
-			end
-		end
-		
-		def request_timeout
-			@options[:timeout] || DEFAULT_TIMEOUT
-		end
-		
-		# Send the message to available servers. If no servers respond correctly, nil is returned. This result indicates a failure of the resolver to correctly contact any server and get a valid response.
-		def dispatch_request(message)
-			request = Request.new(message, @servers)
-			
-			request.each do |server|
-				@logger.debug "[#{message.id}] Sending request #{message.question.inspect} to server #{server.inspect}" if @logger
-				
-				begin
-					response = nil
-					
-					# This may be causing a problem, perhaps try:
-					# 	after(timeout) { socket.close }
-					# https://github.com/celluloid/celluloid-io/issues/121
-					timeout(request_timeout) do
-						response = try_server(request, server)
-					end
-					
-					if valid_response(message, response)
-						return response
-					end
-				rescue Task::TimeoutError
-					@logger.debug "[#{message.id}] Request timed out!" if @logger
-				rescue InvalidResponseError
-					@logger.warn "[#{message.id}] Invalid response from network: #{$!}!" if @logger
-				rescue DecodeError
-					@logger.warn "[#{message.id}] Error while decoding data from network: #{$!}!" if @logger
-				rescue IOError
-					@logger.warn "[#{message.id}] Error while reading from network: #{$!}!" if @logger
-				end
-			end
-			
-			return nil
-		end
-		
-		private
-		
-		# Lookup a name/resource_class record but use the records cache if possible reather than making a new request if possible.
-		def lookup(name, resource_class = Resolv::DNS::Resource::IN::A, records = {})
-			records.fetch(name) do
-				response = yield(name, resource_class)
-				
-				if response
-					response.answer.each do |name, ttl, record|
-						(records[name] ||= []) << record
-					end
-				end
-				
-				records[name]
-			end
-		end
-		
-		def try_server(request, server)
-			case server[0]
-			when :udp
-				try_udp_server(request, server[1], server[2])
-			when :tcp
-				try_tcp_server(request, server[1], server[2])
-			else
-				raise InvalidProtocolError.new(server)
-			end
-		end
-		
-		def valid_response(message, response)
-			if response.tc != 0
-				@logger.warn "[#{message.id}] Received truncated response!" if @logger
-			elsif response.id != message.id
-				@logger.warn "[#{message.id}] Received response with incorrect message id: #{response.id}!" if @logger
-			else
-				@logger.debug "[#{message.id}] Received valid response with #{response.answer.count} answer(s)." if @logger
-				
-				return true
-			end
-			
-			return false
-		end
-		
-		def try_udp_server(request, host, port)
-			family = RubyDNS::address_family(host)
-			socket = UDPSocket.new(family)
-			
-			socket.send(request.packet, 0, host, port)
-			
-			data, (_, remote_port) = socket.recvfrom(UDP_TRUNCATION_SIZE, 0)
-			# Need to check host, otherwise security issue.
-			
-			# May indicate some kind of spoofing attack:
-			if port != remote_port
-				raise InvalidResponseError.new("Data was not received from correct remote port (#{port} != #{remote_port})")
-			end
-			
-			message = RubyDNS::decode_message(data)
-		ensure
-			socket.close if socket
-		end
-		
-		def try_tcp_server(request, host, port)
-			begin
-				socket = TCPSocket.new(host, port)
-			rescue Errno::EALREADY
-				# This is a hack to work around faulty behaviour in celluloid-io:
-				# https://github.com/celluloid/celluloid/issues/436
-				raise IOError.new("Could not connect to remote host!")
-			end
-			
-			StreamTransport.write_chunk(socket, request.packet)
-			
-			input_data = StreamTransport.read_chunk(socket)
-			
-			message = RubyDNS::decode_message(input_data)
-		rescue Errno::ECONNREFUSED => error
-			raise IOError.new(error.message)
-		rescue Errno::EPIPE => error
-			raise IOError.new(error.message)
-		rescue Errno::ECONNRESET => error
-			raise IOError.new(error.message)
-		ensure
-			socket.close if socket
-		end
-		
-		# Manages a single DNS question message across one or more servers.
-		class Request
-			def initialize(message, servers)
-				@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
-			end
-			
-			attr :message
-			attr :packet
-			attr :logger
-			
-			def each(&block)
-				@servers.each do |server|
-					next if @packet.bytesize > UDP_TRUNCATION_SIZE
-					
-					yield server
-				end
-			end
-
-			def update_id!(id)
-				@message.id = id
-				@packet = @message.encode
-			end
-		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

data/lib/rubydns/transaction.rb

@@ -1,204 +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.
-
-module RubyDNS
-	
-	# 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
-			
-			@server.logger.info "Resource class: #{resource_class.inspect}"
-			resource = resource_class.new(*args)
-			@server.logger.info "Resource: #{resource.inspect}"
-			
-			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