Create a new instance of Net::DNS::RR class, or an instance of any of the subclass of the appropriate type.

Argument can be a string or an hash. With a sting, we can pass a RR resource record in the canonical format:

  a     = Net::DNS::RR.new("foo.example.com. 86400 A 10.1.2.3")
  mx    = Net::DNS::RR.new("example.com. 7200 MX 10 mailhost.example.com.")
  cname = Net::DNS::RR.new("www.example.com 300 IN CNAME www1.example.com")
  txt   = Net::DNS::RR.new('baz.example.com 3600 HS TXT "text record"')

Incidentally, a, mx, cname and txt objects will be instances of respectively Net::DNS::RR::A, Net::DNS::RR::MX, Net::DNS::RR::CNAME and Net::DNS::RR::TXT classes.

The name and RR data are required; all other informations are optional. If omitted, the TTL defaults to 10800, type default to A and the RR class defaults to IN. Omitting the optional fields is useful for creating the empty RDATA sections required for certain dynamic update operations. All names must be fully qualified. The trailing dot (.) is optional.

The preferred method is however passing an hash with keys and values:

  rr = Net::DNS::RR.new(
                :name    => "foo.example.com",
                :ttl     => 86400,
                :cls     => "IN",
                :type    => "A",
                :address => "10.1.2.3"
        )

  rr = Net::DNS::RR.new(
                :name => "foo.example.com",
                :rdata => "10.1.2.3"
        )

Name and data are required; all the others fields are optionals like we‘ve seen before. The data field can be specified either with the right name of the resource (+:address+ in the example above) or with the generic key +:rdata+. Consult documentation to find the exact name for the resource in each subclass.

[Source]

# File lib/net/dns/rr.rb, line 133
      def initialize(arg)
        case arg
        when String
          instance = new_from_string(arg)
        when Hash
          instance = new_from_hash(arg)
        else
          raise RRArgumentError, "Invalid argument, must be a RR string or an hash of values"
        end

        if @type.to_s == "ANY"
          @cls = Net::DNS::RR::Classes.new("IN")
        end

        build_pack
        set_type

        instance
      end

Return a new RR object of the correct type (like Net::DNS::RR::A if the type is A) from a binary string, usually obtained from network stream.

This method is used when parsing a binary packet by the Packet class.

[Source]

# File lib/net/dns/rr.rb, line 160
      def RR.parse(data)
        o = allocate
        obj,offset = o.send(:new_from_binary, data, 0)
        return obj
      end

Same as RR.parse, but takes an entire packet binary data to perform name expansion. Default when analizing a packet just received from a network stream.

Return an instance of appropriate class and the offset pointing at the end of the data parsed.

[Source]

# File lib/net/dns/rr.rb, line 173
      def RR.parse_packet(data,offset)
        o = allocate
        o.send(:new_from_binary,data,offset)
      end

Class accessor

[Source]

# File lib/net/dns/rr.rb, line 250
      def cls
        @cls.to_s
      end

Return the RR object in binary data format, suitable for using in network streams, with names compressed. Must pass as arguments the offset inside the packet and an hash of compressed names.

This method is to be used in other classes and is not intended for user space programs.

TO FIX in one of the future releases

[Source]

# File lib/net/dns/rr.rb, line 188
      def comp_data(offset,compnames)
        type,cls = @type.to_i, @cls.to_i
        str,offset,names = dn_comp(@name,offset,compnames)
        str += [type,cls,@ttl,@rdlength].pack("n2 N n")
        offset += Net::DNS::RRFIXEDSZ
        return str,offset,names
      end

Return the RR object in binary data format, suitable for using in network streams.

  raw_data = rr.data
  puts "RR is #{raw_data.size} bytes long"

[Source]

# File lib/net/dns/rr.rb, line 202
      def data
        type,cls = @type.to_i, @cls.to_i
        str = pack_name(@name)
        return str + [type,cls,@ttl,@rdlength].pack("n2 N n") + get_data
      end

Canonical inspect method

  mx = Net::DNS::RR.new("example.com. 7200 MX 10 mailhost.example.com.")
    #=> example.com.            7200    IN      MX      10 mailhost.example.com.

[Source]

# File lib/net/dns/rr.rb, line 213
      def inspect
        data = get_inspect 
        # Returns the preformatted string
        if @name.size < 24
          [@name, @ttl.to_s, @cls.to_s, @type.to_s, 
            data].pack("A24 A8 A8 A8 A*")
        else
          to_a.join("   ")
        end
      end

Returns an array with all the fields for the RR record.

  mx = Net::DNS::RR.new("example.com. 7200 MX 10 mailhost.example.com.")
  mx.to_a
    #=> ["example.com.",7200,"IN","MX","10 mailhost.example.com."]

[Source]

# File lib/net/dns/rr.rb, line 240
      def to_a
        [@name,@ttl,@cls.to_s,@type.to_s,get_inspect]
      end

Returns the RR in a string format.

  mx = Net::DNS::RR.new("example.com. 7200 MX 10 mailhost.example.com.")
  mx.to_s
    #=> "example.com.            7200    IN      MX      10 mailhost.example.com."

[Source]

# File lib/net/dns/rr.rb, line 230
      def to_s
        "#{self.inspect}"
      end

Type accessor

[Source]

# File lib/net/dns/rr.rb, line 245
      def type
        @type.to_s
      end