dnsruby 1.57.0 → 1.58.0

data/lib/dnsruby/single_resolver.rb

@@ -114,7 +114,7 @@ module Dnsruby
         end
       end
 
-      isr = PacketSender.new({:server=>@server, :dnssec=>@dnssec,
+      isr = PacketSender.new({:server=>@server, :port=>@port, :dnssec=>@dnssec,
           :use_tcp=>@use_tcp, :no_tcp=>@no_tcp, :packet_timeout=>@packet_timeout,
           :tsig => @tsig, :ignore_truncation=>@ignore_truncation,
           :src_address=>@src_address, :src_address6=>@src_address6, :src_port=>@src_port,
@@ -174,4 +174,4 @@ module Dnsruby
     alias :query_timeout :packet_timeout
     alias :query_timeout= :packet_timeout=
   end
-end
+end

data/lib/dnsruby/version.rb

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

data/lib/dnsruby/zone_reader.rb

@@ -42,14 +42,24 @@ module Dnsruby
       @in_quoted_section = false
     end
 
-    #  Takes a filename string and attempts to load a zone. Returns a list
-    #  of RRs if successful, nil otherwise.
-    def process_file(file)
-      line_num = 0
+    #  Takes a filename string, or any type of IO object, and attempts to load a zone.
+    #  Returns a list of RRs if successful, nil otherwise.
+    def process_file(source)
+      if source.is_a?(String)
+        File.open(source) do |file|
+          process_io(file)
+        end
+      else
+        process_io(source)
+      end
+    end
+
+    #  Iterate over each line in a IO object, and process it.
+    #  Returns a list of RRs if successful, nil otherwise.
+    def process_io(io)
       zone = nil
-      IO.foreach(file) { |line|
+      io.each do |line|
         begin
-
           ret = process_line(line)
           if (ret)
             rr = RR.create(ret)
@@ -59,9 +69,9 @@ module Dnsruby
             zone.push(rr)
           end
         rescue Exception => e
-          raise ParseException.new("Error reading line #{line_num} of #{file} : [#{line}]")
+          raise ParseException.new("Error reading line #{io.lineno} of #{io.inspect} : [#{line}]")
         end
-      }
+      end
       return zone
     end
 
@@ -345,7 +355,7 @@ module Dnsruby
             Types::PTR, Types::DNAME].include?type_was)
         #         if (line[line.length-1, 1] != ".")
         if (!(/\.\z/ =~ line))
-          line = line + "." + @origin.to_s + "."
+          line = line + "." + @origin.to_s
         end
       end
       #  Other RRs have several names. These should be parsed by Dnsruby,

data/lib/dnsruby/zone_transfer.rb

@@ -39,7 +39,7 @@ module Dnsruby
     # * res.tsig=(key_name, key)
     # * res.tsig=nil # Don't sign the transfer
     def tsig=(*args)
-      @tsig = SingleResolver.get_tsig(args)
+      @tsig = Resolver.get_tsig(args)
     end
 
 

data/test/spec_helper.rb

@@ -14,4 +14,12 @@ end
 
 require 'minitest'
 require 'minitest/autorun'
-require 'dnsruby'
+
+# This is in a self invoking anonymous lambda so local variables do not
+# leak to the outer scope.
+-> do
+  load_dir = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+  $LOAD_PATH.unshift(load_dir) unless $LOAD_PATH.include?(load_dir)
+  require_relative '../lib/dnsruby'
+  require_relative 'test_utils'
+end.()

data/test/tc_axfr.rb

@@ -20,12 +20,25 @@ class TestAxfr < Minitest::Test
   def test_axfr
     zt = Dnsruby::ZoneTransfer.new
     zt.transfer_type = Dnsruby::Types.AXFR
-    zt.server = "ns0.validation-test-servers.nominet.org.uk"
-    zone = zt.transfer("validation-test-servers.nominet.org.uk")
-    assert(zone.length > 0)
-    assert(zt.last_tsigstate==nil)
+    zt.server = 'nsztm1.digi.ninja'
+
+    if contactable?(zt.server)
+      zone = zt.transfer('zonetransfer.me')
+      assert(zone.length > 0)
+      assert_nil(zt.last_tsigstate)
+    end
   end
 
+  def contactable?(server)
+    begin
+      sock = UDPSocket.new
+      sock.connect(server, 25)
+      sock.close
+      true
+    rescue Exception
+      false
+    end
+  end
 
   #  NB - test_ixfr is in tc_tsig.rg - this is becuase it requires
   #  TSIG to make an update (which we can then test for with ixfr)

data/test/tc_gpos.rb

@@ -70,9 +70,9 @@ class TestGPOS < Minitest::Test
 
   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)
+    ans_from_data   = RR::GPOS.new_from_data(*EXAMPLE_GPOS_DATA)
+    ans_from_string = RR::GPOS.new_from_string(EXAMPLE_GPOS_STRING)
+    ans_from_hash   = RR::GPOS.new_from_hash(EXAMPLE_GPOS_HASH)
 
     fails_to_populate_rdata = []
     fails_to_populate_rdata << 'data'   if ans_from_data.rdata.nil?

data/test/tc_message.rb

@@ -27,7 +27,7 @@ class TestMessage < Minitest::Test
   #  ;; Security Level : UNCHECKED
   #  ;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 7195
   #  ;; flags: ; QUERY: 1, ANSWER: 0, AUTHORITY: 0, ADDITIONAL: 0
-  def sample_message
+  def   sample_message
     Message.new('cnn.com', 'A')
   end
 
@@ -84,4 +84,10 @@ class TestMessage < Minitest::Test
     test.(msg_a, nil, false)
     #  TODO: Add more tests.
   end
+
+  def test_equals
+    response_as_string = "\x10\a\x81\x90\x00\x01\x00\x04\x00\x00\x00\x06\x03cnn\x03com\x00\x00\x02\x00\x01\xC0\f\x00\x02\x00\x01\x00\x01QC\x00\x14\x03ns3\ntimewarner\x03net\x00\xC0\f\x00\x02\x00\x01\x00\x01QC\x00\x11\x03ns2\x03p42\x06dynect\xC04\xC0\f\x00\x02\x00\x01\x00\x01QC\x00\x06\x03ns1\xC0)\xC0\f\x00\x02\x00\x01\x00\x01QC\x00\x06\x03ns1\xC0I\xC0%\x00\x01\x00\x01\x00\x001\xA2\x00\x04\xC7\aD\xEE\xC0E\x00\x01\x00\x01\x00\x00\xB1\x0E\x00\x04\xCC\r\xFA*\xC0b\x00\x01\x00\x01\x00\x009`\x00\x04\xCCJl\xEE\xC0t\x00\x01\x00\x01\x00\x00\xBDg\x00\x04\xD0NF*\xC0t\x00\x1C\x00\x01\x00\x00\x00\xBB\x00\x10 \x01\x05\x00\x00\x90\x00\x01\x00\x00\x00\x00\x00\x00\x00B\x00\x00)\x0F\xA0\x00\x00\x80\x00\x00\x00".force_encoding("ASCII-8BIT")
+    message = Message.decode(response_as_string)
+    assert(message == message, message.to_s)
+  end
 end

data/test/tc_nxt.rb

@@ -0,0 +1,192 @@
+require_relative 'spec_helper'
+
+require_relative '../lib/dnsruby/resource/NXT'
+require_relative '../lib/dnsruby/code_mappers'
+
+include Dnsruby
+
+# Tests NXT resource record.  See bottom of file for sample zone file.
+class TestNXT < Minitest::Test
+
+  # Get this by running the following script:
+  # require 'dnsruby'
+  # include Dnsruby
+  # query = Message.new('a.dnsruby.com', 'NXT')
+  # resolver = Resolver.new('127.0.0.1')
+  # response, error = resolver.query_raw(query)
+  # puts response.encode.inspect  # to get a quoted string to be inserted in source code
+
+
+  EXAMPLE_NXT_RESPONSE_AS_BINARY = \
+      "\xC2\xE0\x84\x80\x00\x01\x00\x01\x00\x01" +
+      "\x00\x01\x01a\adnsruby\x03com\x00" +
+      "\x00\x1E\x00\x01\xC0\f\x00\x1E\x00\x01\x00\x00*0\x00\x13\x01b\adnsruby\x03com\x00" +
+      "@\x00\x00\n\xC0\x0E\x00\x02\x00\x01\x00\x00*0\x00\x06\x03ns1\xC0\x0E\xC0J\x00\x01\x00" +
+      "\x01\x00\x00*0\x00\x04\x7F\x00\x00\x01"
+
+  def test_type_val_to_string
+    assert_equal 'SOA', RR::NXT::NxtTypes.code_to_name(6)
+    assert_equal 'AXFR', RR::NXT::NxtTypes.code_to_name(252)
+    assert_equal 'TYPE9999', RR::NXT::NxtTypes.code_to_name(9999)
+  end
+
+  def test_type_name_to_code
+    assert_equal 6, RR::NXT::NxtTypes.name_to_code('SOA')
+    assert_equal 252, RR::NXT::NxtTypes.name_to_code('AXFR')
+    assert_equal 9999, RR::NXT::NxtTypes.name_to_code('TYPE9999')
+  end
+
+  def test_type_names_to_codes
+    strings = %w(TYPE9999  SOA  AXFR)
+    assert_equal [9999, 6, 252], RR::NXT::NxtTypes.names_to_codes(strings)
+  end
+
+  def test_type_name_to_codes
+    assert_equal [9999, 6, 252], RR::NXT::NxtTypes.names_string_to_codes("TYPE9999  SOA  AXFR")
+  end
+
+  def test_codes_to_names
+    assert_equal %w(TYPE9999  SOA  AXFR), RR::NXT::NxtTypes.codes_to_names([9999, 6, 252])
+  end
+
+  def test_codes_to_string
+    assert_equal 'SOA AXFR TYPE9999', RR::NXT::NxtTypes.codes_to_string([6, 252, 9999])
+  end
+
+  def test_codes_to_name_sorts_by_code
+    assert_equal 'SOA AXFR TYPE9999', RR::NXT::NxtTypes.codes_to_string([9999, 6, 252])
+  end
+
+  def test_binary_string_to_codes
+    test_type_codes_as_code_array = [1, 6, 28, 100]
+    test_type_codes_as_name_array = %w(A  SOA  AAAA  UINFO)
+    test_type_codes_as_number = 1267650600228229401496971640898  # (2 ** 1) + (2 ** 6) + (2 ** 28) + (2 ** 100)
+    test_type_codes_as_binary_string = "\x10\x0\x0\x0\x0\x0\x0\x0\x0\x10\x0\x0\x42"
+    assert_equal(test_type_codes_as_code_array, RR::NXT::NxtTypes.binary_string_to_codes(test_type_codes_as_binary_string))
+    assert_equal(test_type_codes_as_name_array, RR::NXT::NxtTypes.binary_string_to_names(test_type_codes_as_binary_string))
+    assert_equal(test_type_codes_as_binary_string, RR::NXT::NxtTypes.codes_to_binary_string(test_type_codes_as_code_array))
+  end
+
+  def test_that_codes_are_in_range_1_to_127
+    TestUtils.assert_not_raised(ArgumentError) { RR::NXT::NxtTypes.codes_to_binary_string([1]) }
+    TestUtils.assert_not_raised(ArgumentError) { RR::NXT::NxtTypes.codes_to_binary_string([127]) }
+    assert_raises(ArgumentError) { RR::NXT::NxtTypes.codes_to_binary_string([0]) }
+    assert_raises(ArgumentError) { RR::NXT::NxtTypes.codes_to_binary_string([128]) }
+  end
+
+  def test_that_zero_bit_set_raises_error
+    assert_raises(ArgumentError) { RR::NXT::NxtTypes.codes_to_binary_string([]) }
+  end
+
+  def test_A_AAAA_NXT
+    assert_equal([1, 28, 30], RR::NXT::NxtTypes.names_string_to_codes('A AAAA NXT'))
+    assert_equal("P\x00\x00\x02", RR::NXT::NxtTypes.codes_to_binary_string([1, 28, 30]))
+  end
+
+  def test_type_bitmap_ctor_is_private
+    assert_raises(NoMethodError) { RR::NXT::TypeBitmap.new('') }
+  end
+
+  def test_type_bitmap_to_s
+    type_bitmap = RR::NXT::TypeBitmap.from_type_codes([1, 16, 30])
+    assert_equal('A TXT NXT', type_bitmap.to_s)
+  end
+
+  def test_parse_response_correctly
+    response = Message.decode(EXAMPLE_NXT_RESPONSE_AS_BINARY)
+    answer = response.answer
+    nxt_record = answer[0]
+
+    # Note: Although the NXT class is defined as Dnsruby::RR::NXT and not
+    # Dnsruby::RR::IN::NXT, the IN module (in IN.rb) creates new classes
+    # in the IN module for all class-insensitive resource record classes.
+    # When the binary record is parsed, it is a Dnsruby::RR::IN::NXT
+    # that is created.
+    assert_equal(Dnsruby::RR::IN::NXT, nxt_record.class)
+    actual_tokens = nxt_record.to_s.split
+    expected_tokens = 'a.dnsruby.com. 10800	IN	NXT	b.dnsruby.com A AAAA NXT'.split
+    assert_equal(actual_tokens, expected_tokens)
+  end
+
+  def assert_rr_content(rr)
+    assert_equal(rr.type, 'NXT') # TODO: Should this be a string or a number?
+    assert_equal(rr.name, Name.create('b.dnsruby.com.'))
+    assert_equal(rr.ttl, 10800)
+    assert_equal(rr.klass, 'IN')
+    assert_equal(rr.next_domain, Name.create('a.dnsruby.com.'))
+  end
+
+  def test_new_from_string
+    rr = RR::NXT.new_from_string('b.dnsruby.com.		10800	IN	NXT	a.dnsruby.com. SOA NXT')
+    assert_rr_content(rr)
+  end
+
+  def test_new_from_hash
+    assert_rr_content(sample_nxt_rr)
+  end
+
+  def test_new_from_data
+    rdata = RR::NXT.build_rdata('a.dnsruby.com.', [Types::SOA, Types::NXT])
+
+    rr = RR::NXT.new_from_data('b.dnsruby.com.', Types::NXT, Classes::IN, 10800,
+        rdata.size, rdata, 0)
+    assert_rr_content(rr)
+  end
+
+  def test_owner_alias
+    rr = sample_nxt_rr
+    assert_equal('b.dnsruby.com', rr.owner.to_s)
+    assert_equal('b.dnsruby.com', rr.name.to_s)
+    new_name = Name.create('z.com')
+    rr.owner = new_name
+    assert_equal(new_name, rr.owner)
+    assert_equal(new_name, rr.name)
+  end
+
+
+  def test_encode_decode_message
+    nxt_rr = sample_nxt_rr
+    message = Message.new
+    message.add_answer(nxt_rr)
+    binary_message = message.encode
+    reconstructed_message = Message.decode(binary_message)
+    reconstructed_nxt_rr = reconstructed_message.answer[0]
+    assert_equal(nxt_rr, reconstructed_nxt_rr)
+  end
+
+  def sample_nxt_rr
+    RR::NXT.new_from_hash(
+        name: 'b.dnsruby.com.',
+        ttl: 10800,
+        klass: Classes::IN,
+        next_domain: 'a.dnsruby.com.',
+        types: [Types::SOA, Types::NXT])
+  end
+end
+
+
+
+# Sample zone file for setting up BIND to serve a NXT record:
+=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      NXT     b A AAAA NXT
+
+b.dnsruby.com.  IN      A       2.4.6.9
+        IN      GPOS    40      50      60
+
+=end

data/test/tc_recur.rb

@@ -23,7 +23,8 @@ class TestRecur < Minitest::Test
 #    Dnsruby::TheLog.level = Logger::DEBUG
     ret = r.query("uk", Dnsruby::Types.DNSKEY)
 #    print ret
-    assert(ret && ret.answer.length > 0)
+    assert ret, "Query result was nil."
+    assert ret.answer.length > 0, "Answer length should > 0, but was #{ret.answer.length}."
 #    ret = r.query_dorecursion("aaa.bigzone.uk-dnssec.nic.uk", Dnsruby::Types.DNSKEY)
 #    ret = r.query_dorecursion("uk-dnssec.nic.uk", Dnsruby::Types.DNSKEY)
   end

data/test/tc_resolv.rb

@@ -0,0 +1,73 @@
+# --
+# 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 express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ++
+
+require_relative 'spec_helper'
+require_relative '../lib/dnsruby/resolv'
+
+include Dnsruby
+class TestResolv < Minitest::Test
+
+  RELATIVE_NAME = 'google-public-dns-a.google.com'
+  ABSOLUTE_NAME = RELATIVE_NAME + '.'
+  IPV4_ADDR     = '8.8.8.8'
+  IPV6_ADDR     = '2001:4860:4860::8888'
+  ADDRESSES     = [IPV4_ADDR, IPV6_ADDR]
+
+
+  def test_resolv_name_to_addresses
+
+    assert_equal(IPV4_ADDR, Dnsruby::Resolv.getaddress(ABSOLUTE_NAME).to_s)
+
+    addresses = Dnsruby::Resolv.getaddresses(ABSOLUTE_NAME)
+
+    case addresses.length
+      when 1
+        assert_equal IPV4_ADDR, addresses.first.to_s
+        Dnsruby::Resolv.each_address(ABSOLUTE_NAME) do |address|
+          assert_equal IPV4_ADDR, address.to_s
+        end
+      when 2
+        assert_equal ADDRESSES.sort, addresses.map(&:to_s).sort
+        addresses_from_each = []
+        Dnsruby::Resolv.each_address(ABSOLUTE_NAME) do |address|
+          addresses_from_each << address.to_s
+        end
+        assert_equal ADDRESSES.sort, addresses_from_each.sort
+      else
+        raise "Addresses length must be 1 or 2 but was #{addresses.length}"
+    end
+  end
+
+
+  def test_resolv_address_to_name
+
+    assert_equal(RELATIVE_NAME, Dnsruby::Resolv.getname(IPV4_ADDR).to_s)
+
+    assert_raises(Dnsruby::Resolv::ResolvError) do
+      Dnsruby::Resolv.getname(RELATIVE_NAME)
+    end
+
+    names = Dnsruby::Resolv.getnames(IPV4_ADDR)
+    assert_equal(1, names.size)
+    assert_equal(RELATIVE_NAME, names.first.to_s)
+    Dnsruby::Resolv.each_name(IPV4_ADDR) { |name| assert_equal(RELATIVE_NAME, name.to_s)}
+  end
+
+  def test_resolv_address_to_address
+    local = '127.0.0.1'
+    assert_equal(local, Dnsruby::Resolv.new.getaddress(local))
+  end
+end

data/test/tc_resolver.rb

@@ -1,12 +1,12 @@
 # --
 # 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.
@@ -157,7 +157,7 @@ class TestResolver < Minitest::Test
 #    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
@@ -291,6 +291,10 @@ end
 # Tests to see that query_raw handles send_plain_message's return values correctly.
 class TestRawQuery < Minitest::Test
 
+  KEY_NAME = 'key-name'
+  KEY  = '0123456789'
+  ALGO = 'hmac-md5'
+
   class CustomError < RuntimeError; end
 
   # Returns a new resolver whose send_plain_message method always returns
@@ -357,5 +361,19 @@ class TestRawQuery < Minitest::Test
     assert_nil error
     assert_equal :response_from_send_plain_message, response
   end
+
+  def test_2_args_init
+    options = Resolver.create_tsig_options(KEY_NAME, KEY)
+    assert_equal KEY_NAME, options[:name]
+    assert_equal KEY, options[:key]
+    assert_nil options[:algorithm]
+  end
+
+  def test_3_args_init
+    options = Resolver.create_tsig_options(KEY_NAME,KEY,ALGO)
+    assert_equal KEY_NAME, options[:name]
+    assert_equal KEY, options[:key]
+    assert_equal ALGO, options[:algorithm]
+  end
 end