net-dns 0.6.1 → 0.7.0

data/lib/net/dns/resolver/socks.rb

@@ -62,12 +62,12 @@ class RawSocket # :nodoc:
   
   def check_addr addr
     case addr
-    when String
-      IPAddr.new addr
-    when IPAddr
-      addr
-    else
-      raise ArgumentError, "Wrong address format: #{addr}"
+      when String
+        IPAddr.new(addr)
+      when IPAddr
+        addr
+      else
+        raise ArgumentError, "Wrong address format: #{addr}"
     end
   end
   

data/lib/net/dns/resolver/timeouts.rb

@@ -13,7 +13,7 @@ module Net # :nodoc:
           if seconds.is_a? Numeric and seconds >= 0
             @seconds = seconds
           else
-            raise ::ArgumentError, "Invalid value for tcp timeout"
+            raise ArgumentError, "Invalid value for tcp timeout"
           end
         end
 

data/lib/net/dns/rr.rb

@@ -1,37 +1,37 @@
-require 'net/dns/names/names'
+require 'ipaddr'
+require 'net/dns/names'
 require 'net/dns/rr/types'
 require 'net/dns/rr/classes'
 
-
-%w[a ns mx cname txt soa ptr aaaa mr].each do |file|
+%w(a aaaa cname hinfo mr mx ns ptr soa srv txt).each do |file|
   require "net/dns/rr/#{file}"
 end
 
-module Net # :nodoc:
-  module DNS 
-    
+module Net
+  module DNS
+
     #
     # = Net::DNS::RR - DNS Resource Record class
     #
-    # The Net::DNS::RR is the base class for DNS Resource 
+    # The Net::DNS::RR is the base class for DNS Resource
     # Record (RR) objects. A RR is a pack of data that represents
-    # resources for a DNS zone. The form in which this data is 
+    # resources for a DNS zone. The form in which this data is
     # shows can be drawed as follow:
     #
     #   "name  ttl  class  type  data"
-    # 
+    #
     # The +name+ is the name of the resource, like an canonical
     # name for an +A+ record (internet ip address). The +ttl+ is the
-    # time to live, expressed in seconds. +type+ and +class+ are 
+    # time to live, expressed in seconds. +type+ and +class+ are
     # respectively the type of resource (+A+ for ip addresses, +NS+
-    # for nameservers, and so on) and the class, which is almost 
+    # for nameservers, and so on) and the class, which is almost
     # always +IN+, the Internet class. At the end, +data+ is the
-    # value associated to the name for that particular type of 
+    # value associated to the name for that particular type of
     # resource record. An example:
     #
     #   # A record for IP address
     #   "www.example.com  86400  IN  A  172.16.100.1"
-    #   
+    #
     #   # NS record for name server
     #   "www.example.com  86400  IN  NS  ns.example.com"
     #
@@ -39,34 +39,22 @@ module Net # :nodoc:
     # such the ones above, or specifying each field as the pair
     # of an hash. See the Net::DNS::RR.new method for details.
     #
-    # == Error classes
-    #
-    # Some error classes has been defined for the Net::DNS::RR class,
-    # which are listed here to keep a light and browsable main documentation.
-    # We have:
-    #
-    # ArgumentError:: Generic argument error for class Net::DNS::RR
-    # DataError::     Error in parsing binary data, maybe from a malformed packet.
-    #
     class RR
-      include Net::DNS::Names
-      
-      # Argument Error for class Net::DNS::RR.
-      class ArgumentError < ArgumentError
-      end
-      
+      include Names
+
+
       # Base error class.
       class Error < StandardError
       end
-      
+
       # Error in parsing binary data, maybe from a malformed packet.
       class DataError < Error
       end
-      
-      
+
+
       # Regexp matching an RR string
       RR_REGEXP = Regexp.new("^\\s*(\\S+)\\s*(\\d+)?\\s+(" +
-                               Net::DNS::RR::Classes.regexp + 
+                               Net::DNS::RR::Classes.regexp +
                                "|CLASS\\d+)?\\s*(" +
                                Net::DNS::RR::Types.regexp +
                                "|TYPE\\d+)?\\s*(.*)$", Regexp::IGNORECASE)
@@ -75,17 +63,10 @@ module Net # :nodoc:
       # RR portion of the packet, in bytes
       RRFIXEDSZ = 10
 
-      # Name of the RR
-      attr_reader :name
-      # TTL time (in seconds) of the RR
-      attr_reader :ttl
-      # Data belonging to that appropriate class, 
-      # not to be used (use real accessors instead)
-      attr_reader :rdata
-      
+
       # 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:
       #
@@ -95,12 +76,12 @@ module Net # :nodoc:
       #   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 
+      # 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.  
+      # 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 
+      # 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.
       #
@@ -119,12 +100,12 @@ module Net # :nodoc:
       #                 :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 
+      # 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.
-      # 
+      #
       def initialize(arg)
         instance = case arg
           when String
@@ -151,107 +132,122 @@ module Net # :nodoc:
       #
       # This method is used when parsing a binary packet by the Packet
       # class.
-      # 
+      #
       def RR.parse(data)
         o = allocate
-        obj,offset = o.send(:new_from_binary, data, 0)
-        return obj
+        obj, offset = o.send(:new_from_binary, data, 0)
+        obj
       end
-      
-      # Same as RR.parse, but takes an entire packet binary data to 
+
+      # 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 
+      # Return an instance of appropriate class and the offset
       # pointing at the end of the data parsed.
       #
-      def RR.parse_packet(data,offset)
+      def RR.parse_packet(data, offset)
         o = allocate
-        o.send(:new_from_binary,data,offset)
+        o.send(:new_from_binary, data, offset)
+      end
+
+      def name
+        @name
+      end
+
+      def ttl
+        @ttl
+      end
+
+      # Type accessor
+      def type
+        @type.to_s
+      end
+
+      # Class accessor
+      def cls
+        @cls.to_s
+      end
+
+
+      def value
+        get_inspect
       end
 
-      # Return the RR object in binary data format, suitable 
-      # for using in network streams, with names compressed. 
+      # Data belonging to that appropriate class,
+      # not to be used (use real accessors instead)
+      def rdata
+        @rdata
+      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"
+      #
+      def data
+        str = pack_name(@name)
+        str + [@type.to_i, @cls.to_i, ttl, @rdlength].pack("n2 N n") + get_data
+      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 
+      # 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
       #
       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")
+        str, offset, names = dn_comp(@name, offset, compnames)
+        str    += [@type.to_i, @cls.to_i, 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"
-      #
-      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
+        [str, offset, names]
       end
-      
-      # Canonical inspect method.
+
+
+      # Returns a human readable representation of this record.
+      # The value is always a String.
       #
       #   mx = Net::DNS::RR.new("example.com. 7200 MX 10 mailhost.example.com.")
       #   #=> example.com.            7200    IN      MX      10 mailhost.example.com.
       #
       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
+        to_s
       end
 
-      # Returns the RR in a string format.
+      # Returns a String representation of this record.
       #
       #   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."
       #
       def to_s
-        inspect.to_s
+        items = to_a.map { |e| e.to_s }
+        if @name.size < 24
+          items.pack("A24 A8 A8 A8 A*")
+        else
+          items.join("   ")
+        end.to_s
       end
 
-      # Returns an array with all the fields for the RR record.
+      # Returns an Array with all the attributes for this 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."]
+      #   #=> ["example.com.", 7200, "IN", "MX", "10 mailhost.example.com."]
       #
       def to_a
-        [@name, @ttl, @cls.to_s, @type.to_s, get_inspect]
-      end
-      
-      # Type accessor
-      def type
-        @type.to_s
+        [name, ttl, cls.to_s, type.to_s, value]
       end
-      
-      # Class accessor
-      def cls
-        @cls.to_s
-      end
-      
+
+
       private
 
-        #---
-        # New RR with argument in string form
-        #---
         def new_from_string(rrstring)
-
           unless rrstring =~ RR_REGEXP
             raise ArgumentError,
             "Format error for RR string (maybe CLASS and TYPE not valid?)"
@@ -277,7 +273,7 @@ module Net # :nodoc:
           @rdata = $5 ? $5.strip : ""
 
           if self.class == Net::DNS::RR
-            (eval "Net::DNS::RR::#@type").new(rrstring)
+            Net::DNS::RR.const_get(@type.to_s).new(rrstring)
           else
             subclass_new_from_string(@rdata)
             self.class
@@ -287,7 +283,7 @@ module Net # :nodoc:
         def new_from_hash(args)
           # Name field is mandatory
           unless args.has_key? :name
-            raise ArgumentError, "RR argument error: need at least RR name"
+            raise ArgumentError, ":name field is mandatory"
           end
 
           @name  = args[:name].downcase
@@ -299,9 +295,9 @@ module Net # :nodoc:
           @rdlength = args[:rdlength] || @rdata.size
 
           if self.class == Net::DNS::RR
-            (eval "Net::DNS::RR::#@type").new(args)
+            Net::DNS::RR.const_get(@type.to_s).new(args)
           else
-            hash = args - [:name,:ttl,:type,:cls]
+            hash = args - [:name, :ttl, :type, :cls]
             if hash.has_key? :rdata
               subclass_new_from_string(hash[:rdata])
             else
@@ -309,7 +305,7 @@ module Net # :nodoc:
             end
             self.class
           end
-        end # new_from_hash
+        end
 
         def new_from_binary(data,offset)
           if self.class == Net::DNS::RR
@@ -325,7 +321,7 @@ module Net # :nodoc:
             offset = subclass_new_from_binary(data,offset)
             build_pack
             set_type
-            return [self,offset]
+            [self, offset]
           end
         end
 
@@ -336,7 +332,7 @@ module Net # :nodoc:
         end
         def subclass_new_from_hash(hash)
         end
-        def subclass_new_from_binary(data,offset)
+        def subclass_new_from_binary(data, offset)
         end
         def build_pack
         end
@@ -354,18 +350,17 @@ module Net # :nodoc:
         end
 
 
-      # NEW new method :)
       def self.new(*args)
-        o = allocate
+        o   = allocate
         obj = o.send(:initialize,*args)
         if self == Net::DNS::RR
-          return obj
+          obj
         else
-          return o
+          o
         end
       end
-            
+
     end
-    
+
   end
-end
+end

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

@@ -1,115 +1,124 @@
-require 'ipaddr'
+module Net
+  module DNS
+    class RR
 
-
-module Net # :nodoc:
-  module DNS 
-    
-    class RR 
-      
-      # =Name
-      #
-      # Net::DNS::RR::A   DNS A resource record
       #
-      # =Synopsis
+      # = IPv4 Address Record (A)
       #
-      # require "net/dns/rr"
+      # Class for DNS IPv4 Address (A) resource records.
       #
-      # =Description
+      # The resource data is an IPv4 (i.e. 32 bit long) address,
+      # hold in the instance variable +address+.
       #
-      # Net::DNS::RR::A is the class to handle resource records of type A, the
-      # most common in a DNS query. Its 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("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")
+      #   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 trasmit the RR, the RDATA section is an
+      # 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 imbedded spaces (e.g.,"10.2.0.52" or "192.0.5.6").
+      # without any embedded space (e.g. "10.2.0.52" or "192.0.5.6").
       #
       class A < RR
-        
-        attr_reader :address
-        
-        # Assign to the RR::A object a new IPv4 address, which can be in the
-        # form of a string or an IPAddr object
+
+        # 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")
         #
-        def address=(addr)
-          @address = check_address addr
+        # 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 check_address(addr)
-          address = ""
-          case addr
-          when String 
-            address = IPAddr.new addr
-          when Integer # Address in numeric form
-            tempAddr = [(addr>>24),(addr>>16)&0xFF,(addr>>8)&0xFF,addr&0xFF]
-            tempAddr = tempAddr.collect {|x| x.to_s}.join(".")
-            address = IPAddr.new tempAddr
-          when IPAddr
-            address = addr
-          else
-            raise ArgumentError, "Unknown address type `#{addr}'"
+
+          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
-          raise ArgumentError, "Must specify an IPv4 address" unless address.ipv4?
-          address
-        rescue ::ArgumentError
-          raise ArgumentError, "Invalid address `#{addr}'"
-        end
-          
-        def build_pack
-          @address_pack = @address.hton
-          @rdlength = @address_pack.size
-        end
-        
-        def get_data
-          @address_pack
-        end
 
-        def get_inspect
-          "#@address"
-        end
-        
-        def subclass_new_from_hash(args)
-          if args.has_key? :address 
-            @address = check_address args[:address]
-          elsif args.has_key? :rdata
-            @address = check_address args[:rdata]
-          else
-            # Address field is mandatory
-            raise ArgumentError, ":address field is mandatory but missing"
+          def subclass_new_from_string(str)
+            @address = check_address(str)
           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}"
-          return offset + 4
-        end
-        
-        private
-        
+
+          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
+end