gitlab-net-dns 0.12.0 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 626fddeccebd199f0753f59a1f0da00bf17c923ab59863f6dcf4f1712e565aa9
-  data.tar.gz: 266c1c5e8b273c3b09305cca8a96127b4d46bfe9396ceb103ef3278edef54101
+  metadata.gz: da76ca67ffda2850455d743e3485328b73296a7cfdca4808e8540fc0ba4b2593
+  data.tar.gz: c854da335de562911f61a177047bdcda77541be3c8647be8bc78a10ca0918f62
 SHA512:
-  metadata.gz: f17432960ab586b0e2d74dc9d3d8cdad69a477c050f20139038155825b4dcd116d41fa8b423203310fd88cd8510f49086db89d2fee372219eb72fe5d39a56cf1
-  data.tar.gz: b357ac43e0927bccd981530f026f4af77f3a1da4d2263966621a9744a62781bf44f7438f383b404d3194f5a9f1f0f16ea490ac8116ad1299683aa5a408405af9
+  metadata.gz: 2262bc9366375314c0119d96f2163f658b181d0b6bb1e6044aee62707ccf4da1c89ab8da66c508f3b0155d7fa240c583697cf4b4431b3bfe4bf04057b08a7628
+  data.tar.gz: 1a157339c0ee195365c5aa20692c8496d1401a7eb2a0fb6f48db3ecbc346f42ab7ff8e3bf3c454f851554234a66bcd83dd2d4d1568f22a989ba61812be716562

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,17 +1635,17 @@ 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)
 
             @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]
@@ -1708,7 +1668,7 @@ module Net
                 next
               end
             end
-            return [buffer, ["", @config[:port], ns.to_s, ns.to_s]]
+            return [buffer, ["", ns_port, ns.to_s, ns.to_s]]
           rescue Timeout::Error
             @logger.warn "Nameserver #{ns} not responding within TCP timeout, trying next one"
             next
@@ -1727,15 +1687,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 +1708,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.13.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/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.13.0
 platform: ruby
 authors:
 - Marco Ceresa
 - Simone Carletti
 bindir: bin
 cert_chain: []
-date: 2025-05-03 00:00:00.000000000 Z
+date: 2025-06-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: logger
@@ -122,6 +122,7 @@ 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/header_test.rb
 - test/unit/names_test.rb
@@ -165,6 +166,7 @@ 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/header_test.rb
 - test/unit/names_test.rb