dnsruby 1.73.1 → 2.0.0

data/test/tc_scoped_ipv6_select.rb

@@ -0,0 +1,157 @@
+require_relative 'spec_helper'
+require 'minitest/mock'
+require 'timeout'
+
+class TestScopedIPv6Select < Minitest::Test
+  def test_scoped_response_with_interface_punctuation_is_delivered
+    with_registered_query('fe80::1%7') do |selector, socket, _client_id, message|
+      message.answerip = 'fe80::1%eth-test.100'
+      message.answerfrom = message.answerip
+      bytes = 'response bytes'
+      delivered = []
+
+      selector.stub(:send_response_to_client, ->(*args) { delivered << args }) do
+        selector.process_message(message, bytes, socket)
+      end
+
+      assert_equal([[message, bytes, socket]], delivered)
+    end
+  end
+
+  def test_decode_error_attribution_accepts_numeric_and_named_zones
+    [
+      ['FE80:0000:0000:0000:0000:0000:0000:0001%7', 'fe80::1%eth-test.100'],
+      ['fe80::1%eth-test.100', 'FE80:0:0:0:0:0:0:1%7'],
+    ].each do |destination, source|
+      with_registered_query(destination) do |selector, socket, client_id, _message|
+        assert_equal(client_id, selector.get_client_id_from_answerfrom(socket, source, 53))
+      end
+    end
+  end
+
+  def test_decode_error_attribution_requires_matching_address_and_port
+    with_registered_query('fe80::1%7') do |selector, socket, _client_id, _message|
+      assert_nil(selector.get_client_id_from_answerfrom(socket, 'fe80::2%eth-test.100', 53))
+      assert_nil(selector.get_client_id_from_answerfrom(socket, 'fe80::1%eth-test.100', 54))
+      assert_nil(selector.get_client_id_from_answerfrom(socket, '192.0.2.1', 53))
+    end
+  end
+
+  def test_decode_error_attribution_stays_on_the_receiving_socket
+    with_registered_query('fe80::1%7') do |selector, first_socket, first_id, _message|
+      with_registered_query('fe80::1%8') do |_other_selector, second_socket, second_id, _other_message|
+        assert_equal(first_id, selector.get_client_id_from_answerfrom(first_socket, 'fe80::1%eth0', 53))
+        assert_equal(second_id, selector.get_client_id_from_answerfrom(second_socket, 'fe80::1%eth1', 53))
+      end
+    end
+  end
+
+  def test_malformed_truncated_udp_response_retries_over_tcp
+    with_registered_query('fe80::1%7') do |selector, socket, client_id, query|
+      query.header.id = 12_345
+      settings = Dnsruby::SelectThread.class_variable_get(:@@query_hash)[client_id]
+      settings.client_queue = Queue.new
+      sent = Queue.new
+      sender = Object.new
+      sender.define_singleton_method(:send_async) do |*args|
+        raise 'retry lost original attempt identity' unless Thread.current[:dnsruby_response_query].equal?(settings)
+        sent << args
+      end
+      sender.define_singleton_method(:no_tcp) { false }
+      settings.single_resolver = sender
+      # Keep the matching question complete, then advertise a missing answer.
+      # Only an attributable truncated response may trigger TCP fallback.
+      response = Dnsruby::Message.decode(query.encode)
+      response.header.qr = true
+      response.header.tc = true
+      packet = response.encode
+      packet[6, 2] = [1].pack('n')
+      socket.define_singleton_method(:recvfrom_nonblock) { |_| [packet, ['AF_INET6', 53, 'fe80::1%7', 'fe80::1%7']] }
+      removed = []
+      selector.stub(:tcp?, false) do
+        selector.stub(:remove_id_from_mutex_synchronized_block, ->(id) { removed << id }) do
+          assert_nil(selector.get_incoming_data(socket, 512))
+          assert_equal([query, settings.client_queue, client_id, true], Timeout.timeout(2) { sent.pop })
+        end
+      end
+      assert_empty(removed) # Keep the attempt cancellable until the retry replaces it.
+      assert_nil(Thread.current[:dnsruby_response_query])
+    end
+  end
+
+  def test_tcp_decode_error_uses_partial_header_on_receiving_pipeline_socket
+    with_registered_query('fe80::1%7') do |selector, socket, first_id, query|
+      query.header.id = 12_346
+      second_id = Object.new
+      second = Dnsruby::SelectThread::QuerySettings.new
+      second.query = Dnsruby::Message.new('other.example')
+      second.query.header.id = 12_347
+      queries = Dnsruby::SelectThread.class_variable_get(:@@query_hash)
+      sockets = Dnsruby::SelectThread.class_variable_get(:@@socket_hash)
+      queries[second_id] = second
+      sockets[socket] << second_id
+      assert_equal(second_id, selector.get_client_id_from_answerfrom(socket, nil, nil, 12_347))
+      assert_nil(selector.get_client_id_from_answerfrom(socket, nil, nil, 12_348))
+      assert_nil(selector.get_client_id_from_answerfrom(socket, nil, nil))
+      packet = [query.header.id, 0x8000, 1, 0, 0, 0].pack('n6')
+      errors = []
+      selector.stub(:tcp?, true) do
+        selector.stub(:tcp_read, packet) do
+          selector.stub(:send_exception_to_client, ->(*args) { errors << args }) do
+            assert_nil(selector.get_incoming_data(socket, 0))
+          end
+        end
+      end
+      assert_equal(1, errors.length)
+      assert_kind_of(Dnsruby::DecodeError, errors[0][0])
+      assert_equal([socket, first_id], errors[0][1..])
+    ensure
+      queries.delete(second_id) if queries
+    end
+  end
+
+  private
+
+  def with_registered_query(destination)
+    # Use existing tables when a resolver is active. Otherwise provide only the
+    # tables these methods need, without starting a select loop or binding TCP.
+    # Stubs live on a separate object and tokens never enter the IO.select set.
+    selector_class = Dnsruby::SelectThread
+    temporary_variables = []
+    { :@@mutex => Mutex.new, :@@query_hash => {}, :@@socket_hash => {} }.each do |name, value|
+      next if selector_class.class_variable_defined?(name)
+      selector_class.class_variable_set(name, value)
+      temporary_variables << name
+    end
+    selector = selector_class.send(:allocate)
+    socket = Object.new
+    message = Dnsruby::Message.new('scoped.example')
+    # A negative ID cannot collide with a response arriving on a live socket.
+    message.header.id = -message.object_id
+    client_id = [Object.new, message]
+    settings = Dnsruby::SelectThread::QuerySettings.new
+    settings.query = message
+    settings.socket = socket
+    settings.client_query_id = client_id
+    settings.dest_server = destination
+    settings.dest_port = 53
+
+    mutex = selector_class.class_variable_get(:@@mutex)
+    queries = selector_class.class_variable_get(:@@query_hash)
+    sockets = selector_class.class_variable_get(:@@socket_hash)
+    mutex.synchronize do
+      queries[client_id] = settings
+      sockets[socket] = [client_id]
+    end
+
+    begin
+      yield selector, socket, client_id, message
+    ensure
+      mutex.synchronize do
+        queries.delete(client_id)
+        sockets.delete(socket)
+      end
+      temporary_variables.each { |name| selector_class.remove_class_variable(name) }
+    end
+  end
+end

data/test/tc_scoped_ipv6_transport.rb

@@ -0,0 +1,329 @@
+require_relative 'spec_helper'
+require 'minitest/mock'
+require 'socket'
+require 'timeout'
+
+class TestScopedIPv6Transport < Minitest::Test
+  SCOPED_SERVERS = ['fe80::1%eth0.100', 'fe80::1%4'].freeze
+  ANSWER = '192.0.2.184'.freeze
+
+  # These socket-boundary tests run even on hosts without an IPv6 interface.
+  # They verify that the transport receives the zone, not just the IPv6 address.
+  def test_udp_preserves_scope_and_uses_ipv6
+    SCOPED_SERVERS.each do |server|
+      sender = Dnsruby::PacketSender.new(server: server, port: 5300, src_port: 55000)
+      message = Dnsruby::Message.new('scoped.example.invalid')
+      bytes = message.encode
+      socket = Minitest::Mock.new(Object.new)
+      socket.expect(:bind, 0, ['::', 55000])
+      socket.expect(:connect, 0, [server, 5300])
+      socket.expect(:write_nonblock, bytes.bytesize, [bytes])
+      selector = capture_selector do |settings|
+        assert_equal server, settings.dest_server
+        assert_equal socket.object_id, settings.socket.object_id
+        true
+      end
+
+      constructor = lambda do |family|
+        assert_equal Socket::AF_INET6, family
+        socket
+      end
+      Dnsruby::SelectThread.stub(:instance, selector) do
+        UDPSocket.stub(:new, constructor) do
+          sender.send_dnsruby(bytes, message, :udp_scope, Queue.new, false)
+        end
+      end
+      socket.verify
+    end
+  end
+
+  def test_tcp_preserves_scope_and_uses_ipv6_source
+    SCOPED_SERVERS.each do |server|
+      sender = Dnsruby::PacketSender.new(server: server, port: 5300, src_port: 55000)
+      message = Dnsruby::Message.new('scoped.example.invalid')
+      bytes = message.encode
+      frame = [bytes.bytesize].pack('n') + bytes
+      socket = Minitest::Mock.new(Object.new)
+      socket.expect(:write_nonblock, frame.bytesize, [frame])
+      selector = capture_selector do |settings|
+        assert_equal server, settings.dest_server
+        assert_equal socket.object_id, settings.socket.object_id
+        true
+      end
+
+      connector = lambda do |host, port, source, source_port, deadline, token|
+        assert_equal [server, 5300, '::', 55000], [host, port, source, source_port]
+        assert_operator deadline - Dnsruby::TransportClock.now, :>, 0
+        refute token.cancelled?
+        assert_operator deadline - Dnsruby::TransportClock.now, :<=, sender.packet_timeout
+        socket
+      end
+      Dnsruby::SelectThread.stub(:instance, selector) do
+        sender.stub(:connect_tcp, connector) do
+          sender.send_dnsruby(bytes, message, :tcp_scope, Queue.new, true)
+        end
+      end
+      socket.verify
+    end
+  end
+
+  def test_tcp_pipeline_preserves_scope_and_selects_matching_source_address
+    (SCOPED_SERVERS + ['127.0.0.1']).each do |server|
+      ipv6 = server.include?(':')
+      sender = Dnsruby::PacketSender.new(server: server, port: 5300)
+      source = ipv6 ? '::' : '0.0.0.0'
+      target = 'packed destination including scope'
+      socket = Minitest::Mock.new(Object.new)
+
+      address_builder = lambda do |port, host|
+        assert_equal [5300, server], [port, host]
+        target
+      end
+      connector = lambda do |host, port, local_address, local_port, deadline, token|
+        assert_equal [server, 5300, source, 0], [host, port, local_address, local_port]
+        assert_operator deadline - Dnsruby::TransportClock.now, :>, 0
+        refute token.cancelled?
+        assert_operator deadline - Dnsruby::TransportClock.now, :<=, sender.packet_timeout
+        socket
+      end
+      Socket.stub(:sockaddr_in, address_builder) do
+        sender.stub(:connect_tcp, connector) do
+          connected, new_socket = sender.tcp_pipeline_socket(0)
+          assert_equal socket.object_id, connected.object_id
+          assert new_socket
+        end
+      end
+      socket.verify
+    end
+  end
+
+  def test_tcp_pipeline_does_not_retain_a_failed_scoped_connection
+    SCOPED_SERVERS.each do |server|
+      [Errno::EADDRNOTAVAIL, Errno::ENETUNREACH].each do |error_class|
+        sender = Dnsruby::PacketSender.new(server: server, port: 5300, src_port: 55000)
+        error = error_class.new('unusable scoped source or destination')
+        connector = lambda do |host, port, source, source_port, deadline, token|
+          assert_equal [server, 5300, '::', 55000], [host, port, source, source_port]
+          assert_operator deadline - Dnsruby::TransportClock.now, :>, 0
+          refute token.cancelled?
+          assert_operator deadline - Dnsruby::TransportClock.now, :<=, sender.packet_timeout
+          raise error
+        end
+
+        # The connector closes the socket if bind or connect fails.
+        # The sender must also clear its pipeline and usage count.
+        Socket.stub(:sockaddr_in, 'scoped destination') do
+          sender.stub(:connect_tcp, connector) do
+            assert_same error, assert_raises(error_class) { sender.tcp_pipeline_socket(55000) }
+          end
+        end
+        assert_nil sender.instance_variable_get(:@pipeline_socket)
+        assert_empty sender.instance_variable_get(:@use_counts)
+      end
+    end
+  end
+
+  def test_ipv6_loopback_udp_roundtrip
+    assert_local_roundtrip(:udp, scoped: false)
+  end
+
+  def test_ipv6_loopback_tcp_roundtrip
+    assert_local_roundtrip(:tcp, scoped: false)
+  end
+
+  def test_ipv6_loopback_tcp_pipeline_has_multiple_outstanding_queries
+    assert_local_roundtrip(:pipeline, 3, scoped: false)
+  end
+
+  def test_ipv6_loopback_truncated_udp_retries_over_tcp
+    assert_local_roundtrip(:fallback, scoped: false)
+  end
+
+  def test_scoped_ipv6_udp_roundtrip
+    assert_local_roundtrip(:udp)
+  end
+
+  def test_scoped_ipv6_numeric_zone_udp_roundtrip
+    assert_local_roundtrip(:udp, 1, true)
+  end
+
+  def test_scoped_ipv6_tcp_roundtrip
+    assert_local_roundtrip(:tcp)
+  end
+
+  def test_scoped_ipv6_numeric_zone_tcp_roundtrip
+    assert_local_roundtrip(:tcp, 1, true)
+  end
+
+  def test_scoped_ipv6_tcp_pipeline_has_multiple_outstanding_queries
+    assert_local_roundtrip(:pipeline, 2)
+  end
+
+  def test_scoped_ipv6_numeric_zone_tcp_pipeline_has_multiple_outstanding_queries
+    assert_local_roundtrip(:pipeline, 2, true)
+  end
+
+  def test_scoped_ipv6_truncated_udp_retries_over_tcp
+    assert_local_roundtrip(:fallback)
+  end
+
+  private
+
+  def capture_selector(&registered)
+    current = nil
+    Object.new.tap do |selector|
+      selector.define_singleton_method(:track_socket) { |socket| socket }
+      selector.define_singleton_method(:reserve_send) { |settings, _previous| current = settings; true }
+      selector.define_singleton_method(:query_settings_for_id) { |_| current }
+      selector.define_singleton_method(:selector_thread?) { false }
+      selector.define_singleton_method(:register_query_if_current) do |settings, previous|
+        raise 'wrong attempt replaced' unless current.equal?(previous)
+        current = settings
+        registered.call(settings)
+      end
+    end
+  end
+
+  def assert_local_roundtrip(transport, count = 1, numeric_scope = false, scoped: true)
+    server, udp, tcp = bind_local_servers(transport, numeric_scope, scoped)
+    port = (udp || tcp).local_address.ip_port
+    received = []
+    server_errors = Queue.new
+    worker = Thread.new do
+      Thread.current.abort_on_exception = false
+      Thread.current.report_on_exception = false if Thread.current.respond_to?(:report_on_exception=)
+      connection = nil
+      begin
+        if udp
+          wait_readable(udp)
+          bytes, peer = udp.recvfrom(65_535)
+          query = Dnsruby::Message.decode(bytes)
+          received << [:udp, query.question.first.qname.to_s]
+          response = answer_for(query, transport == :fallback)
+          udp.send(response.encode, 0, peer[3], peer[1])
+        end
+        if tcp
+          wait_readable(tcp)
+          connection, = tcp.accept
+          queries = Array.new(count) do
+            length = read_exactly(connection, 2).unpack1('n')
+            query = Dnsruby::Message.decode(read_exactly(connection, length))
+            received << [:tcp, query.question.first.qname.to_s]
+            query
+          end
+          # Read every request before replying, then reverse the responses.
+          # This requires concurrent outstanding queries on one connection.
+          queries.reverse_each do |query|
+            response = answer_for(query).encode
+            connection.write([response.bytesize].pack('n') + response)
+          end
+        end
+      rescue StandardError => error
+        server_errors << error
+      ensure
+        connection.close if connection && !connection.closed?
+      end
+    end
+
+    resolver = Dnsruby::Resolver.new(
+      nameserver: server, port: port, src_port: 0,
+      dnssec: false, do_caching: false, retry_times: 1,
+      packet_timeout: 2, query_timeout: 3,
+      use_tcp: [:tcp, :pipeline].include?(transport),
+      tcp_pipelining: transport == :pipeline
+    )
+    names = Array.new(count) { |index| "scoped-#{transport}-#{index}.example.invalid" }
+    if transport == :pipeline
+      queue = Queue.new
+      names.each_with_index do |name, index|
+        message = Dnsruby::Message.new(name)
+        # Keep outstanding queries distinct without relying on random DNS IDs.
+        message.header.id = index
+        message.do_caching = false
+        message.do_validation = false
+        resolver.send_async(message, queue, index)
+      end
+      responses = Timeout.timeout(5) { Array.new(count) { queue.pop } }
+      assert_equal (0...count).to_a, responses.map(&:first).sort
+      responses.each do |index, response, error|
+        assert_nil error
+        assert_equal ANSWER, response.answer.first.address.to_s
+        assert_equal names[index], response.question.first.qname.to_s
+      end
+    else
+      name = names.first
+      response = Timeout.timeout(5) { resolver.query(name) }
+      assert_equal ANSWER, response.answer.first.address.to_s
+      assert_equal name, response.question.first.qname.to_s
+    end
+    assert worker.join(3), 'local DNS server did not finish'
+    raise server_errors.pop unless server_errors.empty?
+    expected = transport == :fallback ? [:udp, :tcp] : Array.new(count, transport == :udp ? :udp : :tcp)
+    assert_equal expected, received.map(&:first)
+  ensure
+    resolver.close if resolver
+    if worker
+      worker.kill if worker.alive?
+      worker.join
+    end
+    [udp, tcp].compact.each { |socket| socket.close unless socket.closed? }
+  end
+
+  def answer_for(query, truncated = false)
+    query.header.qr = true
+    query.header.ra = true
+    query.header.tc = truncated
+    unless truncated
+      query.add_answer(Dnsruby::RR.create("#{query.question.first.qname} 60 IN A #{ANSWER}"))
+    end
+    query
+  end
+
+  def wait_readable(socket)
+    raise IOError, 'local DNS server timed out' unless IO.select([socket], nil, nil, 3)
+  end
+
+  def read_exactly(socket, length)
+    bytes = ''.b
+    while bytes.bytesize < length
+      wait_readable(socket)
+      bytes << socket.readpartial(length - bytes.bytesize)
+    end
+    bytes
+  end
+
+  def bind_local_servers(transport, numeric_scope, scoped)
+    servers = ['::1']
+    if scoped
+      unless Socket.respond_to?(:getifaddrs)
+        skip 'Socket.getifaddrs is unavailable; socket-boundary tests cover scoped transport'
+      end
+      interfaces = Socket.getifaddrs.select { |entry| entry.addr && entry.addr.ipv6? && entry.addr.ipv6_linklocal? }
+      interfaces.sort_by! { |entry| (entry.flags & Socket::IFF_LOOPBACK).zero? ? 1 : 0 }
+      servers = interfaces.filter_map do |entry|
+        next if numeric_scope && !entry.respond_to?(:ifindex)
+        zone = numeric_scope ? entry.ifindex : entry.name
+        "#{entry.addr.ip_address.split('%').first}%#{zone}"
+      end
+    end
+    servers.each do |server|
+      udp = tcp = nil
+      begin
+        if [:udp, :fallback].include?(transport)
+          udp = UDPSocket.new(Socket::AF_INET6)
+          udp.bind(server, 0)
+        end
+        if [:tcp, :pipeline, :fallback].include?(transport)
+          tcp = Socket.new(Socket::AF_INET6, Socket::SOCK_STREAM, 0)
+          tcp.bind(Socket.sockaddr_in(udp ? udp.local_address.ip_port : 0, server))
+          tcp.listen(1)
+        end
+        return [server, udp, tcp]
+      rescue SocketError, SystemCallError
+        [udp, tcp].compact.each { |socket| socket.close unless socket.closed? }
+      end
+    end
+    skip(scoped ? 'No bindable local IPv6 link-local address; socket-boundary tests cover scoped transport' :
+      'IPv6 loopback is unavailable; socket-boundary tests cover IPv6 transport')
+  end
+end

data/test/tc_selector_wakeup.rb

@@ -0,0 +1,42 @@
+require_relative 'spec_helper'
+require 'open3'
+require 'rbconfig'
+
+class TestSelectorWakeup < Minitest::Test
+  def test_a_saturated_native_notification_socket_cannot_block_the_selector
+    script = <<~'RUBY'
+      require 'dnsruby'
+      require 'fcntl'
+      require 'timeout'
+      selector = Dnsruby::SelectThread.send(:allocate)
+      writer, reader = selector.get_socket_pair
+      Dnsruby::SelectThread.class_variable_set(:@@wakeup_sockets, [writer, reader])
+      writer.setsockopt(Socket::SOL_SOCKET, Socket::SO_SNDBUF, 1024)
+      reader.setsockopt(Socket::SOL_SOCKET, Socket::SO_RCVBUF, 1024)
+      flags = writer.fcntl(Fcntl::F_GETFL, 0)
+      begin
+        # Fill both kernel buffers; allow already-enqueued data to move across
+        # the connection, then refill until no further transfer creates space.
+        20.times do
+          begin
+            loop { writer.write_nonblock('x' * 4096) }
+          rescue IO::WaitWritable
+          end
+          sleep 0.005
+        end
+        # Filling through write_nonblock can change the descriptor flags. Restore
+        # blocking mode so the old Socket#send implementation really would block.
+        writer.fcntl(Fcntl::F_SETFL, flags & ~Fcntl::O_NONBLOCK)
+        Timeout.timeout(1) { 1000.times { selector.wake_up_select_thread } }
+        raise 'notification disappeared' unless IO.select([reader], nil, nil, 0)
+      ensure
+        writer.close
+        reader.close
+      end
+    RUBY
+    stdout, stderr, status = Open3.capture3(RbConfig.ruby, '-I',
+      File.expand_path('../lib', __dir__), '-e', script)
+    assert(status.success?, "#{stdout}\n#{stderr}")
+    assert_empty(stderr)
+  end
+end