gitlab-net-dns 0.9.1

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

@@ -0,0 +1,114 @@
+module Net
+  module DNS
+    class RR
+      #
+      # = IPv4 Address Record (A)
+      #
+      # Class for DNS IPv4 Address (A) resource records.
+      #
+      # The resource data is an IPv4 (i.e. 32 bit long) address,
+      # hold in the instance variable +address+.
+      #
+      #   a = Net::DNS::RR::A.new("localhost.movie.edu. 360 IN A 127.0.0.1")
+      #
+      #   a = Net::DNS::RR::A.new(:name    => "localhost.movie.edu.",
+      #                           :ttl     => 360,
+      #                           :cls     => Net::DNS::IN,
+      #                           :type    => Net::DNS::A,
+      #                           :address => "127.0.0.1" )
+      #
+      # When computing binary data to transmit the RR, the RDATA section is an
+      # Internet address expressed as four decimal numbers separated by dots
+      # without any embedded space (e.g. "10.2.0.52" or "192.0.5.6").
+      #
+      class A < RR
+        # Gets the current IPv4 address for this record.
+        #
+        # Returns an instance of IPAddr.
+        attr_reader :address
+
+        # Assigns a new IPv4 address to this record, which can be in the
+        # form of a <tt>String</tt> or an <tt>IPAddr</tt> object.
+        #
+        # Examples
+        #
+        #   a.address = "192.168.0.1"
+        #   a.address = IPAddr.new("10.0.0.1")
+        #
+        # Returns the new allocated instance of IPAddr.
+        def address=(string_or_ipaddr)
+          @address = check_address(string_or_ipaddr)
+          build_pack
+          @address
+        end
+
+        # Gets the standardized value for this record,
+        # represented by the value of <tt>address</tt>.
+        #
+        # Returns a String.
+        def value
+          address.to_s
+        end
+
+        private
+
+        def subclass_new_from_hash(options)
+          if options.key?(:address)
+            @address = check_address(options[:address])
+          elsif options.key?(:rdata)
+            @address = check_address(options[:rdata])
+          else
+            raise ArgumentError, ":address or :rdata field is mandatory"
+          end
+        end
+
+        def subclass_new_from_string(str)
+          @address = check_address(str)
+        end
+
+        def subclass_new_from_binary(data, offset)
+          a, b, c, d = data.unpack("@#{offset} CCCC")
+          @address = IPAddr.new("#{a}.#{b}.#{c}.#{d}")
+          offset + 4
+        end
+
+        def set_type
+          @type = Net::DNS::RR::Types.new("A")
+        end
+
+        def get_inspect
+          value
+        end
+
+        def check_address(input)
+          address = case input
+          when IPAddr
+            input
+          # Address in numeric form
+          when Integer
+            IPAddr.new(input, Socket::AF_INET)
+          when String
+            IPAddr.new(input)
+          else
+            raise ArgumentError, "Invalid IP address `#{input}'"
+          end
+
+          unless address.ipv4?
+            raise(ArgumentError, "Must specify an IPv4 address")
+          end
+
+          address
+        end
+
+        def build_pack
+          @address_pack = @address.hton
+          @rdlength = @address_pack.size
+        end
+
+        def get_data
+          @address_pack
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+module Net
+  module DNS
+    class RR
+      #
+      # = IPv6 Address Record (AAAA)
+      #
+      # Class for DNS IPv6 Address (AAAA) resource records.
+      #
+      class AAAA < RR
+        # Gets the current IPv6 address for this record.
+        #
+        # Returns an instance of IPAddr.
+        attr_reader :address
+
+        # Assigns a new IPv6 address to this record, which can be in the
+        # form of a <tt>String</tt> or an <tt>IPAddr</tt> object.
+        #
+        # Examples
+        #
+        #   a.address = "192.168.0.1"
+        #   a.address = IPAddr.new("10.0.0.1")
+        #
+        # Returns the new allocated instance of IPAddr.
+        def address=(string_or_ipaddr)
+          @address = check_address(string_or_ipaddr)
+          build_pack
+          @address
+        end
+
+        # Gets the standardized value for this record,
+        # represented by the value of <tt>address</tt>.
+        #
+        # Returns a String.
+        def value
+          address.to_s
+        end
+
+        private
+
+        def subclass_new_from_hash(options)
+          if options.key?(:address)
+            @address = check_address(options[:address])
+          else
+            raise ArgumentError, ":address field is mandatory"
+          end
+        end
+
+        def subclass_new_from_string(str)
+          @address = check_address(str)
+        end
+
+        def subclass_new_from_binary(data, offset)
+          tokens = data.unpack("@#{offset} n8")
+          @address = IPAddr.new(format("%x:%x:%x:%x:%x:%x:%x:%x", *tokens))
+          offset + 16
+        end
+
+        def set_type
+          @type = Net::DNS::RR::Types.new("AAAA")
+        end
+
+        def get_inspect
+          value
+        end
+
+        def check_address(input)
+          address = case input
+          when IPAddr
+            input
+          when String
+            IPAddr.new(input)
+          else
+            raise ArgumentError, "Invalid IP address `#{input}'"
+          end
+
+          unless address.ipv6?
+            raise(ArgumentError, "Must specify an IPv6 address")
+          end
+
+          address
+        end
+
+        def build_pack
+          @address_pack = @address.hton
+          @rdlength = @address_pack.size
+        end
+
+        def get_data
+          @address_pack
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,130 @@
+module Net
+  module DNS
+    class RR
+      #
+      # = Net::DNS::Classes
+      #
+      # This is an auxiliary class to handle <tt>Net::DNS::RR</tt>
+      # class field in a DNS packet.
+      #
+      class Classes
+        # Hash with the values of each RR class stored with the
+        # respective id number.
+        CLASSES = {
+          'IN' => 1, # RFC 1035
+          'CH' => 3,       # RFC 1035
+          'HS' => 4,       # RFC 1035
+          'NONE' => 254, # RFC 2136
+          'ANY' => 255, # RFC 1035
+        }.freeze
+
+        # The default value when class is nil in Resource Records
+        @@default = CLASSES["IN"]
+
+        # Creates a new object representing an RR class. Performs some
+        # checks on the argument validity too. Il +cls+ is +nil+, the
+        # default value is +ANY+ or the one set with Classes.default=
+        def initialize(cls)
+          case cls
+          when String
+            initialize_from_str(cls)
+          when Integer
+            initialize_from_num(cls)
+          when nil
+            initialize_from_num(@@default)
+          end
+
+          if @str.nil? || @num.nil?
+            raise ArgumentError, "Unable to create a `Classes' from `#{cls}'"
+          end
+        end
+
+        # Returns the class in number format
+        # (default for normal use)
+        #
+        # FIXME: inspect must return a String.
+        #
+        def inspect
+          @num
+        end
+
+        # Returns the class in string format,
+        # ex. "IN" or "CH" or such a string.
+        def to_s
+          @str.to_s
+        end
+
+        # Returns the class in numeric format,
+        # usable by the pack methods for data transfers.
+        def to_i
+          @num.to_i
+        end
+
+        def self.default
+          @@default
+        end
+
+        # Be able to control the default class to assign when
+        # cls argument is +nil+. Default to +IN+
+        def self.default=(str)
+          if CLASSES[str]
+            @@default = CLASSES[str]
+          else
+            raise ArgumentError, "Unknown class `#{str}'"
+          end
+        end
+
+        # Returns whether <tt>cls</tt> is a valid RR class.
+        #
+        #   Net::DNS::RR::Classes.valid?("IN")
+        #   # => true
+        #   Net::DNS::RR::Classes.valid?(1)
+        #   # => true
+        #   Net::DNS::RR::Classes.valid?("Q")
+        #   # => false
+        #   Net::DNS::RR::Classes.valid?(256)
+        #   # => false
+        #   Net::DNS::RR::Classes.valid?(Hash.new)
+        #   # => ArgumentError
+        #
+        # FIXME: valid? should never raise.
+        #
+        # ==== Raises
+        # ArgumentError:: if <tt>cls</tt> isn't either a String or a Fixnum
+        #
+        def self.valid?(cls)
+          case cls
+          when String
+            CLASSES.key?(cls)
+          when Integer
+            CLASSES.invert.key?(cls)
+          else
+            raise ArgumentError, "Wrong cls class: #{cls.class}"
+          end
+        end
+
+        # Gives in output the keys from the +Classes+ hash
+        # in a format suited for regexps
+        def self.regexp
+          CLASSES.keys.sort.join("|")
+        end
+
+        private
+
+        # Initialize a new instance from a Class name.
+        def initialize_from_str(str)
+          key = str.to_s.upcase
+          @num = CLASSES[key]
+          @str = key
+        end
+
+        # Initialize a new instance from the Class value.
+        def initialize_from_num(num)
+          key = num.to_i
+          @num = key
+          @str = CLASSES.invert[key]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+module Net # :nodoc:
+  module DNS
+    class RR
+      #
+      # = Canonical Name Record (CNAME)
+      #
+      # Class for DNS CNAME resource records.
+      #
+      # A CNAME record maps an alias or nickname to the real or Canonical name
+      # which may lie outside the current zone.
+      # Canonical means expected or real name.
+      #
+      class CNAME < RR
+        # Gets the canonical name value.
+        #
+        # Returns a String.
+        attr_reader :cname
+
+        # Gets the standardized value for this record,
+        # represented by the value of <tt>cname</tt>.
+        #
+        # Returns a String.
+        def value
+          cname.to_s
+        end
+
+        private
+
+        def subclass_new_from_hash(options)
+          if options.key?(:cname)
+            @cname = check_name(options[:cname])
+          else
+            raise ArgumentError, ":cname field is mandatory"
+          end
+        end
+
+        def subclass_new_from_string(str)
+          @cname = check_name(str)
+        end
+
+        def subclass_new_from_binary(data, offset)
+          @cname, offset = dn_expand(data, offset)
+          offset
+        end
+
+        def set_type
+          @type = Net::DNS::RR::Types.new("CNAME")
+        end
+
+        def get_inspect
+          value
+        end
+
+        def check_name(input)
+          name = input.to_s
+          unless name =~ /(\w\.?)+\s*$/ && name =~ /[a-zA-Z]/
+            raise ArgumentError, "Invalid Canonical Name `#{name}'"
+          end
+
+          name
+        end
+
+        def build_pack
+          @cname_pack = pack_name(@cname)
+          @rdlength = @cname_pack.size
+        end
+
+        def get_data
+          @cname_pack
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,96 @@
+module Net # :nodoc:
+  module DNS
+    class RR
+      #
+      # = System Information Record (HINFO)
+      #
+      # Class for DNS HINFO resource records.
+      #
+      # Allows definition of the Hardware type and Operating System (OS) in use at a host.
+      # For security reasons these records are rarely used on public servers.
+      # If a space exists in the field it must be enclosed in quotes.
+      # Single space between CPU and OS parameters.
+      #
+      class HINFO < RR
+        # Gets the CPU value.
+        #
+        # Returns a String.
+        attr_reader :cpu
+
+        # Gets the OS value.
+        #
+        # Returns a String.
+        attr_reader :os
+
+        # Gets the standardized value for this record,
+        # represented by the value of <tt>cpu</tt> and <tt>os</tt>.
+        #
+        # Returns a String.
+        def value
+          %Q("#{cpu}" "#{os}")
+        end
+
+        # Gets a list of all the attributes for this record.
+        #
+        # Returns an Array of values.
+        def to_a
+          [nil, nil, cls.to_s, type.to_s, value]
+        end
+
+        private
+
+        def subclass_new_from_hash(options)
+          if options.key?(:cpu) && options.key?(:os)
+            @cpu = options[:cpu]
+            @os  = options[:os]
+          else
+            raise ArgumentError, ":cpu and :os fields are mandatory"
+          end
+        end
+
+        def subclass_new_from_string(str)
+          @cpu, @os = check_hinfo(str)
+        end
+
+        def subclass_new_from_binary(data, offset)
+          len = data.unpack("@#{offset} C").first
+          offset += 1
+          @cpu = data[offset..(offset + len)]
+          offset += len
+
+          len = data.unpack("@#{offset} C").first
+          offset += 1
+          @os = data[offset..(offset + len)]
+          offset += len
+        end
+
+        def set_type
+          @type = Net::DNS::RR::Types.new("HINFO")
+        end
+
+        def get_inspect
+          value
+        end
+
+        def check_hinfo(input)
+          if input.to_s.strip =~ /^(?:["']?(.*?)["']?)\s+(?:["']?(.*?)["']?)$/
+            [Regexp.last_match(1), Regexp.last_match(2)]
+          else
+            raise ArgumentError, "Invalid HINFO Section `#{input}'"
+          end
+        end
+
+        def build_pack
+          @hinfo_pack  = ""
+          @hinfo_pack += [cpu.size].pack("C") + cpu
+          @hinfo_pack += [os.size].pack("C") + os
+          @rdlength = @hinfo_pack.size
+        end
+
+        def get_data
+          @hinfo_pack
+        end
+      end
+    end
+  end
+end