async-dns 1.2.6 → 1.4.0

data/lib/async/dns/resolver.rb

@@ -1,115 +1,138 @@
-# 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.
+# frozen_string_literal: true
 
-require_relative 'handler'
+# Released under the MIT License.
+# Copyright, 2015-2024, by Samuel Williams.
+# Copyright, 2017, by Olle Jonsson.
+# Copyright, 2024, by Sean Dilda.
 
-require 'securerandom'
-require 'async'
+require_relative "handler"
+require_relative "system"
+require_relative "cache"
+
+require "securerandom"
+require "async"
+
+require "io/endpoint/composite_endpoint"
+require "io/endpoint/host_endpoint"
 
 module Async::DNS
+	# Represents a DNS connection which we don't know how to use.
 	class InvalidProtocolError < StandardError
 	end
 	
-	class InvalidResponseError < StandardError
-	end
-	
+	# Represents a failure to resolve a given name to an address.
 	class ResolutionFailure < StandardError
 	end
 	
+	# Resolve names to addresses using the DNS protocol.
 	class Resolver
-		# Wait for up to 5 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 10 times before failing. Override with `options[:retries]`.
-		DEFAULT_RETRIES = 10
+		# The default resolver for the system.
+		def self.default(**options)
+			System.resolver(**options)
+		end
 		
 		# 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(endpoints, origin: nil, logger: Console.logger, timeout: DEFAULT_TIMEOUT)
-			@endpoints = endpoints
+		def initialize(endpoint, ndots: 1, search: nil, origin: nil, cache: Cache.new, **options) 
+			@endpoint = endpoint
+			
+			@ndots = ndots
+			if search
+				@search = search
+			else
+				@search = [nil]
+			end
+			
+			if origin
+				@search = [origin] + @search
+			end
 			
-			@origin = origin
-			@logger = logger
-			@timeout = timeout
+			@cache = cache
+			@options = options
 		end
 		
-		attr_accessor :origin
+		# The search domains, which are used to generate fully qualified names if required.
+		attr :search
 		
-		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
+		# Generates a fully qualified name from a given name.
+		#
+		# @parameter name [String | Resolv::DNS::Name] The name to fully qualify.
+		def fully_qualified_names(name)
+			return to_enum(:fully_qualified_names, name) unless block_given?
+			
+			name = Resolv::DNS::Name.create(name)
 			
-			# ..else if we have a string, we need to do some basic processing:
-			if name.end_with? '.'
-				return Resolv::DNS::Name.create(name)
+			if name.absolute?
+				yield name
 			else
-				return Resolv::DNS::Name.create(name).with_origin(@origin)
+				if @ndots <= name.length - 1
+					yield name
+				end
+				
+				@search.each do |domain|
+					yield name.with_origin(domain)
+				end
 			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.
+		
+		# Query a named resource and return the response.
+		#
+		# Bypasses the cache and always makes a new request.
+		#
+		# @returns [Resolv::DNS::Message] The response from the server.
 		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
+			response = nil
 			
-			dispatch_request(message)
+			self.fully_qualified_names(name) do |fully_qualified_name|
+				response = self.dispatch_query(fully_qualified_name, resource_class)
+				
+				break if response.rcode == Resolv::DNS::RCode::NoError
+			end
+			
+			return response
 		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)
+		# Look up a named resource of the given resource_class.
+		def records_for(name, resource_classes)
+			Console.debug(self) {"Looking up records for #{name.inspect} with #{resource_classes.inspect}."}
+			resource_classes = Array(resource_classes)
+			resources = nil
 			
-			records = lookup(name, resource_class, cache) do |lookup_name, lookup_resource_class|
-				response = nil
-				
-				retries.times do |i|
-					# Wait 10ms before trying again:
-					sleep delay if delay and i > 0
-					
-					response = query(lookup_name, lookup_resource_class)
-					
-					break if response
+			self.fully_qualified_names(name) do |fully_qualified_name|
+				resources = @cache.fetch(fully_qualified_name, resource_classes) do |name, resource_class|
+					if response = self.dispatch_query(name, resource_class)
+						response.answer.each do |name, ttl, record|
+							Console.debug(self) {"Caching record for #{name.inspect} with #{record.class} and TTL #{ttl}."}
+							@cache.store(name, resource_class, record)
+						end
+					end
 				end
 				
-				response or raise ResolutionFailure.new("Could not resolve #{name} after #{retries} attempt(s).")
+				break if resources.any?
+			end
+			
+			return resources
+		end
+		
+		if System.ipv6?
+			ADDRESS_RESOURCE_CLASSES = [Resolv::DNS::Resource::IN::A, Resolv::DNS::Resource::IN::AAAA]
+		else
+			ADDRESS_RESOURCE_CLASSES = [Resolv::DNS::Resource::IN::A]
+		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_classes = ADDRESS_RESOURCE_CLASSES)
+			records = self.records_for(name, resource_classes)
+			
+			if records.empty?
+				raise ResolutionFailure.new("Could not find any records for #{name.inspect}!")
 			end
 			
 			addresses = []
@@ -119,74 +142,60 @@ module Async::DNS
 					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))
+						# 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, resource_classes)
 					end
 				end
 			end
 			
-			if addresses.size > 0
-				return addresses
-			else
-				raise ResolutionFailure.new("Could not find any addresses for #{name}.")
+			if addresses.empty?
+				raise ResolutionFailure.new("Could not find any addresses for #{name.inspect}!")
 			end
+			
+			return addresses
+		end
+		
+		private
+		
+		# In general, DNS servers are only able to handle a single question at a time. This method is used to dispatch a single query to the server and wait for a response.
+		def dispatch_query(name, resource_class)
+			message = Resolv::DNS::Message.new(self.next_id!)
+			message.rd = 1
+			
+			message.add_question(name, resource_class)
+			
+			return dispatch_request(message)
 		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, task: Async::Task.current)
-			request = Request.new(message, @endpoints)
+		def dispatch_request(message)
+			request = Request.new(message, @endpoint)
+			error = nil
 			
 			request.each do |endpoint|
-				@logger.debug "[#{message.id}] Sending request #{message.question.inspect} to address #{endpoint.inspect}" if @logger
+				Console.debug "[#{message.id}] Sending request #{message.question.inspect} to address #{endpoint.inspect}"
 				
 				begin
-					response = nil
-					
-					task.with_timeout(@timeout) do
-						@logger.debug "[#{message.id}] -> Try address #{endpoint}" if @logger
-						response = try_server(request, endpoint)
-						@logger.debug "[#{message.id}] <- Try address #{endpoint} = #{response}" if @logger
-					end
+					response = try_server(request, endpoint)
 					
 					if valid_response(message, response)
 						return response
 					end
-				rescue Async::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, Errno::ECONNRESET
-					@logger.warn "[#{message.id}] Error while reading from network: #{$!}!" if @logger
-				rescue EOFError
-					@logger.warn "[#{message.id}] Could not read complete response from network: #{$!}" if @logger
+				rescue => error
+					# Try the next server.
 				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_in_answer, ttl, record|
-						(records[name_in_answer] ||= []) << record
-					end
-				end
-				
-				records[name]
+			if error
+				raise error
 			end
+			
+			return nil
 		end
 		
 		def try_server(request, endpoint)
 			endpoint.connect do |socket|
-				case socket.type
+				case socket.local_address.socktype
 				when Socket::SOCK_DGRAM
 					try_datagram_server(request, socket)
 				when Socket::SOCK_STREAM
@@ -199,11 +208,11 @@ module Async::DNS
 		
 		def valid_response(message, response)
 			if response.tc != 0
-				@logger.warn "[#{message.id}] Received truncated response!" if @logger
+				Console.warn "Received truncated response!", message_id: message.id
 			elsif response.id != message.id
-				@logger.warn "[#{message.id}] Received response with incorrect message id: #{response.id}!" if @logger
+				Console.warn "Received response with incorrect message id: #{response.id}!", message_id: message.id
 			else
-				@logger.debug "[#{message.id}] Received valid response with #{response.answer.size} answer(s)." if @logger
+				Console.debug "Received valid response with #{response.answer.size} answer(s).", message_id: message.id
 				
 				return true
 			end
@@ -214,9 +223,9 @@ module Async::DNS
 		def try_datagram_server(request, socket)
 			socket.sendmsg(request.packet, 0)
 			
-			data, peer = socket.recvmsg(UDP_TRUNCATION_SIZE)
+			data, peer = socket.recvfrom(UDP_MAXIMUM_SIZE)
 			
-			return Async::DNS::decode_message(data)
+			return ::Resolv::DNS::Message.decode(data)
 		end
 		
 		def try_stream_server(request, socket)
@@ -224,31 +233,34 @@ module Async::DNS
 			
 			transport.write_chunk(request.packet)
 			
-			input_data = transport.read_chunk
+			data = transport.read_chunk
 			
-			return Async::DNS::decode_message(input_data)
+			return ::Resolv::DNS::Message.decode(data)
 		end
 		
 		# Manages a single DNS question message across one or more servers.
 		class Request
-			def initialize(message, endpoints)
+			# Create a new request for the given message and endpoint.
+			#
+			# Encodes the message and stores it for later use.
+			#
+			# @parameter message [Resolv::DNS::Message] The message to send.
+			# @parameter endpoint [IO::Endpoint::Generic] The endpoint to send the message to.
+			def initialize(message, endpoint)
 				@message = message
 				@packet = message.encode
 				
-				@endpoints = endpoints.dup
-				
-				# We select the protocol based on the size of the data:
-				if @packet.bytesize > UDP_TRUNCATION_SIZE
-					@endpoints.delete_if{|server| server[0] == :udp}
-				end
+				@endpoint = endpoint
 			end
 			
+			# @attribute [Resolv::DNS::Message] The message to send.
 			attr :message
+			
+			# @attribute [String] The encoded message to send.
 			attr :packet
-			attr :logger
 			
 			def each(&block)
-				Async::IO::Endpoint.each(@endpoints, &block)
+				@endpoint.each(&block)
 			end
 
 			def update_id!(id)
@@ -256,5 +268,7 @@ module Async::DNS
 				@packet = @message.encode
 			end
 		end
+		
+		private_constant :Request
 	end
 end

data/lib/async/dns/server.rb

@@ -1,59 +1,60 @@
-# 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.
+# frozen_string_literal: true
 
-require 'async'
-require 'async/io'
+# Released under the MIT License.
+# Copyright, 2012-2014, by Tony Arcieri.
+# Copyright, 2013, by Greg Thornton.
+# Copyright, 2014, by Hendrik Beskow.
+# Copyright, 2015-2025, by Samuel Williams.
+# Copyright, 2023, by Hal Brodigan.
 
-require_relative 'transaction'
+require "async"
+
+require "io/endpoint/composite_endpoint"
+require "io/endpoint/host_endpoint"
+
+require_relative "transaction"
+require_relative "handler"
 
 module Async::DNS
+	# A DNS server which can be used to resolve queries.
 	class Server
-		# The default server interfaces
-		DEFAULT_ENDPOINTS = [[:udp, "0.0.0.0", 53], [:tcp, "0.0.0.0", 53]]
-		
-		# Instantiate a server with a block
+		# The default endpoint to listen on.
 		#
-		#	server = Server.new do
-		#		match(/server.mydomain.com/, IN::A) do |transaction|
-		#			transaction.respond!("1.2.3.4")
-		#		end
-		#	end
+		# @parameter port [Integer] The port to listen on, defaults to 53.
+		def self.default_endpoint(port = 53)
+			::IO::Endpoint.composite(
+				::IO::Endpoint.udp("localhost", port),
+				::IO::Endpoint.tcp("localhost", port)
+			)
+		end
+		
+		# Instantiate a server with a block.
 		#
-		def initialize(endpoints = DEFAULT_ENDPOINTS, origin: '.', logger: Console.logger)
-			@endpoints = endpoints
+		# @param endpoints [Array<(Symbol, String, Integer)>]  The endpoints to listen on.
+		# @param origin [String] The default origin to resolve domains within.
+		# @param logger [Console::Logger] The logger to use.
+		def initialize(endpoint = self.class.default_endpoint, origin: ".")
+			@endpoint = endpoint
 			@origin = origin
-			@logger = logger
 		end
-
-		# Records are relative to this origin:
+		
+		# Records are relative to this origin.
+		#
+		# @return [String]
 		attr_accessor :origin
-
-		attr_accessor :logger
-
-		# Fire the named event as part of running the server.
-		def fire(event_name)
+		
+		# @deprecated Use {Console} instead.
+		def logger
+			Console
 		end
 		
 		# Give a name and a record type, try to match a rule and use it for processing the given arguments.
+		#
+		# @param name [String] The resource name.
+		# @param resource_class [Class<Resolv::DNS::Resource>] The requested resource class.
+		# @param transaction [Transaction] The transaction object.
 		def process(name, resource_class, transaction)
-			raise NotImplementedError.new
+			transaction.fail!(:NXDomain)
 		end
 		
 		# Process an incoming DNS message. Returns a serialized message to be sent back to the client.
@@ -76,55 +77,47 @@ module Async::DNS
 					begin
 						question = question.without_origin(@origin)
 						
-						@logger.debug(query) {"Processing question #{question} #{resource_class}..."}
+						Console.debug(query) {"Processing question #{question} #{resource_class}..."}
 						
-						transaction = Transaction.new(self, query, question, resource_class, response, options)
+						transaction = Transaction.new(self, query, question, resource_class, response, **options)
 						
 						transaction.process
-					rescue Resolv::DNS::OriginError
+					rescue Resolv::DNS::OriginError => error
 						# This is triggered if the question is not part of the specified @origin:
-						@logger.debug(query) {"Skipping question #{question} #{resource_class} because #{$!}"}
+						Console.error(self, "Failed to process question #{question} #{resource_class}!", error: error)
 					end
 				end
 			rescue StandardError => error
-				@logger.error(query) {error}
+				Console.error(query) {error}
 				
 				response.rcode = Resolv::DNS::RCode::ServFail
 			end
 			
 			end_time = Time.now
-			@logger.debug(query) {"Time to process request: #{end_time - start_time}s"}
+			Console.debug(query) {"Time to process request: #{end_time - start_time}s"}
 			
 			return response
 		end
 		
 		# Setup all specified interfaces and begin accepting incoming connections.
-		def run(*args)
-			@logger.info "Starting Async::DNS server (v#{Async::DNS::VERSION})..."
+		def run
+			Console.info "Starting Async::DNS server (v#{Async::DNS::VERSION})..."
 			
-			Async::Reactor.run do |task|
-				fire(:setup)
+			Async do |task|
+				wrapper = @endpoint.wrapper
 				
-				Async::IO::Endpoint.each(@endpoints) do |endpoint|
-					task.async do
-						endpoint.bind do |socket|
-							case socket.type
-							when Socket::SOCK_DGRAM
-								@logger.info "<> Listening for datagrams on #{socket.local_address.inspect}"
-								DatagramHandler.new(self, socket).run
-							when Socket::SOCK_STREAM
-								@logger.info "<> Listening for connections on #{socket.local_address.inspect}"
-								StreamHandler.new(self, socket).run
-							else
-								raise ArgumentError.new("Don't know how to handle #{address}")
-							end
-						end
+				@endpoint.bind do |server|
+					Console.info "<> Listening for connections on #{server.local_address.inspect}"
+					case server.local_address.socktype
+					when Socket::SOCK_DGRAM
+						DatagramHandler.new(self, server).run(wrapper)
+					when Socket::SOCK_STREAM
+						StreamHandler.new(self, server).run(wrapper)
+					else
+						raise ArgumentError.new("Don't know how to handle #{server}")
 					end
 				end
-				
-				fire(:start)
 			end
 		end
-		
 	end
 end