gitlab-net-dns 0.9.1

data/lib/net/dns/rr/txt.rb

@@ -0,0 +1,58 @@
+module Net # :nodoc:
+  module DNS
+    class RR
+      #------------------------------------------------------------
+      # RR type TXT
+      #------------------------------------------------------------
+      class TXT < RR
+        attr_reader :txt
+
+        private
+
+        def build_pack
+          str = ""
+          @txt.split(" ").each do |txt|
+            str += [txt.length, txt].pack("C a*")
+          end
+          @txt_pack = str
+          @rdlength = @txt_pack.size
+        end
+
+        def get_data
+          @txt_pack
+        end
+
+        def subclass_new_from_hash(args)
+          if args.key? :txt
+            @txt = args[:txt].strip
+          else
+            raise ArgumentError, ":txt field is mandatory but missing"
+          end
+        end
+
+        def subclass_new_from_string(str)
+          @txt = str.strip
+        end
+
+        def subclass_new_from_binary(data, offset)
+          off_end = offset + @rdlength
+          @txt = ""
+          while offset < off_end
+            len = data.unpack("@#{offset} C")[0]
+            offset += 1
+            str = data[offset..offset + len - 1]
+            offset += len
+            @txt << str << " "
+          end
+          offset
+        end
+
+        private
+
+        def set_type
+          @type = Net::DNS::RR::Types.new("TXT")
+        end
+      end
+    end
+  end
+end

data/lib/net/dns/rr/types.rb

@@ -0,0 +1,191 @@
+module Net # :nodoc:
+  module DNS
+    class RR
+      # This is an auxiliary class to handle RR type field in a DNS packet.
+      class Types
+        TYPES = {
+          'SIGZERO' => 0, # RFC2931 consider this a pseudo type
+          'A' => 1, # RFC 1035, Section 3.4.1
+          'NS' => 2,       # RFC 1035, Section 3.3.11
+          'MD' => 3,       # RFC 1035, Section 3.3.4 (obsolete)
+          'MF' => 4,       # RFC 1035, Section 3.3.5 (obsolete)
+          'CNAME' => 5, # RFC 1035, Section 3.3.1
+          'SOA' => 6, # RFC 1035, Section 3.3.13
+          'MB' => 7,       # RFC 1035, Section 3.3.3
+          'MG' => 8,       # RFC 1035, Section 3.3.6
+          'MR' => 9,       # RFC 1035, Section 3.3.8
+          'NULL' => 10, # RFC 1035, Section 3.3.10
+          'WKS' => 11,      # RFC 1035, Section 3.4.2 (deprecated)
+          'PTR' => 12,      # RFC 1035, Section 3.3.12
+          'HINFO' => 13,      # RFC 1035, Section 3.3.2
+          'MINFO' => 14,      # RFC 1035, Section 3.3.7
+          'MX' => 15, # RFC 1035, Section 3.3.9
+          'TXT' => 16, # RFC 1035, Section 3.3.14
+          'RP' => 17, # RFC 1183, Section 2.2
+          'AFSDB' => 18, # RFC 1183, Section 1
+          'X25' => 19, # RFC 1183, Section 3.1
+          'ISDN' => 20, # RFC 1183, Section 3.2
+          'RT' => 21, # RFC 1183, Section 3.3
+          'NSAP' => 22, # RFC 1706, Section 5
+          'NSAP_PTR' => 23, # RFC 1348 (obsolete)
+          # The following 2 RRs are impemented in Net::DNS::SEC, TODO
+          'SIG' => 24,      # RFC 2535, Section 4.1
+          'KEY' => 25,      # RFC 2535, Section 3.1
+          'PX' => 26, # RFC 2163,
+          'GPOS' => 27,      # RFC 1712 (obsolete)
+          'AAAA' => 28,      # RFC 1886, Section 2.1
+          'LOC' => 29, # RFC 1876
+          # The following RR is implemented in Net::DNS::SEC, TODO
+          'NXT' => 30,      # RFC 2535, Section 5.2
+          'EID' => 31,      # draft-ietf-nimrod-dns-xx.txt
+          'NIMLOC' => 32, # draft-ietf-nimrod-dns-xx.txt
+          'SRV' => 33, # RFC 2052
+          'ATMA' => 34, # ???
+          'NAPTR' => 35, # RFC 2168
+          'KX' => 36, # RFC 2230
+          'CERT' => 37, # RFC 2538
+          'DNAME' => 39, # RFC 2672
+          'OPT' => 41, # RFC 2671
+          # The following 4 RRs are implemented in Net::DNS::SEC TODO
+          'DS' => 43, # draft-ietf-dnsext-delegation-signer
+          'SSHFP' => 44,      # draft-ietf-secsh-dns (No RFC # yet at time of coding)
+          'RRSIG' => 46,      # draft-ietf-dnsext-dnssec-2535typecode-change
+          'NSEC' => 47, # draft-ietf-dnsext-dnssec-2535typecode-change
+          'DNSKEY' => 48, # draft-ietf-dnsext-dnssec-2535typecode-change
+          'UINFO' => 100, # non-standard
+          'UID' => 101,     # non-standard
+          'GID' => 102,     # non-standard
+          'UNSPEC' => 103, # non-standard
+          'TKEY' => 249,     # RFC 2930
+          'TSIG' => 250,     # RFC 2931
+          'IXFR' => 251,     # RFC 1995
+          'AXFR' => 252,     # RFC 1035
+          'MAILB' => 253,     # RFC 1035 (MB, MG, MR)
+          'MAILA' => 254,     # RFC 1035 (obsolete - see MX)
+          'ANY' => 255, # RFC 1035
+        }.freeze
+
+        # The default value when type is nil in Resource Records
+        @@default = TYPES["A"]
+
+        def self.default
+          @@default
+        end
+
+        # Be able to control the default type to assign when
+        # type is +nil+. Default to +A+
+        def self.default=(str)
+          if TYPES.key? str
+            @@default = TYPES[str]
+          else
+            raise ArgumentError, "Unknown type #{str}"
+          end
+        end
+
+        # Checks whether +type+ is a valid RR type.
+        def self.valid?(type)
+          case type
+          when String
+            TYPES.key?(type)
+          when Integer
+            TYPES.invert.key?(type)
+          else
+            raise ArgumentError, "Wrong type class: #{type.class}"
+          end
+        end
+
+        # Returns the type in string format, as "A" or "NS",
+        # given the numeric value
+        def self.to_str(type)
+          case type
+          when Integer
+            if TYPES.invert.key? type
+              TYPES.invert[type]
+            else
+              raise ArgumentError, "Unknown type number #{type}"
+            end
+          else
+            raise ArgumentError, "Wrong type class: #{type.class}"
+          end
+        end
+
+        # Gives in output the keys from the +Types+ hash
+        # in a format suited for regexps
+        def self.regexp
+          # Longest ones go first, so the regex engine will match AAAA before A.
+          TYPES.keys.sort { |a, b| b.length <=> a.length }.join("|")
+        end
+
+        # Creates a new object representing an RR type. Performs some
+        # checks on the argument validity too. Il +type+ is +nil+, the
+        # default value is +ANY+ or the one set with Types.default=
+        def initialize(type)
+          case type
+          when String
+            # type in the form "A" or "NS"
+            new_from_string(type.upcase)
+          when Integer
+            # type in numeric form
+            new_from_num(type)
+          when nil
+            # default type, control with Types.default=
+            @str = TYPES.invert[@@default]
+            @num = @@default
+          else
+            raise ArgumentError, "Wrong type class: #{type.class}"
+          end
+        end
+
+        # Returns the type in number format
+        # (default for normal use)
+        def inspect
+          @num
+        end
+
+        # Returns the type in string format,
+        # i.d. "A" or "NS" or such a string.
+        def to_s
+          @str
+        end
+
+        # Returns the type in numeric format,
+        # usable by the pack methods for data transfers
+        def to_i
+          @num.to_i
+        end
+
+        def to_str
+          @num.to_s
+        end
+
+        private
+
+        # Constructor for string data type.
+        def new_from_string(type)
+          case type
+          when /^TYPE\\d+/
+            # TODO!!!
+          else
+            # String with name of type
+            if TYPES.key? type
+              @str = type
+              @num = TYPES[type]
+            else
+              raise ArgumentError, "Unknown type #{type}"
+            end
+          end
+        end
+
+        # Contructor for numeric data type.
+        def new_from_num(type)
+          if TYPES.invert.key? type
+            @num = type
+            @str = TYPES.invert[type]
+          else
+            raise ArgumentError, "Unkown type number #{type}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/net/dns/version.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Net
+  module DNS
+    # The current library version.
+    VERSION = "0.9.1".freeze
+  end
+end

data/spec/fixtures/resolv.conf

@@ -0,0 +1,4 @@
+search corporate.thoughtworks.com
+nameserver 192.168.1.1
+nameserver 192.168.1.2
+nameserver 192.168.1.3 192.168.1.4

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+require 'rspec'
+require 'net/dns'
+
+unless defined?(SPEC_ROOT)
+  SPEC_ROOT = File.expand_path(__dir__)
+end
+
+# Requires supporting ruby files with custom matchers and macros, etc,
+# in spec/support/ and its subdirectories.
+Dir[File.join(SPEC_ROOT, "support/**/*.rb")].each { |f| require f }
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+end

data/spec/unit/resolver/dns_timeout_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+require 'net/dns/resolver/timeouts'
+
+describe Net::DNS::Resolver::DnsTimeout do
+  subject { described_class.new(10) }
+
+  describe "#initialize" do
+    it "returns an instance of DnsTimeout" do
+      expect(subject.class).to be(described_class)
+    end
+
+    it "sets timeout" do
+      expect(described_class.new(0).seconds).to eq(0)
+      expect(described_class.new(10).seconds).to eq(10)
+    end
+
+    it "raises ArgumentError when timeout is invalid" do
+      expect { described_class.new(nil)   }.to raise_error(ArgumentError)
+      expect { described_class.new("")    }.to raise_error(ArgumentError)
+      expect { described_class.new("foo") }.to raise_error(ArgumentError)
+      expect { described_class.new(-1)    }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe "#to_s" do
+    it "returns the seconds" do
+      expect(subject.to_s).to eq("10")
+    end
+  end
+
+  describe "#timeout" do
+    it "requires a block" do
+      expect { subject.timeout }.to raise_error(LocalJumpError)
+    end
+  end
+end

data/spec/unit/resolver/tcp_timeout_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+require 'net/dns/resolver/timeouts'
+
+describe Net::DNS::Resolver::TcpTimeout do
+  subject { described_class.new(10) }
+
+  it "inherits from DnsTimeout" do
+    expect(described_class.ancestors).to include(Net::DNS::Resolver::DnsTimeout)
+  end
+
+  describe "#initialize" do
+    it "returns an instance of TcpTimeout" do
+      expect(subject.class).to be(described_class)
+    end
+
+    it "sets timeout" do
+      expect(described_class.new(0).seconds).to eq(0)
+      expect(described_class.new(10).seconds).to eq(10)
+    end
+
+    it "raises ArgumentError when timeout is invalid" do
+      expect { described_class.new(nil)   }.to raise_error(ArgumentError)
+      expect { described_class.new("")    }.to raise_error(ArgumentError)
+      expect { described_class.new("foo") }.to raise_error(ArgumentError)
+      expect { described_class.new(-1)    }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe "#to_s" do
+    it "returns infinite when seconds is 0" do
+      expect(described_class.new(0).to_s).to eq("infinite")
+    end
+
+    it "returns the seconds" do
+      expect(subject.to_s).to eq("10")
+    end
+  end
+
+  describe "#pretty_to_s" do
+    it "returns a more verbose version" do
+      expect(described_class.new(30).pretty_to_s).to eq("30 seconds")
+      expect(described_class.new(90).pretty_to_s).to eq("1 minutes and 30 seconds")
+      expect(described_class.new(3690).pretty_to_s).to eq("1 hours, 1 minutes and 30 seconds")
+    end
+  end
+end

data/spec/unit/resolver/udp_timeout_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+require 'net/dns/resolver/timeouts'
+
+describe Net::DNS::Resolver::UdpTimeout do
+  subject { described_class.new(10) }
+
+  it "inherits from DnsTimeout" do
+    expect(described_class.ancestors).to include(Net::DNS::Resolver::DnsTimeout)
+  end
+
+  describe "#initialize" do
+    it "returns an instance of TcpTimeout" do
+      expect(subject.class).to be(described_class)
+    end
+
+    it "sets timeout" do
+      expect(described_class.new(0).seconds).to eq(0)
+      expect(described_class.new(10).seconds).to eq(10)
+    end
+
+    it "raises ArgumentError when timeout is invalid" do
+      expect { described_class.new(nil)   }.to raise_error(ArgumentError)
+      expect { described_class.new("")    }.to raise_error(ArgumentError)
+      expect { described_class.new("foo") }.to raise_error(ArgumentError)
+      expect { described_class.new(-1)    }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe "#to_s" do
+    it "returns infinite when seconds is 0" do
+      expect(described_class.new(0).to_s).to eq("not defined")
+    end
+
+    it "returns the seconds" do
+      expect(subject.to_s).to eq("10")
+    end
+  end
+
+  describe "#pretty_to_s" do
+    it "returns a more verbose version" do
+      expect(described_class.new(30).pretty_to_s).to eq("30 seconds")
+      expect(described_class.new(90).pretty_to_s).to eq("1 minutes and 30 seconds")
+      expect(described_class.new(3690).pretty_to_s).to eq("1 hours, 1 minutes and 30 seconds")
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,13 @@
+require "minitest/autorun"
+require "minitest/reporters"
+
+Minitest::Reporters.use! Minitest::Reporters::DefaultReporter.new(color: true)
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+require "net/dns"
+
+module Minitest::Assertions
+  def assert_nothing_raised(*)
+    yield
+  end
+end

data/test/unit/header_test.rb

@@ -0,0 +1,164 @@
+require 'test_helper'
+require 'net/dns/header'
+
+class HeaderTest < Minitest::Test
+  include Net::DNS
+
+  def setup
+    @default = Header.new
+    @hash = Header.new(id: 441,
+                       qr: 1,
+                       opCode: Header::IQUERY,
+                       aa: 1,
+                       tc: 1,
+                       rd: 0,
+                       cd: 0,
+                       ad: 0,
+                       ra: 1,
+                       rCode: Header::RCode::FORMAT,
+                       qdCount: 1,
+                       anCount: 2,
+                       nsCount: 3,
+                       arCount: 3)
+
+    @modified = Header.new
+    @modified.id = 442
+    @modified.qr = true
+    @modified.opCode = Header::IQUERY
+    @modified.aa = true
+    @modified.tc = true
+    @modified.rd = false
+    @modified.cd = false
+    @modified.ra = true
+    @modified.rCode = Header::RCode::FORMAT
+    @modified.qdCount = 1
+    @modified.anCount = 2
+    @modified.nsCount = 3
+    @modified.arCount = 3
+
+    @data = @modified.data
+    num = [(@data.unpack("n")[0] + 1)].pack("n")
+    @data[0] = num[0]
+    @data[1] = num[1]
+    @binary = Header.parse(@data)
+  end
+
+  def test_simple
+    assert_equal(@default.query?, true)
+    assert_equal(@default.response?, false)
+    assert_equal(@default.opCode, Header::QUERY)
+    assert_equal(@default.auth?, false)
+    assert_equal(@default.truncated?, false)
+    assert_equal(@default.recursive?, true)
+    assert_equal(@default.checking?, true)
+    assert_equal(@default.verified?, false)
+    assert_equal(@default.r_available?, false)
+    assert_equal(@default.rCode.code, Header::RCode::NOERROR)
+    assert_equal(@default.qdCount, 1)
+    assert_equal(@default.anCount, 0)
+    assert_equal(@default.nsCount, 0)
+    assert_equal(@default.arCount, 0)
+
+    assert_equal(@hash.id, 441)
+    assert_equal(@hash.query?, false)
+    assert_equal(@hash.response?, true)
+    assert_equal(@hash.opCode, Header::IQUERY)
+    assert_equal(@hash.auth?, true)
+    assert_equal(@hash.truncated?, true)
+    assert_equal(@hash.recursive?, false)
+    assert_equal(@hash.checking?, true)
+    assert_equal(@hash.verified?, false)
+    assert_equal(@hash.r_available?, true)
+    assert_equal(@hash.rCode.code, Header::RCode::FORMAT)
+    assert_equal(@hash.qdCount, 1)
+    assert_equal(@hash.anCount, 2)
+    assert_equal(@hash.nsCount, 3)
+    assert_equal(@hash.arCount, 3)
+
+    assert_equal(@modified.id, 442)
+    assert_equal(@modified.query?, false)
+    assert_equal(@modified.response?, true)
+    assert_equal(@modified.opCode, Header::IQUERY)
+    assert_equal(@modified.auth?, true)
+    assert_equal(@modified.truncated?, true)
+    assert_equal(@modified.recursive?, false)
+    assert_equal(@modified.checking?, true)
+    assert_equal(@modified.verified?, false)
+    assert_equal(@modified.r_available?, true)
+    assert_equal(@modified.rCode.code, Header::RCode::FORMAT)
+    assert_equal(@modified.qdCount, 1)
+    assert_equal(@modified.anCount, 2)
+    assert_equal(@modified.nsCount, 3)
+    assert_equal(@modified.arCount, 3)
+
+    assert_equal(@binary.data, @data)
+
+    assert_equal(@binary.id, 443)
+    assert_equal(@binary.query?, false)
+    assert_equal(@binary.response?, true)
+    assert_equal(@binary.opCode, Header::IQUERY)
+    assert_equal(@binary.auth?, true)
+    assert_equal(@binary.truncated?, true)
+    assert_equal(@binary.recursive?, false)
+    assert_equal(@binary.checking?, true)
+    assert_equal(@binary.verified?, false)
+    assert_equal(@binary.r_available?, true)
+    assert_equal(@binary.rCode.code, Header::RCode::FORMAT)
+    assert_equal(@binary.qdCount, 1)
+    assert_equal(@binary.anCount, 2)
+    assert_equal(@binary.nsCount, 3)
+    assert_equal(@binary.arCount, 3)
+
+    assert_raises(ArgumentError) do
+      Header.new([])
+    end
+    assert_raises(ArgumentError) do
+      Header.parse([])
+    end
+    assert_raises(ArgumentError) do
+      Header.parse("aa")
+    end
+    assert_raises(ArgumentError) do
+      @default.id = 1_000_000
+    end
+    assert_raises(ArgumentError) do
+      @default.qr = 2
+    end
+    assert_raises(Header::WrongOpcodeError) do
+      @default.opCode = 4
+    end
+    assert_raises(ArgumentError) do
+      @default.aa = 2
+    end
+    assert_raises(ArgumentError) do
+      @default.tc = 2
+    end
+    assert_raises(Header::WrongRecursiveError) do
+      @default.recursive = 2
+    end
+    assert_raises(ArgumentError) do
+      @default.ra = 2
+    end
+    assert_raises(ArgumentError) do
+      @default.cd = 2
+    end
+    assert_raises(ArgumentError) do
+      @default.ad = 2
+    end
+    assert_raises(ArgumentError) do
+      @default.rCode = 46
+    end
+    assert_raises(Header::WrongCountError) do
+      @default.qdCount = 100_000
+    end
+    assert_raises(Header::WrongCountError) do
+      @default.anCount = 100_000
+    end
+    assert_raises(Header::WrongCountError) do
+      @default.nsCount = 100_000
+    end
+    assert_raises(Header::WrongCountError) do
+      @default.arCount = 100_000
+    end
+  end
+end