async-dns 0.10.0

data/lib/async/dns/extensions/string.rb

@@ -0,0 +1,28 @@
+# 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_relative '../chunked'
+
+class String
+	# Chunk a string which is required for the TEXT `resource_class`.
+	def chunked(chunk_size = 255)
+		Async::DNS::chunked(self)
+	end
+end

data/lib/async/dns/handler.rb

@@ -0,0 +1,229 @@
+# 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_relative 'transport'
+
+module Async::DNS
+	class GenericHandler
+		def initialize(server)
+			@server = server
+			@logger = @server.logger || Async.logger
+		end
+		
+		def error_response(query = nil, code = Resolv::DNS::RCode::ServFail)
+			# Encoding may fail, so we need to handle this particular case:
+			server_failure = Resolv::DNS::Message::new(query ? query.id : 0)
+			
+			server_failure.qr = 1
+			server_failure.opcode = query ? query.opcode : 0
+			server_failure.aa = 1
+			server_failure.rd = 0
+			server_failure.ra = 0
+
+			server_failure.rcode = code
+
+			# We can't do anything at this point...
+			return server_failure
+		end
+		
+		def process_query(data, options)
+			@logger.debug "<> Receiving incoming query (#{data.bytesize} bytes) to #{self.class.name}..."
+			query = nil
+
+			begin
+				query = Async::DNS::decode_message(data)
+				
+				return @server.process_query(query, options)
+			rescue StandardError => error
+				@logger.error "<> Error processing request: #{error.inspect}!"
+				Async::DNS::log_exception(@logger, error)
+				
+				return error_response(query)
+			end
+		end
+	end
+	
+	# Handling incoming UDP requests, which are single data packets, and pass them on to the given server.
+	class UDPHandler < GenericHandler
+		def run(socket, reactor:)
+			Async.logger.debug(self.class.name) {"-> Run on #{socket}..."}
+			
+			while true
+				Async.logger.debug(self.class.name) {"-> socket.recvfrom"}
+				input_data, (_, remote_port, remote_host) = socket.recvfrom(UDP_TRUNCATION_SIZE)
+				Async.logger.debug(self.class.name) {"<- socket.recvfrom"}
+				
+				reactor.async do
+					respond(socket, input_data, remote_host, remote_port)
+				end
+			end
+		ensure
+			Async.logger.debug(self.class.name) {"<- Run ensure... #{$!}"}
+		end
+		
+		def respond(socket, input_data, remote_host, remote_port)
+			options = {peer: remote_host, port: remote_port, proto: :udp}
+			
+			response = process_query(input_data, options)
+			
+			output_data = response.encode
+			
+			@logger.debug "<#{response.id}> Writing #{output_data.bytesize} bytes response to client via UDP..."
+			
+			if output_data.bytesize > UDP_TRUNCATION_SIZE
+				@logger.warn "<#{response.id}>Response via UDP was larger than #{UDP_TRUNCATION_SIZE}!"
+				
+				# Reencode data with truncation flag marked as true:
+				truncation_error = Resolv::DNS::Message.new(response.id)
+				truncation_error.tc = 1
+				
+				output_data = truncation_error.encode
+			end
+			
+			socket.send(output_data, 0, remote_host, remote_port)
+		rescue IOError => error
+			@logger.warn "<> UDP response failed: #{error.inspect}!"
+		rescue EOFError => error
+			@logger.warn "<> UDP session ended prematurely: #{error.inspect}!"
+		rescue DecodeError
+			@logger.warn "<> Could not decode incoming UDP data!"
+		end
+	end
+	
+	class UDPSocketHandler < UDPHandler
+		def initialize(server, socket)
+			@socket = socket
+			
+			super(server)
+		end
+		
+		attr :socket
+		
+		def run(reactor: Async::Task.current.reactor)
+			reactor.async(self.socket) do |socket|
+				super(socket, reactor: reactor)
+			end
+		end
+	end
+	
+	class UDPServerHandler < UDPHandler
+		def initialize(server, host, port)
+			@host = host
+			@port = port
+			
+			super(server)
+		end
+		
+		attr :host
+		attr :port
+		
+		def run(reactor: Async::Task.current.reactor)
+			reactor.with(make_socket) do |socket|
+				super(socket, reactor: reactor)
+			end
+		end
+		
+		private
+		
+		def make_socket
+			family ||= Async::DNS::address_family(@host)
+			
+			socket = ::UDPSocket.new(family)
+			socket.bind(@host, @port)
+			
+			return socket
+		end
+	end
+	
+	class TCPHandler < GenericHandler
+		def run(socket, reactor:)
+			Async.logger.debug(self.class.name) {"-> Run on #{socket}..."}
+			
+			reactor.with(socket.accept) do |client|
+				handle_connection(client)
+			end while true
+		ensure
+			Async.logger.debug(self.class.name) {"<- Run ensure... #{$!}"}
+		end
+		
+		def handle_connection(socket)
+			context = Async::Task.current
+			
+			_, remote_port, remote_host = socket.io.peeraddr
+			options = {peer: remote_host, port: remote_port, proto: :tcp}
+			
+			input_data = StreamTransport.read_chunk(socket)
+			
+			response = process_query(input_data, options)
+			
+			length = StreamTransport.write_message(socket, response)
+			
+			@logger.debug "<#{response.id}> Wrote #{length} bytes via TCP..."
+		rescue EOFError => error
+			@logger.warn "<> Error: TCP session ended prematurely!"
+		rescue Errno::ECONNRESET => error
+			@logger.warn "<> Error: TCP connection reset by peer!"
+		rescue Errno::EPIPE
+			@logger.warn "<> Error: TCP session failed due to broken pipe!"
+		rescue DecodeError
+			@logger.warn "<> Error: Could not decode incoming TCP data!"
+		end
+	end
+	
+	class TCPSocketHandler < TCPHandler
+		def initialize(server, socket)
+			@socket = socket
+			
+			super(server)
+		end
+		
+		attr :socket
+		
+		def run(reactor: Async::Task.current.reactor)
+			reactor.async(@socket) do |socket|
+				super(socket, reactor: reactor)
+			end
+		end
+	end
+	
+	class TCPServerHandler < TCPHandler
+		def initialize(server, host, port)
+			@host = host
+			@port = port
+			
+			super(server)
+		end
+		
+		attr :host
+		attr :port
+		
+		def run(reactor: Async::Task.current.reactor)
+			reactor.with(make_socket) do |socket|
+				super(socket, reactor: reactor)
+			end
+		end
+		
+		private
+		
+		def make_socket
+			::TCPServer.new(@host, @port)
+		end
+	end
+end

data/lib/async/dns/logger.rb

@@ -0,0 +1,31 @@
+# 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 'logger'
+
+module Async::DNS
+	# Logs an exception nicely to a standard `Logger`.
+	def self.log_exception(logger, exception)
+		logger.error "#{exception.class}: #{exception.message}"
+		if exception.backtrace
+			Array(exception.backtrace).each { |at| logger.error at }
+		end
+	end
+end

data/lib/async/dns/message.rb

@@ -0,0 +1,75 @@
+# 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 'stringio'
+require 'resolv'
+
+require 'base64'
+
+require_relative 'logger'
+require_relative 'extensions/resolv'
+
+module Async::DNS
+	UDP_TRUNCATION_SIZE = 512
+	
+	# The DNS message container.
+	Message = ::Resolv::DNS::Message
+	DecodeError = ::Resolv::DNS::DecodeError
+
+	@@dump_bad_message = nil
+	
+	# Call this function with a path where bad messages will be saved. Any message that causes an exception to be thrown while decoding the binary will be saved in base64 for later inspection. The log file could grow quickly so be careful - not designed for long term use.
+	def self.log_bad_messages!(log_path)
+		bad_messages_log = Logger.new(log_path, 10, 1024*100)
+		bad_messages_log.level = Logger::DEBUG
+		
+		@dump_bad_message = lambda do |error, data|
+			bad_messages_log.debug("Bad message: #{Base64.encode64(data)}")
+			Async::DNS.log_exception(bad_messages_log, error)
+		end
+	end
+	
+	# Decodes binary data into a {Message}.
+	def self.decode_message(data)
+		# Otherwise the decode process might fail with non-binary data.
+		if data.respond_to? :force_encoding
+			data.force_encoding("BINARY")
+		end
+		
+		begin
+			return Message.decode(data)
+		rescue DecodeError
+			raise
+		rescue StandardError => error
+			new_error = DecodeError.new(error.message)
+			new_error.set_backtrace(error.backtrace)
+			
+			raise new_error
+		end
+		
+	rescue => error
+		# Log the bad messsage if required:
+		if @dump_bad_message
+			@dump_bad_message.call(error, data)
+		end
+		
+		raise
+	end
+end

data/lib/async/dns/replace.rb

@@ -0,0 +1,54 @@
+# Copyright, 2015, 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 'resolv'
+require 'resolv-replace'
+
+module Async::DNS
+	module Replace
+		class << self
+			attr :resolver, true
+			
+			def resolver?
+				resolver != nil
+			end
+		
+			def get_address(host)
+				begin
+					resolver.addresses_for(host).sample.to_s
+				rescue ResolutionFailure
+					raise SocketError, "Hostname not known: #{host}"
+				end
+			end
+		end
+	end
+	
+	class << IPSocket
+		@@resolver = nil
+		
+		def getaddress(host)
+			if Replace.resolver?
+				Replace.get_address(host)
+			else
+				original_resolv_getaddress(host)
+			end
+		end
+	end
+end

data/lib/async/dns/resolver.rb

@@ -0,0 +1,280 @@
+# 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 'async'
+
+module Async::DNS
+	class InvalidProtocolError < StandardError
+	end
+	
+	class InvalidResponseError < StandardError
+	end
+	
+	class ResolutionFailure < StandardError
+	end
+	
+	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
+		
+		# 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, origin: nil, logger: Async.logger, timeout: DEFAULT_TIMEOUT)
+			@servers = servers
+			
+			@origin = origin
+			@logger = logger
+			@timeout = timeout
+		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 raise 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
+				raise ResolutionFailure.new("Could not find any addresses for #{name}.")
+			end
+		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)
+			context = Async::Task.current
+			
+			request.each do |server|
+				@logger.debug "[#{message.id}] Sending request #{message.question.inspect} to server #{server.inspect}" if @logger
+				
+				begin
+					response = nil
+					
+					context.timeout(@timeout) do
+						@logger.debug "[#{message.id}] -> Try server #{server}" if @logger
+						response = try_server(request, server)
+						@logger.debug "[#{message.id}] <- Try server #{server} = #{response}" if @logger
+					end
+					
+					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
+					@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 udp_socket(family)
+			@udp_sockets[family] ||= UDPSocket.new(family)
+		end
+		
+		def try_udp_server(request, host, port)
+			context = Async::Task.current
+			
+			family = Async::DNS::address_family(host)
+			
+			context.with(UDPSocket.new(family)) do |socket|
+				socket.send(request.packet, 0, host, port)
+				
+				data, (_, remote_port) = socket.recvfrom(UDP_TRUNCATION_SIZE)
+				# 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
+				
+				return Async::DNS::decode_message(data)
+			end
+		end
+		
+		def try_tcp_server(request, host, port)
+			context = Async::Task.current
+			
+			context.with(TCPSocket.new(host, port)) do |socket|
+				StreamTransport.write_chunk(socket, request.packet)
+				
+				input_data = StreamTransport.read_chunk(socket)
+				
+				return Async::DNS::decode_message(input_data)
+			end
+		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|
+					# TODO: This seems odd...
+					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