redns 0.0.0 → 0.1.0

data/VERSION

@@ -1 +1 @@
-0.0.0
+0.1.0

data/lib/redns/connection.rb

@@ -0,0 +1,65 @@
+require 'socket'
+
+class ReDNS::Connection < EventMachine::Connection
+  # == Constants ============================================================
+  
+  # == Extensions ===========================================================
+
+  include EventMachine::Deferrable
+
+  # == Class Methods ========================================================
+
+  def self.instance
+    EventMachine.open_datagram_socket(
+      ReDNS::Support.bind_all_addr,
+      0,
+      self
+    )
+  end
+
+  # == Instance Methods =====================================================
+  
+  def post_init
+    # Sequence numbers do not have to be cryptographically secure, but having
+    # a healthy amount of randomness is a good thing.
+    @sequence = (rand(0x10000) ^ (object_id ^ (Time.now.to_f * 100000).to_i)) % 0x10000
+    
+    # Callback tracking is done by matching response IDs in a lookup table
+    @callback = { }
+  end
+  
+  def port
+    Socket.unpack_sockaddr_in(get_sockname)[0]
+  end
+  
+  def receive_data(data)
+    message = ReDNS::Message.new(ReDNS::Buffer.new(data))
+    
+    if (callback = @callback[message.id])
+      callback.yield(message.answers.collect { |a| a.rdata.to_s })
+    end
+  end
+  
+  def resolve(query, type = nil, &callback)
+    message = ReDNS::Message.question(query, type) do |m|
+      m.id = @sequence
+    end
+
+    result = send_datagram(
+      message.serialize.to_s,
+      ReDNS::Support.default_resolver_address,
+      ReDNS::Support.dns_port
+    )
+
+    if (result > 0)
+      @callback[@sequence] = callback
+    else
+      callback.call(nil)
+    end
+
+    @sequence += 1
+  end
+  
+  def unbind
+  end
+end

data/lib/redns/message.rb

@@ -12,7 +12,7 @@ class ReDNS::Message < ReDNS::Fragment
 	attribute :opcode, :default => :query
 	attribute :authorative, :boolean => true, :default => false
 	attribute :truncated, :boolean => true, :default => false
-	attribute :recursion_desired, :boolean => true, :default => false
+	attribute :recursion_desired, :boolean => true, :default => true
 	attribute :recursion_available, :boolean => true, :default => false
 	attribute :response_code, :default => :noerror
 	
@@ -27,11 +27,28 @@ class ReDNS::Message < ReDNS::Fragment
 	attribute :additional_records, :default => lambda { [ ] }
 
   # == Class Methods ========================================================
+  
+  def self.question(name, qtype = nil)
+    qtype ||= ReDNS::Support.is_ip?(name) ? :ptr : :a
+    
+    message = new(
+      :questions => [
+        ReDNS::Question.new(
+          :name => name,
+          :qtype => qtype
+        )
+      ]
+    )
+    
+    yield(message) if (block_given?)
+    
+    message
+  end
 
   # == Instance Methods =====================================================
   
 	def increment_id!
-	  @attributes[:id] += 1
+	  self.id += 1
 	end
 
 	def response?
@@ -83,9 +100,9 @@ class ReDNS::Message < ReDNS::Fragment
     			(ReDNS::OPCODE[self.opcode] || ReDNS::OPCODE[:unknown]) << 12 |
     			(self.authorative? ? 0x0400 : 0) |
     			(self.truncated? ? 0x0200 : 0) |
-    			(self.ecursion_desired? ? 0x0100 : 0) |
+    			(self.recursion_desired? ? 0x0100 : 0) |
     			(self.recursion_available? ? 0x0080 : 0) |
-    			(ReDNS::RCODE[self.reponse_code] || ReDNS::RCODE[:noerror])
+    			(ReDNS::RCODE[self.response_code] || ReDNS::RCODE[:noerror])
   			),
   		  self.questions.length,
   			self.answers.length,
@@ -96,7 +113,7 @@ class ReDNS::Message < ReDNS::Fragment
   	)
 
     [ :questions, :answers, :nameservers, :additional_records ].each do |section|
-      @attributes[:group].each do |part|
+      @attributes[section] and @attributes[section].each do |part|
         part.serialize(buffer)
       end
     end
@@ -110,14 +127,13 @@ class ReDNS::Message < ReDNS::Fragment
 		self.id = data.shift
 
 		flags = data.shift
-		self.query = flags & 0x8000
-		self.opcode = (flags & 0x7800) >> 12
-		self.authorative = flags & 0x0400
-		self.truncated = flags & 0x0200
-		self.recursion_desired = flags & 0x0100
-		
-		self.recursion_available = flags & 0x0080
-		self.response_code = flags & 0x000F
+		self.query = (flags & 0x8000 == 0)
+		self.opcode = ReDNS::OPCODE_LABEL[(flags & 0x7800) >> 12]
+		self.authorative = (flags & 0x0400 != 0)
+		self.truncated = (flags & 0x0200 != 0)
+		self.recursion_desired = (flags & 0x0100 != 0)
+		self.recursion_available = (flags & 0x0080 != 0)
+		self.response_code = ReDNS::RCODE_LABEL[flags & 0x000F]
 		
 		SECTIONS.each do |section|
 		  @attributes[:"#{section}_count"] = data.shift
@@ -128,7 +144,7 @@ class ReDNS::Message < ReDNS::Fragment
 		  
 		  decode_class =
   		  case (section)
-  	    when :question
+  	    when :questions
   	      ReDNS::Question
 	      else
 	        ReDNS::Resource

data/lib/redns/name.rb

@@ -13,7 +13,10 @@ class ReDNS::Name < ReDNS::Fragment
       super(contents)
     when String
       super(:name => contents)
-      self.name << '.' unless (self.name.match(/\.$/))
+      
+      unless (ReDNS::Support.is_ip?(name) or self.name.match(/\.$/))
+        self.name += '.'
+      end
     else
       super(contents)
     end

data/lib/redns/question.rb

@@ -20,13 +20,19 @@ class ReDNS::Question < ReDNS::Fragment
 	
 	def serialize(buffer = ReDNS::Buffer.new)
 	  name.serialize(buffer)
-	  buffer.pack([ self.qtype_rfc, self.qclass_rfc ], "nn")
+	  buffer.pack(
+	    [
+  	    ReDNS::RR_TYPE[self.qtype],
+  	    ReDNS::RR_CLASS[self.qclass]
+  	  ],
+  	  'nn'
+  	)
 
     buffer
 	end
 	
 	def deserialize(buffer)
-	  self.name = DNS::Name.new(buffer)
+	  self.name = ReDNS::Name.new(buffer)
 	  
 	  data = buffer.unpack('nn')
 	  

data/lib/redns/resolver.rb

@@ -0,0 +1,274 @@
+require 'socket'
+require 'fcntl'
+
+BasicSocket.do_not_reverse_lookup = true
+
+class ReDNS::Resolver
+	# == Class Properties =====================================================
+	
+	@servers = nil
+	@timeout = 5
+	
+	# == Class Methods ========================================================
+
+	def self.in_resolv_conf
+		list = [ ]
+		
+		File.open("/etc/resolv.conf") do |fh|
+			list = fh.readlines.collect { |l| l.chomp }.collect { |l| l.sub(/#.*/, '') }
+			
+			list.reject!{ |l| !l.sub!(/^\s*nameserver\s+/, '') }
+		end
+		
+		list
+	end
+	
+	def self.servers
+		@servers ||= in_resolv_conf
+	end
+	
+	def self.servers=(list)
+		@servers = list
+	end
+	
+	def self.timeout
+		@timeout
+	end
+	
+	def self.timeout=(secs)
+		@timeout = secs
+	end
+	
+	# == Instance Methods =====================================================
+
+	def initialize(options = { }, &block)
+		@servers = self.class.servers.dup
+		@responses = { }
+		
+		@socket = UDPSocket.new
+		ReDNS::Support.io_set_nonblock(@socket)
+		
+		yield(self) if (block)
+	end
+	
+	def simple_query(type, name)
+		r = query do |q|
+			q.qtype = type
+			q.name = name.to_s
+		end
+		
+		expand_answers(r)
+	end
+	
+	def bulk_query(type, names)
+		results = { }
+		ids = [ ]
+		
+		message ||= ReDNS::Message.new
+		q = (message.questions[0] ||= ReDNS::Question.new)
+		q.qtype = type
+		
+		names.each do |name|
+			q.name = name.to_s
+			message.increment_id!
+			ids.push(message.id)
+			
+			send_message(message)
+		end
+		
+		wait_for_responses do |response, addr|
+			results[response.questions[0].name.to_s] = response
+
+			ids.delete(response.id)
+				
+			return results if (ids.empty?)
+		end
+		
+		results
+	end
+
+	def a_for(name)
+		simple_query(:a, name)
+	end
+	
+	def ns_for(name)
+		if (name.match(/^(\d+\.\d+\.\d+)\.\d+$/))
+			return simple_query(:ns, ReDNS::Support.addr_to_arpa($1))
+		end
+		
+		simple_query(:ns, name)
+	end
+
+	def mx_for(name)
+		simple_query(:mx, name)
+	end
+
+	def ptr_for(name)
+		simple_query(:ptr, DNS.to_arpa(name))
+	end
+	
+	def ptr_for_list(name)
+		ips = [ ips ].flatten
+		
+		bulk_query(:ptr, ips.collect { |ip| ReDNS::Support.addr_to_arpa(ip) })
+	end
+
+	def soa_for(name)
+		simple_query(:soa, name)
+	end
+	
+	def reverse_addresses(ips)
+		map = ips.inject({ }) do |h, ip|
+			h[ReDNS::Support.addr_to_arpa(ip)] = ip
+			h
+		end
+		
+		list = bulk_query(:ptr, map.keys)
+		
+		list.values.inject({ }) do |h, r|
+			if (ip = map[r.questions[0].name.to_s])
+			  h[ip] = (r.answers[0] and r.answers[0].rdata.to_s)
+		  end
+		  
+			h
+		end
+	end
+	
+	def servers
+		@servers
+	end
+	
+	def servers=(list)
+		@servers = list
+	end
+	
+	def random_server
+		@servers[rand(@servers.length)]
+	end
+	
+	def send_message(message, server = nil)
+		@socket.send(message.serialize.to_s, 0, (server or random_server), 53)
+	end
+	
+	def query(message = nil, server = nil, async = false, &block)
+		# FUTURE: Fix the duplication here and in query_async
+
+		message ||= ReDNS::Message.new
+		message.questions[0] ||= ReDNS::Question.new
+		
+		yield(message.questions[0]) if (block)
+		
+		send_message(message, server)
+		
+		unless (async)
+			wait_for_responses do |r, addr|
+				return r if (r.id == message.id)
+			end
+		end
+	end
+	
+	def response_for(id)
+		@responses[id]
+	end
+	
+	def responses
+		@responses
+	end
+	
+	def timeout
+		@timeout or self.class.timeout
+	end
+	
+	def timeout=(secs)
+		@timeout = secs
+	end
+
+	def wait(_timeout = nil, &block)
+		wait_for_response(nil, _timeout, &block)
+	end
+	
+	def wait_for_responses(_timeout = nil, &block)
+		start = Time.now
+
+		_timeout ||= timeout
+		left = _timeout - Time.now.to_f + start.to_f
+
+		while (left > 0)
+			if (ready = IO.select([ @socket ], nil, nil, left))
+				ready[0].each do |socket|
+					data = socket.recvfrom(1524)
+			
+					r = ReDNS::Message.new(ReDNS::Buffer.new(data[0]))
+					
+					yield(r, data[1]) if (block)
+	
+					@responses[r.id] = [ r, data[1] ]
+				end
+			end
+
+			left = _timeout - Time.now.to_f + start.to_f
+		end
+	end
+	
+	protected
+	def expand_answers(r)
+		unless (r and r.answers)
+			return nil
+		end
+
+		result = r.answers
+		radd = (r.additional or [ ])
+		
+		result.reject { |rr| rr.rtype == :a }.each do |rr|
+			# Additional resource records may be related to the query, or they
+			# might just be convenience records that are not directly helpful.
+			
+			rr_rdata = rr.rdata.to_a[0]
+			
+			# First, see if there are additional records immediately available
+			additional = radd.find_all { |i| i.name.to_s == rr_rdata }
+			
+			if (additional.empty?)
+				# Otherwise go fetch them
+				additional = a_for(rr_rdata)
+			end
+			
+			if (additional and !additional.empty?)
+				# Push any results into the record itself
+				rr.additional = additional
+			end
+		end
+		
+		result
+	end
+
+	def expand_answers_a(r)
+		unless (r and r.answers)
+			return nil
+		end
+		
+		rev = { }
+		
+		res = r.answers.collect do |a|
+			row = a.to_a
+			rev[row[4]] = nil
+			row
+		end
+		
+		r.additional and r.additional.each do |a|
+			row = a.to_a
+			rev[row[0]] = row[4]
+			res.push(row)
+		end
+		
+		rev.each do |addr, ip|
+			unless (ip)
+				if (add = a_for(addr))
+					res += add
+				end
+			end
+		end
+		
+		res
+	end
+end

data/lib/redns/resource.rb

@@ -55,7 +55,7 @@ class ReDNS::Resource < ReDNS::Fragment
 	
 	def deserialize(buffer)
 		self.name = ReDNS::Name.new(buffer)
-		
+
 		raw = buffer.unpack("nnNn")
 		
 		self.rtype = ReDNS::RR_TYPE_LABEL[raw.shift]

data/lib/redns/support.rb

@@ -14,6 +14,48 @@ module ReDNS::Support
 		  c.to_i
 		end.pack("C*")
 	end
+
+	def io_nonblock?(io)
+		(io.fcntl(Fcntl::F_GETFL) & File::NONBLOCK) != 0
+	end
+
+	def io_set_nonblock(io, nb = true)
+		flags = io.fcntl(Fcntl::F_GETFL)
+		
+		if (nb)
+			flags |= File::NONBLOCK
+		else
+			flags &= ~File::NONBLOCK
+		end
+		
+		io.fcntl(Fcntl::F_SETFL, flags)
+	end
+
+	def io_nonblock(nb = true, &block)
+	  flag = io_nonblock?(io)
+	  
+		io_set_nonblock(io, nb)
+		
+		yield(block)
+	ensure
+		io_set_nonblock(io, flag)
+	end
+	
+	def bind_all_addr
+    '0.0.0.0'
+  end
+
+  def is_ip?(address)
+    address and address.match(/^\d+(\.\d+)+$/)
+  end
+  
+  def dns_port
+    53
+  end
+  
+  def default_resolver_address
+    ReDNS::Resolver.servers.first
+  end
 	
 	extend(self)
 end

data/lib/redns.rb

@@ -64,11 +64,13 @@ module ReDNS
 
   autoload(:Address, 'redns/address')
   autoload(:Buffer, 'redns/buffer')
+  autoload(:Connection, 'redns/connection')
   autoload(:Fragment, 'redns/fragment')
   autoload(:Message, 'redns/message')
   autoload(:Name, 'redns/name')
   autoload(:Question, 'redns/question')
   autoload(:Record, 'redns/record')
+  autoload(:Resolver, 'redns/resolver')
   autoload(:Resource, 'redns/resource')
   autoload(:Support, 'redns/support')
 

data/redns.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{redns}
-  s.version = "0.0.0"
+  s.version = "0.1.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["tadman"]
-  s.date = %q{2010-08-13}
+  s.date = %q{2010-08-16}
   s.description = %q{ReDNS is a pure Ruby DNS library with drivers for reactor-model engines such as EventMachine}
   s.email = %q{github@tadman.ca}
   s.extra_rdoc_files = [
@@ -24,6 +24,7 @@ Gem::Specification.new do |s|
      "lib/redns.rb",
      "lib/redns/address.rb",
      "lib/redns/buffer.rb",
+     "lib/redns/connection.rb",
      "lib/redns/fragment.rb",
      "lib/redns/message.rb",
      "lib/redns/name.rb",
@@ -32,6 +33,7 @@ Gem::Specification.new do |s|
      "lib/redns/record/mx.rb",
      "lib/redns/record/null.rb",
      "lib/redns/record/soa.rb",
+     "lib/redns/resolver.rb",
      "lib/redns/resource.rb",
      "lib/redns/support.rb",
      "redns.gemspec",
@@ -39,10 +41,12 @@ Gem::Specification.new do |s|
      "test/test_redns.rb",
      "test/test_redns_address.rb",
      "test/test_redns_buffer.rb",
+     "test/test_redns_connection.rb",
      "test/test_redns_fragment.rb",
      "test/test_redns_message.rb",
      "test/test_redns_name.rb",
      "test/test_redns_question.rb",
+     "test/test_redns_resolver.rb",
      "test/test_redns_resource.rb",
      "test/test_redns_support.rb"
   ]
@@ -56,10 +60,12 @@ Gem::Specification.new do |s|
      "test/test_redns.rb",
      "test/test_redns_address.rb",
      "test/test_redns_buffer.rb",
+     "test/test_redns_connection.rb",
      "test/test_redns_fragment.rb",
      "test/test_redns_message.rb",
      "test/test_redns_name.rb",
      "test/test_redns_question.rb",
+     "test/test_redns_resolver.rb",
      "test/test_redns_resource.rb",
      "test/test_redns_support.rb"
   ]

data/test/test_redns_connection.rb

@@ -0,0 +1,39 @@
+require 'helper'
+
+require 'eventmachine'
+
+class TestReDNSConnection < Test::Unit::TestCase
+  def test_initializer
+    dns = nil
+    
+    EventMachine.run do
+      dns = ReDNS::Connection.instance
+
+      EventMachine.stop_event_loop
+    end
+    
+    assert dns
+    assert_equal ReDNS::Connection, dns.class
+  end
+
+  def test_simple_resolve
+    address = nil
+    
+    EventMachine.run do
+      dns = ReDNS::Connection.instance
+      
+      dns.resolve('example.com') do |result|
+        address = result
+
+        EventMachine.stop_event_loop
+      end
+      
+      EventMachine.add_timer(40) do
+        EventMachine.stop_event_loop
+      end
+    end
+    
+    assert address, "Address was not defined, connection may have timed out"
+    assert_equal %w[ 192.0.32.10 ], address
+  end
+end

data/test/test_redns_message.rb

@@ -17,7 +17,50 @@ class TestReDNSMessage < Test::Unit::TestCase
     assert_equal [ ], message.nameservers
     assert_equal [ ], message.additional_records
     
-    assert_equal ";; HEADER:\n;; opcode: QUERY status: NOERROR id: 1 \n;; flags: ; QUERY: 0, ANSWER: 0, AUTHORITY: 0, ADDITIONAL: 0\n;; QUESTION SECTION:\n\n;; ANSWER SECTION:\n\n;; NAMESERVER SECTION:\n\n;; ADDITIONAL SECTION:\n\n", message.to_s
+    assert_equal ";; HEADER:\n;; opcode: QUERY status: NOERROR id: 1 \n;; flags: rd; QUERY: 0, ANSWER: 0, AUTHORITY: 0, ADDITIONAL: 0\n;; QUESTION SECTION:\n\n;; ANSWER SECTION:\n\n;; NAMESERVER SECTION:\n\n;; ADDITIONAL SECTION:\n\n", message.to_s
+    
+    message.increment_id!
+    
+    assert_equal 2, message.id
+    
+    buffer = message.serialize
+    message_decoded = ReDNS::Message.new(buffer)
+    
+    assert_equal message.to_s, message_decoded.to_s
+  end
+
+  def test_message_all_flags
+    message = ReDNS::Message.new(
+  	  :authorative => true,
+  	  :truncated => true,
+  	  :recursion_desired => false,
+  	  :recursion_available => true,
+  	  :response_code => :server_failure
+    )
+    
+    assert_equal true, message.query?
+
+    assert_equal 1, message.id
+    assert_equal 0, message.questions_count
+    assert_equal 0, message.answers_count
+    assert_equal 0, message.nameservers_count
+    assert_equal 0, message.additional_records_count
+    
+    assert_equal [ ], message.questions
+    assert_equal [ ], message.answers
+    assert_equal [ ], message.nameservers
+    assert_equal [ ], message.additional_records
+    
+    assert_equal ";; HEADER:\n;; opcode: QUERY status: SERVER_FAILURE id: 1 \n;; flags: aa tc ra; QUERY: 0, ANSWER: 0, AUTHORITY: 0, ADDITIONAL: 0\n;; QUESTION SECTION:\n\n;; ANSWER SECTION:\n\n;; NAMESERVER SECTION:\n\n;; ADDITIONAL SECTION:\n\n", message.to_s
+    
+    message.increment_id!
+    
+    assert_equal 2, message.id
+    
+    buffer = message.serialize
+    message_decoded = ReDNS::Message.new(buffer)
+    
+    assert_equal message.to_s, message_decoded.to_s
   end
 
   def test_simple_query
@@ -32,4 +75,97 @@ class TestReDNSMessage < Test::Unit::TestCase
     
     assert_equal 1, message.questions.length
   end
+
+  def test_encoded_fields
+    message = ReDNS::Message.new(
+  	  :authorative => true,
+  	  :truncated => true,
+  	  :questions => [
+  	      ReDNS::Question.new(
+  	        :name => 'example.com',
+  	        :qtype => :a
+  	      )
+  	  ],
+  	  :answers => [
+  	    ReDNS::Resource.new(
+  	      :name => 'example.com',
+  	      :rtype => :a,
+  	      :rdata => ReDNS::Address.new('1.2.3.4'),
+  	      :ttl => 1234
+  	    )
+  	  ],
+  	  :nameservers => [
+  	    ReDNS::Resource.new(
+  	      :name => 'example.com',
+  	      :rtype => :ns,
+  	      :rdata => ReDNS::Name.new('ns.example.com'),
+  	      :ttl => 4321
+  	    )
+  	  ],
+  	  :additional_records => [
+  	    ReDNS::Resource.new(
+  	      :name => 'ns.example.com',
+  	      :rtype => :a,
+  	      :rdata => ReDNS::Address.new('8.6.4.2'),
+  	      :ttl => 9867
+  	    )
+  	  ]
+    )
+    
+    assert_equal ";; HEADER:\n;; opcode: QUERY status: NOERROR id: 1 \n;; flags: aa tc rd; QUERY: 1, ANSWER: 1, AUTHORITY: 1, ADDITIONAL: 1\n;; QUESTION SECTION:\nexample.com. IN A\n;; ANSWER SECTION:\nexample.com. 1234 IN A 1.2.3.4\n;; NAMESERVER SECTION:\nexample.com. 4321 IN NS ns.example.com.\n;; ADDITIONAL SECTION:\nns.example.com. 9867 IN A 8.6.4.2\n", message.to_s
+    
+    buffer = message.serialize
+    assert !buffer.to_s.empty?
+
+    message_decoded = ReDNS::Message.new(buffer)
+    
+    assert_equal message.to_s, message_decoded.to_s
+  end
+  
+  def test_question_default_a
+    question = ReDNS::Message.question('example.com'.freeze)
+    
+    assert_equal ReDNS::Message, question.class
+    
+    assert question.query?
+    assert !question.response?
+    
+    assert_equal 1, question.questions.length
+    
+    assert_equal 'example.com.', question.questions[0].name.to_s
+    assert_equal :a, question.questions[0].qtype
+    assert_equal :in, question.questions[0].qclass
+  end
+
+  def test_question_default_ptr
+    question = ReDNS::Message.question('127.0.0.1'.freeze)
+    
+    assert_equal ReDNS::Message, question.class
+    
+    assert_equal 1, question.questions.length
+
+    assert_equal '127.0.0.1', question.questions[0].name.to_s
+    assert_equal :ptr, question.questions[0].qtype
+  end
+
+  def test_question_default_mx
+    question = ReDNS::Message.question('example.com'.freeze, :mx)
+    
+    assert_equal ReDNS::Message, question.class
+    
+    assert_equal 1, question.questions.length
+
+    assert_equal 'example.com.', question.questions[0].name.to_s
+    assert_equal :mx, question.questions[0].qtype
+  end
+
+  def test_question_does_yield
+    question = ReDNS::Message.question('example.com'.freeze) do |m|
+      m.id = 45532
+    end
+
+    assert_equal ReDNS::Message, question.class
+    
+    assert_equal 45532, question.id
+  end
 end

data/test/test_redns_name.rb

@@ -9,15 +9,23 @@ class TestReDNSName < Test::Unit::TestCase
     
     assert name.empty?
   end
-
+  
   def test_string_initializer
-    name = ReDNS::Name.new('example.net')
+    name = ReDNS::Name.new('example.net'.freeze)
     
     assert_equal 'example.net.', name.to_s
 
     assert !name.empty?
   end
 
+  def test_string_address_initializer
+    name = ReDNS::Name.new('127.0.0.1'.freeze)
+    
+    assert_equal '127.0.0.1', name.to_s
+
+    assert !name.empty?
+  end
+
   def test_defaults
     example_buffer = ReDNS::Buffer.new(
       [

data/test/test_redns_resolver.rb

@@ -0,0 +1,120 @@
+require 'helper'
+
+class TestReReDNSResolver < Test::Unit::TestCase
+	def test_create
+	  res = ReDNS::Resolver.new
+
+		assert res
+
+		assert !res.servers.empty?
+	end
+
+	def test_servers
+		res = ReDNS::Resolver.new
+
+		res.servers = [ "192.168.1.1" ]
+
+		assert_equal [ "192.168.1.1" ], res.servers
+  end
+
+	def test_query
+		res = ReDNS::Resolver.new
+
+		r = res.query do |q|
+			q.qtype = :a
+			q.name = "example.com"
+		end
+
+		assert r, "ReDNS::Resolver#query did not produce a reply"
+
+		assert_equal 1, r.questions.size
+		assert_equal 1, r.answers.size
+
+		assert_equal '192.0.32.10', r.answers[0].rdata.to_s
+	end
+
+	def test_ns_query
+		res = ReDNS::Resolver.new
+		
+		assert !res.servers.empty?
+
+		r = res.query do |q|
+			q.qtype = :ns
+			q.name = "example.com"
+		end
+
+		assert r, "ReDNS::Resolver#query did not produce a reply"
+
+		assert_equal 1, r.questions.size
+		assert_equal 2, r.answers.size
+
+		assert_equal ReDNS::Name, r.answers[0].rdata.class
+		assert_equal ReDNS::Name, r.answers[1].rdata.class
+	end
+
+	def test_bulk_query
+		addrs = %w[
+		  128.100.8.1
+		  128.100.8.2
+		  128.100.8.3
+		  128.100.8.4
+		].collect do |i|
+		  ReDNS::Support.addr_to_arpa(i)
+	  end
+
+		res = ReDNS::Resolver.new
+
+		rlist = res.bulk_query(:ptr, addrs)
+
+		assert rlist
+
+		assert_equal 4, rlist.length
+		
+		assert_equal addrs.sort, rlist.keys.sort
+		
+		assert rlist[addrs[0]]
+		
+		expected =  %w[
+		  sf-ecf.gw.utoronto.ca.
+		  fs.ecf.utoronto.ca.
+		  ecf-if.gw.utoronto.ca.
+		  ecf-8-hub.ecf.utoronto.ca.
+		]
+
+    answers = addrs.collect do |a|
+	    rlist[a] and rlist[a].answers[0] and rlist[a].answers[0].rdata.to_s
+    end
+
+		assert_equal expected, answers
+	end
+
+	def test_reverse_addresses
+    addrs = %w[
+		  128.100.8.1
+		  128.100.8.2
+		  128.100.8.3
+		  128.100.8.4
+		]
+		
+		res = ReDNS::Resolver.new
+
+		rlist = res.reverse_addresses(addrs)
+
+		assert rlist
+		
+		assert_equal addrs.length, rlist.length
+
+		expected =  %w[
+		  sf-ecf.gw.utoronto.ca.
+		  fs.ecf.utoronto.ca.
+		  ecf-if.gw.utoronto.ca.
+		  ecf-8-hub.ecf.utoronto.ca.
+		]
+		
+    answers = addrs.collect do |a|
+	    rlist[a]
+    end
+
+		assert_equal expected, answers
+	end
+end

data/test/test_redns_support.rb

@@ -13,4 +13,9 @@ class TestReDNSSupport < Test::Unit::TestCase
     assert_equal '1.2.3.4', inet_ntoa(inet_aton('1.2.3.4'))
     assert_equal '255.255.255.255', inet_ntoa(inet_aton('255.255.255.255'))
   end
+  
+  def test_default_resolver_address
+    assert ReDNS::Support.default_resolver_address
+    assert !ReDNS::Support.default_resolver_address.empty?
+  end
 end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
+  - 1
   - 0
-  - 0
-  version: 0.0.0
+  version: 0.1.0
 platform: ruby
 authors: 
 - tadman
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-13 00:00:00 -04:00
+date: 2010-08-16 00:00:00 -04:00
 default_executable: 
 dependencies: []
 
@@ -35,6 +35,7 @@ files:
 - lib/redns.rb
 - lib/redns/address.rb
 - lib/redns/buffer.rb
+- lib/redns/connection.rb
 - lib/redns/fragment.rb
 - lib/redns/message.rb
 - lib/redns/name.rb
@@ -43,6 +44,7 @@ files:
 - lib/redns/record/mx.rb
 - lib/redns/record/null.rb
 - lib/redns/record/soa.rb
+- lib/redns/resolver.rb
 - lib/redns/resource.rb
 - lib/redns/support.rb
 - redns.gemspec
@@ -50,10 +52,12 @@ files:
 - test/test_redns.rb
 - test/test_redns_address.rb
 - test/test_redns_buffer.rb
+- test/test_redns_connection.rb
 - test/test_redns_fragment.rb
 - test/test_redns_message.rb
 - test/test_redns_name.rb
 - test/test_redns_question.rb
+- test/test_redns_resolver.rb
 - test/test_redns_resource.rb
 - test/test_redns_support.rb
 has_rdoc: true
@@ -93,9 +97,11 @@ test_files:
 - test/test_redns.rb
 - test/test_redns_address.rb
 - test/test_redns_buffer.rb
+- test/test_redns_connection.rb
 - test/test_redns_fragment.rb
 - test/test_redns_message.rb
 - test/test_redns_name.rb
 - test/test_redns_question.rb
+- test/test_redns_resolver.rb
 - test/test_redns_resource.rb
 - test/test_redns_support.rb