gitlab-net-dns 0.12.0 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 626fddeccebd199f0753f59a1f0da00bf17c923ab59863f6dcf4f1712e565aa9
-  data.tar.gz: 266c1c5e8b273c3b09305cca8a96127b4d46bfe9396ceb103ef3278edef54101
+  metadata.gz: 74ee6c4e55aca3a4b262ef65ed15aa7eb4faefba46e236581313e600f488d4fb
+  data.tar.gz: c0737bd705ee060cb3e0cabd8f16985e24cbc9c32435ab7287435075a70c4532
 SHA512:
-  metadata.gz: f17432960ab586b0e2d74dc9d3d8cdad69a477c050f20139038155825b4dcd116d41fa8b423203310fd88cd8510f49086db89d2fee372219eb72fe5d39a56cf1
-  data.tar.gz: b357ac43e0927bccd981530f026f4af77f3a1da4d2263966621a9744a62781bf44f7438f383b404d3194f5a9f1f0f16ea490ac8116ad1299683aa5a408405af9
+  metadata.gz: 88cc517f05b54349d8cc62a597415e395888398e9d4557b1f9c8176b7dc1b98ab6b4683a82ca50909c37054c1e9bee076648eb637242db69d2ab94899577ea71
+  data.tar.gz: 9e4bfdd6c46a3e1e48449aa384561cd158c4e7580e01593d24f860900ffc708d789fbdfbc5f6b39ba35fdeccc2d5d3971e4f482e158792e16d56509d2d5b200d

data/.rubocop_todo.yml

@@ -11,7 +11,7 @@
 # Include: **/*.gemspec
 Gemspec/RequiredRubyVersion:
   Exclude:
-    - 'net-dns.gemspec'
+    - 'gitlab-net-dns.gemspec'
 
 
 # Offense count: 2

data/README.md

@@ -17,16 +17,16 @@ Ruby >= 2.1
 
 ## Installation
 
-The best way to install this library is via [RubyGems](https://rubygems.org/).
+The best way to install this library is via [RubyGems](https://rubygems.org/gems/gitlab-net-dns/).
 
 ```
-gem install net-dns
+gem install gitlab-net-dns
 ```
 
 
 ## API Documentation
 
-Visit the page http://rdoc.info/gems/net-dns
+Visit the page http://rdoc.info/gems/gitlab-net-dns
 
 
 ## Trivial resolver

data/lib/net/dns/resolver.rb

@@ -92,7 +92,10 @@ module Net
       class NoResponseError < Error
       end
 
-      # An hash with the defaults values of almost all the
+      class ResolverPermissionError < Error
+      end
+
+      # A hash with the default values of almost all the
       # configuration parameters of a resolver object. See
       # the description for each parameter to have an
       # explanation of its usage.
@@ -315,7 +318,16 @@ module Net
       #     #=> ["192.168.0.1","192.168.0.2"]
       #
       def nameservers
-        @config[:nameservers].map(&:to_s)
+        @config[:nameservers].map do |entry|
+          case entry
+          in IPAddr
+            entry.to_s
+          in [IPAddr]
+            [entry[0].to_s]
+          in [IPAddr, Integer]
+            [entry[0].to_s, entry[1]]
+          end
+        end
       end
 
       alias nameserver nameservers
@@ -326,48 +338,38 @@ module Net
       #   res.nameservers = "192.168.0.1"
       #   res.nameservers = ["192.168.0.1","192.168.0.2"]
       #
-      # If you want you can specify the addresses as IPAddr instances.
+      # If you want, you can specify the addresses as IPAddr instances.
       #
-      #   ip = IPAddr.new("192.168.0.3")
-      #   res.nameservers << ip
-      #   #=> ["192.168.0.1","192.168.0.2","192.168.0.3"]
+      #   res.nameservers = IPAddr.new("192.168.0.3")
       #
       # The default is 127.0.0.1 (localhost)
       #
       def nameservers=(arg)
-        case arg
-        when String
-          begin
-            @config[:nameservers] = [IPAddr.new(arg)]
-            @logger.info "Nameservers list changed to value #{@config[:nameservers].inspect}"
-          rescue ArgumentError # arg is in the name form, not IP
-            nameservers_from_name(arg)
-          end
-        when IPAddr
-          @config[:nameservers] = [arg]
-          @logger.info "Nameservers list changed to value #{@config[:nameservers].inspect}"
-        when Array
-          @config[:nameservers] = []
-          arg.each do |x|
-            val = case x
-            when String
-              begin
-                IPAddr.new(x)
-              rescue ArgumentError
-                nameservers_from_name(arg)
-                return
-              end
-            when IPAddr
-              x
-            else
-              raise ArgumentError, "Wrong argument format"
+        @config[:nameservers] = Array(arg).flat_map do |entry|
+          case entry
+          in String
+            begin
+              IPAddr.new(entry)
+            rescue ArgumentError
+              nameservers_from_name(entry)
             end
-            @config[:nameservers] << val
+          in IPAddr
+            entry
+          in [String]
+            [[IPAddr.new(entry[0])]]
+          in [IPAddr]
+            [[entry[0]]]
+          in [String, Integer]
+            validate_port!(entry[1])
+            [[IPAddr.new(entry[0]), entry[1]]]
+          in [IPAddr, Integer]
+            validate_port!(entry[1])
+            [[entry[0], entry[1]]]
+          else
+            raise ArgumentError, "Wrong argument format, neither String, Array nor IPAddr"
           end
-          @logger.info "Nameservers list changed to value #{@config[:nameservers].inspect}"
-        else
-          raise ArgumentError, "Wrong argument format, neither String, Array nor IPAddr"
         end
+        @logger.info "Nameservers list changed to value #{@config[:nameservers].inspect}"
       end
       alias_method("nameserver=", "nameservers=")
 
@@ -402,8 +404,7 @@ module Net
       # The default is port 53.
       #
       def port=(num)
-        (0..65_535).cover?(num) or
-            raise(ArgumentError, "Wrong port number #{num}")
+        validate_port!(num)
 
         @config[:port] = num
         @logger.info "Port number changed to #{num}"
@@ -422,7 +423,7 @@ module Net
       #
       #   res.source_port = 40000
       #
-      # Note that if you want to set a port you need root priviledges, as
+      # Note that if you want to set a port, you need root privileges, as
       # raw sockets will be used to generate packets. The class will then
       # generate the exception ResolverPermissionError if you're not root.
       #
@@ -430,10 +431,8 @@ module Net
       # underlaying layers.
       #
       def source_port=(num)
-        root? or
-            raise(ResolverPermissionError, "Are you root?")
-        (0..65_535).cover?(num) or
-            raise(ArgumentError, "Wrong port number #{num}")
+        raise(ResolverPermissionError, "Are you root?") unless root?
+        validate_port!(num)
 
         @config[:source_port] = num
       end
@@ -871,43 +870,6 @@ module Net
         query(name + ".", type, cls)
       end
 
-      # Performs a DNS query for the given name; the search list
-      # is not applied.  If the name doesn't contain any dots and
-      # +defname+ is true then the default domain will be appended.
-      #
-      # The record type and class can be omitted; they default to +A+
-      # and +IN+.  If the name looks like an IP address (IPv4 or IPv6),
-      # then an appropriate PTR query will be performed.
-      #
-      #   packet = res.query('mailhost')
-      #   packet = res.query('mailhost.example.com')
-      #   packet = res.query('example.com', Net::DNS::MX)
-      #   packet = res.query('user.passwd.example.com', Net::DNS::TXT, Net::DNS::HS)
-      #
-      # If the name is an IP address (Ipv4 or IPv6), in the form of a string
-      # or a +IPAddr+ object, then an appropriate PTR query will be performed:
-      #
-      #   ip = IPAddr.new("172.16.100.2")
-      #   packet = res.query(ip)
-      #   packet = res.query("192.168.10.254")
-      #
-      # Returns a Net::DNS::Packet object. If you need to examine the response
-      # packet whether it contains any answers or not, use the Resolver#query
-      # method instead.
-      #
-      def query(name, type = Net::DNS::A, cls = Net::DNS::IN)
-        return send(name, type, cls) if name.class == IPAddr
-
-        # If the name doesn't contain any dots then append the default domain.
-        if name !~ /\./ && name !~ /:/ && @config[:defname]
-          name += "." + @config[:domain]
-        end
-
-        @logger.debug "Query(#{name},#{Net::DNS::RR::Types.new(type)},#{Net::DNS::RR::Classes.new(cls)})"
-
-        send(name, type, cls)
-      end
-
       # Performs a DNS query for the given name.  Neither the
       # searchlist nor the default domain will be appended.
       #
@@ -1293,11 +1255,9 @@ module Net
         #   res.nameservers = "192.168.0.1"
         #   res.nameservers = ["192.168.0.1","192.168.0.2"]
         #
-        # If you want you can specify the addresses as IPAddr instances.
+        # If you want, you can specify the addresses as IPAddr instances.
         #
-        #   ip = IPAddr.new("192.168.0.3")
-        #   res.nameservers << ip
-        #   #=> ["192.168.0.1","192.168.0.2","192.168.0.3"]
+        #   res.nameservers = IPAddr.new("192.168.0.3")
         #
         # The default is 127.0.0.1 (localhost)
         #
@@ -1639,7 +1599,7 @@ module Net
             arr << ip
           end
         end
-        @config[:nameservers] << arr
+        arr
       end
 
       def make_query_packet(string, type, cls)
@@ -1675,20 +1635,21 @@ module Net
         ans = nil
         length = [packet_data.size].pack("n")
 
-        @config[:nameservers].each do |ns|
+        nameserver_port_pairs.each do |(ns, ns_port)|
           begin
             buffer = ""
             socket = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
             socket.bind(Socket.pack_sockaddr_in(@config[:source_port], @config[:source_address].to_s))
 
-            sockaddr = Socket.pack_sockaddr_in(@config[:port], ns.to_s)
+            sockaddr = Socket.pack_sockaddr_in(ns_port, ns.to_s)
+            success = false
 
             @config[:tcp_timeout].timeout do
               socket.connect(sockaddr)
-              @logger.info "Contacting nameserver #{ns} port #{@config[:port]}"
+              @logger.info "Contacting nameserver #{ns} port #{ns_port}"
               socket.write(length + packet_data)
               ans = socket.recv(Net::DNS::INT16SZ)
-              len = ans.unpack("n")[0]
+              len = ans.unpack("n")[0].to_i
 
               @logger.info "Receiving #{len} bytes..."
 
@@ -1707,8 +1668,16 @@ module Net
                 @logger.warn "Malformed packet from nameserver #{ns}, trying next."
                 next
               end
+
+              success = true
             end
-            return [buffer, ["", @config[:port], ns.to_s, ns.to_s]]
+
+            # Return buffer and the socket "from" data:
+            # from[0] - Address family as a string (e.g., "AF_INET" or "AF_INET6")
+            # from[1] - Port number as an integer
+            # from[2] - IP address as a string (e.g., "192.168.1.1" or "::1")
+            # from[3] - IP address as a string (same as from[2])
+            return [buffer, ["", ns_port, ns.to_s, ns.to_s]] if success
           rescue Timeout::Error
             @logger.warn "Nameserver #{ns} not responding within TCP timeout, trying next one"
             next
@@ -1716,7 +1685,8 @@ module Net
             socket.close
           end
         end
-        ans
+
+        nil
       end
 
       def query_udp(packet, packet_data)
@@ -1727,15 +1697,15 @@ module Net
 
         ans = nil
         response = ""
-        @config[:nameservers].each do |ns|
+        nameserver_port_pairs.each do |(ns, ns_port)|
           begin
             @config[:udp_timeout].timeout do
-              @logger.info "Contacting nameserver #{ns} port #{@config[:port]}"
+              @logger.info "Contacting nameserver #{ns} port #{ns_port}"
               ans = if ns.ipv6?
-                socket6.send(packet_data, 0, ns.to_s, @config[:port])
+                socket6.send(packet_data, 0, ns.to_s, ns_port)
                 socket6.recvfrom(@config[:packet_size])
               else
-                socket4.send(packet_data, 0, ns.to_s, @config[:port])
+                socket4.send(packet_data, 0, ns.to_s, ns_port)
                 socket4.recvfrom(@config[:packet_size])
               end
             end
@@ -1748,6 +1718,22 @@ module Net
         ans
       end
 
+      def nameserver_port_pairs
+        @config[:nameservers].map { |entry| Array(entry) }.map { |ns, ns_port| [ns, ns_port || port] }
+      end
+
+      def validate_port!(port)
+        raise(ArgumentError, "Wrong port number #{port}") unless valid_port?(port)
+      end
+
+      def valid_port?(port)
+        (0..65_535).cover?(port)
+      end
+
+      def root?
+        Process.euid == 0
+      end
+
       # FIXME: a ? method should never raise.
       def valid?(name)
         name !~ /[^-\w\.]/ or

data/lib/net/dns/version.rb

@@ -3,6 +3,6 @@
 module Net
   module DNS
     # The current library version.
-    VERSION = "0.12.0"
+    VERSION = "0.15.0"
   end
 end

data/spec/unit/resolver_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+require 'net/dns/resolver/timeouts'
+
+describe Net::DNS::Resolver do
+  it 'executes UDP query' do
+    ipv4_sock = instance_double(UDPSocket, bind: 0, send: 0)
+    ipv6_sock = instance_double(UDPSocket, bind: 0)
+
+    google_com_a_record_response = [
+      "A\x06\x81\x80\x00\x01\x00\x01\x00\x00\x00\x00\x06google\x03com\x00\x00\x01\x00\x01\xC0\f\x00\x01\x00\x01\x00\x00\x00I\x00\x04\x8E\xFA\xBA\xCE",
+      ['AF_INET', 53, '8.8.8.8', '8.8.8.8']
+    ]
+    allow(ipv4_sock).to receive(:recvfrom).and_return(google_com_a_record_response)
+
+    allow(UDPSocket).to receive(:new).and_return(ipv4_sock)
+    allow(UDPSocket).to receive(:new).with(Socket::AF_INET6).and_return(ipv6_sock)
+
+    resolver = Net::DNS::Resolver.new(nameservers: %w[8.8.8.8])
+    response = resolver.query('google.com')
+
+    expect(response.answer[0].address.to_s).to eq('142.250.186.206')
+    expect(ipv4_sock).to have_received(:bind).with(instance_of(String), instance_of(Integer))
+    expect(ipv4_sock).to have_received(:send).with(instance_of(String), 0, '8.8.8.8', 53)
+    expect(ipv4_sock).to have_received(:recvfrom).with(instance_of(Integer))
+  end
+
+  it 'executes TCP query' do
+    sock = instance_double(Socket, bind: 0, connect: 0, write: 0, close: nil)
+
+    allow(sock).to receive(:recv).and_return("\x00,")
+    google_com_a_record_response = "%\xF9\x81\x80\x00\x01\x00\x01\x00\x00\x00\x00\x06google\x03com\x00\x00\x01\x00\x01\xC0\f\x00\x01\x00\x01\x00\x00\x00\xB3\x00\x04\x8E\xFA\xBA\xCE"
+    allow(sock).to receive(:recvfrom).and_return(google_com_a_record_response)
+
+    allow(Socket).to receive(:new).and_return(sock)
+
+    resolver = Net::DNS::Resolver.new(nameservers: %w[8.8.8.8], use_tcp: true)
+    response = resolver.query('google.com')
+
+    expect(response.answer[0].address.to_s).to eq('142.250.186.206')
+    expect(sock).to have_received(:bind).with(instance_of(String))
+    expect(sock).to have_received(:connect).with(Socket.pack_sockaddr_in(53, '8.8.8.8'))
+    expect(sock).to have_received(:write).with(instance_of(String))
+    expect(sock).to have_received(:recv)
+    expect(sock).to have_received(:recvfrom).with(instance_of(Integer))
+    expect(sock).to have_received(:close)
+  end
+end

data/test/unit/dns_resolver_test.rb

@@ -0,0 +1,80 @@
+require 'test_helper'
+require 'net/dns/resolver'
+
+class TestDNSResolver < Minitest::Test
+  def setup
+    @resolver = Net::DNS::Resolver.new(
+        nameservers: ['8.8.8.8'],
+        port: 53,
+        source_address: IPAddr.new('0.0.0.0'),
+        tcp_timeout: 5,
+        udp_timeout: 5
+      )
+
+    # Sample DNS packet data
+    @packet_data = "\x12\x34\x01\x00\x00\x01\x00\x00\x00\x00\x00\x00\x03www\x06google\x03com\x00\x00\x01\x00\x01"
+  end
+
+  # Tests for query_tcp
+  def test_query_tcp_successful_response
+    mock_socket = Minitest::Mock.new
+
+    Socket.stub(:new, mock_socket) do
+      mock_socket.expect(:bind, nil, [String])
+      mock_socket.expect(:connect, nil, [String])
+      mock_socket.expect(:write, @packet_data.size + 2, [String])
+      mock_socket.expect(:recv, "\x00\x20", [2]) # Length = 32 bytes
+      mock_socket.expect(:recvfrom, ["A" * 32, nil], [32])
+      mock_socket.expect(:close, nil)
+
+      Socket.stub(:pack_sockaddr_in, "mock_sockaddr") do
+        result = @resolver.send(:query_tcp, @packet, @packet_data)
+
+        refute_nil result
+        assert_equal 2, result.size
+        assert_equal "A" * 32, result[0] # Response data
+        assert_equal ["", 53, "8.8.8.8", "8.8.8.8"], result[1] # From info
+      end
+    end
+
+    mock_socket.verify
+  end
+
+  def test_query_tcp_zero_length_response
+    mock_socket = Minitest::Mock.new
+
+    Socket.stub(:new, mock_socket) do
+      mock_socket.expect(:bind, nil, [String])
+      mock_socket.expect(:connect, nil, [String])
+      mock_socket.expect(:write, @packet_data.size + 2, [String])
+      mock_socket.expect(:recv, "\x00\x00", [2]) # Length = 0 bytes
+      mock_socket.expect(:close, nil)
+
+      Socket.stub(:pack_sockaddr_in, "mock_sockaddr") do
+        result = @resolver.send(:query_tcp, @packet, @packet_data)
+        assert_nil result # Should return nil for zero-length response
+      end
+    end
+
+    mock_socket.verify
+  end
+
+  def test_query_tcp_bogus_response
+    mock_socket = Minitest::Mock.new
+
+    Socket.stub(:new, mock_socket) do
+      mock_socket.expect(:bind, nil, [String])
+      mock_socket.expect(:connect, nil, [String])
+      mock_socket.expect(:write, @packet_data.size + 2, [String])
+      mock_socket.expect(:recv, "0", [2]) # Length = 0 bytes
+      mock_socket.expect(:close, nil)
+
+      Socket.stub(:pack_sockaddr_in, "mock_sockaddr") do
+        result = @resolver.send(:query_tcp, @packet, @packet_data)
+        assert_nil result # Should return nil for zero-length response
+      end
+    end
+
+    mock_socket.verify
+  end
+end

data/test/unit/resolver_test.rb

@@ -25,6 +25,69 @@ class ResolverTest < Minitest::Test
     assert_raises(ArgumentError) { Net::DNS::Resolver.new(:foo) }
   end
 
+  def test_set_port
+    resolver = Net::DNS::Resolver.new
+    assert_equal 53, resolver.port
+
+    assert_raises(ArgumentError) { resolver.port = 100_000 }
+    assert_equal 53, resolver.port
+
+    resolver.port = 10_053
+    assert_equal 10_053, resolver.port
+  end
+
+  def test_set_source_port
+    resolver = Net::DNS::Resolver.new
+    assert_equal 0, resolver.source_port
+
+    resolver.stub :root?, false do
+      assert_raises(Net::DNS::Resolver::ResolverPermissionError) { resolver.source_port = 1 }
+      assert_equal 0, resolver.source_port
+    end
+
+    resolver.stub :root?, true do
+      assert_raises(ArgumentError) { resolver.source_port = 100_000 }
+      assert_equal 0, resolver.source_port
+
+      resolver.source_port = 1
+      assert_equal 1, resolver.source_port
+    end
+  end
+
+  def test_set_nameservers
+    resolver = Net::DNS::Resolver.new nameservers: '127.0.0.1'
+    assert_equal ['127.0.0.1'], resolver.nameservers
+
+    assert_raises(ArgumentError) { resolver.nameservers = 1 }
+    assert_equal ['127.0.0.1'], resolver.nameservers
+
+    assert_raises(ArgumentError) { resolver.nameservers = ['192.168.1.1', 1] }
+    assert_equal ['127.0.0.1'], resolver.nameservers
+
+    resolver.stub :nameservers_from_name, [IPAddr.new('192.168.1.1')] do
+      assert_raises(ArgumentError) { resolver.nameservers = ['test.com', 1] }
+      assert_equal ['127.0.0.1'], resolver.nameservers
+
+      resolver.nameservers = 'test.com'
+      assert_equal ['192.168.1.1'], resolver.nameservers
+
+      resolver.nameservers = ['test.com']
+      assert_equal ['192.168.1.1'], resolver.nameservers
+
+      resolver.nameservers = ['192.168.1.2', 'test.com', IPAddr.new('192.168.1.3')]
+      assert_equal ['192.168.1.2', '192.168.1.1', '192.168.1.3'], resolver.nameservers
+    end
+
+    resolver.nameservers = [['192.168.1.1', 30053], ['192.168.1.2'], '192.168.1.3']
+    assert_equal [['192.168.1.1', 30053], ['192.168.1.2'], '192.168.1.3'], resolver.nameservers
+
+    resolver.nameservers = [[IPAddr.new('192.168.1.1'), 30053], [IPAddr.new('192.168.1.2')], IPAddr.new('192.168.1.3')]
+    assert_equal [['192.168.1.1', 30053], ['192.168.1.2'], '192.168.1.3'], resolver.nameservers
+
+    assert_raises(ArgumentError) { resolver.nameservers = [['192.168.1.1', 100_000]] }
+    assert_raises(ArgumentError) { resolver.nameservers = [[IPAddr.new('192.168.1.2'), 100_000]] }
+  end
+
   def test_query_with_no_nameservers_should_raise_resolvererror
     assert_raises(Net::DNS::Resolver::Error) { Net::DNS::Resolver.new(nameservers: []).query("example.com") }
   end
@@ -75,6 +138,13 @@ class ResolverTest < Minitest::Test
     assert_equal Net::DNS::IN.to_i,           packet.question.first.qClass.to_i
   end
 
+  def test_nameserver_port_pairs
+    resolver = Net::DNS::Resolver.new(nameservers: [['172.16.1.1', 30_053], ['172.16.1.2'],  '172.16.1.3'])
+    nameserver_port_pairs = resolver.send(:nameserver_port_pairs)
+    assert_equal ['172.16.1.1', '172.16.1.2', '172.16.1.3'], nameserver_port_pairs.map(&:first).map(&:to_s)
+    assert_equal [30_053, 53, 53], nameserver_port_pairs.map(&:last)
+  end
+
   def test_should_return_state_without_exception
     res = Net::DNS::Resolver.new
     assert_nothing_raised { res.state }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gitlab-net-dns
 version: !ruby/object:Gem::Version
-  version: 0.12.0
+  version: 0.15.0
 platform: ruby
 authors:
 - Marco Ceresa
 - Simone Carletti
 bindir: bin
 cert_chain: []
-date: 2025-05-03 00:00:00.000000000 Z
+date: 2025-07-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: logger
@@ -122,7 +122,9 @@ files:
 - spec/unit/resolver/dns_timeout_spec.rb
 - spec/unit/resolver/tcp_timeout_spec.rb
 - spec/unit/resolver/udp_timeout_spec.rb
+- spec/unit/resolver_spec.rb
 - test/test_helper.rb
+- test/unit/dns_resolver_test.rb
 - test/unit/header_test.rb
 - test/unit/names_test.rb
 - test/unit/packet_test.rb
@@ -165,7 +167,9 @@ test_files:
 - spec/unit/resolver/dns_timeout_spec.rb
 - spec/unit/resolver/tcp_timeout_spec.rb
 - spec/unit/resolver/udp_timeout_spec.rb
+- spec/unit/resolver_spec.rb
 - test/test_helper.rb
+- test/unit/dns_resolver_test.rb
 - test/unit/header_test.rb
 - test/unit/names_test.rb
 - test/unit/packet_test.rb