net-dns2 0.8.1

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

@@ -0,0 +1,124 @@
+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.
+        def address
+          @address
+        end
+
+        # 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.has_key?(:address)
+              @address = check_address(options[:address])
+            elsif options.has_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
+              when Integer # Address in numeric form
+                tmp = [(input >> 24), (input >> 16) & 0xFF, (input >> 8) & 0xFF, input & 0xFF]
+                tmp = tmp.collect { |x| x.to_s }.join(".")
+                IPAddr.new(tmp)
+              when String
+                IPAddr.new(input)
+              else
+                raise ArgumentError, "Invalid IP address `#{input}'"
+            end
+
+            if !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,103 @@
+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.
+        def address
+          @address
+        end
+
+        # 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.has_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(sprintf("%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
+
+            if !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,133 @@
+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
+        }
+
+        # 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 Fixnum
+              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
+
+
+
+        # 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.has_key?(cls)
+            when Fixnum
+              CLASSES.invert.has_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, @str = CLASSES[key], key
+        end
+
+        # Initialize a new instance from the Class value.
+        def initialize_from_num(num)
+          key = num.to_i
+          @num, @str = key, CLASSES.invert[key]
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+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.
+        def cname
+          @cname
+        end
+
+        # 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.has_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*$/ and 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,108 @@
+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.
+        def cpu
+          @cpu
+        end
+
+        # Gets the OS value.
+        #
+        # Returns a String.
+        def os
+          @os
+        end
+
+        # 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.has_key?(:cpu) && options.has_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+(?:["']?(.*?)["']?)$/
+              [$1, $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