dnsruby 1.56.0 → 1.57.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3d4002c20d43d7fa849e81970e596e8b191a9290
-  data.tar.gz: b1ebd40548471fd16a12616d3c834b9c30a8a26e
+  metadata.gz: c6d192a2471584058955bbdd453c5384567f8133
+  data.tar.gz: bc95f3527bfbab7ccc9f2861c3725dc86e5d9e6e
 SHA512:
-  metadata.gz: 4f3f304b2f3ea1df07a0a24854e20a003f16964840800dae9ad574318369095ebec119ce7f074a3658564c530a84ec2f6a6a9a2b8fa2721aa4e6f329f982d6c3
-  data.tar.gz: ab251ceaffa37db6a13eb2b7064c8cf16babdf15d75ef79d91de1e2140a7552b1759cb34f6d051bc649242396bce9edeadc758f51231a02be69788e55b036b44
+  metadata.gz: 408fd7d3242777cea4965ad97f8bf9f1c21677d604b0e6a68a5221f2fb6d9f2389a116936fb754f42f8bed8d4901f3ed87fab0fa67627af2d5fed8ac0426a190
+  data.tar.gz: 18b2bcfa91dc712faef28725394dcf3f89d154e4e0669b666d5bb3e553f29ed38f2d3bf2cca9b2dc5cd6d86c46059535dd0e2343af7ae0999cb3e9c263257e09

data/.coveralls.yml

@@ -0,0 +1,2 @@
+service_name: travis-ci
+repo_token: 99b5l6CKFt3CC4rxYUetvDQvKtaTgCJW2

data/.gitignore

@@ -0,0 +1,24 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+.idea/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+/nbproject/private/

data/.travis.yml

@@ -0,0 +1,15 @@
+language: ruby
+cache: bundler
+sudo: false
+
+script: "bundle exec rake test"
+
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.4
+  - jruby-19mode
+#  - rbx-2
+  - ruby-head
+  - jruby-head
+#  - ree

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/README.md

@@ -5,8 +5,7 @@ Dnsruby
 =======
 
 Dnsruby is a pure Ruby DNS client library which implements a
-stub resolver. It aims to comply with all DNS RFCs, including
-DNSSEC NSEC3 support.
+stub resolver. It aims to comply with all DNS RFCs.
 
 Dnsruby presents an enhanced API for DNS. It is based on Ruby's core
 resolv.rb Resolv API, but has been much extended to provide a
@@ -36,7 +35,7 @@ Dependencies
 Dnsruby can run with no dependencies. However, if you wish to
 use TSIG or DNSSEC then the OpenSSL library must be available.
 This is a part of the Ruby standard library, but appears not to
-be present on all Ruby platforms. If it is not available, then 
+be present on all Ruby platforms. If it is not available, then
 the test code will not run the tests which require it. Code which
 attempts to use the library (if it is not present) will raise an
 exception.
@@ -73,11 +72,6 @@ at runtime:
 bundle exec rake test
 ```
 
-Nominet operates a test server which the Dnsruby test code queries.
-If this server is not available then some of the online tests will 
-not be run.
-
-
 Usage Help
 ----------
 
@@ -88,9 +82,12 @@ in understanding how to use Dnsruby:
 * http://blog.nominet.org.uk/tech/2009/05/21/examples-of-using-dnsruby-with-dnssec/
 
 
-Contact
+Contact/Links
 -------
 
-alex@caerkettontech.com
-https://github.com/alexdalitz/dnsruby
-
+| Link Type | Link/Text |
+|-----|-----
+| Author Email | alex@caerkettontech.com |
+| Github | https://github.com/alexdalitz/dnsruby |
+| Google Group | https://groups.google.com/forum/#!forum/dnsruby |
+| Rubygems | http://rubygems.org/gems/dnsruby/ |

data/RELEASE_NOTES.md

@@ -0,0 +1,100 @@
+# Release Notes
+
+## v1.57.0
+
+* Add query_raw method as alias for send_plain_message, with option to raise or return error.
+* Fixed a bug in RR hash calculation where TTL should have been ignored but wasn't.
+* Add support for (obsolete) GPOS resource record type.
+* Tweak Travis CI configuration.
+* Fix zone reader for case where a line contains whitespace preceding a comment.
+* Add post install message.
+* Improve README.
+* Moved content of NEWS to RELEASE_NOTES.md.
+* Use git ls-files now to determine files for inclusion in gem.
+
+
+## v1.56.0
+
+* Drop support for Ruby 1.8, using lambda -> and hash 'key: value' notations.
+* First release since the move from Rubyforge to Github (https://github.com/alexdalitz/dnsruby).
+* Add EDNS client subnet support.
+* Relocate CodeMapper subclasses, Resolv, RR, and RRSet classes.
+* Add Travis CI and coveralls integration.
+* Improve Google IPV6 support.
+* Convert some file names to snake case.
+* Remove trailing whitespace from lines, and ensure that comments have space between '#' and text.
+* Restore test success when running under JRuby.
+* Disabled attempt to connect to Nominet servers, which are no longer available.
+* Convert from test/unit to minitest/autorun to support Ruby 2.1+.
+* Remove setup.rb.
+* Other minor refactoring and improvements to production code, test code, and documentation.
+
+
+## v1.53
+
+* Validation routine fixes
+* Ruby 1.9 fixes
+* Recursor fixes
+* IPv4 Regex fixes
+* Fixes for A/PTR lookups with IP-like domain name
+* TXT and SSHFP processing fixes
+* Default retry parameters in Resolver more sensible
+
+
+## v1.48
+
+* Fixed deadlock/performance issue seen on some platforms
+* DNSSEC validation now disabled by default
+* Signed root DS record can be added to validator
+* ITAR support removed
+* multi-line DS/RRSIG reading bug fixed (thanks Marco Davids!)
+* DS algorithms of more than one digit can now be read from string
+* LOC records now parsed correctly
+* HINFO records now parsed correctly
+
+
+## v1.42
+
+* Complicated TXT and NAPTR records now handled correctly
+* ZoneReader now handles odd escape characters correctly
+* Warns when immediate timeout occurs because no nameservers are configured
+* Easy hmac-sha1/256 options to Resolver#tsig=
+* ZoneReader fixed for "IN CNAME @" notations
+* ZoneReader supports wildcards
+* Dnsruby.version method added - currently returns 1.42
+
+
+## v1.41
+
+* RFC3597 unknown classes (e.g. CLASS32) now handled correctly
+    in RRSIGs
+* Resolver#do_caching flag added for Resolver-level caching
+* DNSKEY#key_tag now cached - only recalculated when key data
+    changes
+* Bugfix where Resolver would not time queries out if no 
+    nameservers were configured
+* Recursor now performs A and AAAA queries in parallel
+* Fix for zero length salt
+* Fixing priming for signed root
+* Fixes for DLV verification
+* Other minor fixes
+
+
+## v1.40
+
+* Zone file reading support added (Dnsruby::ZoneReader)
+* Name and Label speed-ups
+* CodeMapper speed-ups
+* DHCID RR added
+* LOC presentation format parsing fixed
+* KX RR added
+* Quotations now allowed in text representation for ISDN, X25 and HINFO
+* AFSDB from_string fixes
+* Fixing CERT types and from_string
+* CERT now allows algorithm 0
+* Fix for DS record comparison
+* HIP RR added
+* Minor bug fixes
+* IPSECKEY RR added
+* Clients can now manipulate Name::Labels
+

data/SIGNED_UPDATES

@@ -0,0 +1,22 @@
+Signed updates with Dnsruby
+===========================
+
+In order to use TSIG records to automatically perform TSIG signing/verification of messages :
+
+    res = Dnsruby::Resolver.new("ns0.validation-test-servers.nominet.org.uk")
+        
+    # Now configure the resolver with the TSIG key for signing/verifying
+    KEY_NAME="rubytsig"
+    KEY = "8n6gugn4aJ7MazyNlMccGKH1WxD2B3UvN/O/RA6iBupO2/03u9CTa3Ewz3gBWTSBCH3crY4Kk+tigNdeJBAvrw=="
+    res.tsig=KEY_NAME, KEY
+    
+
+    # Now try sending/receiving some update messages
+    update = Dnsruby::Update.new("validation-test-servers.nominet.org.uk")
+    update_name = generate_update_name
+    update.absent(update_name)
+    update.add(update_name, 'TXT', 100, "test signed update")
+        
+    # Resolver will automatically sign message and verify response
+    response = res.send_message(update)
+    assert(response.verified?) # Check that the response has been verified

data/dnsruby.gemspec

@@ -0,0 +1,41 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'dnsruby/version'
+
+SPEC = Gem::Specification.new do |s|
+  s.name = "dnsruby"
+  s.version = Dnsruby::VERSION
+  s.authors = ["Alex Dalitz"]
+  s.email = 'alex@caerkettontech.com'
+  s.homepage = "https://github.com/alexdalitz/dnsruby"
+  s.platform = Gem::Platform::RUBY
+  s.summary = "Ruby DNS(SEC) implementation"
+  s.description = \
+'Dnsruby is a pure Ruby DNS client library which implements a
+stub resolver. It aims to comply with all DNS RFCs, including
+DNSSEC NSEC3 support.'
+  s.license = "Apache License, Version 2.0"
+  s.files = `git ls-files -z`.split("\x0")
+
+  s.post_install_message = \
+"Installing dnsruby...
+  For issues and source code: https://github.com/alexdalitz/dnsruby
+  For general discussion (please tell us how you use dnsruby): https://groups.google.com/forum/#!forum/dnsruby"
+
+  s.test_file = "test/ts_offline.rb"
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["DNSSEC", "EXAMPLES", "README.md", "EVENTMACHINE"]
+
+  unless /java/ === RUBY_PLATFORM
+    s.add_development_dependency 'pry', '~> 0.10'
+    s.add_development_dependency 'pry-byebug', '~> 2.0' if RUBY_VERSION >= '2'
+  end
+
+  s.add_development_dependency 'rake', '~> 10', '>= 10.3.2'
+  s.add_development_dependency 'minitest', '~> 5.4'
+
+  if RUBY_VERSION >= "1.9.3"
+    s.add_development_dependency 'coveralls', '~> 0.7'
+  end
+end
+

data/lib/dnsruby/code_mapper.rb

@@ -114,7 +114,7 @@ module Dnsruby
         @code = arg.code
         @string = array.values[@code]
       else
-        raise ArgumentError.new("Unknown argument #{arg} for #{self.class}")
+        raise ArgumentError.new("Unknown argument of type #{arg.class}: #{arg} for #{self.class}")
       end
     end
 

data/lib/dnsruby/message/decoder.rb

@@ -18,9 +18,11 @@ class MessageDecoder #:nodoc: all
     @limit = @index + len
     d = yield(len)
     if @index < @limit
-      raise DecodeError.new('junk exists')
+      message = "Junk exists; limit = #{@limit}, index = #{@index}"
+      raise DecodeError.new(message)
     elsif @limit < @index
-      raise DecodeError.new('limit exceeded')
+      message = "Limit exceeded; limit = #{@limit}, index = #{@index}"
+      raise DecodeError.new(message)
     end
     @limit = save_limit
     d

data/lib/dnsruby/resolver.rb

@@ -264,6 +264,30 @@ module Dnsruby
       [response, error]
     end
 
+    # Sends a message with send_plain_message.
+    # Effectively a wrapper around send_plain_message, but adds
+    # the ability to configure whether an error will be raised
+    # or returned if it occurs.
+    #
+    # @param message the message to send to the DNS server
+    # @param error_strategy :return to return [response, error] (default),
+    #                       :raise to return response only, or raise an error if one occurs
+    def query_raw(message, error_strategy = :return)
+
+      unless [:return, :raise].include?(error_strategy)
+        raise ArgumentError.new('error_strategy should be one of [:return, :raise].')
+      end
+
+      response, error = send_plain_message(message)
+
+      if error_strategy == :return
+        [response, error]
+      else
+        raise error if error
+        response
+      end
+    end
+
     #  This method takes a Message (supplied by the client), and sends it to
     #  the configured nameservers. No changes are made to the Message before it
     #  is sent (TSIG signatures will be applied if configured on the Resolver).

data/lib/dnsruby/resource/GPOS.rb

@@ -0,0 +1,187 @@
+# encoding: ASCII-8BIT
+
+module Dnsruby
+  class RR
+    # Class for Geographic Position (GPOS) resource records.
+    #
+    # RFC 1712 (https://www.ietf.org/rfc/rfc1712.txt)
+    class GPOS < RR
+
+      TypeValue = Types::GPOS
+      ClassValue = Classes::IN
+      ClassHash[[TypeValue, ClassValue]] = self  #:nodoc: all
+
+      attr_accessor :longitude, :latitude, :altitude  # NOTE: these are strings, not numbers
+
+      REQUIRED_KEYS = [:longitude, :latitude, :altitude]
+
+
+      # As with all resource record subclasses of RR, this class cannot be
+      # directly instantiated, but instead must be instantiated via use of
+      # one of the RR class methods.  These GPOS class methods are wrappers
+      # around those RR methods, so that there is an interface on the GPOS
+      # class for creating GPOS instances.
+
+      # Create an instance from a hash of parameters, e.g.:
+      #  {
+      #     name:       'techhumans.com',
+      #     type:       Types::GPOS,
+      #     ttl:        1234,
+      #     longitude:  '10.0',
+      #     latitude:   '20.0',
+      #     altitude:   '30.0',
+      #  }
+      def self.from_hash(gpos_params_hash)
+        RR.new_from_hash(gpos_params_hash)
+      end
+
+
+      # Create an instance from a string containing parameters, e.g.:
+      # 'a.dnsruby.com.  10800  IN  GPOS  10.0  20.0  30.0'
+      def self.from_string(gpos_params_string)
+        RR.new_from_string(gpos_params_string)
+      end
+
+
+      # Create an instance from an ordered parameter list, e.g.:
+      # EXAMPLE_GPOS_DATA = begin
+      #   rdata = RR::GPOS.build_rdata(EXAMPLE_LONGITUDE, EXAMPLE_LATITUDE, EXAMPLE_ALTITUDE)
+      #   [EXAMPLE_HOSTNAME, Types::GPOS, Classes::IN, EXAMPLE_TTL, rdata.length, rdata, 0]
+      # end
+      # self.from_data(*EXAMPLE_GPOS_DATA)
+      def self.from_data(*gpos_params_data)
+        RR.new_from_data(*gpos_params_data)
+      end
+
+
+      def from_data(array)
+        unless array.size == 3
+          raise "Array size for creating GPOS record must be 3 (long, lat, alt). Array was:\n#{array.inspect}"
+        end
+
+        from_hash({
+                      longitude: array[0],
+                      latitude:  array[1],
+                      altitude:  array[2]
+                  })
+      end
+
+      def from_hash(init_data)
+        self.class.validate_floats(init_data)
+        @longitude = init_data[:longitude].to_s
+        @latitude  = init_data[:latitude].to_s
+        @altitude  = init_data[:altitude].to_s
+        self.rdata = build_rdata
+        self
+      end
+
+      def from_string(string)
+        # Convert commas to spaces, then split by spaces:
+        from_data(string.gsub(',', ' ').split(' '))
+      end
+
+      # From the RFC:
+      #    GPOS has the following format:
+      # <owner> <ttl> <class> GPOS <longitude> <latitude> <altitude>
+      #
+      # We handle the rdata, the RR superclass does the rest.
+      def rdata_to_string
+        [longitude, latitude, altitude].join(' ')
+      end
+
+      def encode_rdata(msg, _canonical)
+        msg.put_bytes(build_rdata)
+      end
+
+      def build_rdata
+        self.class.build_rdata(longitude, latitude, altitude)
+      end
+
+      def self.build_rdata(longitude, latitude, altitude)
+        binary_string = ''.force_encoding('ASCII-8BIT')
+
+        binary_string << longitude.length.chr
+        binary_string << longitude
+        binary_string << latitude.length.chr
+        binary_string << latitude
+        binary_string << altitude.length.chr
+        binary_string << altitude
+        binary_string
+      end
+
+      def self.decode_rdata(message)
+        rdata_s = message.get_bytes.clone
+
+        index = 0
+
+        long_len = rdata_s[index].ord;         index += 1
+        longitude = rdata_s[index, long_len];  index += long_len
+
+        lat_len = rdata_s[index].ord;          index += 1
+        latitude = rdata_s[index, lat_len];    index += lat_len
+
+        alt_len = rdata_s[index].ord;          index += 1
+        altitude = rdata_s[index, alt_len];    index += alt_len
+
+        validate_latitude(latitude)
+        validate_longitude(longitude)
+
+        new([longitude, latitude, altitude].join(' '))  # e.g. "10.0 20.0 30.0"
+      end
+
+      # 'name' is used in the RR superclass, but 'owner' is the term referred to
+      # in the RFC, so we'll make owner an alias for name.
+      def owner
+        name
+      end
+
+      # 'name' is used in the RR superclass, but 'owner' is the term referred to
+      # in the RFC, so we'll make owner an alias for name.
+      def owner=(owner_string)
+        self.name = owner_string
+      end
+
+      def self.valid_float?(object)
+        begin
+          Float(object)
+          true
+        rescue
+          false
+        end
+      end
+
+      def self.validate_float_in_range(label, object, bound)
+        number = Float(object)
+        valid_range = (-Float(bound)..Float(bound))
+        unless valid_range.include?(number)
+          raise "Value of #{label} (#{number}) was not in the range #{valid_range}."
+        end
+      end
+
+      def self.validate_longitude(value)
+        validate_float_in_range('longitude', value, 180)
+      end
+
+      def self.validate_latitude(value)
+        validate_float_in_range('latitude',  value, 90)
+      end
+
+      def self.validate_floats(init_data)
+        bad_float_keys = REQUIRED_KEYS.reject { |key| valid_float?(init_data[key]) }
+        unless bad_float_keys.empty?
+          message = "The following key value pair(s) do not have valid floats or float strings:\n"
+          bad_float_keys.each do |key|
+            message << "%:-12.12s => %s\n" % [init_data[key]]
+          end
+          raise message
+        end
+
+        validate_longitude(init_data[:longitude])
+        validate_latitude(init_data[:latitude])
+      end
+    end
+  end
+end
+
+
+

data/lib/dnsruby/resource/RR.rb

@@ -320,7 +320,6 @@ class RR
   end
 
   def ==(other)
-
     return false unless self.class == other.class
 
     ivars_to_compare = ->(object) do
@@ -351,7 +350,7 @@ class RR
   end
 
   def hash # :nodoc:
-    vars = self.instance_variables - ['@ttl']
+    vars = (self.instance_variables - [:@ttl]).sort
     vars.inject(0) do |hash_value, var_name|
       hash_value ^ self.instance_variable_get(var_name).hash
     end

data/lib/dnsruby/resource/generic.rb

@@ -163,3 +163,4 @@ require 'dnsruby/resource/IPSECKEY'
 require 'dnsruby/resource/HIP'
 require 'dnsruby/resource/KX'
 require 'dnsruby/resource/DHCID'
+require 'dnsruby/resource/GPOS'

data/lib/dnsruby/version.rb

@@ -1,3 +1,3 @@
 module Dnsruby
-  VERSION = '1.56.0'
+  VERSION = '1.57.0'
 end

data/lib/dnsruby/zone_reader.rb

@@ -69,12 +69,11 @@ module Dnsruby
     #  Returns a string representing the normalised line.
     def process_line(line, do_prefix_hack = false)
       return nil if (line[0,1] == ";")
+      line = strip_comments(line)
       return nil if (line.strip.length == 0)
       return nil if (!line || (line.length == 0))
       @in_quoted_section = false if !@continued_line
 
-      line = strip_comments(line)
-
       if (line.index("$ORIGIN") == 0)
         @origin = line.split()[1].strip #  $ORIGIN <domain-name> [<comment>]
         #                 print "Setting $ORIGIN to #{@origin}\n"

data/test/spec_helper.rb

@@ -12,5 +12,6 @@ if ENV['RUN_EXTRA_TASK'] == 'TRUE'
   end
 end
 
+require 'minitest'
 require 'minitest/autorun'
 require 'dnsruby'

data/test/tc_gpos.rb

@@ -0,0 +1,124 @@
+require_relative 'spec_helper'
+
+require_relative '../lib/dnsruby/resource/GPOS.rb'
+
+include Dnsruby
+
+# Tests GPOS resource record.  See bottom of file for sample zone file.
+class TestGPOS < Minitest::Test
+
+  EXAMPLE_LONGITUDE  = '10.0'
+  EXAMPLE_LATITUDE   = '20.0'
+  EXAMPLE_ALTITUDE   = '30.0'
+  EXAMPLE_HOSTNAME   = 'a.dnsruby.com.'
+  EXAMPLE_TTL        = 3 * 60 * 60  # 10,800 seconds, or 3 hours
+
+  EXAMPLE_GPOS_STRING = 'a.dnsruby.com.  10800  IN  GPOS  10.0  20.0  30.0'
+
+  EXAMPLE_GPOS_HASH  = {
+      name:       EXAMPLE_HOSTNAME,
+      type:       Types::GPOS,
+      ttl:        EXAMPLE_TTL,
+      longitude:  EXAMPLE_LONGITUDE,
+      latitude:   EXAMPLE_LATITUDE,
+      altitude:   EXAMPLE_ALTITUDE,
+  }
+
+  EXAMPLE_GPOS_DATA = begin
+    rdata = RR::GPOS.build_rdata(EXAMPLE_LONGITUDE, EXAMPLE_LATITUDE, EXAMPLE_ALTITUDE)
+    [EXAMPLE_HOSTNAME, Types::GPOS, Classes::IN, EXAMPLE_TTL, rdata.length, rdata, 0]
+  end
+
+  # Returns a GPOS record returned by a BIND server configured with the zone file
+  # shown at the bottom of this file.  I (keithrbennett) was unable to find a GPOS
+  # record on the public Internet to use for live testing.
+  def gpos_from_response
+    # query = Message.new(EXAMPLE_HOSTNAME, 'GPOS')
+    # query_binary = "E0\u0000\u0000\u0000\u0001\u0000\u0000\u0000\u0000\u0000\u0000\u0001a\adnsruby\u0003com\u0000\u0000\e\u0000\u0001"
+    # response, _error = Resolver.new('127.0.0.1').query_raw(query)
+
+    response_binary = "E0\x84\x80\x00\x01\x00\x01\x00\x01\x00\x01\x01a\adnsruby\x03com\x00\x00\e\x00\x01\xC0\f\x00\e\x00\x01\x00\x00*0\x00\x0F\x0410.0\x0420.0\x0430.0\xC0\x0E\x00\x02\x00\x01\x00\x00*0\x00\x06\x03ns1\xC0\x0E\xC0F\x00\x01\x00\x01\x00\x00*0\x00\x04\x7F\x00\x00\x01"
+    response = Message.decode(response_binary)
+
+    # response_binary = "\xE7\x01\x85\x90\x00\x01\x00\x01\x00\x01\x00\x01\x01g\adnsruby\x03com" +
+    #     "\x00\x00\e\x00\x01\xC0\f\x00\e\x00\x01\x00\t:\x80\x00\x0F\x0420.0\x0430.0\x0410.0" +
+    #     "\xC0\x0E\x00\x02\x00\x01\x00\t:\x80\x00\x05\x02ns\xC0\x0E\xC0F\x00\x01\x00\x01\x00" +
+    #     "\t:\x80\x00\x04\xC0\xA8\x01\n"; nil
+    #
+    # response = Message.decode(response_binary)
+
+    response.answer[0]
+  end
+
+
+  def test_answer
+    answer = gpos_from_response
+    assert answer.is_a?(RR::GPOS), "Expected RR::GPOS but got a #{answer.class}: #{answer}"
+    assert_equal(EXAMPLE_LONGITUDE, answer.longitude)
+    assert_equal(EXAMPLE_LATITUDE, answer.latitude)
+    assert_equal(EXAMPLE_ALTITUDE, answer.altitude)
+    assert_equal(EXAMPLE_TTL, answer.ttl)
+  end
+
+
+  # should be: <owner> <ttl> <class> GPOS <longitude> <latitude> <altitude>
+  def test_to_s
+    actual = gpos_from_response.to_s.split
+    expected = %w(a.dnsruby.com.  10800  IN  GPOS  10.0  20.0  30.0)
+    assert_equal(expected, actual)
+  end
+
+  def test_creation_approaches
+
+    ans_from_data   = RR::GPOS.from_data(*EXAMPLE_GPOS_DATA)
+    ans_from_string = RR::GPOS.from_string(EXAMPLE_GPOS_STRING)
+    ans_from_hash   = RR::GPOS.from_hash(EXAMPLE_GPOS_HASH)
+
+    fails_to_populate_rdata = []
+    fails_to_populate_rdata << 'data'   if ans_from_data.rdata.nil?
+    fails_to_populate_rdata << 'string' if ans_from_string.rdata.nil?
+    fails_to_populate_rdata << 'hash'   if ans_from_hash.rdata.nil?
+
+    assert_equal([], fails_to_populate_rdata,
+        "Populate modes failing to populate rdata: #{fails_to_populate_rdata.join(', ')}")
+
+    assert_equal(ans_from_data.rdata, ans_from_hash.rdata)
+    assert_equal(ans_from_data.rdata, ans_from_string.rdata)
+
+    assert_equal(ans_from_data, ans_from_hash)
+    assert_equal(ans_from_data, ans_from_string)
+  end
+
+  def test_decode_encode
+    response_binary = "E0\x84\x80\x00\x01\x00\x01\x00\x01\x00\x01\x01a\adnsruby\x03com\x00\x00\e\x00\x01\xC0\f\x00\e\x00\x01\x00\x00*0\x00\x0F\x0410.0\x0420.0\x0430.0\xC0\x0E\x00\x02\x00\x01\x00\x00*0\x00\x06\x03ns1\xC0\x0E\xC0F\x00\x01\x00\x01\x00\x00*0\x00\x04\x7F\x00\x00\x01"
+    message_object = Message.decode(response_binary)
+    reconstructed_binary = message_object.encode
+    assert_equal response_binary.force_encoding('ASCII-8BIT'), reconstructed_binary
+  end
+end
+
+
+# Sample zone file for setting up BIND to serve GPOS records:
+=begin
+$TTL    3h
+
+@ IN    SOA     dnsruby.com.    foo.dnsruby.com.        (
+        1  ; serial
+        3H ; refresh after 3 hours
+        1H ; retry after 1 hour
+        1W ; expire after 1 week
+        1H) ; negative caching TTL of 1 hour
+
+dnsruby.com.    IN      NS      ns1
+
+; Addresses for canonical names
+
+ns1.dnsruby.com.        IN      A       127.0.0.1
+
+a.dnsruby.com.  IN      A       2.4.6.8
+        IN      GPOS    10.0    20.0    30.0
+
+b.dnsruby.com.  IN      A       2.4.6.9
+        IN      GPOS    40      50      60
+
+=end

data/test/tc_hs.rb

@@ -0,0 +1,25 @@
+require_relative 'spec_helper'
+
+include Dnsruby
+
+class TestDNS < Minitest::Test
+
+  def setup
+    Dnsruby::Config.reset
+  end
+
+
+  # Illustrates that when a message whose class is 'HS' is sent to
+  # a DNS server that does not support the HS class, using send_plain_message,
+  # the response returns with an rcode of NOTIMP and a Dnsruby::NotImp error.
+  def test_hs_class_returns_notimp_code_and_error
+    resolver_host = 'a.gtld-servers.net'
+    resolver = Resolver.new(resolver_host)
+    message = Message.new('test.com', 'A', 'HS')
+    response, error = resolver.send_plain_message(message)
+
+    assert_equal(RCode::NOTIMP, response.rcode)
+    assert_equal(Dnsruby::NotImp, error.class)
+  end
+
+end

data/test/tc_nsec3.rb

@@ -134,9 +134,4 @@ class Nsec3Test < Minitest::Test
      rr = RR.create("929p027vb26s89h6fv5j7hmsis4tcr1p.tjeb.nl.		 3600		 IN		 NSEC3		 1 0 5 beef  9rs4nbe7128ap5i6v196ge2iag5b7rcq A AAAA RRSIG
        ")
   end
-
-  def test_rfc_examples
-    print "IMPLEMENT NSEC3 validation!\n"
-    return
-  end
 end

data/test/tc_resolver.rb

@@ -285,4 +285,77 @@ class TestResolver < Minitest::Test
   def test_eventtype_api
     #  @TODO@ TEST THE Resolver::EventType interface!
   end
-end
+end
+
+
+# Tests to see that query_raw handles send_plain_message's return values correctly.
+class TestRawQuery < Minitest::Test
+
+  class CustomError < RuntimeError; end
+
+  # Returns a new resolver whose send_plain_message method always returns
+  # nil for the response, and a RuntimeError for the error.
+  def resolver_returning_error
+    resolver = Resolver.new
+    def resolver.send_plain_message(_message)
+      [nil, CustomError.new]
+    end
+    resolver
+  end
+
+  # Returns a new resolver whose send_plain_message is overridden to return
+  # :response_from_send_plain_message instead of a real Dnsruby::Message,
+  # for easy comparison in the tests.
+  def resolver_returning_response
+    resolver = Resolver.new
+    def resolver.send_plain_message(_message)
+      [:response_from_send_plain_message, nil]
+    end
+    resolver
+  end
+
+  # Test that when a strategy other than :raise or :return is passed,
+  # an ArgumentError is raised.
+  def test_bad_strategy
+    assert_raises(ArgumentError) do
+      resolver_returning_error.query_raw(Message.new, :invalid_strategy)
+    end
+  end
+
+  # Test that when send_plain_message returns an error,
+  # and the error strategy is :raise, query_raw raises an error.
+  def test_raise_error
+    assert_raises(CustomError) do
+      resolver_returning_error.query_raw(Message.new, :raise)
+    end
+  end
+
+  # Tests that if you don't specify an error strategy, an error will be
+  # returned rather than raised (i.e. strategy defaults to :return).
+  def test_return_error_is_default
+    _response, error = resolver_returning_error.query_raw(Message.new)
+    assert error.is_a?(CustomError)
+  end
+
+  # Tests that when no error is returned, no error is raised.
+  def test_raise_no_error
+    response, _error = resolver_returning_response.query_raw(Message.new, :raise)
+    assert_equal :response_from_send_plain_message, response
+  end
+
+  # Test that when send_plain_message returns an error, and the error strategy
+  # is set to :return, then an error is returned.
+  def test_return_error
+    _response, error = resolver_returning_error.query_raw(Message.new, :return)
+    assert error.is_a?(CustomError)
+  end
+
+  # Test that when send_plain_message returns a valid and response
+  # and nil error, the same are returned by query_raw.
+  def test_return_no_error
+    response, error = resolver_returning_response.query_raw(Message.new, :return)
+    assert_nil error
+    assert_equal :response_from_send_plain_message, response
+  end
+end
+

data/test/tc_rr-opt.rb

@@ -20,6 +20,38 @@ require 'socket'
 
 include Dnsruby
 class TestRrOpt < Minitest::Test
+
+
+
+  # This test illustrates that when an OPT record specifying a maximum
+  # UDP size is added to a query, the server will respect that setting
+  # and limit the response's size to <= that maximum.
+  # This works only with send_plain_message, not send_message, query, etc.
+  def test_plain_respects_bufsize
+
+    resolver = Resolver.new('a.gtld-servers.net')
+
+    run_test = ->(bufsize) do
+
+      create_test_query = ->(bufsize) do
+        message = Message.new('com', Types.ANY, Classes.IN)
+        message.add_additional(RR::OPT.new(bufsize))
+        message
+      end
+
+      query = create_test_query.(bufsize)
+      response, _error = resolver.send_plain_message(query)
+      # puts "\nBufsize is #{bufsize}, binary message size is #{response.encode.size}"
+      assert_equal(true, response.header.tc)
+      assert(response.encode.size <= bufsize)
+    end
+
+    run_test.(512)
+    run_test.(612)
+    run_test.(4096)
+  end
+
+
   def test_rropt
     size=2048;
     ednsflags=0x9e22;

data/test/tc_rr.rb

@@ -319,4 +319,13 @@ class TestRR < Minitest::Test
       # We should be here because the method should not have been found.
     end
   end
+
+  # TTL should be ignored when calculating the hash of an RR.
+  def test_hash_ignores_ttl
+    a1 = RR.new_from_string 'techhumans.com. 1111 IN A 69.89.31.97'
+    a2 = RR.new_from_string 'techhumans.com. 1111 IN A 69.89.31.97'
+    a3 = RR.new_from_string 'techhumans.com. 2222 IN A 69.89.31.97'
+    assert_equal a1.hash, a2.hash
+    assert_equal a1.hash, a3.hash
+  end
 end

data/test/ts_offline.rb

@@ -18,6 +18,7 @@ require_relative 'spec_helper'
 
 Dnsruby.log.level = Logger::FATAL
 
+require_relative 'tc_gpos.rb'
 require_relative 'tc_header.rb'
 require_relative "tc_name.rb"
 require_relative 'tc_message.rb'

data/test/ts_online.rb

@@ -40,6 +40,7 @@ if (online)
   print "It may just be that some UDP packets got lost the first time...\n"
   require_relative "tc_resolver.rb"
   require_relative "tc_dnsruby.rb"
+  require_relative "tc_hs.rb"
   #   require_relative "tc_inet6.rb"
   #   require_relative "tc_recurse.rb"
   require_relative "tc_tcp.rb"

metadata

@@ -1,15 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: dnsruby
 version: !ruby/object:Gem::Version
-  version: 1.56.0
+  version: 1.57.0
 platform: ruby
 authors:
 - Alex Dalitz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-25 00:00:00.000000000 Z
+date: 2014-12-31 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -71,11 +99,17 @@ extra_rdoc_files:
 - README.md
 - EVENTMACHINE
 files:
+- ".coveralls.yml"
+- ".gitignore"
+- ".travis.yml"
 - DNSSEC
 - EVENTMACHINE
 - EXAMPLES
+- Gemfile
 - README.md
+- RELEASE_NOTES.md
 - Rakefile
+- SIGNED_UPDATES
 - demo/axfr.rb
 - demo/check_soa.rb
 - demo/check_zone.rb
@@ -87,6 +121,7 @@ files:
 - demo/rubydig.rb
 - demo/to_resolve.txt
 - demo/trace_dns.rb
+- dnsruby.gemspec
 - lib/dnsruby.rb
 - lib/dnsruby/DNS.rb
 - lib/dnsruby/cache.rb
@@ -117,6 +152,7 @@ files:
 - lib/dnsruby/resource/DLV.rb
 - lib/dnsruby/resource/DNSKEY.rb
 - lib/dnsruby/resource/DS.rb
+- lib/dnsruby/resource/GPOS.rb
 - lib/dnsruby/resource/HINFO.rb
 - lib/dnsruby/resource/HIP.rb
 - lib/dnsruby/resource/IN.rb
@@ -169,11 +205,12 @@ files:
 - test/tc_dnsruby.rb
 - test/tc_ds.rb
 - test/tc_escapedchars.rb
+- test/tc_gpos.rb
 - test/tc_hash.rb
 - test/tc_header.rb
 - test/tc_hip.rb
+- test/tc_hs.rb
 - test/tc_ipseckey.rb
-- test/tc_keith.rb
 - test/tc_message.rb
 - test/tc_misc.rb
 - test/tc_name.rb
@@ -214,7 +251,10 @@ homepage: https://github.com/alexdalitz/dnsruby
 licenses:
 - Apache License, Version 2.0
 metadata: {}
-post_install_message: 
+post_install_message: |-
+  Installing dnsruby...
+    For issues and source code: https://github.com/alexdalitz/dnsruby
+    For general discussion (please tell us how you use dnsruby): https://groups.google.com/forum/#!forum/dnsruby
 rdoc_options: []
 require_paths:
 - lib

data/test/tc_keith.rb

@@ -1,300 +0,0 @@
-# --
-# Copyright 2007 Nominet UK
-# 
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-# 
-#     http://www.apache.org/licenses/LICENSE-2.0
-# 
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either tmexpress or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ++
-require_relative 'spec_helper'
-
-require 'socket'
-
-include Dnsruby
-# @TODO@ We also need a test server so we can control behaviour of server to test
-# different aspects of retry strategy.
-# Of course, with Ruby's limit of 256 open sockets per process, we'd need to run
-# the server in a different Ruby process.
-
-class TestResolver < Minitest::Test
-
-  include Dnsruby
-
-  Thread::abort_on_exception = true
-
-  GOOD_DOMAIN_NAME = 'example.com'
-  BAD_DOMAIN_NAME  = 'dnsruby-test-of-bad-domain-name.blah'
-
-  PORT = 42138
-  @@port = PORT
-
-  def setup
-    Dnsruby::Config.reset
-  end
-
-  def assert_valid_response(response)
-    assert(response.kind_of?(Message), "Expected response to be a message but was a #{response.class}")
-  end
-
-  def assert_nil_response(response)
-    assert(response.nil?, "Expected no response but got a #{response.class}:\n#{response}")
-  end
-
-  def assert_error_is_exception(error, error_class = Exception)
-    assert(error.is_a?(error_class), "Expected error to be an #{error_class}, but was a #{error.class}:\n#{error}")
-  end
-
-  def assert_nil_error(error)
-    assert(error.nil?, "Expected no error but got a #{error.class}:\n#{error}")
-  end
-
-  def test_send_message
-    response = Resolver.new.send_message(Message.new("example.com", Types.A))
-    assert_valid_response(response)
-  end
-
-  def test_send_message_bang_noerror
-    response, error = Resolver.new.send_message!(Message.new(GOOD_DOMAIN_NAME, Types.A))
-    assert_nil_error(error)
-    assert_valid_response(response)
-  end
-
-  def test_send_message_bang_error
-    message = Message.new(BAD_DOMAIN_NAME, Types.A)
-    response, error = Resolver.new.send_message!(message)
-    assert_nil_response(response)
-    assert_error_is_exception(error)
-  end
-
-  def test_send_plain_message
-    resolver = Resolver.new
-    response, error = resolver.send_plain_message(Message.new("cnn.com"))
-    assert_nil_error(error)
-    assert_valid_response(response)
-
-    m = Message.new(BAD_DOMAIN_NAME)
-    m.header.rd = true
-    response, error = resolver.send_plain_message(m)
-    assert_valid_response(response)
-    assert_error_is_exception(error, NXDomain)
-  end
-
-  def test_query
-    response = Resolver.new.query("example.com")
-    assert_valid_response(response)
-  end
-
-  def test_query_bang_noerror
-    response, error = Resolver.new.query!(GOOD_DOMAIN_NAME)
-    assert_nil_error(error)
-    assert_valid_response(response)
-  end
-
-  def test_query_bang_error
-    response, error = Resolver.new.query!(BAD_DOMAIN_NAME)
-    assert_nil_response(response)
-    assert_error_is_exception(error)
-  end
-
-  def test_query_async
-    q = Queue.new
-    Resolver.new.send_async(Message.new("example.com", Types.A),q,q)
-    id, response, error = q.pop
-    assert_equal(id, q, "Id wrong!")
-    assert_valid_response(response)
-    assert_nil_error(error)
-  end
-
-  def test_query_one_duff_server_one_good
-    res = Resolver.new({:nameserver => ["8.8.8.8", "8.8.8.7"]})
-    res.retry_delay=1
-    q = Queue.new
-    res.send_async(Message.new("example.com", Types.A),q,q)
-    id, response, error = q.pop
-    assert_equal(id, q, "Id wrong!")
-    assert_valid_response(response)
-    assert_nil_error(error)
-  end
-
-  #  @TODO@ Implement!!  But then, why would anyone want to do this?
-  #   def test_many_threaded_clients
-  #     assert(false, "IMPLEMENT!")
-  #   end
-
-  def test_reverse_lookup
-    m = Message.new("8.8.8.8", Types.PTR)
-    r = Resolver.new
-    q=Queue.new
-    r.send_async(m,q,q)
-    id,ret, error=q.pop
-    assert(ret.kind_of?(Message))
-    no_pointer=true
-    ret.each_answer do |answer|
-      if (answer.type==Types.PTR)
-        no_pointer=false
-        assert(answer.domainname.to_s=~/google-public-dns/)
-      end
-    end
-    assert(!no_pointer)
-  end
-
-#  def test_bad_host
-#    res = Resolver.new({:nameserver => "localhost"})
-#    res.retry_times=1
-#    res.retry_delay=0
-#    res.query_timeout = 1
-#    q = Queue.new
-#    res.send_async(Message.new("example.com", Types.A), q, q)
-#    id, m, err = q.pop
-#    assert(id==q)
-#    assert(m == nil)
-#    assert(err.kind_of?(OtherResolvError) || err.kind_of?(IOError), "OtherResolvError or IOError expected : got #{err.class}")
-#  end
-# 
-  def test_nxdomain
-    resolver = Resolver.new
-    q = Queue.new
-    resolver .send_async(Message.new(BAD_DOMAIN_NAME, Types.A), q, 1)
-    id, m, error = q.pop
-    assert(id==1, "Id should have been 1 but was #{id}")
-    assert(m.rcode == RCode.NXDOMAIN, "Expected NXDOMAIN but got #{m.rcode} instead.")
-    assert_error_is_exception(error, NXDomain)
-  end
-
-  def test_timeouts
-    # test timeout behaviour for different retry, retrans, total timeout etc.
-    # Problem here is that many sockets will be created for queries which time out.
-    #  Run a query which will not respond, and check that the timeout works
-    if (!RUBY_PLATFORM=~/darwin/)
-      start=stop=0
-      retry_times = 3
-      retry_delay=1
-      packet_timeout=2
-      #  Work out what time should be, then time it to check
-      expected = ((2**(retry_times-1))*retry_delay) + packet_timeout
-      begin
-        res = Resolver.new({:nameserver => "10.0.1.128"})
-        #       res = Resolver.new({:nameserver => "213.248.199.17"})
-        res.packet_timeout=packet_timeout
-        res.retry_times=retry_times
-        res.retry_delay=retry_delay
-        start=Time.now
-        m = res.send_message(Message.new("a.t.dnsruby.validation-test-servers.nominet.org.uk", Types.A))
-        fail
-      rescue ResolvTimeout
-        stop=Time.now
-        time = stop-start
-        assert(time <= expected *1.3 && time >= expected *0.9, "Wrong time take, expected #{expected}, took #{time}")
-      end
-  end
-  end
-
-  def test_packet_timeout
-        res = Resolver.new({:nameserver => []})
-#      res = Resolver.new({:nameserver => "10.0.1.128"})
-      start=stop=0
-      retry_times = retry_delay = packet_timeout= 10
-      query_timeout=2
-      begin
-        res.packet_timeout=packet_timeout
-        res.retry_times=retry_times
-        res.retry_delay=retry_delay
-        res.query_timeout=query_timeout
-        #  Work out what time should be, then time it to check
-        expected = query_timeout
-        start=Time.now
-        m = res.send_message(Message.new("a.t.dnsruby.validation-test-servers.nominet.org.uk", Types.A))
-        fail
-      rescue ResolvTimeout
-        stop=Time.now
-        time = stop-start
-        assert(time <= expected *1.3 && time >= expected *0.9, "Wrong time take, expected #{expected}, took #{time}")
-      end    #
-  end
-
-  def test_queue_packet_timeout
-#    if (!RUBY_PLATFORM=~/darwin/)
-      res = Resolver.new({:nameserver => "10.0.1.128"})
-#      bad = SingleResolver.new("localhost")
-      res.add_server("localhost")
-      expected = 2
-      res.query_timeout=expected
-      q = Queue.new
-      start = Time.now
-      m = res.send_async(Message.new("a.t.dnsruby.validation-test-servers.nominet.org.uk", Types.A), q, q)
-      id,ret,err = q.pop
-      stop = Time.now
-      assert(id=q)
-      assert(ret==nil)
-      assert(err.class == ResolvTimeout, "#{err.class}, #{err}")
-      time = stop-start
-      assert(time <= expected *1.3 && time >= expected *0.9, "Wrong time take, expected #{expected}, took #{time}")
-#    end
-  end
-
-  def test_illegal_src_port
-    #  Also test all singleresolver ports ok
-    #  Try to set src_port to an illegal value - make sure error raised, and port OK
-    res = Resolver.new
-    res.port = 56789
-    tests = [53, 387, 1265, 3210, 48619]
-    tests.each do |bad_port|
-      begin
-        res.src_port = bad_port
-        fail("bad port #{bad_port}")
-      rescue
-      end
-    end
-    assert(res.single_resolvers[0].src_port = 56789)
-  end
-
-  def test_add_src_port
-    #  Try setting and adding port ranges, and invalid ports, and 0.
-    #  Also test all singleresolver ports ok
-    res = Resolver.new
-    res.src_port = [56789,56790, 56793]
-    assert(res.src_port == [56789,56790, 56793])
-    res.src_port = 56889..56891
-    assert(res.src_port == [56889,56890,56891])
-    res.add_src_port(60000..60002)
-    assert(res.src_port == [56889,56890,56891,60000,60001,60002])
-    res.add_src_port([60004,60005])
-    assert(res.src_port == [56889,56890,56891,60000,60001,60002,60004,60005])
-    res.add_src_port(60006)
-    assert(res.src_port == [56889,56890,56891,60000,60001,60002,60004,60005,60006])
-    #  Now test invalid src_ports
-    tests = [0, 53, [60007, 53], [60008, 0], 55..100]
-    tests.each do |x|
-      begin
-        res.add_src_port(x)
-        fail()
-      rescue
-      end
-    end
-    assert(res.src_port == [56889,56890,56891,60000,60001,60002,60004,60005,60006])
-    assert(res.single_resolvers[0].src_port == [56889,56890,56891,60000,60001,60002,60004,60005,60006])
-  end
-
-  def test_eventtype_api
-    #  @TODO@ TEST THE Resolver::EventType interface!
-  end
-
-  def test_rd_not_overwritten
-    message = Message.new(GOOD_DOMAIN_NAME)
-    message.header.rd = false
-    assert(! message.header.rd)
-    resolver = Resolver.new
-    raise "Header rd flag was overwritten to true in #{__FILE__}:#{__LINE__}" if message.header.rd
-    _response = resolver.send_message(message)
-    puts "Header rd: #{message.header.rd}"
-    raise "Header rd flag was overwritten to true in #{__FILE__}:#{__LINE__}" if message.header.rd
-    assert(! message.header.rd, "Header rd flag was overwritten to true")
-  end
-end