ipadmin 0.2.1 → 0.2.2

data/lib/ip_admin.rb

@@ -4,3687 +4,8 @@
 =end
 
 
-module IPAdmin
+require File.join(File.dirname(__FILE__), 'methods.rb')
+require File.join(File.dirname(__FILE__), 'cidr.rb')
+require File.join(File.dirname(__FILE__), 'tree.rb')
 
-#==============================================================================#
-# arpa()
-#==============================================================================#
-
-# Using the provided IPAdmin::CIDR object, 
-# return either an in-addr.arpa. or ip6.arpa. string. The netmask will be used
-# to determine the length of the returned arpa string.
-#
-# - Arguments:
-#   * IPAdmin::CIDR object
-#
-# - Returns:
-#   * IP address in in-addr.arpa or ip6.arpa format
-#
-# Note:
-#   IPAdmin.arpa will use the original IP address passed during the initialization
-#   of the CIDR objects. This IP can be found using the CIDR.ip() method.
-#
-# Example:
-#   arpa = IPAdmin.arpa(cidr)
-#
-def arpa(object)
-
-    unless (object.kind_of? IPAdmin::CIDR)
-        raise ArgumentError, "Expected IPAdmin::CIDR object, " +
-                             "but #{object.class} provided."
-    end
-
-    base = object.ip()
-    netmask = object.bits()
-
-    if (object.version == 4)
-        net = base.split('.')
-
-        if (netmask)
-            while (netmask < 32)
-                net.pop
-                netmask = netmask + 8
-            end
-        end
-
-        arpa = net.reverse.join('.')
-        arpa << ".in-addr.arpa."
-
-    elsif (object.version == 6)
-        fields = base.split(':')
-        net = []
-        fields.each do |field|
-            (field.split("")).each do |x|
-                net.push(x)
-            end
-        end
-
-        if (netmask)
-            while (netmask < 128)
-                net.pop
-                netmask = netmask + 4
-            end
-        end
-
-        arpa = net.reverse.join('.')
-        arpa << ".ip6.arpa."
-
-    end
-
-    return(arpa)
-end
-module_function :arpa
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# compare()
-#==============================================================================#
-
-# Compare IPAdmin::CIDR or NetStruct objects, and determine if one
-# is the supernet of the other.
-#
-# - Arguments:
-#   * Two IPAdmin::CIDR or NetStruct objects
-#
-# - Returns:
-#   * if one object is a subnet of another, then return an array in order of
-#     [supernet,subnet]
-#   * if both are equal, return 1
-#   * if neither is a supernet of the other, return nil
-#
-# Example:
-#   supernet,subnet = IPAdmin.compare(cidr1,cidr2)
-#
-
-def compare(obj1,obj2)
-    ret_val = nil
-
-    # validate arguments
-    unless ( obj1.kind_of?(IPAdmin::CIDR) ||
-             obj1.kind_of?(IPAdmin::NetStruct) )
-        raise ArgumentError, "Expected IPAdmin::CIDR or NetStruct " +
-                             "as first argument, but #{obj1.class} provided."
-    end
-
-    unless ( obj2.kind_of?(IPAdmin::CIDR) ||
-             obj2.kind_of?(IPAdmin::NetStruct) )
-         raise ArgumentError, "Expected IPAdmin::CIDR or NetStruct " +
-                              "as second argument, but #{obj2.class} provided."
-    end
-
-    # make sure both are same version
-    unless (obj1.version == obj2.version )
-        raise "Provided objects are of different IP versions."
-    end
-
-
-    # get network/netmask of each
-    objects = [obj1,obj2]
-    networks = []
-    netmasks = []
-    for obj in objects
-        if ( obj.kind_of?(IPAdmin::CIDR) )
-            networks.push(obj.packed_network)
-            netmasks.push(obj.packed_netmask)
-
-        elsif ( obj.kind_of?(IPAdmin::NetStruct) )
-            networks.push(obj.network)
-            netmasks.push(obj.netmask)
-
-        end
-    end
-
-    # return 1's if objects are equal otherwise
-    # whichever netmask is smaller will be the supernet.
-    # if we '&' both networks by the supernet, and they are
-    # equal, then the supernet is the parent of the other network
-    if ( (networks[0] == networks[1]) && (netmasks[0] == netmasks[1]) )
-        ret_val = 1
-    elsif (netmasks[0] < netmasks[1])
-        if ( (netmasks[0] & networks[0]) == (netmasks[0] & networks[1]) )
-            ret_val = [obj1,obj2]
-        end
-    elsif (netmasks[1] < netmasks[0])
-        if ( (netmasks[1] & networks[0]) == (netmasks[1] & networks[1]) )
-            ret_val = [obj2,obj1]
-        end
-    end
-
-    return(ret_val)
-end
-module_function :compare
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# create_net_struct()
-#==============================================================================#
-
-# Create an IPAdmin::NetStruct object from an IPAdmin::CIDR or NetStruct object.
-# This type of Struct is used internally for various tasks, and is not likely
-# to be useful to anyone.
-#
-# - Arguments:
-#   * IPAdmin::CIDR or NetStruct object
-#
-# - Returns:
-#   * IPAdmin::NetStruct object
-#
-# Example:
-#   net_struct = IPAdmin.create_net_struct(object)
-#
-    def create_net_struct(object)
-
-        if ( object.kind_of?(IPAdmin::CIDR) )
-            network = object.packed_ip
-            netmask = object.packed_netmask
-
-        elsif ( object.kind_of?(IPAdmin::NetStruct) )
-            network = object.network
-            netmask = object.netmask
-        else
-            raise ArgumentError, "Expected IPAdmin::CIDR or NetStruct "+
-                                 "object, but #{object.class} provided."
-        end
-
-        version = object.version
-        net_struct = NetStruct.new(network,netmask,version,object,[])
-
-        return(net_struct)
-    end
-module_function :create_net_struct
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# merge()
-#==============================================================================#
-
-# Given a list of IPAdmin::CIDR or NetStruct objects 
-# merge (supernet) them in the most efficient way possible. Supernetting 
-# will only occur when the newly created supernet will not result in the 
-# 'creation' of additional space. For example the following blocks 
-# (192.168.0.0/24, 192.168.1.0/24, and 192.168.2.0/24) would merge into 
-# 192.168.0.0/23 and 192.168.2.0/24 rather than into 192.168.0.0/22 
-#
-# - Arguments:
-#   * Hash with the following fields:
-#       - :List -- Array of IPAdmin::CIDR or NetStruct objects
-#       - :NetStruct -- if true, return IPAdmin::NetStruct objects (optional)
-#       - :Objectify -- if true, return IPAdmin::CIDR objects (optional)
-#       - :Short -- if true, return IPv6 addresses in short-hand notation (optional)
-#
-# - Returns:
-#   * Array of IPAdmin::CIDR or IPAdmin::NetStruct objects
-#
-# Example:
-#   supernets = IPAdmin.merge(:List => list)
-#
-def merge(options)
-    version = nil
-    short = false
-    objectify = false
-
-    # validate options
-    unless ( options.kind_of?(Hash) )
-        raise ArgumentError, "Hash expected but #{options.class} provided."
-    end
-
-    unless (options[:List])
-        raise ArgumentError, "Missing argument: List."
-    end
-    
-    if (options[:Short])
-        short = true
-    end
-    
-    if (options[:Objectify])
-        objectify = true
-    end
-
-    list = options[:List]
-    ret_struct = 1 if (options[:NetStruct])
-
-    # make sure list is an array
-    unless ( list.kind_of?(Array) )
-        raise ArgumentError, "Expected Array for option :List, " +
-                             "but #{list.class} provided."
-    end
-
-    # make sure all are valid types of the same IP version
-    list.each do |obj|
-        unless (obj.kind_of?(IPAdmin::CIDR) || obj.kind_of?(IPAdmin::NetStruct) )
-            raise ArgumentError, "Expected IPAdmin::CIDR or NetStruct " +
-                                 "object but #{obj.class} provided."
-        end
-
-        version = obj.version if (!version)
-        unless (obj.version == version)
-            raise "Provided objects must be of the same IP version."
-        end 
-    end
-
-    # make all_f    
-    if (version == 4)
-        all_f = 2**32 - 1
-    else
-        all_f = 2**128 - 1
-    end
-
-    # make sure that our list is in order, and contains no duplicates
-    list = IPAdmin.sort(list)
-    index = 0
-    (list.length).times do
-        if ((index > 0)&&(IPAdmin.compare(list[index],list[index-1]) == 1))
-            list.delete_at(index)
-        else
-            index += 1
-        end
-    end
-
-    # create supernet_list from list
-    supernet_list = []
-    list.each do |obj|
-        if (obj.kind_of?(IPAdmin::CIDR))
-            supernet_list.push(IPAdmin.create_net_struct(obj))
-
-        elsif ( obj.kind_of?(IPAdmin::NetStruct) )
-            if (obj.subnets && obj.subnets.length > 0)
-                # get all child subnets of this branch entry
-                children = merge(:List => obj.subnets, :NetStruct => 1)
-
-                # if any child subnets are equal to the parent subnet
-                # then copy the grandchild subnets and delete the child
-                children.each do |child|
-                    if ( (obj.network == child.network) &&
-                         (obj.netmask == child.netmask) )
-                        if (child.subnets && child.subnets.length > 0)
-                            grandchildren = child.subnets
-                            children.concat(grandchildren)
-                        end
-                        children.delete(child)
-                        children =  IPAdmin.sort(children)
-                        break
-                    end
-                end
-
-                obj.subnets.clear
-                obj.subnets.concat(children)
-            end
-
-            supernet_list.push(obj)
-        end
-    end
-
-    # merge subnets of this new branch by removing them from 'supernet_list',
-    # and categorizing them into hash of arrays (key=netmask) 
-    # within each categorization we merge contiguous subnets
-    # and then remove them from that category & put them back into
-    # 'supernet_list'. we do this until our list stops getting any shorter
-    categories = {}
-    supernet_list_length = 0
-    until (supernet_list_length == supernet_list.length)
-        supernet_list_length = supernet_list.length
-
-        # categorize
-        supernet_list.each do |entry|
-            netmask = entry.netmask
-            if (categories.has_key?(netmask) )
-                (categories[netmask]).push(entry)
-            else
-                categories[netmask] = [entry]
-            end
-        end
-        supernet_list.clear
-
-        categories.each_key do |netmask|
-            entries = categories[netmask]
-            bitstep = (all_f + 1) - netmask
-
-            # this entire process depends on the list being in order
-            until (entries.length == 0)
-                to_merge = []
-                multiplier = 1
-                first = entries[0]
-                num_required = 2**multiplier
-                supermask = (netmask << multiplier) & all_f
-                supernet = supermask & first.network
-                if (first.network == supernet)
-                    # take first entry and use it to form a base
-                    # supernet address. this supernet should have
-                    # x number of subnets in it, so we look for
-                    # those subnets & if found store them
-                    expected = first.network
-                    entries.each do |entry|
-                        if ( (entry.network == expected) && (first.network == supernet) )
-                            to_merge.push(entry)
-                            expected = expected + bitstep
-                            if ( (to_merge.length == num_required) &&
-                                 (entries.length > num_required ) )
-                                multiplier += 1
-                                num_required = 2**multiplier
-                                supermask = (netmask << multiplier) & all_f
-                                supernet = supermask & first.network
-                            end
-                        else
-                            # if entry is a duplicate, then kill it
-                            if (IPAdmin.compare(entry,to_merge.last) == 1)
-                                entries.delete(entry)
-                            end
-                            break 
-                        end
-                    end
-                else
-                   to_merge.push(first)
-                end
-
-                # make sure we actually have all of our subnets
-                # create our new supernet
-                unless (to_merge.length == num_required)
-                    multiplier -= 1
-                    supermask = (netmask << multiplier) & all_f
-                    supernet = supermask & first.network
-                end
-                net_struct = NetStruct.new(supernet,supermask,version,nil,[])
-
-                # now that we have the child members of our new supernet
-                # take any grandchild subnets that they may have and 
-                # add them to the new supernet. then kill the children
-                (2**multiplier).times do
-                    to_kill = to_merge.shift
-                    net_struct.subnets.concat(to_kill.subnets) if (to_kill.subnets)
-                    entries.delete(to_kill)
-                end
-                supernet_list.push(net_struct)
-            end
-        end
-        categories.clear
-        supernet_list = IPAdmin.sort(supernet_list)
-    end
-
-    # if '!ret_struct', return CIDR's
-    if (!ret_struct)
-        supernets = []
-        supernet_list.each do |entry|
-            if (version == 4)
-                network = IPAdmin.unpack_ipv4_addr(entry.network)
-                netmask = IPAdmin.unpack_ipv4_netmask(entry.netmask)
-            else
-                network = IPAdmin.unpack_ipv6_addr(entry.network)
-                network = IPAdmin.shorten(network) if (short && !objectify)
-                netmask = IPAdmin.unpack_ipv6_netmask(entry.netmask)
-            end
-
-            if (!objectify)
-                supernets.push("#{network}/#{netmask}")
-            else
-                supernets.push(IPAdmin::CIDR.new(:CIDR => "#{network}/#{netmask}"))
-            end
-        end
-    else
-        supernets = supernet_list
-    end
-
-    return(supernets)
-end
-module_function :merge
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# pack_ipv4_addr()
-#==============================================================================#
-
-# Convert IPv4 addresses into an integer. No attempt at
-# validation is performed.
-#
-# - Arguments:
-#   * IPv4 address
-#
-# - Returns:
-#   * packed IPv4 address or exception on error.
-#
-# Example:
-#   packed = IPAdmin.pack_ipv4_addr('192.168.1.1')
-#
-def pack_ipv4_addr(ip)
-
-    # is this a string?
-    unless (ip.kind_of? String)
-        raise ArgumentError, "Expected String, but #{ip.class} provided."
-    end
-
-    # pack our ip
-    octets = ip.split( /\./ ).reverse
-    packed_ip = 0
-
-    (0..3).each do |x|
-        octets[x] = (octets[x]).to_i
-        octets[x] =  octets[x] << 8*x 
-        packed_ip = packed_ip | octets[x]
-    end
-
-    return(packed_ip)
-end
-module_function :pack_ipv4_addr
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# pack_ipv4_netmask()
-#==============================================================================#
-
-# Convert IPv4 netmask into an integer.  Only very basic
-# validation is performed.
-#
-# - Arguments:
-#   * IPv4 netmask in cidr or extended notation
-#
-# - Returns:
-#   * packed IPv4 netmask or exception on error.
-#
-# Example:
-#   packed = IPAdmin.pack_ipv4_netmask('255.255.255.0')
-#   packed = IPAdmin.pack_ipv4_netmask('24')
-#   packed = IPAdmin.pack_ipv4_netmask('/24')
-#   packed = IPAdmin.pack_ipv4_netmask(24)
-#
-def pack_ipv4_netmask(netmask)
-    all_f = 2**32-1
-
-    # is this a CIDR or Extended mask?
-    if(netmask =~ /\./)
-        # pack extended mask
-        begin
-            packed_netmask = pack_ipv4_addr(netmask)
-            rescue Exception 
-            raise "#{netmask} is not a valid IPv4 netmask."
-        end
-
-    else
-        # remove '/' if present
-        if (netmask =~ /^\// )
-            netmask[0] = " "
-            netmask.lstrip!
-        end
-
-        # check if we have any non numeric characters
-        if (netmask =~ /\D/)
-            raise "#{netmask} is not a valid IPv4 netmask."
-        end
-
-        if (netmask.kind_of? String)
-            netmask = netmask.to_i
-        end
-
-        packed_netmask = all_f ^ (all_f >> netmask)
-    end
-
-    return(packed_netmask)
-end
-module_function :pack_ipv4_netmask
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# pack_ipv6_addr()
-#==============================================================================#
-
-# Convert IPv6 addresses into an integer. No attempt at 
-# validation is performed.
-#
-# - Arguments:
-#   * IPv6 address
-#
-# - Returns:
-#   * packed IPv6 address or exception on error.
-#
-# Example:
-#   packed = IPAdmin.pack_ipv6_addr('fec0::1')
-#
-def pack_ipv6_addr(ip)
-    # is this a string?
-    unless (ip.kind_of? String)
-        raise ArgumentError, "Expected String, but #{ip.class} provided."
-    end
-
-    # look for a '::' to see if this address is in shorthand
-    # if found, split on it
-    hex_fields = []
-    if (ip =~ /::/)
-        shrthnd = ip.split( /::/ )
-        if (ip =~  /^::/)
-            sec_half = shrthnd[1].split( /:/ )
-            zero_pads = 8 - sec_half.length
-            (1..zero_pads).each {hex_fields.push('0')}
-            sec_half.each {|field| hex_fields.push(field)}
-        elsif (ip =~  /::$/)
-            hex_fields = shrthnd[0].split( /:/ )
-            zero_pads = 8 - hex_fields.length
-            (1..zero_pads).each {hex_fields.push('0')}
-        else
-            first_half = shrthnd[0].split( /:/ )
-            sec_half = shrthnd[1].split( /:/ )
-            zero_pads = 8 - (first_half.length + sec_half.length)
-            first_half.each {|field| hex_fields.push(field)}
-            (1..zero_pads).each {hex_fields.push('0')}
-            sec_half.each {|field| hex_fields.push(field)}
-        end
-
-    else
-        hex_fields = ip.split( /:/ )
-    end
-
-    # pack
-    hex_fields.reverse!
-    packed_ip = 0
-    (0..7).each do |x|
-        hex = hex_fields[x]
-        base16 = hex.to_i(16)
-
-        base16 =  base16 << 16*x 
-        packed_ip = packed_ip | base16
-    end
-
-
-    return(packed_ip)
-end
-module_function :pack_ipv6_addr
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# pack_ipv6_netmask()
-#==============================================================================#
-
-# Convert IPv6 netmask into an integer. Only very basic 
-# validation is performed.
-#
-# - Arguments:
-#   * IPv6 netmask in cidr notation
-#
-# - Returns:
-#   * packed IPv6 netmask or exception on error.
-#
-# Example:
-#   packed = IPAdmin.pack_ipv6_netmask('64')
-#   packed = IPAdmin.pack_ipv6_netmask('/64')
-#   packed = IPAdmin.pack_ipv6_netmask(64)
-#
-def pack_ipv6_netmask(netmask)
-    all_f = 2**128-1
-
-    # remove '/' if present
-    if (netmask =~ /^\// )
-        netmask[0] = " "
-        netmask.lstrip!
-    end
-
-    if (netmask !~ /\D/)   
-        # pack
-        if (netmask.kind_of? String)
-            netmask = netmask.to_i
-        end
-
-        packed_netmask = all_f ^ (all_f >> netmask)
-
-    else
-        raise "#{netmask} is not a valid IPv6 netmask."
-
-    end
-
-    return(packed_netmask)
-end
-module_function :pack_ipv6_netmask
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# range()
-#==============================================================================#
-
-# Given two IPAdmin::CIDR objects of the same version, return all IP
-# addresses between them (non-inclusive).
-#
-# - Arguments:
-#   * Hash with the following fields:
-#       - :Bitstep -- enumerate in X sized steps (optional)
-#       - :Boundaries -- array of (2) IPAdmin::CIDR objects
-#       - :Limit -- limit returned list to X number of items (optional)
-#       - :Objectify -- if true, return IPAdmin::CIDR objects (optional)
-#       - :Short -- if true, return IPv6 addresses in short-hand notation (optional)
-#
-# - Returns:
-#   * Array of IP addresses or IPAdmin::CIDR objects
-#
-# Note:
-#   IPAdmin.range will use the original IP address passed during the initialization
-#   of the CIDR objects. This IP can be found using the CIDR.ip() method.
-#
-# Example:
-#   list = IPAdmin.range(:Boundaries => [cidr1,cidr2])
-#
-def range(options)
-    list = []
-    bitstep = 1
-    objectify = false
-    short = false
-    limit = nil
-
-    # check options
-    if (options)
-        unless ( options.has_key?(:Boundaries) ) 
-            raise ArgumentError, "Missing argument: Boundaries."
-        end
-
-        if (options[:Boundaries].length == 2)
-            (cidr1,cidr2) = options[:Boundaries]
-        else
-            raise ArgumentError, "Two IPAdmin::CIDR ojects are required. " +
-                                 "as Boundaries."
-        end
-
-        if( options.has_key?(:Bitstep) )
-            bitstep = options[:Bitstep]
-        end
-
-        if( options.has_key?(:Objectify) )
-            objectify = true
-        end
-        
-        if( options.has_key?(:Short) )
-            short = true
-        end
-
-        if( options.has_key?(:Limit) )
-            limit = options[:Limit]
-        end
-    end
-
-    # check our objects
-    unless (cidr1.kind_of?(IPAdmin::CIDR) && cidr2.kind_of?(IPAdmin::CIDR))
-        raise "One or more values provided under :Boundaries "+
-              "is not a valid IPAdmin::CIDR object."
-    end
-
-    # check version, store & sort
-    if (cidr1.version == cidr2.version)
-        version = cidr1.version
-        boundaries = [cidr1.packed_ip, cidr2.packed_ip]
-        boundaries.sort
-    else
-        raise "Provided IPAdmin::CIDR objects are of different IP versions."
-    end
-
-    # dump our range
-    if (version == 4)
-        my_ip = boundaries[0] + 1
-
-        until (my_ip >= boundaries[1]) 
-            if (!objectify)
-                list.push( IPAdmin.unpack_ipv4_addr(my_ip) )
-            else
-                my_ip_s = IPAdmin.unpack_ipv4_addr(my_ip)
-                list.push( IPAdmin::CIDR.new(:CIDR => my_ip_s) )
-            end
-
-            my_ip = my_ip + bitstep
-            if (limit)
-                limit = limit -1
-                break if (limit == 0)
-            end
-        end
-
-    elsif (version == 6)
-        my_ip = boundaries[0] + 1
-
-        until (my_ip == boundaries[1])
-            if (!objectify)
-                my_ips = IPAdmin.unpack_ipv6_addr(my_ip)
-                my_ips = IPAdmin.shorten(my_ips) if (short)
-                list.push(my_ips)
-                
-            else
-                my_ip_s = IPAdmin.unpack_ipv6_addr(my_ip)
-                list.push( IPAdmin::CIDR.new(:CIDR => my_ip_s) )
-            end
-
-            my_ip = my_ip + bitstep
-            if (limit)
-                limit = limit -1
-                break if (limit == 0)
-            end
-        end
-    end
-
-    return(list)
-end
-module_function :range
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# shorten()
-#==============================================================================#
-
-# Take a standard IPv6 address, and format it in short-hand notation.
-# The address should not contain a netmask.
-#
-# - Arguments:
-#   * IPv6 address
-#
-# - Returns:
-#   * IPv6 short-hand address.
-#
-# Example:
-#   short = IPAdmin.shorten('fec0:0000:0000:0000:0000:0000:0000:0001')
-#
-def shorten(addr)
-
-    # is this a string?
-    unless (addr.kind_of? String)
-        raise ArgumentError, "Expected String, but #{addr.class} provided."
-    end
-
-    validate_ipv6_addr(addr)
-
-    # make sure this isnt already shorthand
-    if (addr =~ /::/)
-        return(addr)
-    end
-
-    # look for most consecutive '0' fields
-    start_field,end_field = nil,nil
-    start_end = []
-    consecutive,longest = 0,0
-    fields = addr.split(":")
-    
-    (0..(fields.length-1)).each do |x|
-        fields[x] = fields[x].to_i(16)
-
-        if (fields[x] == 0)
-            if (!start_field)
-                start_field = x
-                end_field = x
-            else
-                end_field = x
-            end
-            consecutive += 1
-        else
-            if (start_field)
-                if (consecutive > longest)
-                    longest = consecutive
-                    start_end = [start_field,end_field]
-                    start_field,end_field = nil,nil                    
-                end
-                consecutive = 0
-            end
-        end
-
-        fields[x] = fields[x].to_s(16)
-    end
-    
-    # if our longest set of 0's is at the end, then start & end fields
-    # are already set. if not, then make start & end fields the ones we've
-    # stored away in start_end
-    if (consecutive > longest) 
-        longest = consecutive
-    else
-        start_field = start_end[0]
-        end_field = start_end[1]
-    end
-
-    if (longest > 1)        
-        fields[start_field] = ''
-        start_field += 1
-        fields.slice!(start_field..end_field)
-    end
-    short = fields.join(':')
-    short << ':' if (short =~ /:$/)
-    
-    return(short)
-end
-module_function :shorten
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# sort()
-#==============================================================================#
-
-# Given a list of IPAdmin::CIDR or NetStruct objects
-# sort them from lowest to highest by Network/Netmask.
-#
-# - Arguments:
-#   * Array of IPAdmin::CIDR or NetStruct objects
-#
-# - Returns:
-#   * Sorted Array
-#
-# Note:
-#   IPAdmin.sort will use the original IP address passed during the initialization
-#   of the CIDR objects. This IP can be found using the CIDR.ip() method.
-#
-# Example:
-#   sorted = IPAdmin.sort(list)
-#
-def sort(list)
-
-    # make sure list is an array
-    unless ( list.kind_of?(Array) )
-        raise ArgumentError, "Array of IPAdmin::CIDR or NetStruct " +
-                             "objects expected, but #{list.class} provided."
-    end
-
-    # make sure all are valid types of the same IP version
-    version = nil
-    list.each do |obj|
-        unless (obj.kind_of?(IPAdmin::CIDR) || obj.kind_of?(IPAdmin::NetStruct) )
-            raise ArgumentError, "Expected IPAdmin::CIDR or NetStruct " +
-                                 "object but #{obj.class} provided."
-        end
-
-        version = obj.version if (!version)
-        unless (obj.version == version)
-            raise "Provided objects must all be of the same IP version."
-        end 
-    end
-
-    # create unsorted_list from list
-    unsorted_list = []
-    list.each do |obj|
-        unsorted_list.push(IPAdmin.create_net_struct(obj))
-    end
-
-    # sort by network. if networks are equal, sort by netmask.
-    sorted_list = []
-    unsorted_list.each do |entry|
-        index = 0
-        sorted_list.each do
-            if(entry.network < (sorted_list[index]).network)
-                break
-            elsif (entry.network == (sorted_list[index]).network)
-                if (entry.netmask < (sorted_list[index]).netmask)
-                    break
-                end
-            end
-            index += 1
-        end
-        sorted_list.insert(index, entry)
-    end
-
-    # replace sorted_list entries with their .object
-    index = 0
-    sorted_list.length.times do
-        sorted_list[index] = (sorted_list[index]).object
-        index += 1
-    end
-
-    return(sorted_list)
-end
-module_function :sort
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# unpack_ipv4_addr()
-#==============================================================================#
-
-# Unack a packed IPv4 address back into a printable string. No attempt at
-# validation is performed.
-#
-# - Arguments:
-#   * Byte-packed IPv4 address
-#
-# - Returns:
-#   * IPv4 address.
-#
-# Example:
-#   unpacked = IPAdmin.unpack_ipv4_addr(packed)
-#
-def unpack_ipv4_addr(packed_ip)
-    octets = []
-    (0..3).each do |x|
-        octets[x] = packed_ip & 0xFF
-        octets[x] = (octets[x]).to_s
-        packed_ip = packed_ip >> 8
-    end
-
-    octets.reverse!
-    ip = octets.join('.')
-
-    return(ip)
-end
-module_function :unpack_ipv4_addr 
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# unpack_ipv4_netmask()
-#==============================================================================#
-
-# Unack a packed IPv4 netmask into a integer representing the number of
-# bits in the CIDR mask. No attempt at validation is performed.
-#
-# - Arguments:
-#   * Byte-packed IPv4 netmask
-#
-# - Returns:
-#   * IPv4 netmask as number of bits (cidr format).
-#
-# Example:
-#   unpacked = IPAdmin.unpack_ipv4_netmask(packed)
-#
-def unpack_ipv4_netmask(packed_mask)
-    mask = 32
-    32.times do    
-        if ( (packed_mask & 1) != 0)
-            break
-        end
-        packed_mask = packed_mask >> 1
-        mask = mask - 1
-    end
-
-    return(mask)
-end
-module_function :unpack_ipv4_netmask 
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# unpack_ipv6_addr()
-#==============================================================================#
-
-# Unack a packed IPv6 address back into a printable string. No attempt at 
-# validation is performed.
-#
-# - Arguments:
-#   * Byte-packed IPv6 address
-#
-# - Returns:
-#   * IPv6 address.
-#
-# Example:
-#   unpacked = IPAdmin.unpack_ipv6_addr(packed)
-#
-def unpack_ipv6_addr(packed_ip)
-    hex_fields = []
-    (0..7).each do |x|
-        hex_fields[x] = packed_ip & 0xFFFF
-        hex_fields[x] = (hex_fields[x]).to_s(16)
-        packed_ip = packed_ip >> 16
-
-        # if hex_fields[x] < 4 characters, then pad with 0's
-        (4 - hex_fields[x].length).times do
-            hex_fields[x] = '0' << hex_fields[x]
-        end
-    end
-
-    hex_fields.reverse!
-    ip = hex_fields.join(':')
-
-    return(ip)
-end
-module_function :unpack_ipv6_addr 
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# unpack_ipv6_netmask()
-#==============================================================================#
-
-# Unack a packed IPv6 netmask into a integer representing the number of
-# bits in the CIDR mask. No attempt at validation is performed.
-#
-# - Arguments:
-#   * Byte-packed IPv6 netmask
-#
-# - Returns:
-#   * IPv6 netmask as number of bits (cidr format).
-#
-# Example:
-#   unpacked = IPAdmin.unpack_ipv6_netmask(packed)
-#
-def unpack_ipv6_netmask(packed_mask)
-
-    mask = 128
-    128.times do
-        if ( (packed_mask & 1) == 1)
-            break
-        end
-        mask = mask - 1
-        packed_mask = packed_mask >> 1
-    end
-
-    return(mask)
-end
-module_function :unpack_ipv6_netmask 
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# unshorten()
-#==============================================================================#
-
-# Take an IPv6 address in short-hand format, and expand it into standard
-# notation. The address should not contain a netmask.
-#
-# - Arguments:
-#   * IPv6 address
-#
-# - Returns:
-#   * IPv6 short-hand address.
-#
-# Example:
-#   long = IPAdmin.unshorten('fec0::1')
-#
-def unshorten(addr)
-
-    # is this a string?
-    unless (addr.kind_of? String)
-        raise ArgumentError, "Expected String, but #{addr.class} provided."
-    end
-
-    packed = validate_ipv6_addr(addr)
-    long = unpack_ipv6_addr(packed)
-
-    return(long)
-end
-module_function :unshorten
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# validate_ipv4_addr()
-#==============================================================================#
-
-# Validate IPv4 addresses. The address should not contain a netmask.
-#
-# - Arguments:
-#   * IPv4 address
-#
-# - Returns:
-#   * packed IP on valid, or exception on error.
-#
-# Example:
-#   IPAdmin.validate_ipv4_addr('192.168.1.1')
-#
-def validate_ipv4_addr(ip)
-
-    # is this a string?
-    unless (ip.kind_of? String)
-        raise ArgumentError, "Expected String, but #{ip.class} provided."
-    end
-
-    # check validity of characters in the addr
-    if ( (ip =~ /\.{2,}?/ ) || (ip =~ /[^0-9\.]/) )
-        raise "#{ip} is not a valid IPv4 address."
-    end
-
-    # do we have 4 octets?
-    octets = ip.split( /\./ ).reverse
-    if (octets.length != 4)
-        raise "#{ip} is not a valid IPv4 address."
-    end
-
-    # are octets in range 0..255?
-    packed_ip = 0
-    (0..3).each do |x|
-        octets[x] = octets[x].to_i
-        unless ( (octets[x] >= 0) && (octets[x] < 256 ) )
-            raise "#{ip} is not a valid IPv4 address." 
-        end
-        octets[x] =  octets[x] << 8*x 
-        packed_ip = packed_ip | octets[x]
-    end
-
-    # dont allow first octet to be 0
-    if (octets[3] == 0)
-        raise "#{ip} is not a valid IPv4 address." 
-    end
-
-    return(packed_ip)
-
-end
-module_function :validate_ipv4_addr
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# validate_ipv4_netmask()
-#==============================================================================#
-
-# Validate IPv4 Netmask.
-#
-# - Arguments:
-#   * IPv4 netmask in cidr or extended notation
-#
-# - Returns:
-#   * packed netmask on valid, or exception on error.
-#
-# Example:
-#   IPAdmin.validate_ipv4_netmask('255.255.255.0')
-#   IPAdmin.validate_ipv4_netmask('24')
-#   IPAdmin.validate_ipv4_netmask('/24')
-#   IPAdmin.validate_ipv4_netmask(24)
-#
-def validate_ipv4_netmask(netmask)
-    all_f = 2**32 - 1
-    packed_mask = nil
-
-    # is this a CIDR or Extended mask?
-    if(netmask =~ /\./)
-        # validate & pack extended mask
-        begin
-            validate_ipv4_addr(netmask)
-            packed_netmask = pack_ipv4_addr(netmask)
-
-            rescue Exception 
-            raise "#{netmask} is not a valid IPv4 netmask."
-        end
-
-        # cycle through the bits of hostmask and compare
-        # with packed_mask. when we hit the firt '1' within
-        # packed_mask (our netmask boundary), xor hostmask and
-        # packed_mask. the result should be all 1's. this whole
-        # process is in place to make sure that we dont have
-        # and crazy masks such as 255.254.255.0
-        hostmask = 1
-        32.times do 
-            check = packed_netmask & hostmask
-            if ( check != 0)
-                hostmask = hostmask >> 1
-                unless ( (packed_netmask ^ hostmask) == all_f)
-                    raise "#{netmask} is not a valid IPv4 netmask." 
-                end
-                break
-            else
-                hostmask = hostmask << 1
-                hostmask = hostmask | 1
-            end
-        end
-
-    else
-        # remove '/' if present
-        if (netmask =~ /^\// )
-            netmask[0] = " "
-            netmask.lstrip!
-        end
-
-        # check if we have any non numeric characters
-        if (netmask =~ /\D/)
-            raise "#{netmask} is not a valid IPv4 netmask."
-        end
-
-        # are we between 1 and 32 inclusive
-        if (netmask.kind_of? String)
-            netmask = netmask.to_i
-        end
-
-        if ( (netmask > 32) || (netmask == 0) )
-            raise "#{netmask} is not a valid IPv4 netmask." 
-        end
-
-        packed_netmask = all_f ^ (all_f >> netmask)
-    end
-
-    return(packed_netmask)
-end
-module_function :validate_ipv4_netmask
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# validate_ipv6_addr()
-#==============================================================================#
-
-# Validate IPv6 addresses. The address should not contain a netmask.
-#
-# - Arguments:
-#   * IPv6 address
-#
-# - Returns:
-#   * packed IP on valid, or exception on error.
-#
-# Example:
-#   IPAdmin.validate_ipv6_addr('fec0::')
-#
-def validate_ipv6_addr(ip)
-    # is this a string?
-    unless (ip.kind_of? String)
-        raise ArgumentError, "Expected String, but #{ip.class} provided."
-    end
-
-    # check validity of characters in the addr
-    if ( (ip =~ /:{3,}?/ ) || (ip =~ /[^0-9a-fA-F:]/) )
-        raise "#{ip} is not a valid IPv6 address."
-    end
-
-    # look for a '::' to see if this address is in shorthand
-    # if found, split on it & make sure that we have at most
-    # two elements
-    if (ip =~ /::/)
-        shrthnd = ip.split( /::/ ) 
-        unless ( (shrthnd.length > 0) && (shrthnd.length < 3) )
-            raise "#{ip} is not a valid IPv6 address."
-        end
-    end
-
-    if (shrthnd)
-        # if shorthand, we should have between 1 and 7
-        # hex fields
-        hex_fields = []
-        shrthnd.each do |x|
-            elements = x.split( /:/ )
-            elements.each {|x| hex_fields.push(x)}
-        end
-        if ( (hex_fields.length < 1) || (hex_fields.length > 7) )
-            raise "#{ip} is not a valid IPv6 address."
-        end
-
-     else
-        # since no shorthand notation was detected we should
-        # have exactly 8 hex fields
-        hex_fields = ip.split( /:/ )
-        if (hex_fields.length != 8)
-            raise "#{ip} is not a valid IPv6 address."
-        end
-
-    end
-
-    # check that we have no more than 4 characters in each 
-    # hex field
-    hex_fields.each do |x|
-        if (x.length > 4)
-            raise "#{ip} is not a valid IPv6 address."
-        end
-    end
-
-    packed_ip = IPAdmin.pack_ipv6_addr(ip)
-    return(packed_ip)
-end
-module_function :validate_ipv6_addr
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# validate_ipv6_netmask()
-#==============================================================================#
-
-# Validate IPv6 netmask.
-#
-# - Arguments:
-#   * IPv6 netmask in cidr notation
-#
-# - Returns:
-#   * packed netmask on valid, or exception on error.
-#
-# Example:
-#   IPAdmin.validate_ipv6_netmask('64')
-#   IPAdmin.validate_ipv6_netmask('/64')
-#   IPAdmin.validate_ipv6_netmask(64)
-#
-def validate_ipv6_netmask(netmask)
-    all_f = 2**128 -1
-
-    # remove '/' if present
-    if (netmask =~ /^\// )
-        netmask[0] = " "
-        netmask.lstrip!
-    end
-
-    if (netmask =~ /\D/)
-        raise "#{netmask} is not a valid IPv6 netmask."
-
-    else
-        # are we between 1 and 128 inclusive
-        if (netmask.kind_of? String)
-            netmask = netmask.to_i
-        end
-
-        if ( (netmask > 128) || (netmask == 0) )
-            raise "#{netmask} is not a valid IPv6 netmask." 
-        end
-
-    end
-
-    packed_netmask = all_f ^ (all_f >> netmask)
-    return(packed_netmask)
-end
-module_function :validate_ipv6_netmask
-
-#======================================#
-#
-#======================================#
-
-
-#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++#
-#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++#
-#
-#  BEGIN class CIDR
-#
-#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++#
-#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++#
-
-=begin rdoc
- A class & series of methods for creating and manipulating CIDR network
- addresses. Both IPv4 and IPv6 are supported.
- 
- This class accepts a CIDR address in (x.x.x.x/yy or xxxx::/yy) format for
- IPv4 and IPv6, or (x.x.x.x/y.y.y.y) for IPv4. An optional tag hash may be 
- provided with each CIDR as a way of adding custom labels to the object.
- 
- Upon initialization, the IP version is auto-detected and assigned to the 
- object. The original IP/Netmask passed within the CIDR is stored and then 
- used to determine the confines of the CIDR block. Various properties of the
- CIDR block are accessible via several different methods. There are also
- methods for modifying the CIDR or creating new derivative CIDR's.
- 
- An example CIDR object is as follows:
-    IPAdmin::CIDR.new(:CIDR => '192.168.1.20/24')
- 
- This would create a CIDR object (192.168.1.0/24) with the following properties:
-    version = 4
-    base network = 192.168.1.0
-    ip address = 192.168.1.20
-    netmask = /24 (255.255.255.0)
-    size = 256 IP addresses
-    broadcast = 192.168.1.255
-    
- You can see how the CIDR object is based around the entire IP space
- defined by the provided IP/Netmask pair, and not necessarily the individual
- IP address itself.
-=end
-
-class CIDR
-
-# instance variables
-# @all_f
-# @hostmask
-# @ip
-# @max_bits 
-# @netmask
-# @network
-# @tag
-# @version
-
-#==============================================================================#
-# attr_reader/attr_writer
-#==============================================================================#
-
-    # IP version 4 or 6.
-    attr_reader :version
-
-    # Hash of custom tags. Should be in the format tag => value.
-    attr_reader :tag
-
-    # 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
-    #
-    def tag=(new_tag)
-        unless (new_tag.kind_of? Hash)
-            raise ArgumentError, "Expected Hash, but #{new_tag.class} provided."
-        end
-        @tag = new_tag
-    end
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# initialize()
-#==============================================================================#
-
-# - Arguments:
-#   * Hash with the following fields:
-#       - :CIDR -- IPv4 or IPv6 cidr block
-#       - :Netmask -- IPv4 netmask in extended format (optional)
-#       - :Tag -- Custom descriptor tag. Hash, tag => value. (optional)
-#
-# Note:
-#   Will assume a host address (/32 or /128) if netmask not specified
-#   as either part of the :CIDR or :Netmask arguments.
-#
-# Example:
-#   cidr4 = IPAdmin::CIDR.new(:CIDR => '192.168.1.1/24')
-#   cidr6 = IPAdmin::CIDR.new(:CIDR => 'fec0::/64',
-#                             :Tag => {'interface' => 'g0/1'})
-#
-#
-    def initialize(options)
-        unless (options.kind_of? Hash)
-            raise ArgumentError, "Expected Hash, but #{options.class} provided."
-        end
-
-        unless ( options.has_key?(:CIDR) )
-            raise ArgumentError, "Missing argument: CIDR."
-        end
-
-        cidr =  options[:CIDR]
-
-        if (cidr =~/\./) # assume IPv4
-            @version = 4
-            @max_bits = 32
-            @all_f = 2**@max_bits - 1
-
-            if (cidr =~ /\//)
-                ip,netmask = cidr.split(/\//)
-
-                # validate
-                @ip = IPAdmin.validate_ipv4_addr(ip)
-                @netmask = IPAdmin.validate_ipv4_netmask(netmask)
-
-            elsif ( options.has_key?(:Netmask) )
-                netmask = options[:Netmask]
-
-                # validate
-                @ip = IPAdmin.validate_ipv4_addr(cidr)
-                @netmask = IPAdmin.validate_ipv4_netmask(netmask)
-
-            else
-                @ip = IPAdmin.validate_ipv4_addr(cidr)
-                @netmask = IPAdmin.pack_ipv4_netmask(32) 
-
-            end
-
-            @hostmask = @netmask ^ @all_f
-
-        elsif (cidr =~/:/) # assume IPv6
-            @version = 6
-            @max_bits = 128
-            @all_f = 2**@max_bits - 1
-
-            if (cidr =~ /\//)
-                ip,netmask = cidr.split(/\//)
-
-                # validate
-                @ip = IPAdmin.validate_ipv6_addr(ip)
-                @netmask = IPAdmin.validate_ipv6_netmask(netmask)
-
-            else
-                @ip = IPAdmin.validate_ipv6_addr(cidr)
-                @netmask = IPAdmin.pack_ipv6_netmask(128)
-
-            end
-
-            @hostmask = @netmask ^ @all_f
-
-        else
-            raise "Invalid CIDR address format: #{cidr}."
-        end
-
-        # get @network
-        @network = (@ip & @netmask)
-
-        # set tag if present
-        if ( options.has_key?(:Tag) )
-            @tag = options[:Tag]
-            unless (@tag.kind_of? Hash)
-                raise "Expected Hash, but #{@tag.class} provided for option :Tag."
-            end
-        end
-
-    end
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# bits()
-#==============================================================================#
-
-# Provide number of bits in Netmask.
-#
-# - Arguments:
-#   * none
-#
-# - Returns:
-#   * Number of bits in Netmask.
-#
-# Example:
-#   puts cidr4.bits()   --> 24
-#
-    def bits()
-        if (@version == 4)
-            bits = IPAdmin.unpack_ipv4_netmask(@netmask)
-        else
-            bits = IPAdmin.unpack_ipv6_netmask(@netmask)
-        end
-
-        return(bits)
-    end
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# contains?()
-#==============================================================================#
-
-# Determines if this object contains (is supernet of)
-# provided IPAdmin::CIDR object.
-#
-# - Arguments:
-#   * IPAdmin:CIDR object
-#
-# - Returns:
-#   * true or false
-#
-# Example:
-#   cidr4_2 = IPAdmin::CIDR.new(:CIDR => '192.168.1.0/26')
-#   contains? = cidr4.contains(cidr4_2)   --> true
-#
-    def contains?(object)
-        is_contained = false
-
-        if (object.kind_of?(IPAdmin::CIDR))
-            network = object.packed_network 
-            netmask = object.packed_netmask
-
-        else 
-            raise ArgumentError, "Expected IPAdmin::CIDR " +
-                                 " object but #{object.class} provided."
-        end
-
-
-        unless (object.version == @version)
-            raise "Attempted to compare a version #{object.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)
-            is_contained = true if (netmask > @netmask)
-
-        else
-            if ( (network | @hostmask) == (@network | @hostmask) )
-                is_contained = true
-            end
-        end
-
-        return(is_contained)
-    end
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# desc()
-#==============================================================================#
-
-# Displays base network, and netmask of this object.
-#
-# - Arguments:
-#   * Optional hash with the following fields:
-#       - :IP -- true, return the ip/netmask passed during initialization (optional)
-#       - :Short -- if true, return IPv6 addresses in short-hand notation (optional)
-#
-# - Returns:
-#   * Description in network/netmask format
-#
-# Example:
-#   puts cidr4.desc()   --> 192.168.1.0/24
-#   puts cidr4.desc(:IP => 1)   --> 192.168.1.1/24
-#
-    def desc(options=nil)
-        short = false
-        orig_ip = false
-
-        if (options)
-            unless (options.kind_of? Hash)
-                raise ArgumentError, "Expected Hash, but #{options.class} provided."
-            end
-            
-            if (options.has_key?(:Short))
-                short = true
-            end
-            
-            if (options.has_key?(:IP))
-                orig_ip = true
-            end
-        end
-        
-        if (@version == 4)
-            if (!orig_ip)
-                ip = IPAdmin.unpack_ipv4_addr(@network)
-            else
-                ip = IPAdmin.unpack_ipv4_addr(@ip)
-            end
-            mask = IPAdmin.unpack_ipv4_netmask(@netmask)
-        else
-            if (!orig_ip)
-                ip = IPAdmin.unpack_ipv6_addr(@network)
-            else
-                ip = IPAdmin.unpack_ipv6_addr(@ip)
-            end
-            ip = IPAdmin.shorten(ip) if (short)
-            mask = IPAdmin.unpack_ipv6_netmask(@netmask)
-        end
-
-        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 (optional)
-#       - :Limit -- limit returned list to X number of items (optional)
-#       - :Objectify -- if true, return IPAdmin::CIDR objects (optional)
-#       - :Short -- if true, return IPv6 addresses in short-hand notation (optional)
-#
-# - Returns:
-#   * Array of IP addresses or IPAdmin::CIDR objects
-#
-# Example:
-#   ip_list = cidr4.enumerate(:Bitstep => 2, :Limit => 2)   --> ['192.168.1.0','192.168.1.1']
-#
-    def enumerate(options=nil)
-        bitstep = 1
-        objectify = false
-        limit = nil
-        short = false
-
-        if (options)
-            if( options.has_key?(:Bitstep) )
-                bitstep = options[:Bitstep]
-            end
-
-            if( options.has_key?(:Objectify) )
-                objectify = true
-            end
-
-            if( options.has_key?(:Limit) )
-                limit = options[:Limit]
-            end
-            
-            if( options.has_key?(:Short) )
-                short = true
-            end
-        end
-
-        list = []
-        if (@version == 4)
-            my_ip = @network
-            change_mask = @hostmask | my_ip
-
-            until ( change_mask != (@hostmask | @network) ) 
-                if (!objectify)
-                    list.push( IPAdmin.unpack_ipv4_addr(my_ip) )
-                else
-                    my_ip_s = IPAdmin.unpack_ipv4_addr(my_ip)
-                    list.push( IPAdmin::CIDR.new(:CIDR => my_ip_s) )
-                end
-                my_ip = my_ip + bitstep
-                change_mask = @hostmask | my_ip
-                if (limit)
-                    limit = limit -1
-                    break if (limit == 0)
-                end
-            end
-
-        elsif (@version == 6)
-            my_ip = @network
-            change_mask = @hostmask | my_ip
-
-            until ( change_mask != (@hostmask | @network) )                
-                if (!objectify)
-                    my_ip_s = IPAdmin.unpack_ipv6_addr(my_ip)
-                    my_ip_s = IPAdmin.shorten(my_ip_s) if (short)
-                    list.push(my_ip_s)
-                else
-                    my_ip_s = IPAdmin.unpack_ipv6_addr(my_ip)
-                    list.push( IPAdmin::CIDR.new(:CIDR => my_ip_s) )
-                end
-                my_ip = my_ip + bitstep
-                change_mask = @hostmask | my_ip
-                if (limit)
-                    limit = limit -1
-                    break if (limit == 0)
-                end
-            end
-
-        else
-            list = nil
-
-        end
-
-        return(list)
-    end
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# hostmask_ext()
-#==============================================================================#
-
-# Provide IPv4 Hostmask in extended format.
-#
-# - Arguments:
-#   * none
-#
-# - Returns:
-#   * Hostmask in extended (y.y.y.y) format.
-#
-# Example:
-#   puts cidr4.hostmask_ext()   --> 0.0.0.255
-#
-    def hostmask_ext()
-        if (@version == 4)
-            hostmask = IPAdmin.unpack_ipv4_addr(@hostmask)
-        else
-            raise "IPv6 does not support extended hostmask notation." 
-        end
-
-        return(hostmask)
-    end
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# ip()
-#==============================================================================#
-
-# Provide original IP address passed during initialization.
-#
-# - Arguments:
-#   * Optional Hash with the following fields:
-#       - :Objectify -- if true, return IPAdmin::CIDR object (optional)
-#       - :Short -- if true, return IPv6 addresses in short-hand notation (optional)
-#
-# - Returns:
-#   * IP address or IPAdmin::CIDR object.
-#
-# Example:
-#   puts cidr4.ip()   --> 192.168.1.1
-#
-    def ip(options=nil)
-        objectify = false
-        short = false
-        
-        if (options)
-            unless(options.kind_of?(Hash))
-                raise Argumenterror, "Expected Hash, but " +
-                                     "#{options.class} provided."
-            end
-            
-            if( options.has_key?(:Short) )
-                short = true
-            end
-            
-            if( options.has_key?(:Objectify) )
-                objectify = true
-            end
-        end
-
-        if (@version == 4)
-            ip = IPAdmin.unpack_ipv4_addr(@ip)
-        else
-            ip = IPAdmin.unpack_ipv6_addr(@ip)
-            ip = IPAdmin.shorten(ip) if (short && !objectify)
-        end
-        
-        if (objectify)
-            ip = IPAdmin::CIDR.new(:CIDR => ip)
-        end
-
-        return(ip)
-    end
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# last()
-#==============================================================================#
-
-# Provide last IP address in this CIDR object. The broadcast() method is
-# aliased to this method, and thus works for IPv6 despite the fact that the
-# IPv6 protocol does not support IP broadcasting.
-#
-# - Arguments:
-#   * Optional Hash with the following fields:
-#       - :Objectify -- if true, return IPAdmin::CIDR object (optional)
-#       - :Short -- if true, return IPv6 addresses in short-hand notation (optional)
-#
-# - Returns:
-#   * IP address or IPAdmin::CIDR object.
-#
-# Example:
-#   puts cidr4.last()   --> 192.168.1.255
-#
-    def last(options=nil)
-        objectify = false
-        short = false
-        
-        if (options)
-            unless(options.kind_of?(Hash))
-                raise Argumenterror, "Expected Hash, but " +
-                                     "#{options.class} provided."
-            end
-            
-            if( options.has_key?(:Short) )
-                short = true
-            end
-            
-            if( options.has_key?(:Objectify) )
-                objectify = true
-            end
-
-        end
-        
-        packed_ip = @network | @hostmask
-        if (@version == 4)
-            ip = IPAdmin.unpack_ipv4_addr(packed_ip)
-        else
-            ip = IPAdmin.unpack_ipv6_addr(packed_ip)
-            ip = IPAdmin.shorten(ip) if (short && !objectify)
-        end
-        
-        if (objectify)
-            ip = IPAdmin::CIDR.new(:CIDR => ip)
-        end
-
-        return(ip)
-    end
-    
-    alias :broadcast :last
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# netmask()
-#==============================================================================#
-
-# Provide netmask in cidr format.
-#
-# - Arguments:
-#   * none
-#
-# - Returns:
-#   * Netmask in CIDR format.
-#
-# Example:
-#   puts cidr4.netmask()   --> /24
-#
-    def netmask()
-        if (@version == 4)
-            bits = IPAdmin.unpack_ipv4_netmask(@netmask)
-        else
-            bits = IPAdmin.unpack_ipv6_netmask(@netmask)
-        end
-
-        return("/#{bits}")
-    end
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# netmask_ext()
-#==============================================================================#
-
-# Provide IPv4 netmask in extended format.
-#
-# - Arguments:
-#   * none
-#
-# - Returns:
-#   * Netmask in extended (y.y.y.y) format.
-#
-# Example:
-#   puts cidr4.netmask_ext()   --> 255.255.255.0
-#
-    def netmask_ext()    
-        if (@version == 4)
-            netmask = IPAdmin.unpack_ipv4_addr(@netmask)
-        else
-            raise "IPv6 does not support extended netmask notation. " +
-                  "Use netmask() method instead."
-        end
-
-        return(netmask)
-    end
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# network()
-#==============================================================================#
-
-# Provide base network address.
-#
-# - Arguments:
-#   * Optional Hash with the following fields:
-#       - :Objectify -- if true, return IPAdmin::CIDR object (optional)
-#       - :Short -- if true, return IPv6 addresses in short-hand notation (optional)
-#
-# - Returns:
-#   * IP address or IPAdmin::CIDR object.
-#
-# Example:
-#   puts cidr4.network()   --> 192.168.1.0
-#
-    def network(options=nil)
-        objectify = false
-        short = false
-        
-        if (options)
-            unless(options.kind_of?(Hash))
-                raise Argumenterror, "Expected Hash, but " +
-                                     "#{options.class} provided."
-            end
-            
-            if( options.has_key?(:Short) )
-                short = true
-            end
-            
-            if( options.has_key?(:Objectify) )
-                objectify = true
-            end
-        end
-
-        if (@version == 4)
-            ip = IPAdmin.unpack_ipv4_addr(@network)
-        else
-            ip = IPAdmin.unpack_ipv6_addr(@network)
-            ip = IPAdmin.shorten(ip) if (short && !objectify)
-        end
-        
-        if (objectify)
-            ip = IPAdmin::CIDR.new(:CIDR => ip)
-        end
-
-        return(ip)
-    end
-
-    alias :base :network
-    alias :first :network
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# next_ip()
-#==============================================================================#
-
-# Provide the next IP following the last available IP within this 
-# CIDR object. 
-#
-# - Arguments:
-#   * Optional Hash with the following fields:
-#       - :Bitstep -- step in X sized steps (optional)
-#       - :Objectify -- if true, return IPAdmin::CIDR object (optional)
-#       - :Short -- if true, return IPv6 addresses in short-hand notation (optional)
-#
-# - Returns:
-#   * IP address or IPAdmin::CIDR object.
-#
-# Example:
-#   puts cidr4.next_ip()   --> 192.168.2.0
-#
-    def next_ip(options=nil)
-        bitstep = 1
-        objectify = false
-        short = false
-        
-        if (options)
-            unless(options.kind_of?(Hash))
-                raise Argumenterror, "Expected Hash, but " +
-                                     "#{options.class} provided."
-            end
-            
-            if( options.has_key?(:Bitstep) )
-                bitstep = options[:Bitstep]
-            end
-            
-            if( options.has_key?(:Short) )
-                short = true
-            end
-        
-            if( options.has_key?(:Objectify) )
-                objectify = true
-            end
-        end
-        
-        next_ip = @network + @hostmask + bitstep
-        
-        unless (next_ip <= @all_f)
-            raise "Returned IP is out of bounds for IPv#{@version}."
-        end
-
-        if (@version == 4)
-            next_ip = IPAdmin.unpack_ipv4_addr(next_ip)
-        else
-            next_ip = IPAdmin.unpack_ipv6_addr(next_ip)
-            next_ip = IPAdmin.shorten(next_ip) if (short && !objectify)
-        end
-        
-        if (objectify)
-            next_ip = IPAdmin::CIDR.new(:CIDR => next_ip)
-        end
-        
-        return(next_ip)
-    end
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# next_subnet()
-#==============================================================================#
-
-# Provide the next subnet following this CIDR object. The next subnet will
-# be of the same size as the current CIDR object. 
-#
-# - Arguments:
-#   * Optional Hash with the following fields:
-#       - :Bitstep -- step in X sized steps. (optional)
-#       - :Objectify -- if true, return IPAdmin::CIDR object (optional)
-#       - :Short -- if true, return IPv6 addresses in short-hand notation (optional)
-#
-# - Returns:
-#   * CIDR address or IPAdmin::CIDR object.
-#
-# Example:
-#   puts cidr4.next_subnet()   --> 192.168.2.0/24
-#
-    def next_subnet(options=nil)
-        bitstep = 1
-        objectify = false
-        short = false
-        
-        if (options)
-            unless(options.kind_of?(Hash))
-                raise Argumenterror, "Expected Hash, but " +
-                                     "#{options.class} provided."
-            end
-            
-            if( options.has_key?(:Bitstep) )
-                bitstep = options[:Bitstep]
-            end
-            
-            if( options.has_key?(:Short) )
-                short = true
-            end
-        
-            if( options.has_key?(:Objectify) )
-                objectify = true
-            end
-        end
-        
-        bitstep = bitstep * (2**(@max_bits - self.bits) )
-        next_sub = @network + bitstep
-        
-        unless (next_sub <= @all_f)
-            raise "Returned subnet is out of bounds for IPv#{@version}."
-        end
-
-        if (@version == 4)
-            next_sub = IPAdmin.unpack_ipv4_addr(next_sub)
-        else
-            next_sub = IPAdmin.unpack_ipv6_addr(next_sub)
-            next_sub = IPAdmin.shorten(next_sub) if (short && !objectify)
-        end
-        
-        next_sub = next_sub << "/" << self.bits.to_s        
-        if (objectify)
-            next_sub = IPAdmin::CIDR.new(:CIDR => next_sub)
-        end
-        
-        return(next_sub)
-    end
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# nth()
-#==============================================================================#
-
-# Provide the nth IP within this object.
-#
-# - Arguments:
-#   * Hash with the following fields:
-#       - :Index -- index number of the IP address to return
-#       - :Objectify -- if true, return IPAdmin::CIDR objects (optional)
-#       - :Short -- if true, return IPv6 addresses in short-hand notation (optional)
-#
-# - Returns:
-#   * IP address or IPAdmin::CIDR object.
-#
-# Example:
-#   puts cidr4.nth(:Index => 1)   --> 192.168.1.1
-#
-    def nth(options)
-        objectify = false
-        short = false
-
-        unless(options.kind_of?(Hash))
-            raise Argumenterror, "Expected Hash, but " +
-                                 "#{options.class} provided."
-        end
-        
-        unless( options.has_key?(:Index) )
-            raise ArgumentError, "Missing argument: Index."
-        end
-        index = options[:Index]
-
-        if( options.has_key?(:Short) )
-            short = true
-        end
-        
-        if( options.has_key?(:Objectify) )
-                objectify = true
-        end
-
-        my_ip = @network + index
-        if ( (@hostmask | my_ip) == (@hostmask | @network) )
-
-            if (@version == 4)
-                my_ip = IPAdmin.unpack_ipv4_addr(my_ip)
-                if (objectify)
-                    my_ip = IPAdmin::CIDR.new(:CIDR => my_ip)
-                end
-            elsif (@version == 6)
-                my_ip = IPAdmin.unpack_ipv6_addr(my_ip)
-                my_ip = IPAdmin.shorten(my_ip) if (short && !objectify)
-                if (objectify)
-                    my_ip = IPAdmin::CIDR.new(:CIDR => my_ip)
-                end
-            end
-
-        else
-            raise "Index of #{index} returns IP that is out of " +
-                  "bounds of CIDR network."
-        end
-
-        return(my_ip)
-    end
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# packed_hostmask()
-#==============================================================================#
-
-# Provide an integer representing the packed Hostmask of this object.
-#
-# - Arguments:
-#   * none
-#
-# - Returns:
-#   * Byte-packed Hostmask.
-#
-# Example:
-#   puts cidr4.packed_hostmask().to_s(16)   --> ff
-#
-    def packed_hostmask()
-        return(@hostmask)
-    end
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# packed_ip()
-#==============================================================================#
-
-# Provide an integer representing the packed IP of this object.
-#
-# - Arguments:
-#   * none
-#
-# - Returns:
-#   * Byte-packed IP.
-#
-# Example:
-#   puts cidr4.packed_ip().to_s(16)   --> c0c80101
-#
-    def packed_ip()
-        return(@ip)
-    end
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# packed_netmask()
-#==============================================================================#
-
-# Provide an integer representing the packed Netmask of this object.
-#
-# - Arguments:
-#   * none
-#
-# - Returns:
-#   * Byte-packed Netmask.
-#
-# Example:
-#   puts cidr4.packed_netmask().to_s(16)   --> ffffff00
-#
-    def packed_netmask()
-        return(@netmask)
-    end
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# packed_network()
-#==============================================================================#
-
-# Provide an integer representing the packed Network address of this object.
-#
-# - Arguments:
-#   * none
-# 
-# - Returns:
-#   * Byte-packed Network Address.
-#
-# Example:
-#   packed = cidr4.packed_network().to_s(16)   --> c0c80100
-#
-    def packed_network()
-        return(@network)
-    end
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# range()
-#==============================================================================#
-
-# Given two Indexes, return all IP addresses within the CIDR that are
-# between them (inclusive).
-#
-# - Arguments:
-#   * Hash with the following fields:
-#       - :Bitstep -- enumerate in X sized steps (optional)
-#       - :Indexes -- array of (2) index numbers of the addresses to use as boundaries
-#       - :Objectify -- if true, return IPAdmin::CIDR objects (optional)
-#       - :Short -- if true, return IPv6 addresses in short-hand notation (optional)
-#
-# - Returns:
-#   * Array of IP addresses or IPAdmin::CIDR objects
-#
-# Example:
-#   list = cidr4.range(:Indexes => [0,1]) --> ['192.168.1.0','192.168.1.1']
-#
-    def range(options)
-        objectify = false
-        short = false
-        bitstep = 1
-
-        unless(options.kind_of?(Hash))
-            raise Argumenterror, "Expected Hash, but #{options.class} provided."
-        end
-        
-        unless( options.has_key?(:Indexes) )
-            raise ArgumentError, "Missing argument: Indexes."
-        end
-        indexes = options[:Indexes]
-        indexes.sort!
-        
-        unless( (indexes.kind_of?(Array)) && (indexes.length == 2))
-            raise ArgumentError, "Argument :Index should be an array of (2) index numbers."
-        end
-
-        unless ( (indexes[0] >= 0) && (indexes[0] < self.size) )
-            raise ArgumentError, "Index #{indexes[0]} is out of bounds for this CIDR."
-        end
-        
-        unless (indexes[1] < self.size)
-            raise ArgumentError, "Index #{indexes[1]} is out of bounds for this CIDR."
-        end
-        
-        if( options.has_key?(:Short) )
-            short = true
-        end
-        
-        if( options.has_key?(:Objectify) )
-            objectify = true
-        end
-        
-        if( options.has_key?(:Bitstep) )
-            bitstep = options[:Bitstep]
-        end
-
-        start_ip = @network + indexes[0]
-        end_ip = @network + indexes[1]
-        my_ip = start_ip
-        list = []
-        until (my_ip > end_ip)
-            if (@version == 4)
-                my_ip_s = IPAdmin.unpack_ipv4_addr(my_ip)
-            elsif (@version == 6)
-                my_ip_s = IPAdmin.unpack_ipv6_addr(my_ip)
-                my_ip_s = IPAdmin.shorten(my_ip_s) if (short && !objectify)
-            end
-            
-            if (objectify)
-                my_ip_s = IPAdmin::CIDR.new(:CIDR => my_ip_s)
-            end
-            
-            list.push(my_ip_s)
-            my_ip += bitstep
-        end
-
-        return(list)
-    end
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# remainder()
-#==============================================================================#
-
-# Given a subnet of the current CIDR, provide the remaining subnets of
-# the CIDR.
-#
-# - Arguments:
-#   * Optional hash with the following fields:
-#       - :Exclude -- IPAdmin::CIDR object to use in calculating the remainder.
-#       - :Objectify -- if true, return IPAdmin::CIDR objects (optional)
-#       - :Short -- if true, return IPv6 addresses in short-hand notation (optional)
-#
-# - Returns:
-#   * Array of CIDR addresses or IPAdmin::CIDR objects
-#
-#
-# Example:
-#   cidr4_2 = IPAdmin::CIDR.new(:CIDR => '192.168.1.64/26')
-#   cidr4.remainder(:Exclude => cidr4_2).each {|x| puts}
-#
-    def remainder(options)
-        short = nil
-        objectify = nil
-        
-        unless (options.kind_of? Hash)
-            raise ArgumentError, "Expected Hash, but #{options.class} provided."
-        end
-            
-        unless ( options.has_key?(:Exclude) )
-            raise ArgumentError, "Missing argument: Exclude."
-        end
-        to_exclude = options[:Exclude]
-            
-        unless ( to_exclude.kind_of?(IPAdmin::CIDR) )
-            raise ArgumentError, "Expeced IPAdmin::CIDR, but #{exclude.class} " +
-                                 "for option: Exclude."
-        end
-        
-        if( options.has_key?(:Short) )
-            short = true
-        end
-        
-        if( options.has_key?(:Objectify) )
-            objectify = true
-        end
-        
-        # make sure 'to_exclude' is the same ip version
-        unless ( to_exclude.version == @version )
-            raise "#{to_exclude.desc(:Short => true)} is of a different " +
-                  "IP version than #{self.desc(:Short => true)}."
-        end    
-
-        # make sure we contain 'to_exclude'
-        unless ( self.contains?(to_exclude) == true )
-            raise "#{to_exclude.desc(:Short => true)} does not fit " +
-                  "within the bounds of #{self.desc(:Short => true)}."
-        end
-
-        # split this cidr in half & see which half 'to_exclude'
-        # belongs in. take that half & repeat the process. every time
-        # we repeat, store off the non-matching half
-        new_mask = self.bits + 1
-        lower_network = self.packed_network
-        upper_network = self.packed_network + 2**(@max_bits - new_mask)
-        
-        new_subnets = []
-        until(new_mask > to_exclude.bits)
-            if (to_exclude.packed_network < upper_network)
-                match = lower_network
-                non_match = upper_network
-            else
-                match = upper_network
-                non_match = lower_network
-            end
-            
-            if (@version == 4)
-                non_match = IPAdmin.unpack_ipv4_addr(non_match)
-            else
-                non_match = IPAdmin.unpack_ipv6_addr(non_match)
-                non_match = IPAdmin.shorten(non_match) if (short && !objectify)
-            end
-            
-            if (!objectify)
-                new_subnets.unshift("#{non_match}/#{new_mask}")
-            else
-                new_subnets.unshift(IPAdmin::CIDR.new(:CIDR => "#{non_match}/#{new_mask}"))
-            end
-            
-            new_mask = new_mask + 1
-            lower_network = match
-            upper_network = match + 2**(@max_bits - new_mask)
-        end
-        
-        return(new_subnets)
-    end
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# resize()
-#==============================================================================#
-
-# Resize the CIDR by changing the size of the Netmask. 
-# Return the resulting CIDR as a new object.
-#
-# - Arguments:
-#   * Hash with the following fields:
-#       - :Subnet -- Number of bits of new Netmask (24,26, etc...)
-#
-# - Returns:
-#   * IPAdmin::CIDR object
-#
-# Example:
-#   new_cidr = cidr4.resize(:Subnet => 23)
-#   puts new_cidr.desc   --> 192.168.1.0/23
-#
-    def resize(options)
-        unless(options.kind_of?(Hash))
-                raise Argumenterror, "Expected Hash, but " +
-                                     "#{options.class} provided."
-        end
-            
-        unless( options.has_key?(:Subnet) )
-                raise Argumenterror, "Missing argument: Subnet."
-        end
-        bits = options[:Subnet]
-        
-        if (@version == 4)
-            netmask = IPAdmin.validate_ipv4_netmask(bits)
-            network = IPAdmin.unpack_ipv4_addr(@network & netmask)
-        else
-            netmask = IPAdmin.validate_ipv6_netmask(bits)
-            network = IPAdmin.unpack_ipv6_addr(@network & netmask)
-        end
-        
-        cidr = IPAdmin::CIDR.new(:CIDR => "#{network}/#{bits}")
-        return(cidr)
-    end
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# resize!()
-#==============================================================================#
-
-# Resize this object by changing the size of the Netmask. 
-#
-# - Arguments:
-#   * Hash with the following fields:
-#       - :Subnet -- Number of bits of new Netmask (24,26, etc...)
-#
-# - Returns:
-#   * IPAdmin::CIDR object
-#
-# Note:
-# 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.
-#
-# Example:
-#   cidr4.resize!(:Subnet => 23)
-#   puts cidr4.desc   --> 192.168.1.0/23
-#
-    def resize!(options)
-        unless(options.kind_of?(Hash))
-                raise Argumenterror, "Expected Hash, but " +
-                                     "#{options.class} provided."
-        end
-            
-        unless( options.has_key?(:Subnet) )
-                raise Argumenterror, "Missing argument: Subnet."
-        end
-        bits = options[:Subnet]
-        
-        if (@version == 4)
-            netmask = IPAdmin.validate_ipv4_netmask(bits)
-        else
-            netmask = IPAdmin.validate_ipv6_netmask(bits)
-        end
-        
-        @netmask = netmask
-        @network = @network & netmask
-        @hostmask = @netmask ^ @all_f
-        
-        # check @ip
-        if ((@ip & @netmask) != (@network))
-            @ip = @network
-        end
-        
-        return(nil)
-    end
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# size()
-#==============================================================================#
-
-# Provide number of IP addresses within this object.
-#
-# - Arguments:
-#   * none
-#
-# - Returns:
-#   * Number of IP addresses in this CIDR block.
-#
-# Example:
-#   puts cidr4.size()   --> 256
-#
-    def size()
-        return(@hostmask + 1)
-    end
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# subnet()
-#==============================================================================#
-
-# Subnet this object. Object will be fully subnetted into X number of subnets
-# of specified size. If :MinCount is provided, then method will return at least 
-# that number of subnets (of size X). The remainder of the new subnets
-# will be merged together as tightly as possible. If a size is not provided,
-# then the current object will be split in half.
-#
-# - Arguments:
-#   * Optional hash with the following fields:
-#       - :IPCount -- Minimum number of IP's that new subnets should contain (optional)
-#       - :MinCount -- Minimum number of X sized subnets to return (optional)
-#       - :Objectify -- if true, return IPAdmin::CIDR objects (optional)
-#       - :Short -- if true, return IPv6 addresses in short-hand notation (optional)
-#       - :Subnet --  Netmask (in bits) of new subnets (optional)
-#
-# - Returns:
-#   * Array of CIDR addresses or IPAdmin::CIDR objects
-#
-# Note:
-#    :Subnet always takes precedence over :IPCount.
-#
-# Example:
-#   cidr_list = cidr4.subnet(:Subnet => 28, :MinCount => 3)
-#   cidr_list = cidr4.subnet(:IPCount => 19)
-#   puts cidr_list[0]   --> 192.168.1.0/27
-#
-    def subnet(options=nil)
-        my_network = self.packed_network
-        my_mask = self.bits
-        subnet_bits = my_mask + 1
-        min_count = nil 
-        objectify = false
-        short = false       
-        
-        if (options)
-            unless (options.kind_of? Hash)
-                raise ArgumentError, "Expected Hash, but #{options.class} provided."
-            end
-            
-            if ( options.has_key?(:IPCount) )
-                num_ips = options[:IPCount]
-                bits_needed = 0
-                until (2**bits_needed >= num_ips)
-                    bits_needed += 1
-                end
-                subnet_bits = @max_bits - bits_needed
-            end
-            
-            if ( options.has_key?(:Subnet) )
-                subnet_bits = options[:Subnet]
-            end
-            
-            if ( options.has_key?(:MinCount) )
-                min_count = options[:MinCount]
-            end
-            
-            if( options.has_key?(:Short) )
-                short = true
-            end
-        
-            if( options.has_key?(:Objectify) )
-                objectify = true
-            end
-            
-        end
-
-        # get number of subnets possible with the requested subnet_bits
-        num_avail = 2**(subnet_bits - my_mask)        
-
-        # get the number of bits in the next supernet and
-        # make sure min_count is a power of 2
-        bits_needed = 1
-        min_count = num_avail if (!min_count)
-        until (2**bits_needed >= min_count)
-            bits_needed += 1
-        end
-        min_count = 2**bits_needed
-        next_supernet_bits = subnet_bits - bits_needed
-        
-
-        # make sure subnet isnt bigger than available bits
-        if (subnet_bits > @max_bits)
-            raise "Requested subnet (#{subnet_bits}) does not fit " +
-                  "within the bounds of IPv#{@version}."
-        end
-
-        # make sure subnet is larger than mymask
-        if (subnet_bits < my_mask)
-            raise "Requested subnet (#{subnet_bits}) is too large for " +
-                  "current CIDR space."
-        end
-
-        # make sure MinCount is smaller than available subnets
-        if (min_count > num_avail)
-            raise "Requested subnet count (#{min_count}) exceeds subnets " +
-                  "available for allocation (#{num_avail})."
-        end
-
-        # list all 'subnet_bits' sized subnets of this cidr block
-        # with a limit of min_count
-        bitstep = 2**(@max_bits - subnet_bits)
-        subnets = self.enumerate(:Bitstep => bitstep, :Limit => min_count)
-
-        # turn the first min_count subnets into IPAdmin::CIDR
-        # objects and push them to new_subnets
-        new_subnets = []
-        subnets.each do |subnet|
-            subnet = IPAdmin.shorten(subnet) if ((@version == 6) && short && !objectify)
-            if (!objectify)
-                new_subnets.push("#{subnet}/#{subnet_bits}")
-            else            
-                new_subnets.push(IPAdmin::CIDR.new(:CIDR => "#{subnet}/#{subnet_bits}"))
-            end
-        end
-
-        # now go through the rest of the cidr space and make the rest
-        # of the subnets. we want these to be as tightly merged as possible
-        next_supernet_bitstep = (bitstep * min_count)
-        next_supernet_ip = my_network + next_supernet_bitstep
-        until (next_supernet_bits == my_mask)
-            if (@version == 4)
-                next_network = IPAdmin.unpack_ipv4_addr(next_supernet_ip)
-            else
-                next_network = IPAdmin.unpack_ipv6_addr(next_supernet_ip)
-                next_network = IPAdmin.shorten(next_network) if (short && !objectify)
-            end
-            
-            if (!objectify)
-                new_subnets.push("#{next_network}/#{next_supernet_bits}")
-            else
-                new_subnets.push(IPAdmin::CIDR.new(:CIDR => "#{next_network}/#{next_supernet_bits}"))
-            end
-            
-            next_supernet_bits -= 1
-            next_supernet_ip = next_supernet_ip + next_supernet_bitstep
-            next_supernet_bitstep = next_supernet_bitstep << 1
-        end
-
-        return(new_subnets)
-    end
-
-#======================================#
-#
-#======================================#
-
-end
-
-#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++#
-#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++#
-#
-#  END class CIDR
-#
-#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++#
-#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++#
-
-
-
-
-
-
-#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++#
-#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++#
-#
-#  BEGIN class Tree
-#
-#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++#
-#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++#
-
-=begin rdoc
- A class & series of methods for creating and manipulating IP-based
- heirarchical trees. Both IPv4 and IPv6 are supported.
-
- Tree's are useful for creating mini 'routing tables' of CIDR address space.
- Using a tree, you can quickly determine the 'route' of another CIDR via
- the standard longest-match algorithm.
- 
- Tree's are not dynamic, in that if you modify any of the CIDR objects
- contained within, the Tree will not automatically adjust itself accordingly.
- For example if you have a tree like the following:
- 
-    192.168.0.0/24
-        192.168.0.0/26
-    192.168.1.0/24
-    
- You decide to resize 192.168.0.0/24 to 192.168.0.0/23. The tree will now
- be incorrect:
- 
-    192.168.0.0/23
-        192.168.0.0/26
-    192.168.1.0/24
- 
- You would need to remove and re-add the CIDR 192.168.0.0/23 in order for the
- tree to rebuild itself properly.    
-=end
-
-class Tree
-
-# instance variables
-# @all_f
-# @max_bits
-# @root
-# @version
-
-#==============================================================================#
-# attr_reader / attr_writer
-#==============================================================================#
-
-    # IP version for this tree (4 or 6)
-    attr_reader :version
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# initialize()
-#==============================================================================#
-
-# - Arguments:
-#   * Hash with the following fields:
-#       - :Version -- IP version for this tree (4 or 6)
-#
-# Example:
-#   table = IPAdmin::CIDRTable.new(:Version => 4)
-#
-    def initialize(options)
-        unless (options.kind_of? Hash)
-            raise ArgumentError, "Expected Hash, but #{options.class} provided."
-        end
-
-        if ( options.has_key?(:Version) )
-            @version =  options[:Version]
-
-            unless ( @version == 4 || @version == 6 )
-                raise "IP version should be either 4 or 6."
-            end
-        else
-            raise ArgumentError, "Missing argument: Version."
-        end
-
-        if (@version == 4)
-            @max_bits = 32
-            @all_f = 2**@max_bits - 1
-        else
-            @max_bits = 128
-            @all_f = 2**@max_bits - 1
-        end
-
-        # root of our ordered IP tree
-        @root = []
-
-    end
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# add()
-#==============================================================================#
-
-# Add an IPAdmin::CIDR object to the tree.
-#
-# - Arguments:
-#   * IPAdmin::CIDR object
-#
-# - Returns:
-#   * nothing
-#
-# Example:
-#   tree.add(cidr)
-#
-    def add(object)
-
-        # validate object
-        unless ( object.kind_of?(IPAdmin::CIDR) )
-            raise ArgumentError, "IPAdmin::CIDR object " +
-                                 "required but #{object.class} provided."
-        end
-
-        unless (object.version == @version )
-            raise "IP version #{object.version} is incompatible with " +
-                  "Tree IP version #{@version}."
-        end
-
-        net_struct = IPAdmin.create_net_struct(object)
-
-        # search tree for it's home branch
-        search_results = find_home(net_struct, @root)
-        home_struct = search_results[0] if (search_results)
-        home_branch = home_struct.subnets if (search_results)
-        home_branch = @root if (!home_branch)
-
-        # make sure we dont have a duplicate
-        if (home_struct)
-            if ( (net_struct.network == home_struct.network) && 
-                 (net_struct.netmask == home_struct.netmask) )
-                raise "Attempted to add #{object.desc()} multiple times."
-            end
-        end
-
-        # now that we have our branch location, check that other entries
-        # of this branch are not subnets of our new object. if they are
-        # then make them a branch of our new object
-        home_branch.each do |entry|
-            is_contained = contains(net_struct, entry)
-
-            if (is_contained)
-                net_struct.subnets.push(entry)
-            end
-        end
-
-        net_struct.subnets.each do |entry|
-            home_branch.delete(entry)
-        end
-
-        # add new object as an ordered entry to home_branch
-        add_to_branch(net_struct,home_branch)
-
-        return(nil)
-    end
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# add_to_branch() private
-#==============================================================================#
-
-# Add Netstruct object to an array of NetStruct's
-#
-# - Arguments:
-#   * NetStruct, and array of NetStruct's in which to add it
-#
-# - Returns:
-#   * none
-#
-# Example:
-#   add_to_branch(net_struct,branch)
-#
-    def add_to_branch(net_struct,branch)
-        # make sure we have appropriate types 
-        unless (net_struct.kind_of?(IPAdmin::NetStruct) && 
-                branch.kind_of?(Array) )
-            raise ArgumentError, "Incorrect argument types " +
-                                 "#{net_struct.class} and #{branch}."
-        end
-        
-        index = 0
-        branch.each do
-            if(net_struct.network < (branch[index]).network)
-                break
-            end
-            index += 1
-        end
-
-        branch.insert(index, net_struct)
-
-        return()
-    end
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# collapse()
-#==============================================================================#
-
-# Collapse (supernet) all subnets of the tree,
-# and return a new tree. The supernetting of subnets will only occur in
-# situations where the newly created supernet will not result in the
-# 'creation' of additional space. For example the following blocks
-# (192.168.0.0/24, 192.168.1.0/24, and 192.168.2.0/24) would merge into
-# 192.168.0.0/23 and 192.168.2.0/24 rather than into 192.168.0.0/22.
-#
-# - Arguments:
-#   * none
-#
-# - Returns:
-#   * IPAdmin::Tree object
-#
-# Example:
-#   new_tree = tree.collapse()
-#
-    def collapse()
-            tree = IPAdmin::Tree.new(:Version => @version)
-            branch = IPAdmin.merge(:List => @root, :NetStruct => 1)
-            dumped = dump_branch(branch)
-            dumped.each do |entry|
-                net_struct = entry[:NetStruct]
-
-                if (@version == 4)
-                    network = IPAdmin.unpack_ipv4_addr(net_struct.network)
-                    netmask = IPAdmin.unpack_ipv4_netmask(net_struct.netmask)
-                else
-                    network = IPAdmin.unpack_ipv6_addr(net_struct.network)
-                    netmask = IPAdmin.unpack_ipv6_netmask(net_struct.netmask)
-                end
-                cidr = IPAdmin::CIDR.new(:CIDR => "#{network}/#{netmask}")
-                tree.add(cidr)
-            end
-        return(tree)
-    end
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# contains() private
-#==============================================================================#
-
-# Is the first NetStruct object the supernet of the second?
-#
-# - Arguments:
-#   * Two NetStruct objects
-#
-# - Returns:
-#   * true if struct1 contains or is equal to struct2, or false if not.
-#
-# Example:
-#   is_contained = contains(struct1,struct2)
-#
-    def contains(struct1,struct2)
-
-        # make sure we have appropriate types 
-        unless (struct1.kind_of?(IPAdmin::NetStruct) && 
-                struct2.kind_of?(IPAdmin::NetStruct) )
-            raise ArgumentError, "Incorrect argument types " +
-                                 "#{struct1.class} and #{struct2.class}."
-        end
-
-        network1 = struct1.network
-        netmask1 = struct1.netmask
-        network2 = struct2.network
-        netmask2 = struct2.netmask
-        hostmask1 = netmask1 ^ @all_f
-
-        # if network1 == network2, then we have to go by netmask length
-        # else we can tell by or'ing network1 and network2 by hostmask1
-        # and comparing the results
-        is_contained = false
-        if (network1 == network2)
-            if (netmask2 >= netmask1)
-                is_contained = true
-            end
-        else
-            if ( (network1 | hostmask1) == (network2 | hostmask1) )
-                is_contained = true
-            end
-        end
-
-        return(is_contained)
-    end
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# dump
-#==============================================================================#
-
-# Dump the contents of this tree.
-#
-# - Arguments:
-#   * none
-#
-# - Returns:
-#   * ordered array of hashes with the following fields: 
-#       - :Object => CIDR object
-#       - :Depth => (depth level in tree)
-# Example:
-#   dumped = tree.dump()
-#
-    def dump()
-        list = []
-        dumped = dump_branch(@root)
-
-        dumped.each do |entry|
-            depth = entry[:Depth]
-            net_struct = entry[:NetStruct]
-            object = net_struct.object
-            list.push({:Depth => depth, :Object => object})
-        end
-
-        return(list)
-    end
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# dump_branch() private
-#==============================================================================#
-
-#  Dump contents of an Array of NetStruct objects
-#
-# - Arguments:
-#   * array of NetStruct objects, and an optional depth within the tree
-#
-# - Returns:
-#   * array of hashes in form: :NetStruct => IPAdmin::NetStruct object
-#                              :Depth => (depth level in tree)
-# Example: 
-#   dumped = dump_branch(branch)
-#
-    def dump_branch(branch,depth=nil)
-        list = []
-        depth = 0 if (!depth)
-
-        branch.each do |entry|
-            subnets = entry.subnets
-            list.push({:NetStruct => entry, :Depth => depth})
-
-            if (subnets.length > 0)
-                list.concat( dump_branch(subnets, (depth+1) ) )
-            end
-
-        end
-
-        return(list)
-    end
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# exists?()
-#==============================================================================#
-
-# Has an IPAdmin::CIDR object already been added to the tree?
-#
-# - Arguments:
-#   * IPAdmin::CIDR object
-#
-# - Returns:
-#   * true or false
-#
-# Example:
-#   added = tree.exists?(cidr)
-#
-    def exists?(object)
-
-        # validate object
-        unless ( object.kind_of?(IPAdmin::CIDR) )
-            raise ArgumentError, "IPAdmin::CIDR object " +
-                                 "required but #{object.class} provided."
-        end
-
-        unless (object.version == @version )
-            raise "IP version #{object.version} is incompatible with " +
-                  "Tree IP version #{@version}."
-        end
-
-        net_struct = IPAdmin.create_net_struct(object)
-        home_struct,home_branch = find_home(net_struct, @root)
-
-        # check for match
-        found = false
-        if (home_struct)  
-            if ( (net_struct.network == home_struct.network) && 
-                 (net_struct.netmask == home_struct.netmask) )
-                found = true
-            end
-        end
-
-
-        return(found)
-    end
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# find()
-#==============================================================================#
-
-# Find the longest matching branch of our tree to which an 
-# IPAdmin::CIDR object belongs. Useful for performing 'routing table' lookups.
-#
-# - Arguments:
-#   * IPAdmin::CIDR object
-#
-# - Returns:
-#   * IPAdmin::CIDR object, or nil if not found
-#
-# Example:
-#   longest_match = tree.find(ip)
-#
-    def find(object)
-        unless ( object.kind_of?(IPAdmin::CIDR) )
-            raise ArgumentError, "IPAdmin::CIDR object " +
-                                 "required but #{object.class} provided."
-        end
-
-        unless (object.version == @version )
-            raise "IP version #{object.version} is incompatible with " +
-                  "Tree IP version #{@version}."
-        end
-
-        net_struct = IPAdmin.create_net_struct(object)
-        home_struct,home_branch = find_home(net_struct, @root)
-        found_obj = home_struct.object if (home_struct)
-
-        return(found_obj)
-    end
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# find_home() private
-#==============================================================================#
-
-# Find the branch to which a NetStruct object belongs.
-#
-# - Arguments:
-#   * IPAdmin::NetStruct to find, and Array of
-#     IPAdmin::NetStruct's to search
-#
-# - Returns:
-#   * array of: container IPAdmin::NetStruct object,
-#               and container branch, or nil
-#
-# Example:
-#   branch = find_home(net_struct,branch)
-#
-    def find_home(net_struct,branch)
-        ret_val = nil
-
-        branch.each do |entry|
-            is_contained = contains(entry,net_struct)
-
-            if (is_contained)
-                home_struct = entry
-                home_branch = branch
-
-                if (home_struct.subnets.length > 0)
-                    search_results = find_home(net_struct,home_struct.subnets)
-                    if (search_results)
-                        home_struct = search_results[0] 
-                        home_branch = search_results[1]
-                    end
-                end
-
-                ret_val = [home_struct,home_branch]
-                break
-            end
-        end
-
-        return(ret_val)
-    end
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# find_space()
-#==============================================================================#
-
-# Find Tree entries that can hold a subnet of size X. Returns only the smallest
-# matching subnets of each supernet. If neither IPCount or Subnet or provided,
-# then method returns all entries that can fit a single IP.
-#
-# - Arguments:
-#   * Hash with the following fields:
-#       - :IPCount -- Minimum number of IP's that should fit within subnet (optional)
-#       - :Limit -- Maximum entries to return (optional)
-#       - :Subnet -- Netmask (in bits) of space to find(optional)
-#
-# - Returns:
-#   * ordered array of IPAdmin::CIDR objects
-#
-# Note:
-#    :Subnet always takes precedence over :IPCount.
-#
-# Example:
-#   list = tree.find_space(:Subnet => 27)
-#   list = tree.find_space(:IPCount => 33, :Limit => 2)
-#
-    def find_space(options)
-        limit = nil
-        list = []
-
-        # validate options
-        unless (options.kind_of? Hash)
-            raise ArgumentError, "Expected Hash, but #{options.class} provided."
-        end
-
-        if ( options.has_key?(:Limit) )
-            limit = options[:Limit]
-        end
-        
-        if ( options.has_key?(:IPCount) )
-            num_ips = options[:IPCount]
-            bits_needed = 0
-            until (2**bits_needed >= num_ips)
-                bits_needed += 1
-            end
-            subnet_size = @max_bits - bits_needed
-        end
-        
-        if ( options.has_key?(:Subnet) )
-            subnet_size = options[:Subnet]
-        end
-
-        # check that subnet_size is a valid size
-        if (@version == 4)
-            subnet_size = 32 if (!subnet_size)
-            unless ( (subnet_size > 0) && (subnet_size < 33) )
-                raise "#{subnet_size} is out of range for an " +
-                      "IP version #{@version} Tree."
-            end
-
-        else
-            subnet_size = 128 if (!subnet_size)
-            unless ( (subnet_size > 0) && (subnet_size < 129) )
-                raise "#{subnet_size} is out of range for an " +
-                      "IP version #{@version} Tree."
-            end
-        end
-
-        search_list = dump_branch(@root)
-
-        search_list.each do |entry|
-            depth = entry[:Depth]
-            net_struct = entry[:NetStruct]
-
-            # we only want leaf nodes of type IPAdmin::CIDR
-            if ( (net_struct.subnets.length == 0) &&
-                 (net_struct.object.kind_of?(IPAdmin::CIDR)) )
-
-                 if (subnet_size >= net_struct.object.bits)
-                    list.push(net_struct.object)
-                 end
-            end
-
-            if (limit && (list.length >= limit) )
-                break
-            end
-
-        end
-
-        return(list)
-
-    end
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# prune()
-#==============================================================================#
-
-# Remove an IPAdmin::CIDR object, and all child
-# objects from the tree.
-#
-# - Arguments:
-#   * IPAdmin::CIDR object
-#
-# - Returns:
-#   * true on success, or false
-#
-# Example:
-#   did_prune = tree.prune(ip)
-#
-    def prune(object)
-        unless ( object.kind_of?(IPAdmin::CIDR) )
-            raise ArgumentError, "IPAdmin::CIDR object " +
-                                 "required but #{object.class} provided."
-        end
-
-        unless (object.version == @version )
-            raise "IP version #{object.version} is incompatible with " +
-                  "Tree IP version #{@version}."
-        end
-
-        net_struct = IPAdmin.create_net_struct(object)
-        home_struct,home_branch = find_home(net_struct, @root)
-
-        if(!home_struct)
-            raise "#{object.desc} could not be found."
-        end
-        
-        # remove if home_struct.object = object
-        pruned = false
-        if (home_struct.object = object)
-            home_branch.delete(home_struct)
-            pruned = true
-        end
-
-        return(pruned)
-    end
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# remove()
-#==============================================================================#
-
-# Remove a single IPAdmin::CIDR object from the tree.
-#
-# - Arguments:
-#   * IPAdmin::CIDR object
-#
-# - Returns:
-#   * true on success, or false
-#
-# Example:
-#   did_remove = tree.remove(ip)
-#
-    def remove(object)
-        unless ( object.kind_of?(IPAdmin::CIDR) )
-            raise ArgumentError, "IPAdmin::CIDR object " +
-                                 "required but #{object.class} provided."
-        end
-
-        unless (object.version == @version )
-            raise "IP version #{object.version} is incompatible with " +
-                  "Tree IP version #{@version}."
-        end
-
-        net_struct = IPAdmin.create_net_struct(object)
-        home_struct,home_branch = find_home(net_struct, @root)
-
-        # remove if home_struct.object = object
-        removed = false
-        if (home_struct.object = object)
-
-            # if we have children subnets, move them up one level
-            if (home_struct.subnets.length > 0)
-                home_struct.subnets.each do |entry|
-                    index = 0
-                    home_branch.each do
-                        if(entry.network < (home_branch[index]).network)
-                            break
-                        end
-                        index += 1
-                    end
-                    home_branch.insert(index, entry)
-                end
-            end
-
-            home_branch.delete(home_struct)
-            removed = true
-        end
-
-        return(removed)
-    end
-
-#======================================#
-#
-#======================================#
-
-
-#==============================================================================#
-# show()
-#==============================================================================#
-
-# Print the tree in a nicely formatted string.
-#
-# - Arguments:
-#   * none
-#
-# - Returns:
-#   * String representing the contents of the tree
-#
-# Example:
-#   puts tree.show()
-#
-    def show()
-        printed = ""
-        list = dump_branch(@root)
-
-        list.each do |entry|
-            net_struct = entry[:NetStruct]
-            depth = entry[:Depth]
-
-            if (@version == 4)
-                network = IPAdmin.unpack_ipv4_addr(net_struct.network)
-                netmask = IPAdmin.unpack_ipv4_netmask(net_struct.netmask)
-
-            else
-                network = IPAdmin.unpack_ipv6_addr(net_struct.network)
-                netmask = IPAdmin.unpack_ipv6_netmask(net_struct.netmask)
-                network = IPAdmin.shorten(network)
-            end
-
-            if (depth == 0)
-                indent = ""
-            else
-                indent = " " * (depth*3)
-            end
-
-            printed << "#{indent}#{network}/#{netmask}\n"
-        end
-
-        return(printed)
-    end
-
-#======================================#
-#
-#======================================#
-
-private :add_to_branch, :contains,  :dump_branch,   :find_home
-
-end
-
-#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++#
-#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++#
-#
-#  END class Tree
-#
-#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++#
-#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++#
-
-
-#==============================================================================#
-# NetStruct
-#==============================================================================#
-
-# Struct object used internally by IPAdmin. It is not likely directly useful
-# to anyone.
-#
-# Description of fields:
-#   * network - byte-packed IP network
-#   * netmask - byte-packed IP netmask
-#   * version - IP version
-#   * object - holds an IPAdmin class object
-#   * subnets - an array of children IPAdmin::NetStruct objects
-#
-NetStruct = Struct.new(:network, :netmask, :version, :object, :subnets)
-
-#======================================#
-#
-#======================================#
-
-end # module IPAdmin
 __END__
-