rubydns 0.3.4 → 0.4.0

data/README.md

@@ -26,12 +26,15 @@ This is copied from `test/example1.rb`. It has been simplified slightly.
 	$R = Resolv::DNS.new
 
 	RubyDNS::run_server do
+		Name = Resolv::DNS::Name
+		IN = Resolv::DNS::Resource::IN
+		
 		# For this exact address record, return an IP address
-		match("dev.mydomain.org", :A) do |transaction|
+		match("dev.mydomain.org", IN::A) do |transaction|
 			transaction.respond!("10.0.0.80")
 		end
 
-		match(/^test([0-9]+).mydomain.org$/, :A) do |match_data, transaction|
+		match(/^test([0-9]+).mydomain.org$/, IN::A) do |match_data, transaction|
 			offset = match_data[1].to_i
 
 			if offset > 0 && offset < 10
@@ -56,6 +59,22 @@ After starting this server you can test it using dig:
 	dig @localhost dev.mydomain.org
 	dig @localhost google.com
 
+Compatibility
+-------------
+
+From RubyDNS version `0.4.0`, the recommended minimum Ruby version is `1.9.3` for complete support. Some features may not work as expected on Ruby version `1.8.x` and it is not tested significantly.
+
+### Migrating from RubyDNS 0.3.x to 0.4.x ###
+
+Due to changes in `resolv.rb`, superficial parts of RubyDNS have changed. Rather than using `:A` to specify A-records, one must now use the class name.
+
+	match(..., :A)
+
+becomes
+
+	IN = Resolv::DNS::Resource::IN
+	match(..., IN::A)
+
 Todo
 ----
 

data/lib/rubydns.rb

@@ -19,7 +19,15 @@
 # THE SOFTWARE.
 
 require 'rubydns/version'
-require 'rubydns/resolv'
+
+if RUBY_VERSION < "1.9"
+	require 'rubydns/extensions/resolv-1.8'
+	require 'rubydns/extensions/string-1.8'
+else
+	require 'rubydns/extensions/resolv-1.9'
+	require 'rubydns/extensions/string-1.9'
+end
+
 require 'rubydns/server'
 
 require 'logger'

data/lib/rubydns/extensions/hexdump.rb

@@ -25,7 +25,7 @@ class String
 		i = 1
 		out = StringIO.new
 		
-		out.puts "Size: #{self.size}"
+		out.puts "Size: #{self.bytesize}"
 		while (self.length > 16*(i-1))
 			a = self.slice(16*(i-1)..(16*i)-1)
 			out.printf("%06x: %4.4x %4.4x %4.4x %4.4x   %4.4x %4.4x %4.4x %4.4x ", (i-1)*16,  *a.unpack("n16"))

data/lib/rubydns/{resolv.rb → extensions/resolv-1.8.rb}

@@ -59,10 +59,10 @@ class Resolv
 				# Authoritive Answer
 				@aa = @aa && other.aa
 
-				@additional += other.additional
+				@question += other.question
 				@answer += other.answer
 				@authority += other.authority
-				@question += other.question
+				@additional += other.additional
 
 				# Recursion Available
 				@ra = @ra || other.ra

data/lib/rubydns/extensions/resolv-1.9.rb

@@ -0,0 +1,111 @@
+# Copyright (c) 2009, 2011 Samuel G. D. Williams. <http://www.oriontransfer.co.nz>
+# 
+# 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'
+
+class Resolv
+	class DNS
+		# This issue was not fixed in 1.9.3 but the proposed patch works as expected:
+		# https://bugs.ruby-lang.org/issues/4788
+		def fetch_resource(name, typeclass)
+			lazy_initialize
+			requester = make_udp_requester
+			senders = {}
+			begin
+				@config.resolv(name) {|candidate, tout, nameserver, port|
+					msg = Message.new
+					msg.rd = 1
+					msg.add_question(candidate, typeclass)
+					unless sender = senders[[candidate, nameserver, port]]
+						sender = senders[[candidate, nameserver, port]] =
+						requester.sender(msg, candidate, nameserver, port)
+					end
+					reply, reply_name = requester.request(sender, tout)
+					case reply.rcode
+					when RCode::NoError
+						if reply.tc == 1 and not Requester::TCP === requester
+							requester.close
+							# Retry via TCP:
+							requester = make_tcp_requester(nameserver, port)
+							senders = {}
+							# This will use TCP for all remaining candidates (assuming the
+							# current candidate does not already respond successfully via
+							# TCP).  This makes sense because we already know the full
+							# response will not fit in an untruncated UDP packet.
+							redo
+						else
+							yield(reply, reply_name)
+						end
+						return
+					when RCode::NXDomain
+						raise Config::NXDomain.new(reply_name.to_s)
+					else
+						raise Config::OtherResolvError.new(reply_name.to_s)
+					end
+				}
+			ensure
+				requester.close
+			end
+		end
+
+		def each_resource(name, typeclass, &proc)
+			fetch_resource(name, typeclass) do |reply, reply_name|
+				extract_resources(reply, reply_name, typeclass, &proc)
+			end
+		end
+
+		# 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)
+			fetch_resource(name, typeclass) do |reply, reply_name|
+				return reply, reply_name
+			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
+
+				@question += other.question
+				@answer += other.answer
+				@authority += other.authority
+				@additional += other.additional
+
+				# 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/extensions/string-1.8.rb

@@ -0,0 +1,41 @@
+# Copyright (c) 2009, 2011 Samuel G. D. Williams. <http://www.oriontransfer.co.nz>
+# 
+# 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.
+
+class String
+	def bytesize
+		size
+	end
+	
+	def byteslice(*args)
+		self[*args]
+	end
+	
+	def chunked(chunk_size = 255)
+		chunks = []
+		
+		offset = 0
+		while offset < bytesize
+			chunks << byteslice(offset, chunk_size)
+			offset += chunk_size
+		end
+		
+		return chunks
+	end
+end

data/lib/rubydns/extensions/string-1.9.rb

@@ -0,0 +1,33 @@
+# Copyright (c) 2009, 2011 Samuel G. D. Williams. <http://www.oriontransfer.co.nz>
+# 
+# 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.
+
+class String
+	def chunked(chunk_size = 255)
+		chunks = []
+		
+		offset = 0
+		while offset < bytesize
+			chunks << byteslice(offset, chunk_size)
+			offset += chunk_size
+		end
+		
+		return chunks
+	end
+end

data/lib/rubydns/handler.rb

@@ -23,23 +23,39 @@ require 'stringio'
 
 module RubyDNS
 	
-	UDP_TRUNCATION_SIZE = 512
-	
 	module UDPHandler
+		UDP_TRUNCATION_SIZE = 512
+
 		def initialize(server)
 			@server = server
 		end
-		
+
 		def self.process(server, data, &block)
-			server.logger.debug "Receiving incoming query (#{data.size} bytes)..."
-			
+			server.logger.debug "Receiving incoming query (#{data.bytesize} bytes)..."
+			query = nil
+
 			begin
-				server.receive_data(data, &block)
+				query = Resolv::DNS::Message::decode(data)
+
+				return server.process_query(query, &block)
 			rescue
 				server.logger.error "Error processing request!"
 				server.logger.error "#{$!.class}: #{$!.message}"
 
 				$!.backtrace.each { |at| server.logger.error at }
+
+				# 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 = Resolv::DNS::RCode::ServFail
+
+				# We can't do anything at this point...
+				yield server_failure
 			end
 		end
 		
@@ -47,13 +63,14 @@ module RubyDNS
 			UDPHandler.process(@server, data) do |answer|
 				data = answer.encode
 				
-				@server.logger.debug "Writing response to client (#{data.size} bytes)"
+				@server.logger.debug "Writing response to client (#{data.bytesize} bytes) via UDP..."
 				
-				if (data.size > UDP_TRUNCATION_SIZE)
+				if data.bytesize > UDP_TRUNCATION_SIZE
 					@server.logger.warn "Response via UDP was larger than #{UDP_TRUNCATION_SIZE}!"
 					
+					# Reencode data with truncation flag marked as true:
 					answer.tc = 1
-					data = answer.encode[0,UDP_TRUNCATION_SIZE]
+					data = answer.encode.byteslice(0,UDP_TRUNCATION_SIZE)
 				end
 				
 				self.send_data(data)
@@ -73,29 +90,30 @@ module RubyDNS
 		end
 		
 		def receive_data(data)
+			# We buffer data until we've received the entire packet:
 			@buffer ||= StringIO.new
 			@buffer.write(data)
 			
-			# Message includes a 16-bit length field
+			# Message includes a 16-bit length field.. we need to see if we have received it yet:
 			if @length == nil
 				if (@buffer.size - @processed) < 2
 					raise LengthError.new("Malformed message smaller than two bytes received")
 				end
 				
-				@length = @buffer.string[@processed, 2].unpack('n')[0]
+				# Grab the length field:
+				@length = @buffer.string.byteslice(@processed, 2).unpack('n')[0]
 				@processed += 2
 			end
 			
-			
 			if (@buffer.size - @processed) >= @length
-				data = @buffer.string[@processed, @length]
+				data = @buffer.string.byteslice(@processed, @length)
 				
 				UDPHandler.process(@server, data) do |answer|
 					data = answer.encode
 					
-					@server.logger.debug "Writing response to client (#{data.size} bytes)"
+					@server.logger.debug "Writing response to client (#{data.bytesize} bytes) via TCP..."
 					
-					self.send_data([data.size].pack('n'))
+					self.send_data([data.bytesize].pack('n'))
 					self.send_data(data)
 				end
 				

data/lib/rubydns/server.rb

@@ -26,11 +26,10 @@ module RubyDNS
 	# 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|
+		#     match(/server.mydomain.com/, IN::A) do |transaction|
 		#       transaction.respond!("1.2.3.4")
 		#     end
 		#   end
@@ -55,22 +54,10 @@ module RubyDNS
 		# types which the rule matches against.
 		# 
 		#   match("www.google.com")
-		#   match("gmail.com", :MX)
-		#   match(/g?mail.(com|org|net)/, [:MX, :A])
+		#   match("gmail.com", IN::MX)
+		#   match(/g?mail.(com|org|net)/, [IN::MX, IN::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
-
+		def match(*pattern, &block)
 			@rules << [pattern, Proc.new(&block)]
 		end
 
@@ -108,22 +95,22 @@ module RubyDNS
 		#
 		# 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}"
+		def process(name, resource_class, *args)
+			@logger.debug "Searching for #{name} #{resource_class.name}"
 
 			@rules.each do |rule|
 				@logger.debug "Checking rule #{rule[0].inspect}..."
 				
 				pattern = rule[0]
 
-				# Match failed against record_type?
+				# Match failed against resource_class?
 				case pattern[1]
-				when String
-					next unless pattern[1] == record_type
-					@logger.debug "Resource type #{record_type} matched"
+				when Class
+					next unless pattern[1] == resource_class
+					@logger.debug "Resource class #{resource_class.name} matched"
 				when Array
-					next unless pattern[1].include?(record_type)
-					@logger.debug "Resource type #{record_type} matched #{pattern[1].inspect}"
+					next unless pattern[1].include?(resource_class)
+					@logger.debug "Resource class #{resource_class} matched #{pattern[1].inspect}"
 				end
 
 				# Match succeeded against name?
@@ -167,15 +154,13 @@ module RubyDNS
 			if @otherwise
 				@otherwise.call(*args)
 			else
-				@logger.warn "Failed to handle #{name} #{record_type}!"
+				@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 receive_data(data, &block)
-			query = Resolv::DNS::Message::decode(data)
-
+		def process_query(query, &block)
 			# Setup answer
 			answer = Resolv::DNS::Message::new(query.id)
 			answer.qr = 1                 # 0 = Query, 1 = Response
@@ -202,7 +187,7 @@ module RubyDNS
 			if block_given?
 				yield answer
 			else
-				answer.encode
+				return answer
 			end
 		end
 	end