redns 0.1.17 → 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d2bafcebc9a854b66739ac0f38dd909dd56ec4ef
+  data.tar.gz: e3da07761ddd463efaecdbf544d28ef4a8fa7bbd
+SHA512:
+  metadata.gz: 51dc9b6de6d62d44cad19112d858a98ad14cc8457213841665c5526da4d6e5eac7045d9c20f0750d8f3622d412e77d4c0f8ec39f013ee4eb160ebacb33d48d2a
+  data.tar.gz: 617feea176a9adf4f3e7895bc0f46da460850654ccaa598e26aa168dea00acfa262490f9cee88d62af526b747dafbcbd96f67e588dc2e723ccc4efbc6d476ace

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+rvm:
+  - 1.9.3-p551
+  - 2.0.0-p648
+  - 2.1.10
+  - 2.2.5
+  - 2.3.1
+  - 2.4.1

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+gem 'rake'
+gem 'eventmachine'
+
+group :test do
+  gem 'test-unit'
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2005-2016 Scott Tadman
+
+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.

data/README.md

@@ -0,0 +1,31 @@
+# redns
+
+Reactor-Ready DNS Library
+
+This library includes native Ruby encoder/decoder classes for typical
+DNS records that are specified in RFC1035.
+
+In addition, RFC2671 extension mechanisms are also supported.
+
+## Installation
+
+To install as a dependency, add to your `Gemfile`:
+
+    gem 'redns'
+
+Then `bundle install` should pick up any dependencies.
+
+## Usage
+
+
+
+## References
+
+* [RFC1035](http://www.faqs.org/rfcs/rfc1035.html) - Domain names - implementation and specification
+* [RFC2671](http://www.faqs.org/rfcs/rfc2671.html) - Extension Mechanisms for DNS (EDNS0)
+
+## Copyright
+
+(C) 2005-2017 Scott Tadman
+
+See [LICENSE](LICENSE.txt) for more details.

data/Rakefile

@@ -19,22 +19,11 @@ rescue LoadError
 end
 
 require 'rake/testtask'
+
 Rake::TestTask.new(:test) do |test|
   test.libs << 'lib' << 'test'
   test.pattern = 'test/**/test_*.rb'
   test.verbose = true
 end
 
-task :test => :check_dependencies
-
-task :default => :test
-
-require 'rake/rdoctask'
-Rake::RDocTask.new do |rdoc|
-  version = File.exist?('VERSION') ? File.read('VERSION') : ""
-
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "redns #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
+task default: :test

data/VERSION

@@ -1 +1 @@
-0.1.17
+0.2.0

data/bin/redig

@@ -4,12 +4,13 @@ $LOAD_PATH << File.expand_path(File.join('..','lib'), File.dirname(__FILE__))
 
 require 'optparse'
 
+require 'eventmachine'
 require 'redns'
 
 # == Main ===================================================================
 
 options = {
-  :query_type => :any,
+  query_type: :any,
 }
 
 op = OptionParser.new do |op|
@@ -30,20 +31,26 @@ queries = op.parse(*ARGV).select do |query|
   end
 end
 
-resolver = ReDNS::Resolver.new do |resolver|
-  if (options[:nameservers])
-    resolver.servers = options[:nameservers]
+EventMachine.run do
+  resolver = ReDNS::Connection.instance do |c|
+    if (options[:nameservers])
+      c.nameservers = options[:nameservers]
+    end
+
+    c.timeout = 2
   end
-end
 
-queries.each do |query|
-  results = resolver.simple_query(options[:query_type], query)
-  
-  if (results)
-    results.each do |result|
-      puts result.to_s
+  queries.each do |query|
+    resolver.resolve(query, options[:query_type]) do |results|
+      if (results)
+        results.each do |result|
+          puts result.to_s
+        end
+      else
+        puts "No results"
+      end
+
+      EventMachine.stop_event_loop
     end
-  else
-    puts "No results"
   end
 end

data/lib/redns.rb

@@ -4,26 +4,26 @@ module ReDNS
   # RFC1035 Resource Record Type Constants
 
   RR_TYPE = {
-    :a => 1,
-    :ns => 2,
-    :md => 3,
-    :mf => 4,
-    :cname => 5,
-    :soa => 6,
-    :mb => 7,
-    :mg => 8,
-    :mr => 9,
-    :null => 10,
-    :wks => 11,
-    :ptr => 12,
-    :hinfo => 13,
-    :minfo => 14,
-    :mx => 15,
-    :txt => 16,
-    :axfr => 252,
-    :mailb => 253,
-    :maila => 254,
-    :any => 255
+    a: 1,
+    ns: 2,
+    md: 3,
+    mf: 4,
+    cname: 5,
+    soa: 6,
+    mb: 7,
+    mg: 8,
+    mr: 9,
+    null: 10,
+    wks: 11,
+    ptr: 12,
+    hinfo: 13,
+    minfo: 14,
+    mx: 15,
+    txt: 16,
+    axfr: 252,
+    mailb: 253,
+    maila: 254,
+    any: 255
   }.freeze
   
   RR_TYPE_LABEL = RR_TYPE.invert.freeze
@@ -34,28 +34,28 @@ module ReDNS
   #       context. This library is entirely IN(internet)-bound.
   
   RR_CLASS = {
-    :in => 1
+    in: 1
   }.freeze
   
   RR_CLASS_LABEL = RR_CLASS.invert.freeze
   
   OPCODE = {
-    :query => 0,
-    :iquery => 1,
-    :status => 2,
-    :unknown => 15
+    query: 0,
+    iquery: 1,
+    status: 2,
+    unknown: 15
   }.freeze
   
   OPCODE_LABEL = OPCODE.invert.freeze
 
   RCODE = {
-    :noerror => 0,
-    :format_error => 1,
-    :server_failure => 2,
-    :name_error => 3,
-    :not_implemented => 4,
-    :refused => 5,
-    :unknown => 15
+    noerror: 0,
+    format_error: 1,
+    server_failure: 2,
+    name_error: 3,
+    not_implemented: 4,
+    refused: 5,
+    unknown: 15
   }.freeze
   
   RCODE_LABEL = RCODE.invert.freeze

data/lib/redns/address.rb

@@ -1,7 +1,7 @@
 class ReDNS::Address < ReDNS::Fragment
   # == Attributes ===========================================================
   
-  attribute :address, :default => '0.0.0.0'
+  attribute :address, default: '0.0.0.0'
   
   # == Class Methods ========================================================
 
@@ -14,7 +14,7 @@ class ReDNS::Address < ReDNS::Fragment
       # method, not intercepted and treated as an actual String
       super(contents)
     when String
-      super(:address => contents)
+      super(address: contents)
     else
       super(contents)
     end
@@ -24,21 +24,21 @@ class ReDNS::Address < ReDNS::Fragment
     self.address == '0.0.0.0'
   end
   
-	def to_s
-	  self.address
-	end
-	
-	def to_a
-		[ to_s ]
-	end
-	
-	def serialize(buffer = ReDNS::Buffer.new)
-	  buffer.append(inet_aton(self.address))
-	  buffer
-	end
-	
-	def deserialize(buffer)
-	  self.address = inet_ntoa(buffer)
-	  self
-	end	
+  def to_s
+    self.address
+  end
+  
+  def to_a
+    [ to_s ]
+  end
+  
+  def serialize(buffer = ReDNS::Buffer.new)
+    buffer.append(inet_aton(self.address))
+    buffer
+  end
+  
+  def deserialize(buffer)
+    self.address = inet_ntoa(buffer).encode('UTF-8')
+    self
+  end 
 end

data/lib/redns/connection.rb

@@ -3,13 +3,13 @@ require 'socket'
 class ReDNS::Connection < EventMachine::Connection
   # == Constants ============================================================
   
-  DEFAULT_TIMEOUT = 5
-  DEFAULT_ATTEMPTS = 2
+  TIMEOUT_DEFAULT = 5.0
+  ATTEMPTS_DEFAULT = 5
   SEQUENCE_LIMIT = 0x10000
   
   # == Properties ===========================================================
   
-  attr_accessor :timeout, :attempts
+  attr_reader :timeout, :attempts
 
   # == Extensions ===========================================================
 
@@ -37,14 +37,14 @@ class ReDNS::Connection < EventMachine::Connection
   # If the supplied value is zero or nil, will revert to the default.
   def timeout=(value)
     @timeout = value.to_i
-    @timeout = DEFAULT_TIMEOUT if (@timeout == 0)
+    @timeout = TIMEOUT_DEFAULT if (@timeout == 0)
   end
 
   # Sets the current retry attempts parameter to the supplied value.
   # If the supplied value is zero or nil, will revert to the default.
   def attempts=(value)
     @attempts = value.to_i
-    @attempts = DEFAULT_ATTEMPTS if (@attempts == 0)
+    @attempts = ATTEMPTS_DEFAULT if (@attempts == 0)
   end
 
   # Returns the configured list of nameservers as an Array. If not configured
@@ -62,7 +62,7 @@ class ReDNS::Connection < EventMachine::Connection
     @nameservers = nil if (list.empty?)
   end
   
-  # Picks a random nameserver from the configured list=
+  # Picks a random nameserver from the configured list.
   def random_nameserver
     nameservers[rand(nameservers.length)]
   end
@@ -93,13 +93,13 @@ class ReDNS::Connection < EventMachine::Connection
 
     if (result > 0)
       @callback[@sequence] = {
-        :serialized_message => serialized_message,
-        :type => type,
-        :filter_by_type => (type == :any || !filter) ? false : type,
-        :nameserver => target_nameserver,
-        :attempts => self.attempts - 1,
-        :callback => callback,
-        :at => Time.now
+        serialized_message: serialized_message,
+        type: type,
+        filter_by_type: (type == :any || !filter) ? false : type,
+        nameserver: target_nameserver,
+        attempts: self.attempts - 1,
+        callback: callback,
+        at: Time.now
       }
     else
       callback.call(nil)
@@ -118,8 +118,8 @@ class ReDNS::Connection < EventMachine::Connection
     # Callback tracking is done by matching response IDs in a lookup table
     @callback = { }
     
-    @timeout ||= DEFAULT_TIMEOUT
-    @attempts ||= DEFAULT_ATTEMPTS
+    @timeout ||= TIMEOUT_DEFAULT
+    @attempts ||= ATTEMPTS_DEFAULT
     
     EventMachine.add_periodic_timer(1) do
       check_for_timeouts!
@@ -155,7 +155,7 @@ protected
   # Checks all pending queries for timeouts and triggers callbacks or retries
   # if necessary.
   def check_for_timeouts!
-    timeout_at = Time.now - (@timeout || DEFAULT_TIMEOUT)
+    timeout_at = Time.now - (@timeout || TIMEOUT_DEFAULT)
   
     @callback.keys.each do |k|
       if (params = @callback[k])

data/lib/redns/fragment.rb

@@ -76,10 +76,10 @@ class ReDNS::Fragment
 
   # == Instance Methods =====================================================
   
-	def initialize(contents = nil)
-	  @attributes = { }
+  def initialize(contents = nil)
+    @attributes = { }
 
-	  case (contents)
+    case (contents)
     when Hash
       assign(contents)
     when ReDNS::Buffer
@@ -94,8 +94,8 @@ class ReDNS::Fragment
     end
     
     yield(self) if (block_given?)
-	end
-	
+  end
+  
 protected
   def assign(attributes)
     attributes.each do |k, v|

data/lib/redns/message.rb

@@ -5,26 +5,26 @@ class ReDNS::Message < ReDNS::Fragment
 
   # == Attributes ===========================================================
   
-	attribute :random_id, :default => lambda { rand(0x10000) }
+  attribute :random_id, default: lambda { rand(0x10000) }
 
-  attribute :id, :convert => lambda { |v| v.to_i % 0x10000 }, :default => 1
-	attribute :query, :boolean => true, :default => true
-	attribute :opcode, :default => :query
-	attribute :authorative, :boolean => true, :default => false
-	attribute :truncated, :boolean => true, :default => false
-	attribute :recursion_desired, :boolean => true, :default => true
-	attribute :recursion_available, :boolean => true, :default => false
-	attribute :response_code, :default => :noerror
-	
-	attribute :questions_count, :convert => :to_i, :default => 0
-	attribute :answers_count, :convert => :to_i, :default => 0
-	attribute :nameservers_count, :convert => :to_i, :default => 0
-	attribute :additional_records_count, :convert => :to_i, :default => 0
-	
-	attribute :questions, :default => lambda { [ ] }
-	attribute :answers, :default => lambda { [ ] }
-	attribute :nameservers, :default => lambda { [ ] }
-	attribute :additional_records, :default => lambda { [ ] }
+  attribute :id, convert: lambda { |v| v.to_i % 0x10000 }, default: 1
+  attribute :query, boolean: true, default: true
+  attribute :opcode, default: :query
+  attribute :authorative, boolean: true, default: false
+  attribute :truncated, boolean: true, default: false
+  attribute :recursion_desired, boolean: true, default: true
+  attribute :recursion_available, boolean: true, default: false
+  attribute :response_code, default: :noerror
+  
+  attribute :questions_count, convert: :to_i, default: 0
+  attribute :answers_count, convert: :to_i, default: 0
+  attribute :nameservers_count, convert: :to_i, default: 0
+  attribute :additional_records_count, convert: :to_i, default: 0
+  
+  attribute :questions, default: lambda { [ ] }
+  attribute :answers, default: lambda { [ ] }
+  attribute :nameservers, default: lambda { [ ] }
+  attribute :additional_records, default: lambda { [ ] }
 
   # == Class Methods ========================================================
   
@@ -42,10 +42,10 @@ class ReDNS::Message < ReDNS::Fragment
     end
     
     message = new(
-      :questions => [
+      questions: [
         ReDNS::Question.new(
-          :name => name,
-          :qtype => qtype
+          name: name,
+          qtype: qtype
         )
       ]
     )
@@ -57,78 +57,78 @@ class ReDNS::Message < ReDNS::Fragment
 
   # == Instance Methods =====================================================
   
-	def increment_id!
-	  self.id = (self.id + 1) % 0x10000
-	end
+  def increment_id!
+    self.id = (self.id + 1) % 0x10000
+  end
 
   # Returns true if this is a response type message, false otherwise, as is
   # the case with query messages.
-	def response?
-	  !self.query?
-	end
-	
-	# Returns a string representation of the message in a format similar to what
-	# the dig shell utility produces.
-	def to_s
-	  flags = [ ]
-	  flags << 'qr' if (response?)
-	  flags << 'aa' if (authorative?)
-	  flags << 'tc' if (truncated?)
-	  flags << 'rd' if (recursion_desired?)
-	  flags << 'ra' if (recursion_available?)
-	  
-		";; HEADER:\n;; opcode: #{opcode.to_s.upcase} status: #{response_code.to_s.upcase} id: #{id} \n" +
-		";; flags: #{flags.join(' ')}; QUERY: #{questions.length}, ANSWER: #{answers.length}, AUTHORITY: #{nameservers.length}, ADDITIONAL: #{additional_records.length}" +
-		"\n" +
-		";; QUESTION SECTION:\n" +
-		questions.collect(&:to_s).join("\n") + "\n" +
-		";; ANSWER SECTION:\n" +
-		answers.collect(&:to_s).join("\n") + "\n" +
-		";; NAMESERVER SECTION:\n" +
-		nameservers.collect(&:to_s).join("\n") + "\n" +
-		";; ADDITIONAL SECTION:\n" +
-		additional_records.collect(&:to_s).join("\n") + "\n"
-	end
-	
-	# Returns the length of the encoded DNS request.
-	def length
-		to_dns.length
-	end
-	
-	# Returns true if the questions, answers, nameservers and additional records
-	# are all empty, false otherwise.
-	def empty?
-		questions.empty? and
-		  answers.empty? and
-		  nameservers.empty? and
-		  additional_records.empty?
-	end
-	
-	# Returns a YAML serialized version of the message.
-	def to_yaml
-		@attributes.to_yaml
-	end
+  def response?
+    !self.query?
+  end
+  
+  # Returns a string representation of the message in a format similar to what
+  # the dig shell utility produces.
+  def to_s
+    flags = [ ]
+    flags << 'qr' if (response?)
+    flags << 'aa' if (authorative?)
+    flags << 'tc' if (truncated?)
+    flags << 'rd' if (recursion_desired?)
+    flags << 'ra' if (recursion_available?)
+    
+    ";; HEADER:\n;; opcode: #{opcode.to_s.upcase} status: #{response_code.to_s.upcase} id: #{id} \n" +
+    ";; flags: #{flags.join(' ')}; QUERY: #{questions.length}, ANSWER: #{answers.length}, AUTHORITY: #{nameservers.length}, ADDITIONAL: #{additional_records.length}" +
+    "\n" +
+    ";; QUESTION SECTION:\n" +
+    questions.collect(&:to_s).join("\n") + "\n" +
+    ";; ANSWER SECTION:\n" +
+    answers.collect(&:to_s).join("\n") + "\n" +
+    ";; NAMESERVER SECTION:\n" +
+    nameservers.collect(&:to_s).join("\n") + "\n" +
+    ";; ADDITIONAL SECTION:\n" +
+    additional_records.collect(&:to_s).join("\n") + "\n"
+  end
+  
+  # Returns the length of the encoded DNS request.
+  def length
+    to_dns.length
+  end
+  
+  # Returns true if the questions, answers, nameservers and additional records
+  # are all empty, false otherwise.
+  def empty?
+    questions.empty? and
+      answers.empty? and
+      nameservers.empty? and
+      additional_records.empty?
+  end
+  
+  # Returns a YAML serialized version of the message.
+  def to_yaml
+    @attributes.to_yaml
+  end
 
   # Serializes the message into a supplied buffer, or allocates a new one to
   # store it. Returns the buffer used.
-	def serialize(buffer = ReDNS::Buffer.new)
-	  buffer.pack(
-		  'nnnnnn',
-			self.id,
-			(
-  			(self.query? ? 0 : 0x8000) |
-  			(ReDNS::OPCODE[self.opcode] || ReDNS::OPCODE[:unknown]) << 12 |
-  			(self.authorative? ? 0x0400 : 0) |
-  			(self.truncated? ? 0x0200 : 0) |
-  			(self.recursion_desired? ? 0x0100 : 0) |
-  			(self.recursion_available? ? 0x0080 : 0) |
-  			(ReDNS::RCODE[self.response_code] || ReDNS::RCODE[:noerror])
-			),
-		  self.questions.length,
-			self.answers.length,
-			self.nameservers.length,
-			self.additional_records.length
-  	)
+  def serialize(buffer = ReDNS::Buffer.new)
+    buffer.pack(
+      'nnnnnn',
+      self.id,
+      (
+        (self.query? ? 0 : 0x8000) |
+        (ReDNS::OPCODE[self.opcode] || ReDNS::OPCODE[:unknown]) << 12 |
+        (self.authorative? ? 0x0400 : 0) |
+        (self.truncated? ? 0x0200 : 0) |
+        (self.recursion_desired? ? 0x0100 : 0) |
+        (self.recursion_available? ? 0x0080 : 0) |
+        (ReDNS::RCODE[self.response_code] || ReDNS::RCODE[:noerror])
+      ),
+      self.questions.length,
+      self.answers.length,
+      self.nameservers.length,
+      self.additional_records.length
+    )
 
     [ :questions, :answers, :nameservers, :additional_records ].each do |section|
       @attributes[section] and @attributes[section].each do |part|
@@ -137,50 +137,50 @@ class ReDNS::Message < ReDNS::Fragment
     end
     
     buffer
-	end
+  end
 
   # Extracts a message from the supplied buffer. Will return the message if
   # successful, nil if an error occurred or no suitable data cound be found
   # in the buffer.
-	def deserialize(buffer)
-	  return unless (buffer)
-	  
-		data = buffer.unpack("nnnnnn")
-		
-		# Abandon efforts to decode if insufficient data is available.
-		return if (data.length < 6)
-		
-		self.id = data.shift
+  def deserialize(buffer)
+    return unless (buffer)
+    
+    data = buffer.unpack("nnnnnn")
+    
+    # Abandon efforts to decode if insufficient data is available.
+    return if (data.length < 6)
+    
+    self.id = data.shift
 
-		flags = data.shift
-		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
-	  end
-		
-		SECTIONS.each do |section|
-		  collection = @attributes[section] = [ ]
-		  
-		  decode_class =
-  		  case (section)
-  	    when :questions
-  	      ReDNS::Question
-	      else
-	        ReDNS::Resource
+    flags = data.shift
+    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
+    end
+    
+    SECTIONS.each do |section|
+      collection = @attributes[section] = [ ]
+      
+      decode_class =
+        case (section)
+        when :questions
+          ReDNS::Question
+        else
+          ReDNS::Resource
         end
         
-		  @attributes[:"#{section}_count"].times do
-		    collection << decode_class.new(buffer)
-	    end
-	  end
-	  
-	  self
-	end
+      @attributes[:"#{section}_count"].times do
+        collection << decode_class.new(buffer)
+      end
+    end
+    
+    self
+  end
 end