ipadmin 0.4.0 → 0.4.1

data/lib/cidr.rb

@@ -27,8 +27,8 @@ class CIDR
     # Hash of custom tags. Should be in the format tag => value.
     #
     # Example:
-    #   cidr4.tag['test'] = 'modified cidr4 tag'
-    #   puts cidr4.tag['test']   --> modified cidr4 tag
+    #   cidr4.tag[:name] = 'IPv4 CIDR'
+    #   puts cidr4.tag[:name]
     #
     def tag=(new_tag)
         if (!new_tag.kind_of? Hash)
@@ -37,35 +37,30 @@ class CIDR
         @tag = new_tag
     end
 
-#======================================#
-#
-#======================================#
-
-
 #==============================================================================#
 # initialize()
 #==============================================================================#
 
 # - Arguments:
-#   * CIDR address as a string, or a Hash with the following fields:
-#       - :CIDR -- IP address in CIDR notation - String (optional)
-#       - :Netmask -- IP Netmask - String or Integer (optional)
+#   * CIDR address as a String, or a Hash with the following fields:
+#       - :CIDR -- CIDR address, single IP, or IP and Netmask in extended format - String (optional)
 #       - :PackedIP -- Integer representation of an IP address (optional)
 #       - :PackedNetmask -- Integer representation of an IP Netmask (optional)
 #       - :Version -- IP version - Integer (optional)
 #       - :Tag -- Custom descriptor tag - Hash, tag => value. (optional)
 #
 # - Notes:
-#   * At a minimum, either :CIDR or PackedIP must be provided.
-#   * Netmask defaults to /32 or /128 if not provided.
-#   * :PackedIP takes precedence over :CIDR
-#   * :PackedNetmask always takes precedence over any other provided netmasks.
-#   * Netmask within :CIDR takes precedence over :Netmask.
+#   * At a minimum, either :CIDR or :PackedIP must be provided.
+#   * CIDR formatted netmasks take precedence over extended formatted ones.
+#   * CIDR address defaults to a host network (/32 or /128) if netmask not provided.
+#   * :PackedIP takes precedence over IP given within :CIDR.
+#   * :PackedNetmask takes precedence over netmask given within :CIDR.
 #   * Version will be auto-detected if not specified
 #
 # Examples:
 #   cidr4 = IPAdmin::CIDR.new('192.168.1.1/24')
 #   cidr4 = IPAdmin::CIDR.new(:CIDR => '192.168.1.1/24')
+#   cidr4 = IPAdmin::CIDR.new('192.168.1.1 255.255.255.0')
 #   cidr4_2 = IPAdmin::CIDR.new(:PackedIP => 0x0a010001,
 #                               :PackedNetmask => 0xffffff00
 #                               :Version => 4)
@@ -75,6 +70,7 @@ class CIDR
 #
     def initialize(options)
         @tag = {}
+        
         if (!options.kind_of?(Hash) && !options.kind_of?(String))
             raise ArgumentError, "Expected Hash or String, but #{options.class} provided."
         end
@@ -82,8 +78,9 @@ class CIDR
         if (options.kind_of? String)
             cidr = options
         end
-        
+                
         if (options.kind_of? Hash) 
+            # packed_ip takes precedence over cidr
             if (options.has_key?(:PackedIP))
                 packed_ip = options[:PackedIP]
                 raise ArgumentError, "Expected Integer, but #{packed_ip.class} " +
@@ -100,11 +97,6 @@ class CIDR
                 packed_netmask = options[:PackedNetmask]
                 raise ArgumentError, "Expected Integer, but #{packed_netmask.class} " +
                                      "provided for option :PackedNetmask." if (!packed_netmask.kind_of?(Integer))
-
-            elsif (options.has_key?(:Netmask))
-                netmask = options[:Netmask]
-                raise ArgumentError, "Expected String or Integer, but #{netmask.class} " +
-                                     "provided for option :Netmask." if (!netmask.kind_of?(String) && !netmask.kind_of?(Integer))
             end    
         
             if (options.has_key?(:Version))
@@ -123,20 +115,28 @@ class CIDR
         end
         
         
-        if (packed_ip)
-            if (packed_ip < 2**32)
-                @version = 4 if (!@version)
-                @netmask = 2**32-1 if (!netmask && !packed_netmask)
-            else
-                @version = 6 if (!@version)
-                @netmask = 2**128-1 if (!netmask && !packed_netmask)
+        if (packed_ip) 
+            # attempt to determine version if not provided
+            if (!@version)
+                if (packed_ip < 2**32)
+                    @version = 4
+                else
+                    @version = 6
+                end
             end
             
             # validate & store packed_ip
             IPAdmin.validate_ip_addr(:IP => packed_ip, :Version => @version)
             @ip = packed_ip
         
-        else            
+        else           
+            netmask = nil
+            
+            # if extended netmask provided. should only apply to ipv4            
+            if (cidr =~ /.+\s+.+/ )
+                cidr,netmask = cidr.split(' ')
+            end            
+            
             # determine version if not set
             if (!@version)
                 if (cidr =~ /\./ && cidr !~ /:/)
@@ -144,37 +144,26 @@ class CIDR
                 elsif (cidr =~ /:/)
                     @version = 6
                 end
-            end        
-
-            # get ip/netmask
-            if (cidr =~ /\//) # if netmask part of cidr
+            end
+            
+            # if ipv6 and extended netmask was provided, then raise exception
+            raise ArgumentError, "Garbage provided at end of IPv6 address." if (@version == 6 && netmask)    
+            
+            # if netmask part of cidr, then over-ride any provided extended netmask.
+            if (cidr =~ /\//) 
                 ip,netmask = cidr.split(/\//)
-                raise ArgumentError, ":CIDR is improperly formatted." if (!ip || !netmask)
-            elsif (@version == 4)
-                ip = cidr
-                @netmask = 2**32-1 if (!netmask && !packed_netmask)
-            elsif (@version == 6)
+                if (!ip || !netmask)
+                    raise ArgumentError, "CIDR address is improperly formatted. Missing netmask after '/' character." 
+                end
+            else
                 ip = cidr
-                @netmask = 2**128-1 if (!netmask && !packed_netmask)
             end
-
-            # pack ip                
-            @ip = IPAdmin.pack_ip_addr(:IP => ip, :Version => @version)            
             
+            # pack ip                
+            @ip = IPAdmin.pack_ip_addr(:IP => ip, :Version => @version)           
         end
 
                 
-        # validate & store netmask || packed_netmask if needed
-        if (!@netmask)
-            if (packed_netmask)
-                IPAdmin.validate_ip_netmask(:Netmask => packed_netmask, :Packed => true, :Version => @version)
-                @netmask = packed_netmask
-            else
-                IPAdmin.validate_ip_netmask(:Netmask => netmask, :Version => @version)
-                @netmask = IPAdmin.pack_ip_netmask(:Netmask => netmask, :Version => @version)
-            end
-        end
-        
         # set vars based on version
         if (@version == 4)
             @max_bits = 32
@@ -184,17 +173,26 @@ class CIDR
             @all_f = 2**@max_bits - 1
         end
         
-        # get @network & @hostmask
+        # if no netmask or packed_netmask, then set as /32 or /128.
+        # else validate. packed_netmask takes precedence over netmask
+        if (!netmask && !packed_netmask)
+            @netmask = @all_f
+        else            
+            if (packed_netmask)
+                IPAdmin.validate_ip_netmask(:Netmask => packed_netmask, :Packed => true, :Version => @version)
+                @netmask = packed_netmask
+            else
+                IPAdmin.validate_ip_netmask(:Netmask => netmask, :Version => @version)
+                @netmask = IPAdmin.pack_ip_netmask(:Netmask => netmask, :Version => @version)
+            end
+        end
+        
+        # set @network & @hostmask
         @network = (@ip & @netmask)
         @hostmask = @netmask ^ @all_f
 
     end
 
-#======================================#
-#
-#======================================#
-
-
 #==============================================================================#
 # arpa()
 #==============================================================================#
@@ -210,7 +208,10 @@ class CIDR
 #   * String
 #
 # Examples:
-#   arpa = cidr4.arpa()
+#   cidr4 = IPAdmin::CIDR.new('192.168.1.1/24')
+#   cidr6 = IPAdmin::CIDR.new(:CIDR => 'fec0::/64')
+#   puts "arpa for #{cidr4.desc()} is #{cidr4.arpa}"
+#   puts "arpa for #{cidr6.desc(:Short => true)} is #{cidr6.arpa}"
 #
     def arpa()
 
@@ -254,11 +255,6 @@ class CIDR
         return(arpa)
     end
 
-#======================================#
-#
-#======================================#
-
-
 #==============================================================================#
 # bits()
 #==============================================================================#
@@ -272,32 +268,34 @@ class CIDR
 #   * Integer.
 #
 # Examples:
-#   puts cidr4.bits()
+#   cidr4 = IPAdmin::CIDR.new('192.168.1.1/24')
+#   cidr6 = IPAdmin::CIDR.new(:CIDR => 'fec0::/64')
+#   puts "cidr4 netmask in bits #{cidr4.bits()}"
+#   puts "cidr6 netmask in bits #{cidr6.bits()}"
 #
     def bits()
         return(IPAdmin.unpack_ip_netmask(:Integer => @netmask))
     end
 
-#======================================#
-#
-#======================================#
-
-
 #==============================================================================#
 # contains?()
 #==============================================================================#
 
 # Determines if this CIDR contains (is supernet of)
-# the provided CIDR addresss or IPAdmin::CIDR object.
+# the provided CIDR address or IPAdmin::CIDR object.
 #
 # - Arguments:
-#   * CIDR addresss or IPAdmin::CIDR object
+#   * CIDR address or IPAdmin::CIDR object
 #
 # - Returns:
 #   * true or false
 #
 # Examples:
-#   contains? = cidr4.contains('192.168.1.32/27')
+#   cidr4 = IPAdmin::CIDR.new('192.168.1.1/24')
+#   cidr6 = IPAdmin::CIDR.new('fec0::/64')
+#   cidr6_2 = IPAdmin::CIDR.new('fec0::/96')
+#   puts "#{cidr4.desc} contains 192.168.1.2" if ( cidr4.contains?('192.168.1.2') )
+#   puts "#{cidr6.desc} contains #{cidr6_2.desc(:Short => true)}" if ( cidr6.contains?(cidr6_2) )
 #
     def contains?(cidr)
         is_contained = false
@@ -335,11 +333,6 @@ class CIDR
         return(is_contained)
     end
 
-#======================================#
-#
-#======================================#
-
-
 #==============================================================================#
 # desc()
 #==============================================================================#
@@ -352,11 +345,15 @@ class CIDR
 #       - :Short -- if true, return IPv6 addresses in short-hand notation (optional)
 #
 # - Returns:
-#   * CIDR address as a String
+#   * String
 #
 # Examples:
-#   puts cidr4.desc()
+#   cidr4 = IPAdmin::CIDR.new('192.168.1.1/24')
+#   cidr6 = IPAdmin::CIDR.new('fec0::/64')
 #   puts cidr4.desc(:IP => true)
+#   puts "cidr4 description #{cidr4.desc()}"
+#   puts "cidr6 description #{cidr6.desc()}"
+#   puts "cidr6 short-hand description #{cidr6.desc(:Short => true)}"
 #
     def desc(options=nil)
         short = false
@@ -387,30 +384,29 @@ class CIDR
         return("#{ip}/#{mask}")
     end
 
-#======================================#
-#
-#======================================#
-
-
 #==============================================================================#
 # enumerate()
 #==============================================================================#
 
 # Provide all IP addresses contained within the IP space of this CIDR.
-# (warning: this can be quite large for big blocks)
 #
 # - Arguments:
 #   * Optional Hash with the following fields:
-#       - :Bitstep -- enumerate in X sized steps 0 - Integer (optional)
+#       - :Bitstep -- enumerate in X sized steps - Integer (optional)
 #       - :Limit -- limit returned list to X number of items - Integer (optional)
 #       - :Objectify -- if true, return IPAdmin::CIDR objects (optional)
 #       - :Short -- if true, return IPv6 addresses in short-hand notation (optional)
 #
 # - Returns:
-#   * Array of IP address Strings or IPAdmin::CIDR objects
+#   * Array of Strings, or Array of IPAdmin::CIDR objects
 #
 # Examples:
-#   ip_list = cidr4.enumerate(:Bitstep => 2, :Limit => 2)
+#   cidr4 = IPAdmin::CIDR.new('192.168.1.1/24')
+#   cidr6 = IPAdmin::CIDR.new('fec0::/64')
+#   puts "first 4 cidr4 addresses (bitstep 32)"
+#   cidr4.enumerate(:Limit => 4, :Bitstep => 32).each {|x| puts "  #{x}"} 
+#   puts "first 4 cidr6 addresses (bitstep 32)"
+#   cidr6.enumerate(:Limit => 4, :Bitstep => 32, :Objectify => true).each {|x| puts "  #{x.desc}"}
 #
     def enumerate(options=nil)
         bitstep = 1
@@ -463,11 +459,6 @@ class CIDR
         return(list)
     end
 
-#======================================#
-#
-#======================================#
-
-
 #==============================================================================#
 # fill_in()
 #==============================================================================#
@@ -476,14 +467,14 @@ class CIDR
 # holes (missing subnets) filled in.
 #
 # - Arguments:
-#   * Array of CIDR addresses or IPAdmin::CIDR objects,
+#   * Array of CIDR addresses, Array of IPAdmin::CIDR objects,
 #     or a Hash with the following fields:
 #       - :List -- Array of CIDR addresses or IPAdmin::CIDR objects
 #       - :Objectify -- if true, return IPAdmin::CIDR objects (optional)
 #       - :Short -- if true, return IPv6 addresses in short-hand notation (optional)
 #
 # - Returns:
-#   * Array of CIDR address Strings or IPAdmin::CIDR objects
+#   * Array of CIDR Strings or Array of IPAdmin::CIDR objects
 #
 # Examples:
 #   subnets = cidr4.fill_in(['192.168.1.0/27','192.168.1.64/26','192.168.1.128/25'])
@@ -584,11 +575,6 @@ class CIDR
         end
     end
 
-#======================================#
-#
-#======================================#
-
-
 #==============================================================================#
 # hostmask_ext()
 #==============================================================================#
@@ -614,11 +600,6 @@ class CIDR
         return(hostmask)
     end
 
-#======================================#
-#
-#======================================#
-
-
 #==============================================================================#
 # ip()
 #==============================================================================#
@@ -631,10 +612,11 @@ class CIDR
 #       - :Short -- if true, return IPv6 addresses in short-hand notation (optional)
 #
 # - Returns:
-#   * IP address String or IPAdmin::CIDR object.
+#   * String or IPAdmin::CIDR object.
 #
 # Examples:
 #   puts cidr4.ip()
+#   puts cidr4.ip(:Objectify => true).desc
 #
     def ip(options=nil)
         objectify = false
@@ -667,11 +649,6 @@ class CIDR
         return(ip)
     end
 
-#======================================#
-#
-#======================================#
-
-
 #==============================================================================#
 # last()
 #==============================================================================#
@@ -684,7 +661,7 @@ class CIDR
 #       - :Short -- if true, return IPv6 addresses in short-hand notation (optional)
 #
 # - Returns:
-#   * IP address String or IPAdmin::CIDR object.
+#   * String or IPAdmin::CIDR object.
 #
 # - Notes:
 #   * The broadcast() method is aliased to this method, and thus works for
@@ -727,11 +704,6 @@ class CIDR
     
     alias :broadcast :last
 
-#======================================#
-#
-#======================================#
-
-
 #==============================================================================#
 # multicast_mac()
 #==============================================================================#
@@ -740,17 +712,17 @@ class CIDR
 # and ff00::/8 for IPv6), return its ethernet MAC address (EUI-48) mapping.
 #
 # - Arguments:
-#   * Optional hash with the following fields:
+#   * Optional Hash with the following fields:
 #       - :Objectify -- if true, return EUI objects (optional)
 #
 # - Returns:
-#   * IPAdmin::EUI48 object
+#   * String or IPAdmin::EUI48 object
 #
 # - Note:
 #   * MAC address is based on original IP address passed during initialization.
 #
 # Examples:
-#   mcast = IPAdmin::CIDR.new(:CIDR => '224.0.0.6')
+#   mcast = IPAdmin::CIDR.new('224.0.0.6')
 #   puts mcast.multicast_mac.address
 #
     def multicast_mac(options=nil)
@@ -790,16 +762,11 @@ class CIDR
         return(eui)
     end
 
-#======================================#
-#
-#======================================#
-
-
 #==============================================================================#
 # netmask()
 #==============================================================================#
 
-# Provide netmask in CIDR format.
+# Provide netmask in CIDR format (/yy).
 #
 # - Arguments:
 #   * none
@@ -815,11 +782,6 @@ class CIDR
         return("/#{bits}")
     end
 
-#======================================#
-#
-#======================================#
-
-
 #==============================================================================#
 # netmask_ext()
 #==============================================================================#
@@ -846,11 +808,6 @@ class CIDR
         return(netmask)
     end
 
-#======================================#
-#
-#======================================#
-
-
 #==============================================================================#
 # network()
 #==============================================================================#
@@ -863,7 +820,7 @@ class CIDR
 #       - :Short -- if true, return IPv6 addresses in short-hand notation (optional)
 #
 # - Returns:
-#   * CIDR address String or IPAdmin::CIDR object.
+#   * String or IPAdmin::CIDR object.
 #
 # Examples:
 #   puts cidr4.network()
@@ -901,11 +858,6 @@ class CIDR
     alias :base :network
     alias :first :network
 
-#======================================#
-#
-#======================================#
-
-
 #==============================================================================#
 # next_ip()
 #==============================================================================#
@@ -920,10 +872,13 @@ class CIDR
 #       - :Short -- if true, return IPv6 addresses in short-hand notation (optional)
 #
 # - Returns:
-#   * IP address String or IPAdmin::CIDR object.
+#   * String or IPAdmin::CIDR object.
 #
 # Examples:
-#   puts cidr4.next_ip()
+#   cidr4 = IPAdmin::CIDR.new('192.168.1.1/24')
+#   cidr6 = IPAdmin::CIDR.new('fec0::/64')
+#   puts "cidr4 next subnet #{cidr4.next_subnet()}"
+#   puts "cidr6 next subnet #{cidr6.next_subnet(:Short => true)}"
 #
     def next_ip(options=nil)
         bitstep = 1
@@ -966,11 +921,6 @@ class CIDR
         return(next_ip)
     end
 
-#======================================#
-#
-#======================================#
-
-
 #==============================================================================#
 # next_subnet()
 #==============================================================================#
@@ -985,10 +935,13 @@ class CIDR
 #       - :Short -- if true, return IPv6 addresses in short-hand notation (optional)
 #
 # - Returns:
-#   * CIDR address String or IPAdmin::CIDR object.
+#   * String or IPAdmin::CIDR object.
 #
 # Examples:
-#   puts cidr4.next_subnet()
+#   cidr4 = IPAdmin::CIDR.new('192.168.1.1/24')
+#   cidr6 = IPAdmin::CIDR.new('fec0::/64')
+#   puts "cidr4 next subnet #{cidr4.next_subnet()}"
+#   puts "cidr6 next subnet #{cidr6.next_subnet(:Short => true)}"
 #
     def next_subnet(options=nil)
         bitstep = 1
@@ -1020,24 +973,20 @@ class CIDR
         if (next_sub > @all_f)
             raise "Returned subnet is out of bounds for IPv#{@version}."
         end
-
-        netmask =  self.bits       
+      
         if (!objectify)
             next_sub = IPAdmin.unpack_ip_addr(:Integer => next_sub, :Version => @version)
             next_sub = IPAdmin.shorten(next_sub) if (short && @version == 6)        
-            next_sub = next_sub << "/" << netmask.to_s
+            next_sub = next_sub << "/" << self.bits.to_s
         else
-            next_sub = IPAdmin::CIDR.new(:PackedIP => next_sub, :Netmask => netmask, :Version => @version)
+            next_sub = IPAdmin::CIDR.new(:PackedIP => next_sub, 
+                                         :PackedNetmask => self.packed_netmask, 
+                                         :Version => @version)
         end
         
         return(next_sub)
     end
 
-#======================================#
-#
-#======================================#
-
-
 #==============================================================================#
 # nth()
 #==============================================================================#
@@ -1051,9 +1000,10 @@ class CIDR
 #       - :Short -- if true, return IPv6 addresses in short-hand notation (optional)
 #
 # - Returns:
-#   * IP address String or IPAdmin::CIDR object.
+#   * String or IPAdmin::CIDR object.
 #
 # Examples:
+#   cidr4 = IPAdmin::CIDR.new('192.168.1.1/24')
 #   puts cidr4.nth(1)
 #   puts cidr4.nth(:Index => 1, :Objectify => true)
 #
@@ -1099,16 +1049,11 @@ class CIDR
         return(my_ip)
     end
 
-#======================================#
-#
-#======================================#
-
-
 #==============================================================================#
 # packed_hostmask()
 #==============================================================================#
 
-# Provide an integer representation of the Hostmask of this object.
+# Provide an Integer representation of the Hostmask of this object.
 #
 # - Arguments:
 #   * none
@@ -1123,16 +1068,11 @@ class CIDR
         return(@hostmask)
     end
 
-#======================================#
-#
-#======================================#
-
-
 #==============================================================================#
 # packed_ip()
 #==============================================================================#
 
-# Provide an integer representation of the IP address of this object.
+# Provide an Integer representation of the IP address of this object.
 #
 # - Arguments:
 #   * none
@@ -1147,16 +1087,11 @@ class CIDR
         return(@ip)
     end
 
-#======================================#
-#
-#======================================#
-
-
 #==============================================================================#
 # packed_netmask()
 #==============================================================================#
 
-# Provide an integer representation of the Netmask of this object.
+# Provide an Integer representation of the Netmask of this object.
 #
 # - Arguments:
 #   * none
@@ -1171,16 +1106,11 @@ class CIDR
         return(@netmask)
     end
 
-#======================================#
-#
-#======================================#
-
-
 #==============================================================================#
 # packed_network()
 #==============================================================================#
 
-# Provide an integer representation of the Network address of this object.
+# Provide an Integer representation of the Network address of this object.
 #
 # - Arguments:
 #   * none
@@ -1195,11 +1125,6 @@ class CIDR
         return(@network)
     end
 
-#======================================#
-#
-#======================================#
-
-
 #==============================================================================#
 # range()
 #==============================================================================#
@@ -1215,9 +1140,10 @@ class CIDR
 #       - :Short -- if true, return IPv6 addresses in short-hand notation (optional)
 #
 # - Returns:
-#   * Array IP address Strings or IPAdmin::CIDR objects
+#   * Array of Strings, or Array of IPAdmin::CIDR objects
 #
 # Examples:
+#   cidr4 = IPAdmin::CIDR.new('192.168.1.1/24')
 #   list = cidr4.range([0,1])
 #   list = cidr4.range(:Indexes => [0,1], :Objectify => true)
 #
@@ -1283,11 +1209,6 @@ class CIDR
         return(list)
     end
 
-#======================================#
-#
-#======================================#
-
-
 #==============================================================================#
 # remainder()
 #==============================================================================#
@@ -1298,13 +1219,13 @@ class CIDR
 # and 192.168.0.128/25 will be returned as the remainders.
 #
 # - Arguments:
-#   * CIDR address or IPAdmin::CIDR object, or a Hash with the following fields:
+#   * CIDR address, IPAdmin::CIDR object, or a Hash with the following fields:
 #       - :Exclude -- CIDR address or IPAdmin::CIDR object.
 #       - :Objectify -- if true, return IPAdmin::CIDR objects (optional)
 #       - :Short -- if true, return IPv6 addresses in short-hand notation (optional)
 #
 # - Returns:
-#   * Array of CIDR address Strings or IPAdmin::CIDR objects
+#   * Array of Strings, or Array of IPAdmin::CIDR objects
 #
 #
 # Examples:
@@ -1381,7 +1302,7 @@ class CIDR
                 new_subnets.unshift("#{non_match}/#{new_mask}")
             else
                 new_subnets.unshift(IPAdmin::CIDR.new(:PackedIP => non_match, 
-                                                      :Netmask => new_mask, 
+                                                      :PackedNetmask => IPAdmin.pack_ip_netmask(new_mask), 
                                                       :Version => @version))
             end
             
@@ -1393,11 +1314,6 @@ class CIDR
         return(new_subnets)
     end
 
-#======================================#
-#
-#======================================#
-
-
 #==============================================================================#
 # resize()
 #==============================================================================#
@@ -1413,6 +1329,7 @@ class CIDR
 #   * IPAdmin::CIDR object
 #
 # Examples:
+#   cidr4 = IPAdmin::CIDR.new('192.168.1.1/24')
 #   new_cidr = cidr4.resize(23)
 #   new_cidr = cidr4.resize(:Netmask => 23)
 #   puts new_cidr.desc
@@ -1438,11 +1355,6 @@ class CIDR
         return(cidr)
     end
 
-#======================================#
-#
-#======================================#
-
-
 #==============================================================================#
 # resize!()
 #==============================================================================#
@@ -1459,10 +1371,6 @@ class CIDR
 # - Notes:
 #   * If CIDR is resized such that the original IP is no longer contained within,
 #     then that IP will be reset to the base network address.
-#
-# Examples:
-#   cidr4.resize!(23)
-#   puts cidr4.desc
 #
     def resize!(options)
         if (options.kind_of?(Hash))
@@ -1492,11 +1400,6 @@ class CIDR
         return(true)
     end
 
-#======================================#
-#
-#======================================#
-
-
 #==============================================================================#
 # size()
 #==============================================================================#
@@ -1516,11 +1419,6 @@ class CIDR
         return(@hostmask + 1)
     end
 
-#======================================#
-#
-#======================================#
-
-
 #==============================================================================#
 # subnet()
 #==============================================================================#
@@ -1530,12 +1428,12 @@ class CIDR
 #   * By providing the number of IP addresses needed in the new subnets in :IPCount
 #
 # If :Mincount is not provided, then the CIDR will be fully subnetted. Otherwise,
-# if provided then :Mincount number of subnets of requested size will be returned and
+# :Mincount number of subnets of the requested size will be returned and
 # the remainder of the subnets will be summarized as much as possible. If neither :Subnet
 # or :IPCount is provided, then the current CIDR will be split in half.
 #
 # - Arguments:
-#   * Optional hash with the following fields:
+#   * Optional Hash with the following fields:
 #       - :IPCount -- Minimum number of IP's that new subnets should contain - Integer (optional)
 #       - :MinCount -- Minimum number of X sized subnets to return - Integer (optional)
 #       - :Objectify -- if true, return IPAdmin::CIDR objects (optional)
@@ -1543,14 +1441,16 @@ class CIDR
 #       - :Subnet --  Netmask (in bits) of new subnets - Integer (optional)
 #
 # - Returns:
-#   * Array of CIDR address Strings or IPAdmin::CIDR objects
+#   * Array of Strings, or Array of IPAdmin::CIDR objects
 #
 # - Notes:
 #   * :Subnet always takes precedence over :IPCount.
 #
 # Examples:
-#   cidr_list = cidr4.subnet(:Subnet => 28, :MinCount => 3)
-#   cidr_list = cidr4.subnet(:IPCount => 19)
+#   cidr_list = cidr4.subnet(:Subnet => 28, :MinCount => 3).each {|x| puts "  #{x}"}
+#   cidr_list = cidr4.subnet(:IPCount => 19).each {|x| puts "  #{x}"}
+#   cidr4.subnet(:Subnet => 28).each {|x| puts "  #{x}"}  "
+#   cidr6.subnet(:Subnet => 67, :MinCount => 4, :Short => true).each {|x| puts "  #{x}"}
 #
     def subnet(options=nil)
         my_network = self.packed_network
@@ -1647,7 +1547,7 @@ class CIDR
                 new_subnets.push("#{next_network}/#{next_supernet_bits}")
             else
                 new_subnets.push(IPAdmin::CIDR.new(:PackedIP => next_supernet_ip,
-                                                   :Netmask =>next_supernet_bits,
+                                                   :PackedNetmask => IPAdmin.pack_ip_netmask(next_supernet_bits),
                                                    :Version => @version))
             end
             
@@ -1659,10 +1559,6 @@ class CIDR
         return(new_subnets)
     end
 
-#======================================#
-#
-#======================================#
-
 
 # PRIVATE INSTANCE METHODS
 private
@@ -1713,12 +1609,7 @@ private
         return(list)
     end
 
-#======================================#
-#
-#======================================#
-
-
-end
+end # end class CIDR
 
 end # module IPAdmin
 __END__