redns 0.1.17 → 0.2.0

data/lib/redns/name.rb

@@ -5,7 +5,7 @@ class ReDNS::Name < ReDNS::Fragment
   
   # == Attributes ===========================================================
   
-  attribute :name, :default => '.'
+  attribute :name, default: '.'
 
   # == Instance Methods =====================================================
   
@@ -16,7 +16,7 @@ class ReDNS::Name < ReDNS::Fragment
       # method, not intercepted and treated as an actual String
       super(contents)
     when String
-      super(:name => contents)
+      super(name: contents)
       
       unless (ReDNS::Support.is_ip?(name) or self.name.match(/\.$/))
         self.name += '.'
@@ -26,37 +26,37 @@ class ReDNS::Name < ReDNS::Fragment
     end
   end
   
-	def to_s
-	  self.name
-	end
-	
-	def to_a
-		[ self.name ]
-	end
-	
-	def length
-		to_s.length
-	end
-	
-	def empty?
-		name == '.'
-	end
-	
-	def serialize(buffer = ReDNS::Buffer.new)
-		buffer.append(
-		  self.name.split(/\./).collect { |l| [ l.length, l ].pack("ca*") }.join('')
-		)
+  def to_s
+    self.name
+  end
+  
+  def to_a
+    [ self.name ]
+  end
+  
+  def length
+    to_s.length
+  end
+  
+  def empty?
+    name == '.'
+  end
+  
+  def serialize(buffer = ReDNS::Buffer.new)
+    buffer.append(
+      self.name.split(/\./).collect { |l| [ l.length, l ].pack("ca*") }.join('')
+    )
 
-		buffer.append("\0")
-		
-		buffer
-	end
-	
-	def deserialize(buffer)
-		self.name = ''
-		
-		return_to_offset = nil
-		pointer_count = 0
+    buffer.append("\0")
+    
+    buffer
+  end
+  
+  def deserialize(buffer)
+    self.name = ''
+    
+    return_to_offset = nil
+    pointer_count = 0
 
     while (c = buffer.unpack('C')[0])
       if (c & 0xC0 == 0xC0)
@@ -99,7 +99,9 @@ class ReDNS::Name < ReDNS::Fragment
       buffer.rewind
       buffer.advance(return_to_offset)
     end
+
+    self.name.encode!('UTF-8')
     
     self
-	end
+  end
 end

data/lib/redns/question.rb

@@ -3,38 +3,38 @@ class ReDNS::Question < ReDNS::Fragment
   
   # == Attributes ===========================================================
   
-	attribute :name, :class => ReDNS::Name, :default => lambda { ReDNS::Name.new }
-	
-	attribute :qclass, :default => :in
-	attribute :qtype, :default => :any
+  attribute :name, class: ReDNS::Name, default: lambda { ReDNS::Name.new }
+  
+  attribute :qclass, default: :in
+  attribute :qtype, default: :any
 
   # == Class Methods ========================================================
 
   # == Instance Methods =====================================================
 
-	def to_s
-		"#{name} #{qclass.to_s.upcase} #{qtype.to_s.upcase}"
-	end
-	
-	def serialize(buffer = ReDNS::Buffer.new)
-	  name.serialize(buffer)
-	  buffer.pack(
-	    'nn',
-	    ReDNS::RR_TYPE[self.qtype],
-	    ReDNS::RR_CLASS[self.qclass]
-  	)
+  def to_s
+    "#{name} #{qclass.to_s.upcase} #{qtype.to_s.upcase}"
+  end
+  
+  def serialize(buffer = ReDNS::Buffer.new)
+    name.serialize(buffer)
+    buffer.pack(
+      'nn',
+      ReDNS::RR_TYPE[self.qtype],
+      ReDNS::RR_CLASS[self.qclass]
+    )
 
     buffer
-	end
-	
-	def deserialize(buffer)
-	  self.name = ReDNS::Name.new(buffer)
-	  
-	  data = buffer.unpack('nn')
-	  
-		self.qtype = ReDNS::RR_TYPE_LABEL[data.shift]
-		self.qclass = ReDNS::RR_CLASS_LABEL[data.shift]
-		
-		self
-	end
+  end
+  
+  def deserialize(buffer)
+    self.name = ReDNS::Name.new(buffer)
+    
+    data = buffer.unpack('nn')
+    
+    self.qtype = ReDNS::RR_TYPE_LABEL[data.shift]
+    self.qclass = ReDNS::RR_CLASS_LABEL[data.shift]
+    
+    self
+  end
 end

data/lib/redns/record/mx.rb

@@ -1,28 +1,28 @@
 class ReDNS::Record::MX < ReDNS::Fragment
   # == Attributes ===========================================================
   
-  attribute :name, :default => lambda { ReDNS::Name.new }, :class => ReDNS::Name
-  attribute :preference, :default => 0, :convert => :to_i
+  attribute :name, default: lambda { ReDNS::Name.new }, class: ReDNS::Name
+  attribute :preference, default: 0, convert: :to_i
 
   # == Class Methods ========================================================
 
   # == Instance Methods =====================================================
-	
-	def to_s
-		"#{preference} #{name}"
-	end
-	
-	def to_a
-		[ name.to_s, preference ]
-	end
-	
-	def serialize(buffer = ReDNS::Buffer.new)
-	  buffer.pack('n', self.preference)
-	  self.name.serialize(buffer)
-	end
+  
+  def to_s
+    "#{preference} #{name}"
+  end
+  
+  def to_a
+    [ name.to_s, preference ]
+  end
+  
+  def serialize(buffer = ReDNS::Buffer.new)
+    buffer.pack('n', self.preference)
+    self.name.serialize(buffer)
+  end
 
-	def deserialize(buffer)
-	  self.preference = buffer.unpack('n')[0]
-	  self.name = ReDNS::Name.new(buffer)
-	end
+  def deserialize(buffer)
+    self.preference = buffer.unpack('n')[0]
+    self.name = ReDNS::Name.new(buffer)
+  end
 end

data/lib/redns/record/null.rb

@@ -1,39 +1,39 @@
 class ReDNS::Record::Null < ReDNS::Fragment
   # == Attributes ===========================================================
   
-  attribute :contents, :default => '', :primary => true
+  attribute :contents, default: '', primary: true
 
   # == Class Methods ========================================================
 
   # == Instance Methods =====================================================
-	
-	def to_s
-		"#{self.contents}"
-	end
-	
-	def to_a
-		[ self.contents ]
-	end
-	
-	def serialize(buffer = ReDNS::Buffer.new)
-	  buffer.pack('C', self.contents.length)
+  
+  def to_s
+    "#{self.contents}"
+  end
+  
+  def to_a
+    [ self.contents ]
+  end
+  
+  def serialize(buffer = ReDNS::Buffer.new)
+    buffer.pack('C', self.contents.length)
 
-	  buffer.append(self.contents)
+    buffer.append(self.contents)
 
-	  buffer
-	end
+    buffer
+  end
 
-	def deserialize(buffer)
-	  self.contents = ''
-	  
-	  while (!buffer.empty?)
-  	  if (content_length = buffer.unpack('C')[0])
-  	    if (string = buffer.unpack("a#{content_length}")[0])
-      	  self.contents << string
-    	  end
-  	  end
-	  end
+  def deserialize(buffer)
+    self.contents = ''
+    
+    while (!buffer.empty?)
+      if (content_length = buffer.unpack('C')[0])
+        if (string = buffer.unpack("a#{content_length}")[0])
+          self.contents << string
+        end
+      end
+    end
 
-	  self
-	end
+    self
+  end
 end

data/lib/redns/record/soa.rb

@@ -1,63 +1,63 @@
 class ReDNS::Record::SOA < ReDNS::Fragment
   # == Attributes ===========================================================
   
-  attribute :mname, :default => lambda { ReDNS::Name.new }, :class => ReDNS::Name
-  attribute :rname, :default => lambda { ReDNS::Name.new }, :class => ReDNS::Name
+  attribute :mname, default: lambda { ReDNS::Name.new }, class: ReDNS::Name
+  attribute :rname, default: lambda { ReDNS::Name.new }, class: ReDNS::Name
   
-  attribute :serial, :default => 0, :convert => :to_i
-  attribute :refresh, :default => 0, :convert => :to_i
-  attribute :retry, :default => 0, :convert => :to_i
-  attribute :expire, :default => 0, :convert => :to_i
-  attribute :minimum, :default => 0, :convert => :to_i
+  attribute :serial, default: 0, convert: :to_i
+  attribute :refresh, default: 0, convert: :to_i
+  attribute :retry, default: 0, convert: :to_i
+  attribute :expire, default: 0, convert: :to_i
+  attribute :minimum, default: 0, convert: :to_i
 
   # == Class Methods ========================================================
 
   # == Instance Methods =====================================================
-	
-	def to_s
-	  to_a.join(' ')
-	end
+  
+  def to_s
+    to_a.join(' ')
+  end
 
-	def to_a
-		[
-		  self.mname,
-		  self.rname,
-		  self.serial,
-		  self.refresh,
-		  self.retry,
-		  self.expire,
-		  self.minimum
-		]
-	end
-	
-	def serialize(buffer = ReDNS::Buffer.new)
-	  self.mname.serialize(buffer)
-	  self.rname.serialize(buffer)
+  def to_a
+    [
+      self.mname,
+      self.rname,
+      self.serial,
+      self.refresh,
+      self.retry,
+      self.expire,
+      self.minimum
+    ]
+  end
+  
+  def serialize(buffer = ReDNS::Buffer.new)
+    self.mname.serialize(buffer)
+    self.rname.serialize(buffer)
 
-		buffer.pack(
-	    'NNNNN',
-			self.serial,
-			self.refresh,
-			self.retry,
-			self.expire,
-			self.minimum
-		)
-		
-		buffer
-	end
+    buffer.pack(
+      'NNNNN',
+      self.serial,
+      self.refresh,
+      self.retry,
+      self.expire,
+      self.minimum
+    )
+    
+    buffer
+  end
 
-	def deserialize(buffer)
-	  self.mname = ReDNS::Name.new(buffer)
-	  self.rname = ReDNS::Name.new(buffer)
+  def deserialize(buffer)
+    self.mname = ReDNS::Name.new(buffer)
+    self.rname = ReDNS::Name.new(buffer)
 
-		data = buffer.unpack('NNNNN')
+    data = buffer.unpack('NNNNN')
 
-		self.serial = data.shift
-		self.refresh = data.shift
-		self.retry = data.shift
-		self.expire = data.shift
-		self.minimum = data.shift
-		
-		self
-	end
+    self.serial = data.shift
+    self.refresh = data.shift
+    self.retry = data.shift
+    self.expire = data.shift
+    self.minimum = data.shift
+    
+    self
+  end
 end

data/lib/redns/resolver.rb

@@ -4,285 +4,287 @@ require 'fcntl'
 BasicSocket.do_not_reverse_lookup = true
 
 class ReDNS::Resolver
-	# == Class Properties =====================================================
-	
-	@servers = nil
-	@timeout = 5
-	
-	# == Class Methods ========================================================
+  # == Constants ============================================================
 
-	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
+  TIMEOUT_DEFAULT = 5
+  RESOLV_CONF = '/etc/resolv.conf'.freeze
+  
+  # == Class Methods ========================================================
 
-	rescue Errno::ENOENT
-	  # /etc/resolv.conf may not be present on misconfigured or offline systems
-	  [ ]
-	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 self.in_resolv_conf
+    File.open(RESOLV_CONF) do |fh|
+      fh.readlines.map do |l|
+        l.chomp.sub(/#.*/, '')
+      end.reject do |l|
+        !l.sub!(/\A\s*nameserver\s+/, '')
+      end
+    end
+    
+  rescue Errno::ENOENT
+    # /etc/resolv.conf may not be present on misconfigured or offline systems
+    [ ]
+  end
+  
+  def self.servers
+    @servers ||= self.in_resolv_conf
+  end
+  
+  def self.servers=(list)
+    @servers = list
+  end
+  
+  def self.timeout
+    @timeout ||= TIMEOUT_DEFAULT
+  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
+  def initialize(options = { }, &block)
+    @servers = self.class.servers.dup
+    @responses = { }
+    @timeout = nil
+    
+    @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
+      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 a_for(name)
+    simple_query(:a, name)
+  end
+  
+  def ns_for(name)
+    if (name.match(/\A(\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 mx_for(name)
+    simple_query(:mx, name)
+  end
 
-	def ptr_for(name)
-		simple_query(:ptr, ReDNS::Support.addr_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 ptr_for(name)
+    simple_query(:ptr, ReDNS::Support.addr_to_arpa(name))
+  end
+  
+  def ptr_for_list(name)
+    ips = [ ips ].flatten
+    
+    bulk_query(
+      :ptr,
+      ips.map do |ip|
+        ReDNS::Support.addr_to_arpa(ip)
+      end
+    )
+  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
+  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.each_with_object({ }) do |r, h|
+      if (ip = map[r.questions[0].name.to_s])
+        h[ip] = (r.answers[0] and r.answers[0].rdata.to_s)
+      end
+    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
+    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
+  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
+    _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
+    while (left > 0)
+      if (ready = IO.select([ @socket ], nil, nil, [ 1.0, left ].min))
+        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
-	
+      left = _timeout - Time.now.to_f + start.to_f
+    end
+  end
+  
 protected
-	def expand_answers(r)
+  def expand_answers(r)
 
-		unless (r and r.answers)
-			return nil
-		end
+    unless (r and r.answers)
+      return nil
+    end
 
-		result = r.answers
-		radd = (r.additional_records or [ ])
-		
-		result.select do |rr|
-		  case (rr.rtype)
-	    when :ns
-	      # These record types require further investigation if they are to
-	      # be included in the result-set.
-	      true
+    result = r.answers
+    radd = (r.additional_records or [ ])
+    
+    result.select do |rr|
+      case (rr.rtype)
+      when :ns
+        # These record types require further investigation if they are to
+        # be included in the result-set.
+        true
       else
         false
-		  end
-		end.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
-				r.additional_records = additional
-			end
-		end
-		
-		result
-	end
+      end
+    end.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
+        r.additional_records = 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_records and r.additional_records.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
+  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_records and r.additional_records.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