dnsruby 1.57.0 → 1.58.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c6d192a2471584058955bbdd453c5384567f8133
-  data.tar.gz: bc95f3527bfbab7ccc9f2861c3725dc86e5d9e6e
+  metadata.gz: 0542a8574fb4f542e8cdfac4b3efa08335954d76
+  data.tar.gz: 540ef10a9ec536cf6d19cfba946429ac30771c63
 SHA512:
-  metadata.gz: 408fd7d3242777cea4965ad97f8bf9f1c21677d604b0e6a68a5221f2fb6d9f2389a116936fb754f42f8bed8d4901f3ed87fab0fa67627af2d5fed8ac0426a190
-  data.tar.gz: 18b2bcfa91dc712faef28725394dcf3f89d154e4e0669b666d5bb3e553f29ed38f2d3bf2cca9b2dc5cd6d86c46059535dd0e2343af7ae0999cb3e9c263257e09
+  metadata.gz: 793cd5fa6961776a89b2b1e508fe78573cbf6f52c64dd47b62afe2a4173c4448a9e5291be7a8e95837f862aa48a0b37dd710ba0490872d0db4b780468945df8f
+  data.tar.gz: 604d96ae611adce512eba2a95a93229603d0b85e4f234c3ce4f7d19e78842a8c76aeb70deefd502f2c577d28943e6de1cf6af5e8b5e3e034c4dee5915d8b5ab7

data/.gitignore

@@ -20,5 +20,4 @@ tmp
 *.so
 *.o
 *.a
-mkmf.log
-/nbproject/private/
+mkmf.log

data/.travis.yml

@@ -11,5 +11,5 @@ rvm:
   - jruby-19mode
 #  - rbx-2
   - ruby-head
-  - jruby-head
+#  - jruby-head
 #  - ree

data/README.md

@@ -16,8 +16,8 @@ queries. It is therefore suitable for high volume DNS applications.
 
 The following is a (non-exhaustive) list of features :
 
-- Implemented RRs :  A, AAAA, AFSDB, ANY, CERT, CNAME, DNAME,
-     HINFO, ISDN, LOC, MB, MG, MINFO, MR, MX, NAPTR, NS, NSAP,
+- Implemented RRs :  A, AAAA, AFSDB, ANY, CERT, CNAME, DNAME, GPOS,
+     HINFO, ISDN, LOC, MB, MG, MINFO, MR, MX, NAPTR, NS, NSAP, NXT,
      OPT, PTR, PX, RP, RT, SOA, SPF, SRV, TKEY, TSIG, TXT, WKS,
      X25, DNSKEY, RRSIG, NSEC, NSEC3, NSEC3PARAM, DS, DLV
 

data/RELEASE_NOTES.md

@@ -1,5 +1,21 @@
 # Release Notes
 
+
+## v1.58.0
+
+* Add TCP pipelining (reusing a single TCP connection for multiple requests).
+* Enhance zone reading, including reading data from a string.
+* Add add_answer! method for adding duplicate answers, as needed for an AXFR response.
+* Add support for GPOS and NXT resource records.
+* Test cleanup, including removal of use of Nominet servers, soak_test cleanup.
+* Refactorings: MessageDecoder, Resolv, Resolver (part).
+* Fix zone reader adding unwanted dot to relative hostnames being converted to absolute.
+* Fix default access for tsig options in Resolver.
+* Fix ZoneTransfer not to use deprecated SingleResolver.
+* Fix Resolver bug in parameter to create_tsig_options.
+* Fix tests to always use working copy and not gem.
+
+
 ## v1.57.0
 
 * Add query_raw method as alias for send_plain_message, with option to raise or return error.

data/Rakefile

@@ -28,3 +28,5 @@ end
 create_task(:test,         'test/ts_dnsruby.rb')
 create_task(:test_offline, 'test/ts_offline.rb')
 create_task(:test_online,  'test/ts_online.rb')
+create_task(:soak,         'test/tc_soak.rb')
+

data/dnsruby.gemspec

@@ -33,6 +33,8 @@ DNSSEC NSEC3 support.'
 
   s.add_development_dependency 'rake', '~> 10', '>= 10.3.2'
   s.add_development_dependency 'minitest', '~> 5.4'
+  s.add_development_dependency 'rubydns', '~> 1.0'
+  s.add_development_dependency 'nio4r', '~> 1.1'
 
   if RUBY_VERSION >= "1.9.3"
     s.add_development_dependency 'coveralls', '~> 0.7'

data/lib/dnsruby.rb

@@ -27,6 +27,7 @@ require 'dnsruby/update'
 require 'dnsruby/zone_transfer'
 require 'dnsruby/dnssec'
 require 'dnsruby/zone_reader'
+require 'dnsruby/resolv'
 
 
 # = Dnsruby library
@@ -208,6 +209,10 @@ module Dnsruby
   class OtherResolvError < ResolvError
   end
 
+  # Socket was closed by server before request was processed
+  class SocketEofResolvError < ResolvError
+  end
+
   # An error occurred processing the TSIG
   class TsigError < OtherResolvError
   end

data/lib/dnsruby/bit_mapping.rb

@@ -0,0 +1,138 @@
+# This code is copied from the trick_bag gem (see https://github.com/keithrbennett/trick_bag).
+# It is copied a) to avoid adding a new dependency and b) because that gem is in
+# version 0 and is unstable.
+
+module Dnsruby
+
+# Provides methods for converting between the various representations
+# of a bitmap: number, binary encoded string, array, and sparse array.
+#
+# Where an array is used to represent bits, the first element (#0) will be the
+# low (1) bit and the last bit will be the high bit.
+  module BitMapping
+
+    module_function
+
+    # Converts from a binary string to a number, e.g. "\x01\x00" => 256
+    def binary_string_to_number(string)
+      string = string.clone.force_encoding(Encoding::ASCII_8BIT)
+      string.bytes.inject(0) do |number, byte|
+        number * 256 + byte.ord
+      end
+    end
+
+
+    # Converts a number to a binary encoded string, e.g. 256 => "\x01\x00"
+    def number_to_binary_string(number, min_length = 0)
+      assert_non_negative(number)
+      binary_string = ''.force_encoding(Encoding::ASCII_8BIT)
+
+      while number > 0
+        byte_value = number & 0xFF
+        binary_string << byte_value
+        number >>= 8
+      end
+
+      binary_string.reverse.rjust(min_length, "\x00")
+    end
+
+
+    # Converts a number to an array of place values, e.g. 9 => [8, 0, 0, 1]
+    def number_to_place_value_array(number)
+      assert_non_negative(number)
+      array = []
+      bit_value = 1
+      while number > 0
+        array << ((number & 1 == 1) ? bit_value : 0)
+        number >>= 1
+        bit_value <<= 1
+      end
+      array.reverse
+    end
+
+
+    # Converts from a value array to a number, e.g. [8, 0, 0, 1] => 9
+    def place_value_array_to_number(place_value_array)
+      place_value_array.inject(&:+)
+    end
+
+
+    # Converts a number to an array of bit values, e.g. 9 => [1, 0, 0, 1]
+    def number_to_bit_array(number, minimum_binary_places = 0)
+      assert_non_negative(number)
+      array = []
+      while number > 0
+        array << (number & 1)
+        number >>= 1
+      end
+      array.reverse!
+      zero_pad_count = minimum_binary_places - array.size
+      zero_pad_count.times { array.unshift(0) }
+      array
+    end
+
+
+    # Converts an array of bit values, e.g. [1, 0, 0, 1], to a number, e.g. 9
+    def bit_array_to_number(bit_array)
+      return nil if bit_array.empty?
+      multiplier = 1
+      bit_array.reverse.inject(0) do |result, n|
+        result += n * multiplier
+        multiplier *= 2
+        result
+      end
+    end
+
+
+    # Converts a number to a sparse array containing bit positions that are set/true/1.
+    # Note that these are bit positions, e.g. 76543210, and not bit column values
+    # such as 128/64/32/16/8/4/2/1.
+    def number_to_set_bit_positions_array(number)
+      assert_non_negative(number)
+      array = []
+      position = 0
+      while number > 0
+        array << position if number & 1 == 1
+        position += 1
+        number >>= 1
+      end
+      array
+    end
+
+
+    # Converts an array of bit position numbers to a numeric value, e.g. [0, 2] => 5
+    def set_bit_position_array_to_number(position_array)
+      return nil if position_array.empty?
+      position_array.inject(0) do |result, n|
+        result += 2 ** n
+      end
+    end
+
+
+    # Converts a binary string to an array of bit values, e.g. "\x0C" => [1, 1, 0, 0]
+    def binary_string_to_bit_array(string, minimum_binary_places = 0)
+      number = binary_string_to_number(string)
+      number_to_bit_array(number, minimum_binary_places)
+    end
+
+
+    # If number is negative, raises an ArgumentError; else does nothing.
+    def assert_non_negative(number)
+      unless number.is_a?(Integer) && number >= 0
+        raise ArgumentError.new(
+                  "Parameter must be a nonnegative Integer (Fixnum, Bignum) " +
+                      "but is #{number.inspect} (a #{number.class})")
+      end
+    end
+
+    # Reverses a binary string.  Note that it is not enough to reverse
+    # the string itself because although the bytes would be reversed,
+    # the bits within each byte would not.
+    def reverse_binary_string_bits(binary_string)
+      binary_place_count = binary_string.size * 8
+      reversed_bit_array = binary_string_to_bit_array(binary_string, binary_place_count).reverse
+      number = bit_array_to_number(reversed_bit_array)
+      number_to_binary_string(number)
+    end
+  end
+end

data/lib/dnsruby/bitmap.rb

@@ -0,0 +1,108 @@
+# This code is copied from the trick_bag gem (see https://github.com/keithrbennett/trick_bag).
+# It is copied a) to avoid adding a new dependency and b) because that gem is in
+# version 0 and is unstable.
+
+require_relative = ->(*args) do
+  this_file_dir = File.expand_path(File.dirname(__FILE__))
+  args.each { |arg| require(File.join(this_file_dir, arg)) }
+end
+
+require 'forwardable'
+require_relative.('bit_mapping')
+
+
+module Dnsruby
+
+# Instances of this class can be created that will hold on to bitmap data and be used
+# to test bits and convert to other formats.
+#
+# Where an array is used to represent bits, the first element (#0) will be the
+# high bit and the last element will be the low (1's column) bit.
+class Bitmap
+
+  extend Forwardable
+
+  # This is the internal representation of the bitmap value:
+  attr_reader :number
+
+  # Some instance methods can be delegated to this number:
+  [:&, :|, :^, :hash].each do |method_name|
+    def_delegator :@number, method_name
+  end
+
+  # Set a new value to number, validating first that it is nonnegative.
+  def number=(new_number)
+    self.assert_non_negative(new_number)
+    @number = new_number
+  end
+
+
+  # The constructor is made private because:
+  #
+  # 1) each type of initialization requires its own validation, and it
+  #    would be wasteful to do the validation unnecessarily
+  # 2) to enforce that the more descriptively
+  #    named class methods should be used to create instances.
+  private_class_method :new
+
+
+  # Class methods to create instances from the various representation types
+  # handled in the BitMapping module's methods.
+
+  # Creates an instance from a nonnegative number.
+  def self.from_number(number)
+    new(number)
+  end
+
+  # Creates an instance from a binary string (e.g. "\x0C").
+  def self.from_binary_string(string)
+    new(BitMapping.binary_string_to_number(string))
+  end
+
+  # Creates an instance from a value array (e.g. [8, 0, 0, 1])
+  def self.from_place_value_array(array)
+    new(BitMapping.place_value_array_to_number(array))
+  end
+
+  # Creates an instance from a bit array (e.g. [1, 0, 0, 1])
+  def self.from_bit_array(array)
+    new(BitMapping.bit_array_to_number(array))
+  end
+
+  # Creates an instance from an array of positions for the bits that are set (e.g. [0, 3])
+  def self.from_set_bit_position_array(array)
+    new(BitMapping.set_bit_position_array_to_number(array))
+  end
+
+  # Instance methods to convert the data to the various representation types:
+
+  # Returns the instance's value as a binary string (e.g. "\x0C")
+  def to_binary_string(min_length = 0)
+    BitMapping.number_to_binary_string(number, min_length)
+  end
+
+  # Returns the instance's value as an array of bit column values (e.g. [8, 0, 0, 1])
+  def to_place_value_array
+    BitMapping.number_to_place_value_array(number)
+  end
+
+  # Returns the instance's value as an array of bit column place values (e.g. [8, 0, 0, 1])
+  def to_bit_array
+    BitMapping.number_to_bit_array(number)
+  end
+
+  # Returns the instance's value as an array of positions for the bits that are set (e.g. [0, 3])
+  def to_set_bit_position_array
+    BitMapping.number_to_set_bit_positions_array(number)
+  end
+
+  def initialize(number)
+    BitMapping.assert_non_negative(number)
+    @number = number
+  end
+
+  def ==(other)
+    other.is_a?(self.class) && other.number == self.number
+  end
+end
+end

data/lib/dnsruby/message/decoder.rb

@@ -1,6 +1,18 @@
 module Dnsruby
+
+# This class decodes a binary string containing the raw bytes of the message
+# as in coming over the wire from a nameserver, and parses it into a
+# Dnsruby::Message.
 class MessageDecoder #:nodoc: all
-  attr_reader :index
+
+  # Keeps a running @index containing the current position (like a cursor)
+  # into the binary string.  In general 'get_' methods will position @index
+  # to follow the data they have read.
+
+  attr_reader :data, :index
+
+  # Creates an instance of the decoder, optionally with code block
+  # to be executed with the instance as its parameter.
   def initialize(data)
     @data = data
     @index = 0
@@ -8,159 +20,157 @@ class MessageDecoder #:nodoc: all
     yield self if block_given?
   end
 
-  def has_remaining
-    @limit - @index > 0
+  # Has bytes remaining in the binary string to be parsed?
+  def has_remaining?
+    @limit > @index
+  end
+
+  # Asserts that the specified position is a valid position in the buffer.
+  # If not, raises a DecodeError.  If so, does nothing.
+  def assert_buffer_position_valid(end_position)
+    unless (0..@limit).include?(end_position)
+      raise DecodeError.new("requested position of #{end_position} must be between 0 and buffer size (#{@limit}).")
+    end
   end
 
+  # Gets the byte value at the specified position
+  def get_byte_at(position)
+    assert_buffer_position_valid(position)
+    return nil if @data[position].nil?
+    @data[position].getbyte(0)
+  end
+
+  # Gets a 16-bit length field from the binary string and yields to the block.
+  # This will be the length of the next item to parse in the binary string.
+  # Returns the object returned from that block.
+  #
+  # When this method returns, @index will point to the byte after the
+  # 16-bit length field.
   def get_length16
     len, = self.get_unpack('n')
     save_limit = @limit
     @limit = @index + len
-    d = yield(len)
+    parsed_data = yield(len)
     if @index < @limit
       message = "Junk exists; limit = #{@limit}, index = #{@index}"
       raise DecodeError.new(message)
-    elsif @limit < @index
-      message = "Limit exceeded; limit = #{@limit}, index = #{@index}"
-      raise DecodeError.new(message)
     end
+    assert_buffer_position_valid(@index)
     @limit = save_limit
-    d
+    parsed_data
   end
 
+  # Returns the specified number of bytes from the binary string.
+  # Length defaults to the remaining (not yet processed) size of the string.
   def get_bytes(len = @limit - @index)
-    d = @data[@index, len]
+    bytes = @data[@index, len]
     @index += len
-    d
+    bytes
   end
 
+  # Calls String.unpack to get numbers as specified in the template string.
   def get_unpack(template)
     len = 0
-    littlec = ?c
-    bigc = ?C
-    littleh = ?h
-    bigh = ?H
-    littlen = ?n
-    bign = ?N
-    star = ?*
-
-    if (littlec.class != Fixnum)
-      #  We're using Ruby 1.9 - convert the codes
-      littlec = littlec.getbyte(0)
-      bigc = bigc.getbyte(0)
-      littleh = littleh.getbyte(0)
-      bigh = bigh.getbyte(0)
-      littlen = littlen.getbyte(0)
-      bign = bign.getbyte(0)
-      star = star.getbyte(0)
-    end
 
-    template.each_byte {|byte|
-      case byte
-        when littlec, bigc
-          len += 1
-        when littleh, bigh
+    template.bytes.each do |byte|
+      case byte.chr
+        when 'c', 'C', 'h', 'H'
           len += 1
-        when littlen
+        when 'n'
           len += 2
-        when bign
+        when 'N'
           len += 4
-        when star
+        when '*'
           len = @limit - @index
         else
           raise StandardError.new("unsupported template: '#{byte.chr}' in '#{template}'")
       end
-    }
-    raise DecodeError.new('limit exceeded') if @limit < @index + len
-    arr = @data.unpack("@#{@index}#{template}")
+    end
+
+    assert_buffer_position_valid(@index + len)
+    number_array = @data.unpack("@#{@index}#{template}")
     @index += len
-    arr
+    number_array
   end
 
+  # Gets a string whose 1-byte length is at @index, and the string starting at @index + 1.
   def get_string
-    len = @data[@index]
-    if len.class == String
-      len = len.getbyte(0)
-    end
-    raise DecodeError.new("limit exceeded\nlimit = #{@limit}, index = #{@index}, len = #{len}\n") if @limit < @index + 1 + (len ? len : 0)
-    d = @data[@index + 1, len]
+    len = get_byte_at(@index) || 0
+    assert_buffer_position_valid(@index + 1 + len)
+    data_item = @data[@index + 1, len]
     @index += 1 + len
-    d
+    data_item
   end
 
+  # Gets all strings from @index to the end of the binary string.
   def get_string_list
     strings = []
-    while @index < @limit
-      strings << self.get_string
-    end
+    strings << get_string while has_remaining?
     strings
   end
 
+  # Gets a Name from the current @index position.
   def get_name
-    Name.new(self.get_labels)
+    Name.new(get_labels)
   end
 
-  def get_labels(limit=nil)
-    limit = @index if !limit || @index < limit
-    d = []
+  # Returns labels starting at @index.
+  def get_labels(limit = nil)
+    limit = @index if limit.nil? || (@index < limit)
+    labels = []
     while true
-      temp = @data[@index]
-      if temp.class == String
-        temp = temp.getbyte(0)
-      end
-      case temp # @data[@index]
+      temp = get_byte_at(@index)
+      case temp
         when 0
           @index += 1
-          return d
+          return labels
         when 192..255
-          idx = self.get_unpack('n')[0] & 0x3fff
+          idx = get_unpack('n')[0] & 0x3fff
           if limit <= idx
             raise DecodeError.new('non-backward name pointer')
           end
           save_index = @index
           @index = idx
-          d += self.get_labels(limit)
+          labels += self.get_labels(limit)
           @index = save_index
-          return d
+          return labels
         else
-          d << self.get_label
+          labels << self.get_label
       end
     end
-    d
+    labels
   end
 
+  # Gets a single label.
   def get_label
     begin
-      #         label = Name::Label.new(Name::decode(self.get_string))
-      label = Name::Label.new(self.get_string)
-      return label
-        #          return Name::Label::Str.new(self.get_string)
+      Name::Label.new(get_string)
     rescue ResolvError => e
       raise DecodeError.new(e) # Turn it into something more suitable
     end
   end
 
+  # Gets a question record.
   def get_question
     name = self.get_name
     type, klass = self.get_unpack('nn')
-    q = Question.new(name, type, klass)
-    q
+    Question.new(name, type, klass)
   end
 
+  # Gets a resource record.
   def get_rr
-    name = self.get_name
-    type, klass, ttl = self.get_unpack('nnN')
+    name = get_name
+    type, klass, ttl = get_unpack('nnN')
     klass = Classes.new(klass)
     typeclass = RR.get_class(type, klass)
     #  @TODO@ Trap decode errors here, and somehow mark the record as bad.
     #  Need some way to represent raw data only
-    rec = self.get_length16 { typeclass.decode_rdata(self) }
-    rec.name = name
-    rec.ttl = ttl
-    rec.type = type
-    rec.klass = klass
-    rec
+    record = get_length16 { typeclass.decode_rdata(self) }
+    record.name = name
+    record.ttl = ttl
+    record.type = type
+    record.klass = klass
+    record
   end
 end
-
 end