netaddr 1.1.0 → 1.2.0

data/changelog

@@ -0,0 +1,27 @@
+
+==Version
+*1.2.0*
+
+
+===Known Issues
+
+* users may directly modify CIDR objects stored within a Tree, 
+  essentially invalidating the structure of that Tree
+
+
+===Changes
+
+* CIDRv4#new and CIDRv6#new methods have been changed for the sake of speed improvements.
+  Please use the CIDR#create method instead.
+* changes to CIDR#wildcard_mask
+* bug fix with validate_eui method
+* bug fix with validate_ip_addr
+* bug fix and *vast* simplification of NetAddr.merge
+
+
+===New Features
+
+* speed improvements
+* added CIDR#set_wildcard_mask
+* added <=>, >, <, == methods to CIDR
+* NetAddr.merge now reports which CIDR addresses were used to create new summary addresses

data/lib/cidr.rb

@@ -1,6 +1,6 @@
 =begin rdoc
  Copyleft (c) 2006 Dustin Spinhirne (www.spinhirne.com) 
- 
+
  Licensed under the same terms as Ruby, No Warranty is provided.
 =end
 
@@ -50,10 +50,13 @@ private_class_method :new
 
     # Hash of custom tags. Should be in the format tag => value.
     attr_reader :tag
-    
+
     # Integer of either 32 or 128 bits in length, with all bits set to 1
     attr_reader :all_f
 
+    # Integer representing number of bits in this CIDR address
+    attr_reader :address_len
+
     # Hash of custom tags. Should be in the format tag => value.
     #
     # Example:
@@ -67,6 +70,52 @@ private_class_method :new
         @tag = new_tag
     end
 
+#==============================================================================#
+# initialize()
+#==============================================================================#
+
+# This method performs absolutely no error checking, and is meant to be used only by
+# other internal methods for the sake of the speedier creation of CIDR objects.
+# Please consider using #create unless you know what you are doing with 100% certainty.
+#
+#===Arguments:
+#* ip - Integer representing an ip address
+#* netmask - Integer representing a binary mask
+#* tag - Hash used to append custom tags to CIDR
+#* wildcard_mask - Integer representing a binary mask
+#* wildcard_mask_bit_flipped - indicates whether or not the wildcard_mask is bit-flipped or not
+#
+    def initialize(ip, netmask=nil, tag={}, wildcard_mask=nil, wildcard_mask_bit_flipped=false)
+        @ip = ip
+
+        if ( self.kind_of?(NetAddr::CIDRv4) )
+            @version = 4
+            @address_len = 32
+        else
+            @version = 6
+            @address_len = 128
+        end
+        @all_f = 2**@address_len - 1
+
+        if (netmask)
+            @netmask = netmask
+        else
+            @netmask = 2**@address_len - 1
+        end
+
+        @network = (@ip & @netmask)
+        @hostmask = @netmask ^ @all_f
+        @tag = tag
+
+        if (!wildcard_mask)
+            @wildcard_mask = @netmask
+        else
+            @wildcard_mask = wildcard_mask
+            @wildcard_mask = ~@wildcard_mask if (wildcard_mask_bit_flipped)
+        end
+
+    end
+
 #==============================================================================#
 # create()
 #==============================================================================#
@@ -78,87 +127,292 @@ private_class_method :new
 #:PackedNetmask takes precedence over netmask given within CIDR addresses.
 #Version will be auto-detected if not specified.
 #
-# cidr4 = NetAddr::CIDR.create('192.168.1.1/24')
-# cidr4 = NetAddr::CIDR.create('192.168.1.1 255.255.255.0')
-# cidr4_2 = NetAddr::CIDR.create(0x0a010001,
-#                                :PackedNetmask => 0xffffff00
-#                                :Version => 4)
-# cidr4_3 = NetAddr::CIDRv4.new('192.168.1.1',
-#                               :WildcardMask => ['0.7.0.255', :inversed])
-# cidr4_4 = NetAddr::CIDRv4.new('192.168.5.0',
-#                               :WildcardMask => ['255.248.255.0'])
-# cidr6 = NetAddr::CIDR.create('fec0::/64')
-# cidr6 = NetAddr::CIDR.create('fec0::/64',
-#                              :Tag => {'interface' => 'g0/1'})
-# cidr6_2 = NetAddr::CIDR.create('::ffff:192.168.1.1/96')
+# NetAddr::CIDR.create('192.168.1.1/24')
+# NetAddr::CIDR.create('192.168.1.1 255.255.255.0')
+# NetAddr::CIDR.create(0x0a010001,
+#                      :PackedNetmask => 0xffffff00
+#                      :Version => 4)
+# NetAddr::CIDR.create('192.168.1.1',
+#                      :WildcardMask => ['0.7.0.255', true])
+# NetAddr::CIDR.create('192.168.1.1',
+#                      :WildcardMask => [0x000007ff, true]
+# NetAddr::CIDR.create('192.168.5.0',
+#                      :WildcardMask => ['255.248.255.0'])
+# NetAddr::CIDR.create('fec0::/64')
+# NetAddr::CIDR.create('fec0::/64',
+#                      :Tag => {'interface' => 'g0/1'})
+# NetAddr::CIDR.create('::ffff:192.168.1.1/96')
 #
 #===Arguments:
-#* CIDR address as a String, or a packed IP address as an Integer
-#* Optional Hash with the following keys:
-#     :PackedNetmask -- Integer representation of an IP Netmask (optional)
-#     :Version -- IP version - Integer (optional)
-#     :Tag -- Custom descriptor tag - Hash, tag => value. (optional)
+#* addr = CIDR address as a String, or a packed IP address as an Integer
+#* options = Hash with the following keys:
+#     :PackedNetmask -- Integer representation of an IP Netmask
+#     :Version -- IP version - Integer
+#     :Tag -- Custom descriptor tag - Hash, tag => value.
 #     :WildcardMask -- 2 element Array. First element contains a special bit mask used for
-#                      advanced IP pattern matching. The second element should be :inversed if this
-#                      bit mask is in inverse format. (optional)
+#                      advanced IP pattern matching. The second element should be set to True if this
+#                      bit mask is bit flipped.
 #
     def CIDR.create(addr, options=nil)
         known_args = [:PackedNetmask, :Version, :Tag, :WildcardMask]
-        cidr = nil
-        packed_ip = nil
-        version = nil
-
-        # validate addr arg
-        if (addr.kind_of?(String))
-            cidr = addr
-        elsif (addr.kind_of?(Integer))
-            packed_ip = addr
-        else
-            raise ArgumentError, "String or Integer expected for argument 'addr' but #{addr.class} provided."
-        end
+        ip, netmask, tag = nil, nil, {}
+        version, wildcard_mask ,wildcard_mask_bit_flipped = nil, nil, false
+        packed_netmask, all_f = nil, nil
 
         # validate options
-        if (options)     
+        if (options)
             raise ArgumentError, "Hash expected for argument 'options' but " +
                                  "#{options.class} provided." if (!options.kind_of?(Hash) )
             NetAddr.validate_args(options.keys,known_args)
+
+            if (options.has_key?(:PackedNetmask))
+                packed_netmask = options[:PackedNetmask]
+                raise ArgumentError, "Expected Integer, but #{packed_netmask.class} " +
+                                     "provided for option :PackedNetmask." if (!packed_netmask.kind_of?(Integer))
+            end
+
+            if (options.has_key?(:Tag))
+                tag = options[:Tag]
+                if (!tag.kind_of? Hash)
+                    raise ArgumentError, "Expected Hash, but #{tag.class} provided for option :Tag."
+                end
+            end
+
             if (options.has_key?(:Version))
                 version = options[:Version]
-                options.delete(:Version)
                 if (version != 4 && version != 6)
                     raise VersionError, ":Version should be 4 or 6, but was '#{version}'."
                 end
             end
+
+            if (options.has_key?(:WildcardMask))
+                if (!options[:WildcardMask].kind_of?(Array))
+                    raise ArgumentError, "Expected Array, but #{options[:WildcardMask].class} provided for option :WildcardMask."
+                end
+
+                wildcard_mask = options[:WildcardMask][0]
+                if (!wildcard_mask.kind_of?(String) &&  !wildcard_mask.kind_of?(Integer))
+                    raise ArgumentError, "Expected String or Integer, but #{wildcard_mask.class} provided for wildcard mask."
+                end
+                wildcard_mask_bit_flipped = true if (options[:WildcardMask][1] && options[:WildcardMask][1].kind_of?(TrueClass))
+            end
         end
 
-        # attempt to determine version if not provided
-        if (!version)
-            if (packed_ip) 
-                if (packed_ip < 2**32)
-                    version = 4
-                else
-                    version = 6
+        # validate addr arg & set version if not provided by user
+        if (addr.kind_of?(String))
+            version = NetAddr.detect_ip_version(addr) if (!version)
+
+            # if extended netmask provided. should only apply to ipv4
+            if (version == 4 && addr =~ /.+\s+.+/ )
+                addr,netmask = addr.split(' ')
+            end
+
+            # if netmask part of ip, then separate ip & mask.
+            if (addr =~ /\//)
+                ip,netmask = addr.split(/\//)
+                if (!ip || !netmask)
+                    raise ArgumentError, "CIDR address is improperly formatted. Missing netmask after '/' character." 
                 end
             else
-                if (cidr =~ /\./ && cidr !~ /:/)
+                ip = addr
+            end
+
+            NetAddr.validate_ip_str(ip,version)
+            ip = NetAddr.ip_str_to_int(ip,version)
+
+        elsif (addr.kind_of?(Integer))
+            ip = addr
+            if (!version)
+                if (ip < 2**32)
                     version = 4
-                elsif (cidr =~ /:/)
+                else
                     version = 6
                 end
             end
+            NetAddr.validate_ip_int(ip,version)
+
+        else
+            raise ArgumentError, "String or Integer expected for argument 'addr' but #{addr.class} provided."
         end
 
-        # create CIDRvX object
-        if (version == 4)
-            return(NetAddr::CIDRv4.new(addr, options))
-        elsif (version == 6)
-            return(NetAddr::CIDRv6.new(addr, options))
+        # set all_f based on version
+        all_f = 2**32-1
+        all_f = 2**128-1 if (version == 6)
+
+        # set netmask. packed_netmask takes precedence. set to all_f if no netmask provided
+        if (packed_netmask)
+            NetAddr.validate_netmask_int(packed_netmask,version,true)
+            netmask = packed_netmask
+        elsif (netmask)
+            NetAddr.validate_netmask_str(netmask,version)
+            netmask = NetAddr.netmask_str_to_int(netmask, version)
         else
-            raise ArgumentError, "IP version omitted or could not be detected."
+            netmask = all_f
+        end
+
+        # set wildcard mask if not provided, or validate if provided.
+        if (wildcard_mask)
+            begin
+                if (wildcard_mask.kind_of?(String))
+                    NetAddr.validate_ip_str(wildcard_mask,version)
+                    wildcard_mask = NetAddr.ip_str_to_int(wildcard_mask, version)
+                else (wildcard_mask.kind_of?(Integer))
+                    NetAddr.validate_ip_int(wildcard_mask,version)
+                end
+            rescue Exception => error
+                raise ValidationError, "Provided wildcard mask failed validation: #{error}"
+            end
+        end
+
+        return( NetAddr.cidr_build(version, ip, netmask, tag, wildcard_mask, wildcard_mask_bit_flipped) )
+    end
+
+#==============================================================================#
+# <=>()
+#==============================================================================#
+
+#===Synopsis
+#Compare the sort order of the current CIDR with a provided CIDR and return:
+#* 1 if the current CIDR is greater than the provided CIDR
+#* 0 if the current CIDR and the provided CIDR are equal (base address and netmask are equal)
+#* -1 if the current CIDR is less than the provided CIDR
+#
+#===Arguments:
+#* CIDR address or NetAddr::CIDR object
+#
+#===Returns:
+#* Integer
+#
+    def <=>(cidr)
+        if (!cidr.kind_of?(NetAddr::CIDR))
+            begin
+                cidr = NetAddr::CIDR.create(cidr)
+            rescue Exception => error
+                raise ArgumentError, "Provided argument raised the following " +
+                                     "errors: #{error}"
+            end
+        end
+
+        if (cidr.version != @version)
+            raise VersionError, "Attempted to compare a version #{cidr.version} CIDR " +
+                                 "with a version #{@version} CIDR."
         end
 
+        # compare
+        comparasin = NetAddr.cidr_gt_lt(self,cidr)
+
+        return(comparasin)
     end
 
+#==============================================================================#
+# >()
+#==============================================================================#
+
+#===Synopsis
+#Compare the sort order of the current CIDR with a provided CIDR and return true
+#if current CIDR is greater than provided CIDR.
+#
+#===Arguments:
+#* CIDR address or NetAddr::CIDR object
+#
+#===Returns:
+#* true or false
+#
+    def >(cidr)
+        if (!cidr.kind_of?(NetAddr::CIDR))
+            begin
+                cidr = NetAddr::CIDR.create(cidr)
+            rescue Exception => error
+                raise ArgumentError, "Provided argument raised the following " +
+                                     "errors: #{error}"
+            end
+        end
+
+        if (cidr.version != @version)
+            raise VersionError, "Attempted to compare a version #{cidr.version} CIDR " +
+                                 "with a version #{@version} CIDR."
+        end
+
+        # compare
+        gt = false
+        gt = true if ( NetAddr.cidr_gt_lt(self,cidr) == 1)
+
+        return(gt)
+    end
+
+#==============================================================================#
+# <()
+#==============================================================================#
+
+#===Synopsis
+#Compare the sort order of the current CIDR with a provided CIDR and return true
+#if current CIDR is less than provided CIDR.
+#
+#===Arguments:
+#* CIDR address or NetAddr::CIDR object
+#
+#===Returns:
+#* true or false
+#
+    def <(cidr)
+        if (!cidr.kind_of?(NetAddr::CIDR))
+            begin
+                cidr = NetAddr::CIDR.create(cidr)
+            rescue Exception => error
+                raise ArgumentError, "Provided argument raised the following " +
+                                     "errors: #{error}"
+            end
+        end
+
+        if (cidr.version != @version)
+            raise VersionError, "Attempted to compare a version #{cidr.version} CIDR " +
+                                 "with a version #{@version} CIDR."
+        end
+
+        # compare
+        lt = false
+        lt = true if ( NetAddr.cidr_gt_lt(self,cidr) == -1)
+
+        return(lt)
+    end
+
+#==============================================================================#
+# ==()
+#==============================================================================#
+
+#===Synopsis
+#Compare the sort order of the current CIDR with a provided CIDR and return true
+#if current CIDR is equal to the provided CIDR.
+#
+#===Arguments:
+#* CIDR address or NetAddr::CIDR object
+#
+#===Returns:
+#* true or false
+#
+    def ==(cidr)
+        if (!cidr.kind_of?(NetAddr::CIDR))
+            begin
+                cidr = NetAddr::CIDR.create(cidr)
+            rescue Exception => error
+                raise ArgumentError, "Provided argument raised the following " +
+                                     "errors: #{error}"
+            end
+        end
+
+        if (cidr.version != @version)
+            raise VersionError, "Attempted to compare a version #{cidr.version} CIDR " +
+                                 "with a version #{@version} CIDR."
+        end
+
+        # compare
+        eq = false
+        eq = true if ( NetAddr.cidr_gt_lt(self,cidr) == 0)
+
+        return(eq)
+    end
+    alias :eql? :==
+
 #==============================================================================#
 # arpa()
 #==============================================================================#
@@ -168,11 +422,6 @@ private_class_method :new
 #return either an in-addr.arpa. or ip6.arpa. string. The netmask will be used
 #to determine the length of the returned string.
 #
-# cidr4 = NetAddr::CIDR.create('192.168.1.1/24')
-# cidr6 = NetAddr::CIDR.create('fec0::/64')
-# puts "arpa for #{cidr4.desc()} is #{cidr4.arpa}"
-# puts "arpa for #{cidr6.desc(:Short => true)} is #{cidr6.arpa}"
-#
 #===Arguments:
 #* none
 #
@@ -228,11 +477,6 @@ private_class_method :new
 #===Synopsis
 #Provide number of bits in Netmask.
 #
-# cidr4 = NetAddr::CIDR.create('192.168.1.1/24')
-# cidr6 = NetAddr::CIDR.create('fec0::/64')
-# puts "cidr4 netmask in bits #{cidr4.bits()}"
-# puts "cidr6 netmask in bits #{cidr6.bits()}"
-#
 #===Arguments:
 #* none
 #
@@ -240,7 +484,7 @@ private_class_method :new
 #* Integer.
 #
     def bits()
-        return(NetAddr.unpack_ip_netmask(@netmask))
+        return(NetAddr.mask_to_bits(@netmask))
     end
 
 #==============================================================================#
@@ -256,8 +500,8 @@ private_class_method :new
 #
 # cidr4 = NetAddr::CIDR.create('192.168.1.0/24')
 # cidr4_2 = NetAddr::CIDR.create('192.168.1.0/26')
-# comp1 = cidr4.cmp(cidr4_2)
-# comp2 = cidr4.cmp('192.168.1.0/26')
+# cidr4.cmp(cidr4_2)
+# cidr4.cmp('192.168.1.0/26')
 #
 #===Arguments:
 #* CIDR address or NetAddr::CIDR object
@@ -279,23 +523,9 @@ private_class_method :new
             raise VersionError, "Attempted to compare a version #{cidr.version} CIDR " +
                                  "with a version #{@version} CIDR."
         end
-        
+
         # compare
-        comparasin = nil
-        if ( (@network == cidr.packed_network))
-            if (@netmask == cidr.packed_netmask)
-                comparasin = 0
-            elsif(@netmask < cidr.packed_netmask)
-                comparasin = 1
-            elsif(@netmask > cidr.packed_netmask)
-                comparasin = -1            
-            end
-        
-        elsif( (cidr.packed_network | @hostmask) == (@network | @hostmask) )
-            comparasin = 1
-        elsif( (cidr.packed_network | cidr.packed_hostmask) == (@network | cidr.packed_hostmask) )
-            comparasin = -1
-        end
+        comparasin = NetAddr.cidr_compare(self,cidr)
 
     return(comparasin)
 end
@@ -311,11 +541,11 @@ end
 # cidr4 = NetAddr::CIDR.create('192.168.1.1/24')
 # cidr6 = NetAddr::CIDR.create('fec0::/64')
 # cidr6_2 = NetAddr::CIDR.create('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) )
+# cidr4.contains?('192.168.1.2')
+# cidr6.contains?(cidr6_2)
 #
 #===Arguments:
-#* CIDR address or NetAddr::CIDR object
+#* cidr = CIDR address or NetAddr::CIDR object
 #
 #===Returns:
 #* true or false
@@ -331,27 +561,13 @@ end
                                      "errors: #{error}"
             end
         end
-        
-        network = cidr.packed_network 
-        netmask = cidr.packed_netmask
-
 
         if (cidr.version != @version)
             raise VersionError, "Attempted to compare a version #{cidr.version} CIDR " +
                                  "with a version #{@version} CIDR."
         end
 
-        # if network == @network, then we have to go by netmask length
-        # else we can tell by or'ing network and @network by @hostmask
-        # and comparing the results
-        if (network == @network)
-            contains = true if (netmask > @netmask)
-
-        else
-            if ( (network | @hostmask) == (@network | @hostmask) )
-                contains = true
-            end
-        end
+        contains = true if ( NetAddr.cidr_compare(self,cidr) == 1 )
 
         return(contains)
     end
@@ -365,15 +581,14 @@ end
 #
 # cidr4 = NetAddr::CIDR.create('192.168.1.1/24')
 # cidr6 = NetAddr::CIDR.create('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)}"
+# cidr4.desc(:IP => true)
+# cidr4.desc()
+# cidr6.desc(:Short => true)
 #
 #===Arguments:
-#* Optional hash with the following keys:
-#    :IP -- if true, return the original ip/netmask passed during initialization (optional)
-#    :Short -- if true, return IPv6 addresses in short-hand notation (optional)
+#* options = Optional hash with the following keys:
+#    :IP -- if true, return the original ip/netmask passed during initialization
+#    :Short -- if true, return IPv6 addresses in short-hand notation
 #
 #===Returns:
 #* String
@@ -388,23 +603,23 @@ end
                 raise ArgumentError, "Expected Hash, but #{options.class} provided."
             end
             NetAddr.validate_args(options.keys,known_args)
-            
+
             if (options.has_key?(:Short) && options[:Short] == true)
                 short = true
             end
-            
+
             if (options.has_key?(:IP) && options[:IP] == true)
                 orig_ip = true
             end
         end
-        
+
         if (!orig_ip)
-            ip = NetAddr.unpack_ip_addr(@network, :Version => @version)
+            ip = NetAddr.ip_int_to_str(@network, @version)
         else
-            ip = NetAddr.unpack_ip_addr(@ip, :Version => @version)
+            ip = NetAddr.ip_int_to_str(@ip, @version)
         end
         ip = NetAddr.shorten(ip) if (short && @version == 6)
-        mask = NetAddr.unpack_ip_netmask(@netmask)
+        mask = NetAddr.mask_to_bits(@netmask)
 
         return("#{ip}/#{mask}")
     end
@@ -418,17 +633,15 @@ end
 #
 #   cidr4 = NetAddr::CIDR.create('192.168.1.1/24')
 #   cidr6 = NetAddr::CIDR.create('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}"}
+#   cidr4.enumerate(:Limit => 4, :Bitstep => 32)
+#   cidr6.enumerate(:Limit => 4, :Bitstep => 32, :Objectify => true)
 #
 #===Arguments:
-#* Optional Hash with the following keys:
-#    :Bitstep -- enumerate in X sized steps - Integer (optional)
-#    :Limit -- limit returned list to X number of items - Integer (optional)
-#    :Objectify -- if true, return NetAddr::CIDR objects (optional)
-#    :Short -- if true, return IPv6 addresses in short-hand notation (optional)
+#* options = Hash with the following keys:
+#    :Bitstep -- enumerate in X sized steps - Integer
+#    :Limit -- limit returned list to X number of items - Integer
+#    :Objectify -- if true, return NetAddr::CIDR objects
+#    :Short -- if true, return IPv6 addresses in short-hand notation
 #
 #===Returns:
 #* Array of Strings, or Array of NetAddr::CIDR objects
@@ -445,7 +658,7 @@ end
                 raise ArgumentError, "Expected Hash, but #{options.class} provided."
             end
             NetAddr.validate_args(options.keys,known_args)
-            
+
             if( options.has_key?(:Bitstep) )
                 bitstep = options[:Bitstep]
             end
@@ -457,7 +670,7 @@ end
             if( options.has_key?(:Limit) )
                 limit = options[:Limit]
             end
-            
+
             if( options.has_key?(:Short) && options[:Short] == true )
                 short = true
             end
@@ -469,11 +682,11 @@ end
 
         until ( change_mask != (@hostmask | @network) ) 
             if (!objectify)
-                my_ip_s = NetAddr.unpack_ip_addr(my_ip, :Version => @version)
+                my_ip_s = NetAddr.ip_int_to_str(my_ip, @version)
                 my_ip_s = NetAddr.shorten(my_ip_s) if (short && @version == 6)
                 list.push( my_ip_s )
             else
-                list.push( NetAddr::CIDR.create(my_ip, :Version => @version) )
+                list.push( NetAddr.cidr_build(@version,my_ip) )
             end
             my_ip = my_ip + bitstep
             change_mask = @hostmask | my_ip
@@ -481,48 +694,9 @@ end
                 limit = limit -1
                 break if (limit == 0)
             end
-        end       
-        
-        return(list)
-    end
-
-#==============================================================================#
-# eql?
-#==============================================================================#
-
-#===Synopsis
-#Return true if the current CIDR and the provided CIDR are equal 
-#(base address and netmask are equal).
-#
-# cidr4 = NetAddr::CIDR.create('192.168.1.0/24')
-# cidr4.eql?('192.168.1.0/24')
-#
-#===Arguments:
-#* CIDR address or NetAddr::CIDR object
-#
-#===Returns:
-#* true or false
-#
-    def eql?(cidr)
-        is_eql = false
-
-        if (!cidr.kind_of?(NetAddr::CIDR))
-            begin
-                cidr = NetAddr::CIDR.create(cidr)
-            rescue Exception => error
-                raise ArgumentError, "Provided argument raised the following " +
-                                     "errors: #{error}"
-            end
         end
-        
-        if (cidr.version != @version)
-            raise VersionError, "Attempted to compare a version #{cidr.version} CIDR " +
-                                 "with a version #{@version} CIDR."
-        end
-        
-        is_eql = true if (self.packed_network == cidr.packed_network && self.packed_netmask == cidr.packed_netmask)
-        
-        return(is_eql)
+
+        return(list)
     end
 
 #==============================================================================#
@@ -534,13 +708,13 @@ end
 #holes (missing subnets) filled in.
 #
 # cidr4 = NetAddr::CIDR.create('192.168.1.0/24')
-# subnets = cidr4.fill_in(['192.168.1.0/27','192.168.1.64/26','192.168.1.128/25'])
+# cidr4.fill_in(['192.168.1.0/27','192.168.1.64/26','192.168.1.128/25'])
 #
 #===Arguments:
-#* Array of CIDR addresses, or Array of NetAddr::CIDR objects
-#* Optional Hash with the following keys:
-#    :Objectify -- if true, return NetAddr::CIDR objects (optional)
-#    :Short -- if true, return IPv6 addresses in short-hand notation (optional)
+#* list = Array of CIDR addresses, or Array of NetAddr::CIDR objects
+#* options = Hash with the following keys:
+#    :Objectify -- if true, return NetAddr::CIDR objects
+#    :Short -- if true, return IPv6 addresses in short-hand notation
 #
 #===Returns:
 #* Array of CIDR Strings, or an Array of NetAddr::CIDR objects
@@ -553,17 +727,17 @@ end
 
         # validate list
         raise ArgumentError, "Array expected for argument 'list' but #{list.class} provided." if (!list.kind_of?(Array) )
-    
+
         # validate options
-        if (options)     
+        if (options)
             raise ArgumentError, "Hash expected for argument 'options' but " +
                                  "#{options.class} provided." if (!options.kind_of?(Hash) )
             NetAddr.validate_args(options.keys,known_args)
-    
+
             if (options.has_key?(:Short) && options[:Short] == true)
                 short = true
             end
-    
+
             if (options.has_key?(:Objectify) && options[:Objectify] == true)
                 objectify = true
             end
@@ -584,7 +758,7 @@ end
             if (!obj.version == self.version)
                 raise VersionError, "#{obj.desc(:Short => true)} is not a version #{self.version} address."
             end
-            
+
             # make sure we contain the cidr
             if ( self.contains?(obj) == false )
                 raise "#{obj.desc(:Short => true)} does not fit " +
@@ -592,37 +766,8 @@ end
             end
             cidr_list.push(obj)
         end
-        
-        # sort our cidr's and see what is missing
-        complete_list = []
-        expected = self.packed_network
-        NetAddr.sort(cidr_list).each do |cidr|
-            network = cidr.packed_network
-            bitstep = (@all_f + 1) - cidr.packed_netmask
-            
-            if (network > expected)
-                num_ips_missing = network - expected
-                sub_list = make_subnets_from_base_and_ip_count(expected,num_ips_missing)
-                complete_list.concat(sub_list)                               
-            elsif (network < expected)
-                next
-            end
-            complete_list.push(NetAddr::CIDR.create(network,
-                                                    :PackedNetmask => cidr.packed_netmask,
-                                                    :Version => self.version))
-            expected = network + bitstep
-        end
-        
-        # if expected is not the next subnet, then we're missing subnets 
-        # at the end of the cidr
-        next_sub = self.next_subnet(:Objectify => true).packed_network
-        if (expected != next_sub)
-            num_ips_missing = next_sub - expected
-            sub_list = make_subnets_from_base_and_ip_count(expected,num_ips_missing)
-            complete_list.concat(sub_list)
-        end
-        
-        # decide what to return
+
+        complete_list = NetAddr.cidr_fill_in(self,cidr_list)
         if (!objectify)
             subnets = []
             complete_list.each {|entry| subnets.push(entry.desc(:Short => short))}
@@ -639,13 +784,10 @@ end
 #===Synopsis
 #Provide original IP address passed during initialization.
 #
-# puts cidr4.ip()
-# puts cidr4.ip(:Objectify => true).desc
-#
 #===Arguments:
-#* Optional Hash with the following keys:
-#    :Objectify -- if true, return NetAddr::CIDR object (optional)
-#    :Short -- if true, return IPv6 addresses in short-hand notation (optional)
+#* options = Hash with the following keys:
+#    :Objectify -- if true, return NetAddr::CIDR object
+#    :Short -- if true, return IPv6 addresses in short-hand notation
 #
 #===Returns:
 #* String or NetAddr::CIDR object.
@@ -654,30 +796,29 @@ end
         known_args = [:Objectify, :Short]
         objectify = false
         short = false
-        
+
         if (options)
             if (!options.kind_of?(Hash))
                 raise Argumenterror, "Expected Hash, but " +
                                      "#{options.class} provided."
             end
             NetAddr.validate_args(options.keys,known_args)
-            
+
             if( options.has_key?(:Short) && options[:Short] == true )
                 short = true
             end
-            
+
             if( options.has_key?(:Objectify) && options[:Objectify] == true )
                 objectify = true
             end
         end
 
-        
-        
+
         if (!objectify)
-            ip = NetAddr.unpack_ip_addr(@ip, :Version => @version)
+            ip = NetAddr.ip_int_to_str(@ip, @version)
             ip = NetAddr.shorten(ip) if (short && @version == 6)
         else
-            ip = NetAddr::CIDR.create(@ip, :Version => @version)
+            ip = NetAddr.cidr_build(@version,@ip)
         end
 
         return(ip)
@@ -692,10 +833,10 @@ end
 #the provided CIDR address or NetAddr::CIDR object.
 #
 # cidr4 = NetAddr::CIDR.create('192.168.1.1/24')
-# puts "#{cidr4.desc} is contained within 192.168.0.0/23" if ( cidr4.is_contained?('192.168.0.0/23') )
+# cidr4.is_contained?('192.168.0.0/23')
 #
 #===Arguments:
-#* CIDR address or NetAddr::CIDR object
+#* cidr = CIDR address or NetAddr::CIDR object
 #
 #===Returns:
 #* true or false
@@ -711,27 +852,17 @@ end
                                      "errors: #{error}"
             end
         end
-        
+
         if (cidr.version != @version)
             raise VersionError, "Attempted to compare a version #{cidr.version} CIDR " +
                                  "with a version #{@version} CIDR."
         end
-        
+
         network = cidr.packed_network 
         netmask = cidr.packed_netmask
         hostmask = cidr.packed_hostmask
 
-        # if network == @network, then we have to go by netmask length
-        # else we can tell by or'ing network and @network by hostmask
-        # and comparing the results
-        if (network == @network)
-            is_contained = true if (@netmask > netmask)
-
-        else
-            if ( (network | hostmask) == (@network | hostmask) )
-                is_contained = true
-            end
-        end
+        is_contained = true if ( NetAddr.cidr_compare(self,cidr) == -1 )
 
         return(is_contained)
     end
@@ -741,14 +872,12 @@ end
 #==============================================================================#
 
 #===Synopsis
-#Provide last IP address in this CIDR object. 
-#
-# puts cidr4.last() 
+#Provide last IP address in this CIDR object.
 #
 #===Arguments:
-#* Optional Hash with the following keys:
-#    :Objectify -- if true, return NetAddr::CIDR object (optional)
-#    :Short -- if true, return IPv6 addresses in short-hand notation (optional)
+#* options = Hash with the following keys:
+#    :Objectify -- if true, return NetAddr::CIDR object
+#    :Short -- if true, return IPv6 addresses in short-hand notation
 #
 #===Returns:
 #* String or NetAddr::CIDR object.
@@ -757,30 +886,30 @@ end
         known_args = [:Objectify, :Short]
         objectify = false
         short = false
-        
+
         if (options)
             if (!options.kind_of?(Hash))
                 raise Argumenterror, "Expected Hash, but " +
                                      "#{options.class} provided."
             end
             NetAddr.validate_args(options.keys,known_args)
-            
+
             if( options.has_key?(:Short) && options[:Short] == true )
                 short = true
             end
-            
+
             if( options.has_key?(:Objectify) && options[:Objectify] == true )
                 objectify = true
             end
 
         end
-        
+
         packed_ip = @network | @hostmask
         if (!objectify)
-            ip = NetAddr.unpack_ip_addr(packed_ip, :Version => @version)
+            ip = NetAddr.ip_int_to_str(packed_ip, @version)
             ip = NetAddr.shorten(ip) if (short && !objectify && @version == 6)
         else
-            ip = NetAddr::CIDR.create(packed_ip, :Version => @version)
+            ip = NetAddr.cidr_build(@version,packed_ip)
         end
 
         return(ip)
@@ -791,18 +920,18 @@ end
 #==============================================================================#
 
 #===Synopsis
-#Given an IP address (or if a CIDR, then the original IP of that CIDR), determine
+#Given an IP address (or if a NetAddr::CIDR object, then the original IP of that object), determine
 #if it falls within the range of addresses resulting from the combination of the 
 #IP and Wildcard Mask of this CIDR.
 #
-# cidr4 = NetAddr.CIDRv4.new('10.0.0.0', :WildcardMask => ['0.7.0.255', :inversed])
+# cidr4 = NetAddr.CIDRv4.create('10.0.0.0', :WildcardMask => ['0.7.0.255', true])
 # cidr4.matches?('10.0.0.22') -> true
 # cidr4.matches?('10.8.0.1') -> false
 # cidr4.matches?('10.1.0.1') -> true
 # cidr4.matches?('10.0.1.22') -> false
 #
 #===Arguments:
-#* IP address as a String or a CIDR object
+#* ip = IP address as a String or a CIDR object
 #
 #===Returns:
 #* True or False
@@ -820,9 +949,7 @@ end
             packed = ip.packed_ip
         end
 
-        mask = ~@wildcard_mask & @all_f
-
-        return(true) if (@ip & mask == packed & mask)
+        return(true) if (@ip & @wildcard_mask == packed & @wildcard_mask)
         return(false)
     end
 
@@ -836,11 +963,11 @@ end
 #MAC address is based on original IP address passed during initialization.
 #
 # mcast = NetAddr::CIDR.create('224.0.0.6')
-# puts mcast.multicast_mac.address
+# mcast.multicast_mac.address
 #
 #===Arguments:
-#* Optional Hash with the following keys:
-#    :Objectify -- if true, return EUI objects (optional)
+#* options = Hash with the following keys:
+#    :Objectify -- if true, return EUI objects
 #
 #===Returns:
 #* String or NetAddr::EUI48 object
@@ -848,18 +975,18 @@ end
     def multicast_mac(options=nil)
         known_args = [:Objectify]
         objectify = false
-        
+
         if (options)
             if (!options.kind_of? Hash)
                 raise ArgumentError, "Expected Hash, but #{options.class} provided."
             end
             NetAddr.validate_args(options.keys,known_args)
-        
+
             if (options.has_key?(:Objectify) && options[:Objectify] == true)
                 objectify = true
             end
         end
-        
+
         if (@version == 4)
             if (@ip & 0xf0000000 == 0xe0000000)
                 # map low order 23-bits of ip to 01:00:5e:00:00:00
@@ -875,9 +1002,9 @@ end
             else
                 raise ValidationError, "#{self.ip} is not a valid multicast address. IPv6 multicast " +
                       "addresses should be in the range ff00::/8."
-            end             
+            end
         end
-        
+
         eui = NetAddr::EUI48.new(mac)
         eui = eui.address if (!objectify)
 
@@ -891,8 +1018,6 @@ end
 #===Synopsis
 #Provide netmask in CIDR format (/yy).
 #
-# puts cidr4.netmask()
-#
 #===Arguments:
 #* none
 #
@@ -900,7 +1025,7 @@ end
 #* String
 #
     def netmask()
-        bits = NetAddr.unpack_ip_netmask(@netmask)
+        bits = NetAddr.mask_to_bits(@netmask)
         return("/#{bits}")
     end
 
@@ -911,12 +1036,10 @@ end
 #===Synopsis
 #Provide base network address.
 #
-# puts cidr4.network()
-#
 #===Arguments:
-#* Optional Hash with the following fields:
-#    :Objectify -- if true, return NetAddr::CIDR object (optional)
-#    :Short -- if true, return IPv6 addresses in short-hand notation (optional)
+#* options = Hash with the following fields:
+#    :Objectify -- if true, return NetAddr::CIDR object
+#    :Short -- if true, return IPv6 addresses in short-hand notation
 #
 #===Returns:
 #* String or NetAddr::CIDR object.
@@ -925,29 +1048,29 @@ end
         known_args = [:Objectify, :Short]
         objectify = false
         short = false
-        
+
         if (options)
             if (!options.kind_of?(Hash))
                 raise Argumenterror, "Expected Hash, but " +
                                      "#{options.class} provided."
             end
             NetAddr.validate_args(options.keys,known_args)
-            
+
             if( options.has_key?(:Short) && options[:Short] == true )
                 short = true
             end
-            
+
             if( options.has_key?(:Objectify) && options[:Objectify] == true )
                 objectify = true
             end
         end
 
-            
+
         if (!objectify)
-            ip = NetAddr.unpack_ip_addr(@network, :Version => @version)
+            ip = NetAddr.ip_int_to_str(@network, @version)
             ip = NetAddr.shorten(ip) if (short && @version == 6)
         else
-            ip = NetAddr::CIDR.create(@network, :Version => @version)
+            ip = NetAddr.cidr_build(@version,@network)
         end
 
         return(ip)
@@ -965,14 +1088,14 @@ end
 #
 # cidr4 = NetAddr::CIDR.create('192.168.1.1/24')
 # cidr6 = NetAddr::CIDR.create('fec0::/64')
-# puts "cidr4 next subnet #{cidr4.next_subnet()}"
-# puts "cidr6 next subnet #{cidr6.next_subnet(:Short => true)}" 
+# cidr4.next_subnet()
+# cidr6.next_subnet(:Short => true)}
 #
 #===Arguments:
-#* Optional Hash with the following keys:
-#     :Bitstep -- step in X sized steps - Integer (optional)
-#     :Objectify -- if true, return NetAddr::CIDR object (optional)
-#     :Short -- if true, return IPv6 addresses in short-hand notation (optional)
+#* options = Hash with the following keys:
+#     :Bitstep -- step in X sized steps - Integer
+#     :Objectify -- if true, return NetAddr::CIDR object
+#     :Short -- if true, return IPv6 addresses in short-hand notation
 #
 #===Returns:
 #* String or NetAddr::CIDR object.
@@ -982,41 +1105,41 @@ end
         bitstep = 1
         objectify = false
         short = false
-        
+
         if (options)
             if (!options.kind_of?(Hash))
                 raise Argumenterror, "Expected Hash, but " +
                                      "#{options.class} provided."
             end
             NetAddr.validate_args(options.keys,known_args)
-            
+
             if( options.has_key?(:Bitstep) )
                 bitstep = options[:Bitstep]
             end
-            
+
             if( options.has_key?(:Short) && options[:Short] == true )
                 short = true
             end
-        
+
             if( options.has_key?(:Objectify) && options[:Objectify] == true )
                 objectify = true
             end
         end
-        
+
         next_ip = @network + @hostmask + bitstep
-        
+
         if (next_ip > @all_f)
             raise BoundaryError, "Returned IP is out of bounds for IPv#{@version}."
         end
 
-                
+
         if (!objectify)
-            next_ip = NetAddr.unpack_ip_addr(next_ip, :Version => @version)
+            next_ip = NetAddr.ip_int_to_str(next_ip, @version)
             next_ip = NetAddr.shorten(next_ip) if (short && @version == 6)
         else
-            next_ip = NetAddr::CIDR.create(next_ip, :Version => @version)
+            next_ip = NetAddr.cidr_build(@version,next_ip)
         end
-        
+
         return(next_ip)
     end
 
@@ -1030,14 +1153,14 @@ end
 #
 #   cidr4 = NetAddr::CIDR.create('192.168.1.1/24')
 #   cidr6 = NetAddr::CIDR.create('fec0::/64')
-#   puts "cidr4 next subnet #{cidr4.next_subnet()}"
-#   puts "cidr6 next subnet #{cidr6.next_subnet(:Short => true)}" 
+#   cidr4.next_subnet()
+#   cidr6.next_subnet(:Short => true) 
 #
 #===Arguments:
-#* Optional Hash with the following keys:
-#    :Bitstep -- step in X sized steps. - Integer (optional)
-#    :Objectify -- if true, return NetAddr::CIDR object (optional)
-#    :Short -- if true, return IPv6 addresses in short-hand notation (optional)
+#* options = Hash with the following keys:
+#    :Bitstep -- step in X sized steps. - Integer
+#    :Objectify -- if true, return NetAddr::CIDR object
+#    :Short -- if true, return IPv6 addresses in short-hand notation
 #
 #===Returns:
 #* String or NetAddr::CIDR object.
@@ -1047,44 +1170,42 @@ end
         bitstep = 1
         objectify = false
         short = false
-        
+
         if (options)
             if (!options.kind_of?(Hash))
                 raise Argumenterror, "Expected Hash, but " +
                                      "#{options.class} provided."
             end
             NetAddr.validate_args(options.keys,known_args)
-            
+
             if( options.has_key?(:Bitstep) )
                 bitstep = options[:Bitstep]
             end
-            
+
             if( options.has_key?(:Short) && options[:Short] == true )
                 short = true
             end
-        
+
             if( options.has_key?(:Objectify) && options[:Objectify] == true )
                 objectify = true
             end
         end
-        
-        bitstep = bitstep * (2**(@max_bits - self.bits) )
+
+        bitstep = bitstep * (2**(@address_len - self.bits) )
         next_sub = @network + bitstep
-        
+
         if (next_sub > @all_f)
             raise BoundaryError, "Returned subnet is out of bounds for IPv#{@version}."
         end
-      
+
         if (!objectify)
-            next_sub = NetAddr.unpack_ip_addr(next_sub, :Version => @version)
+            next_sub = NetAddr.ip_int_to_str(next_sub, @version)
             next_sub = NetAddr.shorten(next_sub) if (short && @version == 6)        
             next_sub = next_sub << "/" << self.bits.to_s
         else
-            next_sub = NetAddr::CIDR.create(next_sub, 
-                                            :PackedNetmask => self.packed_netmask, 
-                                            :Version => @version)
+            next_sub = NetAddr.cidr_build(@version,next_sub,self.packed_netmask)
         end
-        
+
         return(next_sub)
     end
 
@@ -1096,14 +1217,14 @@ end
 #Provide the nth IP within this object.
 #
 # cidr4 = NetAddr::CIDR.create('192.168.1.1/24')
-# puts cidr4.nth(1)
-# puts cidr4.nth(1, :Objectify => true
+# cidr4.nth(1)
+# cidr4.nth(1, :Objectify => true)
 #
 #===Arguments:
-#* Index number as an Integer
-#* Optional Hash with the following keys:
-#    :Objectify -- if true, return NetAddr::CIDR objects (optional)
-#    :Short -- if true, return IPv6 addresses in short-hand notation (optional)
+#* index = Index number as an Integer
+#* options = Hash with the following keys:
+#    :Objectify -- if true, return NetAddr::CIDR objects
+#    :Short -- if true, return IPv6 addresses in short-hand notation
 #
 #===Returns:
 #* String or NetAddr::CIDR object.
@@ -1116,7 +1237,7 @@ end
         # validate list
         raise ArgumentError, "Integer expected for argument 'index' but " +
                              "#{index.class} provided." if (!index.kind_of?(Integer) )
-    
+
         # validate options
         if (options)     
             raise ArgumentError, "Hash expected for argument 'options' but #{options.class} provided." if (!options.kind_of?(Hash) )
@@ -1125,21 +1246,21 @@ end
             if( options.has_key?(:Short) && options[:Short] == true )
                 short = true
             end
-        
+
             if( options.has_key?(:Objectify) && options[:Objectify] == true )
                     objectify = true
             end
         end
-        
+
         my_ip = @network + index
         if ( (@hostmask | my_ip) == (@hostmask | @network) )
-            
+
             if (!objectify)
-                my_ip = NetAddr.unpack_ip_addr(my_ip, :Version => @version)
+                my_ip = NetAddr.ip_int_to_str(my_ip, @version)
                 my_ip = NetAddr.shorten(my_ip) if (short && @version == 6)
             else
-                my_ip = NetAddr::CIDR.create(my_ip, :Version => @version)
-            end
+                my_ip = NetAddr.cidr_build(@version,my_ip)
+             end
 
         else
             raise BoundaryError, "Index of #{index} returns IP that is out of " +
@@ -1156,8 +1277,6 @@ end
 #===Synopsis
 #Provide an Integer representation of the Hostmask of this object.
 #
-# puts cidr4.packed_hostmask().to_s(16)
-#
 #===Arguments:
 #* none
 #
@@ -1175,8 +1294,6 @@ end
 #===Synopsis
 #Provide an Integer representation of the IP address of this object.
 #
-# puts cidr4.packed_ip().to_s(16)
-#
 #===Arguments:
 #* none
 #
@@ -1194,8 +1311,6 @@ end
 #===Synopsis
 #Provide an Integer representation of the Netmask of this object.
 #
-# puts cidr4.packed_netmask().to_s(16)
-#
 #===Arguments:
 #* none
 #
@@ -1213,11 +1328,9 @@ end
 #===Synopsis
 #Provide an Integer representation of the Network address of this object.
 #
-# packed = cidr4.packed_network().to_s(16)
-#
 #===Arguments:
 #* none
-# 
+#
 #===Returns:
 #* Integer
 #
@@ -1232,8 +1345,6 @@ end
 #===Synopsis
 #Provide an Integer representation of the IPv4 Wildcard Mask.
 #
-# puts cidr4.packed_wildcard_mask()
-#
 #===Arguments:
 #* none
 #
@@ -1254,17 +1365,17 @@ end
 #all addresses from the lower bound up will be returned. 
 #
 # cidr4 = NetAddr::CIDR.create('192.168.1.1/24')
-# list = cidr4.range(0, 1)
-# list = cidr4.range(0, 1, :Objectify => true)
-# list = cidr4.range(0, nil, :Objectify => true)
+# cidr4.range(0, 1)
+# cidr4.range(0, 1, :Objectify => true)
+# cidr4.range(0, nil, :Objectify => true)
 #
 #===Arguments:
-#* Lower range boundary index as an Integer
-#* Upper range boundary index as an Integer
-#* Optional Hash with the following keys:
-#    :Bitstep -- enumerate in X sized steps - Integer (optional)
-#    :Objectify -- if true, return NetAddr::CIDR objects (optional)
-#    :Short -- if true, return IPv6 addresses in short-hand notation (optional)
+#* lower = Lower range boundary index as an Integer
+#* upper = Upper range boundary index as an Integer
+#* options = Hash with the following keys:
+#    :Bitstep -- enumerate in X sized steps - Integer
+#    :Objectify -- if true, return NetAddr::CIDR objects
+#    :Short -- if true, return IPv6 addresses in short-hand notation
 #
 #===Returns:
 #* Array of Strings, or Array of NetAddr::CIDR objects
@@ -1278,52 +1389,52 @@ end
         # validate indexes
         raise ArgumentError, "Integer expected for argument 'lower' " +
                              "but #{lower.class} provided." if (!lower.kind_of?(Integer))
-        
+
         raise ArgumentError, "Integer expected for argument 'upper' " +
                              "but #{upper.class} provided." if (upper && !upper.kind_of?(Integer))
-            
+
         upper = @hostmask if (upper.nil?)
         indexes = [lower,upper]
         indexes.sort!
         if ( (indexes[0] < 0) || (indexes[0] > self.size) )
             raise BoundaryError, "Index #{indexes[0]} is out of bounds for this CIDR."
         end
-        
+
         if (indexes[1] >= self.size)
             raise BoundaryError, "Index #{indexes[1]} is out of bounds for this CIDR."
         end
-        
+
         # validate options
-        if (options)     
+        if (options)
             raise ArgumentError, "Hash expected for argument 'options' but #{options.class} provided." if (!options.kind_of?(Hash) )
             NetAddr.validate_args(options.keys,known_args)
-            
+
             if( options.has_key?(:Short) && options[:Short] == true )
                 short = true
             end
-        
+
             if( options.has_key?(:Objectify) && options[:Objectify] == true )
                 objectify = true
             end
-        
+
             if( options.has_key?(:Bitstep) )
                 bitstep = options[:Bitstep]
             end
         end
-        
+
         # make range
         start_ip = @network + indexes[0]
         end_ip = @network + indexes[1]
         my_ip = start_ip
         list = []
-        until (my_ip > end_ip)            
+        until (my_ip > end_ip)
             if (!objectify)
-                ip = NetAddr.unpack_ip_addr(my_ip, :Version => @version)
+                ip = NetAddr.ip_int_to_str(my_ip, @version)
                 ip = NetAddr.shorten(ip) if (short && @version == 6)
             else
-                ip = NetAddr::CIDR.create(:PackedIP => my_ip, :Version => @version)
+                ip = NetAddr.cidr_build(@version,my_ip)
             end
-            
+
             list.push(ip)
             my_ip += bitstep
         end
@@ -1341,14 +1452,15 @@ end
 #provide 192.168.0.64/26 as the portion to exclude, then 192.168.0.0/26,
 #and 192.168.0.128/25 will be returned as the remainders.
 #
-# cidr4.remainder('192.168.1.32/27').each {|x| puts x}
-# cidr4.remainder('192.168.1.32/27', :Objectify => true).each {|x| puts x.desc}
+# cidr4 = NetAddr::CIDR.create('192.168.1.0/24')
+# cidr4.remainder('192.168.1.32/27')
+# cidr4.remainder('192.168.1.32/27', :Objectify => true)
 #
 #===Arguments:
-#* CIDR address or NetAddr::CIDR object
-#* Optional Hash with the following keys:
-#    :Objectify -- if true, return NetAddr::CIDR objects (optional)
-#    :Short -- if true, return IPv6 addresses in short-hand notation (optional)
+#* addr = CIDR address or NetAddr::CIDR object
+#* options = Hash with the following keys:
+#    :Objectify -- if true, return NetAddr::CIDR objects 
+#    :Short -- if true, return IPv6 addresses in short-hand notation
 #
 #===Returns:
 #* Array of Strings, or Array of NetAddr::CIDR objects
@@ -1357,22 +1469,22 @@ end
         known_args = [:Objectify, :Short]
         short = nil
         objectify = nil
-        
+
         # validate options
-        if (options)     
+        if (options)
             raise ArgumentError, "Hash expected for argument 'options' but " +
                                  "#{options.class} provided." if (!options.kind_of?(Hash) )
             NetAddr.validate_args(options.keys,known_args)
-            
+
             if( options.has_key?(:Short) && options[:Short] == true )
                 short = true
             end
-        
+
             if( options.has_key?(:Objectify) && options[:Objectify] == true )
                 objectify = true
-            end        
+            end
         end
-        
+
         if ( !addr.kind_of?(NetAddr::CIDR) )
             begin
                 addr = NetAddr::CIDR.create(addr)
@@ -1381,13 +1493,13 @@ end
                                      "errors: #{error}"
             end
         end
-        
-        
+
+
         # make sure 'addr' is the same ip version
         if ( addr.version != @version )
             raise VersionError, "#{addr.desc(:Short => true)} is of a different " +
                                 "IP version than #{self.desc(:Short => true)}."
-        end    
+        end
 
         # make sure we contain 'to_exclude'
         if ( self.contains?(addr) != true )
@@ -1400,8 +1512,8 @@ end
         # we repeat, store the non-matching half
         new_mask = self.bits + 1
         lower_network = self.packed_network
-        upper_network = self.packed_network + 2**(@max_bits - new_mask)
-        
+        upper_network = self.packed_network + 2**(@address_len - new_mask)
+
         new_subnets = []
         until(new_mask > addr.bits)
             if (addr.packed_network < upper_network)
@@ -1412,22 +1524,19 @@ end
                 non_match = lower_network
             end
 
-            
             if (!objectify)
-                non_match = NetAddr.unpack_ip_addr(non_match, :Version => @version)
+                non_match = NetAddr.ip_int_to_str(non_match, @version)
                 non_match = NetAddr.shorten(non_match) if (short && @version == 6)
                 new_subnets.unshift("#{non_match}/#{new_mask}")
             else
-                new_subnets.unshift(NetAddr::CIDR.create(non_match, 
-                                                         :PackedNetmask => NetAddr.pack_ip_netmask(new_mask), 
-                                                         :Version => @version))
+                new_subnets.unshift( NetAddr.cidr_build(@version, non_match, NetAddr.bits_to_mask(new_mask,version) ) )
             end
-            
+
             new_mask = new_mask + 1
             lower_network = match
-            upper_network = match + 2**(@max_bits - new_mask)
+            upper_network = match + 2**(@address_len - new_mask)
         end
-        
+
         return(new_subnets)
     end
 
@@ -1441,24 +1550,22 @@ end
 #
 # cidr4 = NetAddr::CIDR.create('192.168.1.1/24')
 # new_cidr = cidr4.resize(23)
-# puts new_cidr.desc
 #
 #===Arguments:
-#* Netmask as an Integer
+#* bits = Netmask as an Integer
 #
 #===Returns:
 #* NetAddr::CIDR object
 #
     def resize(bits)
         raise Argumenterror, "Integer or Hash expected, but " +
-                                 "#{bits.class} provided." if (!bits.kind_of?(Integer))
-        
+                             "#{bits.class} provided." if (!bits.kind_of?(Integer))
+
         NetAddr.validate_ip_netmask(bits, :Version => @version)
-        netmask = NetAddr.pack_ip_netmask(bits, :Version => @version)
+        netmask = NetAddr.bits_to_mask(bits, @version)
         network = @network & netmask
-        
-        cidr = NetAddr::CIDR.create(network, :PackedNetmask => netmask, :Version => @version)
-        return(cidr)
+
+        return( NetAddr.cidr_build(@version, network, netmask) )
     end
 
 #==============================================================================#
@@ -1471,11 +1578,10 @@ end
 #it no longer falls within the bounds of the CIDR.
 #
 # cidr4 = NetAddr::CIDR.create('192.168.1.1/24')
-# new_cidr = cidr4.resize(23)
-# puts new_cidr.desc 
+# cidr4.resize!(23)
 #
 #===Arguments:
-#* Netmask as an Integer
+#* bits = Netmask as an Integer
 #
 #===Returns:
 #* True
@@ -1483,22 +1589,60 @@ end
     def resize!(bits)
         raise Argumenterror, "Integer or Hash expected, but " +
                                  "#{bits.class} provided." if (!bits.kind_of?(Integer))
-        
+
         NetAddr.validate_ip_netmask(bits, :Version => @version)
         netmask = NetAddr.pack_ip_netmask(bits, :Version => @version)
-        
+
         @netmask = netmask
         @network = @network & netmask
         @hostmask = @netmask ^ @all_f
-        
+
         # check @ip
         if ((@ip & @netmask) != (@network))
             @ip = @network
         end
-        
+
         return(true)
     end
 
+#==============================================================================#
+# set_wildcard_mask()
+#==============================================================================#
+
+#===Synopsis
+#Set the wildcard mask. Wildcard masks are typically used for matching
+#entries in an access-list.
+#
+# cidr4 = NetAddr::CIDR.create('192.168.1.0/24')
+# cidr4.set_wildcard_mask('0.0.0.255', true)
+# cidr4.set_wildcard_mask('255.255.255.0')
+#
+#===Arguments:
+#* mask = wildcard mask as a String or Integer
+#* bit_flipped = if set True then the wildcard mask is interpereted as bit-flipped.
+#
+#===Returns:
+#* nil
+#
+    def set_wildcard_mask(mask, bit_flipped=false)
+        packed = nil
+        if (mask.kind_of?(Integer))
+            NetAddr.validate_ip_int(mask,@version)
+            packed = mask
+        else
+            begin
+                NetAddr.validate_ip_str(mask,@version)
+                packed = NetAddr.ip_str_to_int(mask, @version)
+            rescue NetAddr::ValidationError
+                raise NetAddr::ValidationError, "Wildcard Mask must be a valid IPv#{@version} address."
+            end
+        end
+        packed = ~packed if (bit_flipped)
+        @wildcard_mask = packed
+
+        return(nil)
+    end
+
 #==============================================================================#
 # size()
 #==============================================================================#
@@ -1506,8 +1650,6 @@ end
 #===Synopsis
 #Provide number of IP addresses within this CIDR.
 #
-# puts cidr4.size()
-#
 #===Arguments:
 #* none
 #
@@ -1523,9 +1665,9 @@ end
 #==============================================================================#
 
 #===Synopsis
-#Subnet this CIDR. There are 2 ways to subnet:
-#   * By providing the netmask (in bits) of the new subnets in :Bits.
-#   * By providing the number of IP addresses needed in the new subnets in :IPCount
+#Create subnets for this CIDR. There are 2 ways to create subnets:
+#   * By providing the netmask (in bits) of the new subnets with :Bits.
+#   * By providing the number of IP addresses needed in the new subnets with :IPCount
 #
 #:NumSubnets is used to determine how the CIDR is subnetted. For example, if I request
 #the following operation:
@@ -1541,18 +1683,20 @@ end
 #If neither :Bits nor :IPCount is provided, then the current CIDR will be split in half.
 #If both :Bits and :IPCount are provided, then :Bits takes precedence.
 #
-# cidr_list = cidr4.subnet(:Bits => 28, :NumSubnets => 3).each {|x| puts "  #{x}"}
-# cidr_list = cidr4.subnet(:IPCount => 19).each {|x| puts "  #{x}"}
-# cidr4.subnet(:Bits => 28).each {|x| puts "  #{x}"}  "
-# cidr6.subnet(:Bits => 67, :NumSubnets => 4, :Short => true).each {|x| puts "  #{x}"}
+# cidr4 = NetAddr::CIDR.create('192.168.1.0/24')
+# cidr6 = NetAddr::CIDR.create('fec0::/64')
+# cidr4.subnet(:Bits => 28, :NumSubnets => 3)
+# cidr4.subnet(:IPCount => 19)
+# cidr4.subnet(:Bits => 28)
+# cidr6.subnet(:Bits => 67, :NumSubnets => 4, :Short => true)
 #
 #===Arguments:
-#* Optional Hash with the following keys:
-#    :Bits --  Netmask (in bits) of new subnets - Integer (optional)
-#    :IPCount -- Minimum number of IP's that new subnets should contain - Integer (optional)
-#    :NumSubnets -- Number of X sized subnets to return - Integer (optional)
-#    :Objectify -- if true, return NetAddr::CIDR objects (optional)
-#    :Short -- if true, return IPv6 addresses in short-hand notation (optional)
+#* options = Hash with the following keys:
+#    :Bits --  Netmask (in bits) of new subnets - Integer
+#    :IPCount -- Minimum number of IP's that new subnets should contain - Integer
+#    :NumSubnets -- Number of X sized subnets to return - Integer
+#    :Objectify -- if true, return NetAddr::CIDR objects
+#    :Short -- if true, return IPv6 addresses in short-hand notation
 #
 #===Returns:
 #* Array of Strings, or Array of NetAddr::CIDR objects
@@ -1564,38 +1708,38 @@ end
         subnet_bits = my_mask + 1
         min_count = nil 
         objectify = false
-        short = false       
-        
+        short = false
+
         if (options)
             if (!options.kind_of? Hash)
                 raise ArgumentError, "Expected Hash, but #{options.class} provided."
             end
             NetAddr.validate_args(options.keys,known_args)
-            
+
             if ( options.has_key?(:IPCount) )
-                subnet_bits = NetAddr.minimum_size(options[:IPCount], :Version => @version)
+                subnet_bits = NetAddr.ip_count_to_size(options[:IPCount], @version)
             end
-            
+
             if ( options.has_key?(:Bits) )
                 subnet_bits = options[:Bits]
             end
-            
+
             if ( options.has_key?(:NumSubnets) )
                 num_subnets = options[:NumSubnets]
             end
-            
+
             if( options.has_key?(:Short) && options[:Short] == true )
                 short = true
             end
-        
+
             if( options.has_key?(:Objectify) && options[:Objectify] == true )
                 objectify = true
             end
-            
+
         end
 
         # get number of subnets possible with the requested subnet_bits
-        num_avail = 2**(subnet_bits - my_mask)        
+        num_avail = 2**(subnet_bits - my_mask)
 
         # get the number of bits in the next supernet and
         # make sure num_subnets is a power of 2
@@ -1606,10 +1750,10 @@ end
         end
         num_subnets = 2**bits_needed
         next_supernet_bits = subnet_bits - bits_needed
-        
+
 
         # make sure subnet isnt bigger than available bits
-        if (subnet_bits > @max_bits)
+        if (subnet_bits > @address_len)
             raise BoundaryError, "Requested subnet (#{subnet_bits}) does not fit " +
                   "within the bounds of IPv#{@version}."
         end
@@ -1628,17 +1772,20 @@ end
 
         # list all 'subnet_bits' sized subnets of this cidr block
         # with a limit of num_subnets
-        bitstep = 2**(@max_bits - subnet_bits)
-        subnets = self.enumerate(:Bitstep => bitstep, :Limit => num_subnets)
+        bitstep = 2**(@address_len - subnet_bits)
+        subnets = self.enumerate(:Bitstep => bitstep, :Limit => num_subnets, :Objectify => true)
 
         # save our subnets
         new_subnets = []
         subnets.each do |subnet|
             if (!objectify)
-                subnet = NetAddr.shorten(subnet) if (short && @version == 6)
-                new_subnets.push("#{subnet}/#{subnet_bits}")
-            else            
-                new_subnets.push(NetAddr::CIDR.create("#{subnet}/#{subnet_bits}", :Version => @version))
+                if (short && @version == 6)
+                    new_subnets.push("#{subnet.network(:Short => true)}/#{subnet_bits}")
+                else
+                    new_subnets.push("#{subnet.network}/#{subnet_bits}")
+                end
+            else
+                new_subnets.push( NetAddr.cidr_build(@version, subnet.packed_network, NetAddr.bits_to_mask(subnet_bits,version) ) )
             end
         end
 
@@ -1648,15 +1795,13 @@ end
         next_supernet_ip = my_network + next_supernet_bitstep
         until (next_supernet_bits == my_mask)
             if (!objectify)
-                next_network = NetAddr.unpack_ip_addr(next_supernet_ip, :Version => @version)
+                next_network = NetAddr.ip_int_to_str(next_supernet_ip, @version)
                 next_network = NetAddr.shorten(next_network) if (short && @version == 6)
                 new_subnets.push("#{next_network}/#{next_supernet_bits}")
             else
-                new_subnets.push(NetAddr::CIDR.create(next_supernet_ip,
-                                                      :PackedNetmask => NetAddr.pack_ip_netmask(next_supernet_bits),
-                                                      :Version => @version))
+                new_subnets.push(NetAddr.cidr_build(@version, next_supernet_ip, NetAddr.bits_to_mask(next_supernet_bits,version) ) )
             end
-            
+
             next_supernet_bits -= 1
             next_supernet_ip = next_supernet_ip + next_supernet_bitstep
             next_supernet_bitstep = next_supernet_bitstep << 1
@@ -1665,102 +1810,30 @@ end
         return(new_subnets)
     end
 
-
 #==============================================================================#
 # wildcard_mask()
 #==============================================================================#
 
 #===Synopsis
-#Set or return the wildcard mask. Wildcard masks are typically used for matching
-#entries in an access-list.
-#
-# cidr4.wildcard_mask() -> reads the current wildcard mask
-# cidr4.wildcard_mask('0.0.0.255', :inversed) -> sets wildcard mask using a reversed mask
-# cidr4.wildcard_mask('255.255.255.0') -> sets wildcard mask using a standard mask
+#Return the wildcard mask.
 #
 #===Arguments:
-#* wildcard mask as a String or Integer
-#* the label :inversed if the mask is bit-flipped. (optional)
+#* bit_flipped = if set True then returned the bit-flipped version of the wildcard mask.
 #
 #===Returns:
-#* nil
+#* String
 #
-    def wildcard_mask(mask=nil, inversed=nil)
-        if (mask)
-            if (mask.kind_of?(Integer)) 
-                packed = mask
-            else
-                packed = nil
-                begin
-                    packed = NetAddr.pack_ip_addr(mask, :Version => @version)
-                rescue NetAddr::ValidationError
-                    raise NetAddr::ValidationError, "Wildcard Mask must be a valid IPv#{@version} address."
-                end
-            end
-            packed = packed ^ @all_f if (inversed != :inversed)
-            @wildcard_mask = packed
-            ret_val = nil
+    def wildcard_mask(bit_flipped=false)
+        ret_val = nil
+        if (!bit_flipped)
+            ret_val = NetAddr.ip_int_to_str(@wildcard_mask, @version)
         else
-            if (inversed != :inversed)
-                ret_val = NetAddr.unpack_ip_addr(@wildcard_mask ^ @all_f, :Version => @version)
-            else
-                ret_val = NetAddr.unpack_ip_addr(@wildcard_mask, :Version => @version)
-            end
+            ret_val = NetAddr.ip_int_to_str(~@wildcard_mask, @version)
         end
 
         return(ret_val)
     end
 
-
-# PRIVATE INSTANCE METHODS
-private
-
-
-#==============================================================================#
-# make_subnets_from_base_and_ip_count()
-#==============================================================================#
-
-# Make CIDR addresses from a base addr and an number of ip's to encapsulate.
-#
-#===Arguments:
-#   * base ip as packed integer
-#   * number of ip's required
-#
-#===Returns:
-#   * array of NetAddr::CIDR objects
-#
-    def make_subnets_from_base_and_ip_count(base_addr,ip_count)
-        list = []        
-        until (ip_count == 0)
-            mask = @all_f
-            multiplier = 0
-            bitstep = 0
-            last_addr = base_addr
-            done = false
-            until (done == true)
-                if (bitstep < ip_count && (base_addr & mask == last_addr & mask) )
-                    multiplier += 1
-                elsif (bitstep > ip_count || (base_addr & mask != last_addr & mask) )
-                    multiplier -= 1
-                    done = true
-                else
-                    done = true
-                end                
-                bitstep = 2**multiplier
-                mask = @all_f << multiplier & @all_f
-                last_addr = base_addr + bitstep - 1
-            end          
-            
-            list.push(NetAddr::CIDR.create(base_addr,
-                                           :PackedNetmask => mask,
-                                           :Version => self.version))
-            ip_count -= bitstep
-            base_addr += bitstep
-        end
-        
-        return(list)
-    end
-
 end # end class CIDR
 
 
@@ -1771,154 +1844,14 @@ end # end class CIDR
 # Addresses of this class are composed of a 32-bit address space.
 class CIDRv4 < CIDR
 
-public_class_method :new
-
-#==============================================================================#
-# initialize()
-#==============================================================================#
-
-#===Synopsis
-#Return a CIDRv4 object.
-#CIDR formatted netmasks take precedence over extended formatted ones.
-#CIDR address defaults to a host network (/32) if netmask not provided.
-#:PackedNetmask takes precedence over netmask given within CIDR address.
-#
-# cidr4 = NetAddr::CIDRv4.new('192.168.1.1/24')
-# cidr4 = NetAddr::CIDRv4.new('192.168.1.1 255.255.255.0')
-# cidr4_2 = NetAddr::CIDRv4.new(0x0a010001,
-#                               :PackedNetmask => 0xffffff00)
-# cidr4_3 = NetAddr::CIDRv4.new('192.168.1.1',
-#                               :WildcardMask => ['0.7.0.255', :inversed])
-# cidr4_4 = NetAddr::CIDRv4.new('192.168.5.0',
-#                               :WildcardMask => ['255.248.255.0'])
-# cidr4_5 = NetAddr::CIDRv4.new('192.168.1.1',
-#                               :WildcardMask => 0x000700ff)
-#
-#===Arguments:
-#* CIDR address as a String, or a packed IP address as an Integer
-#* Optional Hash with the following keys:
-#     :PackedNetmask -- Integer representation of an IP Netmask (optional)
-#     :Tag -- Custom descriptor tag - Hash, tag => value. (optional)
-#     :WildcardMask -- 2 element Array. First element contains a special bit mask used for
-#                      advanced IP pattern matching. The second element should be :inversed if this
-#                      bit mask is in inverse format. (optional)
-#
-    def initialize(addr, options=nil)
-        known_args = [:PackedNetmask, :Tag, :WildcardMask]
-        @tag = {}
-        @version = 4
-        @max_bits = 32
-        @all_f = 2**@max_bits - 1
-        
-        # validate addr arg
-        if (addr.kind_of?(String))
-            cidr = addr
-        elsif (addr.kind_of?(Integer))
-            packed_ip = addr
-        else
-            raise ArgumentError, "String or Integer expected for argument 'addr' but #{addr.class} provided."
-        end
-        
-        # validate options
-        if (options)     
-            raise ArgumentError, "Hash expected for argument 'options' but " +
-                                 "#{options.class} provided." if (!options.kind_of?(Hash) )
-            NetAddr.validate_args(options.keys,known_args)
-            
-            if (options.has_key?(:PackedNetmask))
-                packed_netmask = options[:PackedNetmask]
-                raise ArgumentError, "Expected Integer, but #{packed_netmask.class} " +
-                                     "provided for option :PackedNetmask." if (!packed_netmask.kind_of?(Integer))
-            end
-
-            if (options.has_key?(:Tag))
-                @tag = options[:Tag]
-                if (!@tag.kind_of? Hash)
-                    raise ArgumentError, "Expected Hash, but #{@tag.class} provided for option :Tag."
-                end
-            end
-
-            if (options.has_key?(:WildcardMask))
-                if (!options[:WildcardMask].kind_of?(Array))
-                    raise ArgumentError, "Expected Array, but #{options[:WildcardMask].class} provided for option :WildcardMask."
-                end
-                wildcardmask = options[:WildcardMask][0]
-                inversed = false
-                inversed = true if (options[:WildcardMask][1] && options[:WildcardMask][1] == :inversed)
-
-                if (wildcardmask.kind_of?(Integer))
-                   begin
-                        @wildcard_mask = wildcardmask
-                        NetAddr.validate_ip_addr(@wildcard_mask, :Version => @version)
-                    rescue NetAddr::ValidationError
-                        raise NetAddr::ValidationError, ":WildcardMask must be a valid IPv#{@version} address."
-                    end 
-                else
-                    begin
-                        @wildcard_mask = NetAddr.pack_ip_addr(wildcardmask, :Version => @version)
-                    rescue NetAddr::ValidationError
-                        raise NetAddr::ValidationError, ":WildcardMask must be a valid IPv#{@version} address."
-                    end
-                end
-
-                @wildcard_mask = @wildcard_mask ^ @all_f if (inversed)
-            end
-        end
-
-
-        if (packed_ip)
-            # validate & store packed_ip
-            NetAddr.validate_ip_addr(packed_ip, :Version => @version)
-            @ip = packed_ip
-        
-        else           
-            # if extended netmask provided. should only apply to ipv4            
-            if (cidr =~ /.+\s+.+/ )
-                cidr,netmask = cidr.split(' ')
-            end           
-   
-            # if netmask part of cidr, then over-ride any provided extended netmask.
-            if (cidr =~ /\//) 
-                ip,netmask = cidr.split(/\//)
-                if (!ip || !netmask)
-                    raise ArgumentError, "CIDR address is improperly formatted. Missing netmask after '/' character." 
-                end
-            else
-                ip = cidr
-            end
-            
-            # pack ip                
-            @ip = NetAddr.pack_ip_addr(ip, :Version => @version)           
-        end
-        
-        # if no netmask or packed_netmask, then set
-        # else validate. packed_netmask takes precedence over netmask
-        if (!netmask && !packed_netmask)
-            @netmask = @all_f
-        else            
-            if (packed_netmask)
-                NetAddr.validate_ip_netmask(packed_netmask, :Packed => true, :Version => @version)
-                @netmask = packed_netmask
-            else
-                NetAddr.validate_ip_netmask(netmask, :Version => @version)
-                @netmask = NetAddr.pack_ip_netmask(netmask, :Version => @version)
-            end
-        end
-        
-        # set @network & @hostmask
-        @network = (@ip & @netmask)
-        @hostmask = @netmask ^ @all_f
-        @wildcard_mask = @hostmask if (!@wildcard_mask)
-
-    end
-
+    public_class_method :new
 
 #==============================================================================#
 # broadcast()
 #==============================================================================#
 
 # Alias for last
-alias :broadcast :last
+    alias :broadcast :last
 
 #==============================================================================#
 # hostmask_ext()
@@ -1927,8 +1860,6 @@ alias :broadcast :last
 #===Synopsis
 #Provide IPv4 Hostmask in extended format (y.y.y.y).
 #
-# puts cidr4.hostmask_ext(
-#
 #===Arguments:
 #* none
 #
@@ -1936,7 +1867,7 @@ alias :broadcast :last
 #* String
 #
     def hostmask_ext()
-        return(NetAddr.unpack_ip_addr(@hostmask, :Version => @version))
+        return(NetAddr.ip_int_to_str(@hostmask, @version))
     end
 
 #==============================================================================#
@@ -1946,160 +1877,29 @@ alias :broadcast :last
 #===Synopsis
 #Provide IPv4 netmask in extended format (y.y.y.y).
 #
-# puts cidr4.netmask_ext()
-#
 #===Arguments:
 #* none
 #
 #===Returns:
 #* String
 #
-    def netmask_ext()    
-        return(NetAddr.unpack_ip_addr(@netmask))
+    def netmask_ext()
+        return(NetAddr.ip_int_to_str(@netmask, 4))
     end
 
 end # end class CIDRv4
- 
-
-# IPv6 CIDR address - Inherits all methods from NetAddr::CIDR. 
-# Addresses of this class are composed of a 128-bit address space.
-class CIDRv6 < CIDR
-
-public_class_method :new
-
-#==============================================================================#
-# initialize()
-#==============================================================================#
-
-#===Synopsis
-#Return a CIDRv6 object.
-#CIDR formatted netmasks take precedence over extended formatted ones.
-#CIDR address defaults to a host network (/128) if netmask not provided.
-#:PackedNetmask takes precedence over netmask given within CIDR address.
-#
-# cidr6 = NetAddr::CIDRv6.new('fec0::/64')
-# cidr6 = NetAddr::CIDRv6.new('fec0::/64',
-#                             :Tag => {'interface' => 'g0/1'})
-# cidr6_2 = NetAddr::CIDRv6.new('::ffff:192.168.1.1/96')
-# cidr6_3 = NetAddr::CIDRv6.new('fec0::',
-#                               :WildcardMask => '0000:ffff::ffff')
-#
-#===Arguments:
-#* CIDR address as a String, or a packed IP address as an Integer
-#* Optional Hash with the following keys:
-#     :PackedNetmask -- Integer representation of an IP Netmask (optional)
-#     :Tag -- Custom descriptor tag - Hash, tag => value. (optional)
-#     :WildcardMask -- 2 element Array. First element contains a special bit mask used for
-#                      advanced IP pattern matching. The second element should be :inversed if this
-#                      bit mask is in inverse format. (optional)
-#
-    def initialize(addr, options=nil)
-        known_args = [:PackedNetmask, :Tag, :WildcardMask]
-        @tag = {}
-        @version = 6
-        @max_bits = 128
-        @all_f = 2**@max_bits - 1
-        
-        # validate addr arg
-        if (addr.kind_of?(String))
-            cidr = addr
-        elsif (addr.kind_of?(Integer))
-            packed_ip = addr
-        else
-            raise ArgumentError, "String or Integer expected for argument 'addr' but #{addr.class} provided."
-        end
-        
-        # validate options
-        if (options)     
-            raise ArgumentError, "Hash expected for argument 'options' but " +
-                                 "#{options.class} provided." if (!options.kind_of?(Hash) )
-            NetAddr.validate_args(options.keys,known_args)        
-        
-            if (options.has_key?(:PackedNetmask))
-                packed_netmask = options[:PackedNetmask]
-                raise ArgumentError, "Expected Integer, but #{packed_netmask.class} " +
-                                     "provided for option :PackedNetmask." if (!packed_netmask.kind_of?(Integer))
-            end    
-        
-            if (options.has_key?(:Tag))
-                @tag = options[:Tag]
-                if (!@tag.kind_of? Hash)
-                    raise ArgumentError, "Expected Hash, but #{@tag.class} provided for option :Tag."
-                end
-            end
-
-            if (options.has_key?(:WildcardMask))
-                if (!options[:WildcardMask].kind_of?(Array))
-                    raise ArgumentError, "Expected Array, but #{options[:WildcardMask].class} provided for option :WildcardMask."
-                end
-                wildcardmask = options[:WildcardMask][0]
-                inversed = false
-                inversed = true if (options[:WildcardMask][1] && options[:WildcardMask][1] == :inversed)
-
-                if (wildcardmask.kind_of?(Integer))
-                   begin
-                        @wildcard_mask = wildcardmask
-                        NetAddr.validate_ip_addr(@wildcard_mask, :Version => @version)
-                    rescue NetAddr::ValidationError
-                        raise NetAddr::ValidationError, ":WildcardMask must be a valid IPv#{@version} address."
-                    end 
-                else
-                    begin
-                        @wildcard_mask = NetAddr.pack_ip_addr(wildcardmask, :Version => @version)
-                    rescue NetAddr::ValidationError
-                        raise NetAddr::ValidationError, ":WildcardMask must be a valid IPv#{@version} address."
-                    end
-                end
-
-                @wildcard_mask = @wildcard_mask ^ @all_f if (inversed)
-            end
-        end
 
 
-        if (packed_ip)
-            # validate & store packed_ip
-            NetAddr.validate_ip_addr(packed_ip, :Version => @version)
-            @ip = packed_ip
-
-        else
-            # if ipv6 and extended netmask was provided, then raise exception
-            raise ArgumentError, "Garbage provided at end of IPv6 address." if (cidr =~ /.+\s+.+/ )
 
-            # get ip and netmask
-            if (cidr =~ /\//) 
-                ip,netmask = cidr.split(/\//)
-                if (!ip || !netmask)
-                    raise ArgumentError, "CIDR address is improperly formatted. Missing netmask after '/' character." 
-                end
-            else
-                ip = cidr
-            end
 
-            # pack ip
-            @ip = NetAddr.pack_ip_addr(ip, :Version => @version)
-        end
 
-        # if no netmask or packed_netmask, then set
-        # else validate. packed_netmask takes precedence over netmask
-        if (!netmask && !packed_netmask)
-            @netmask = @all_f
-        else
-            if (packed_netmask)
-                NetAddr.validate_ip_netmask(packed_netmask, :Packed => true, :Version => @version)
-                @netmask = packed_netmask
-            else
-                NetAddr.validate_ip_netmask(netmask, :Version => @version)
-                @netmask = NetAddr.pack_ip_netmask(netmask, :Version => @version)
-            end
-        end
 
-        # set @network & @hostmask
-        @network = (@ip & @netmask)
-        @hostmask = @netmask ^ @all_f
-        @wildcard_mask = @hostmask if (!@wildcard_mask)
 
-    end
 
+# IPv6 CIDR address - Inherits all methods from NetAddr::CIDR. 
+# Addresses of this class are composed of a 128-bit address space.
+class CIDRv6 < CIDR
+    public_class_method :new
 end # end class CIDRv6
 
 end # module NetAddr