netaddr 1.0.0

data/lib/eui.rb

@@ -0,0 +1,390 @@
+=begin rdoc
+ Copyright (c) 2006 Dustin Spinhirne (www.spinhirne.com)
+  
+ Licensed under the same terms as Ruby, No Warranty is provided.
+=end
+
+module NetAddr
+
+#=EUI - Extended Unique Identifier
+# 
+#A class & series of methods for creating and manipulating Extended Unique Identifier
+#(EUI) addresses. Two types of address formats are supported EUI-48 and EUI-64. The 
+#most common use for this class will be to manipulate MAC addresses (which are essentially
+#a type of EUI-48 address). 
+# 
+#EUI addresses are separated into two parts, the 
+#Organizationally Unique Identifier (OUI) and the Extended Identifier (EI). The OUI
+#is assigned by the IEEE and is used to identify a particular hardware manufacturer.
+#The EI is assigned by the hardware manufacturer as a per device unique address.
+# 
+#Probably the most useful feature of this class, and thus the reason it was created,
+#is to help automate certain address assignments within IP. For example, IPv6
+#Link Local addresses use MAC addresses for IP auto-assignment and multicast MAC addresses
+#are determined based on the multicast IP address.
+#
+class EUI
+
+private_class_method :new
+
+#==============================================================================#
+# create()
+#==============================================================================#
+
+#===Synopsis
+#Create a new EUI48 or EUI64 object.
+#
+# addr = NetAddr::EUI.new('aa-bb-cc-dd-ee-ff')
+# addr = NetAddr::EUI.new('aa:bb:cc:dd:ee:ff')
+# addr = NetAddr::EUI.new('aabb.ccdd.eeff')
+# addr = NetAddr::EUI.new('aa-bb-cc-dd-ee-ff-00-01')
+#
+#===Arguments
+#* EUI as a String
+#
+#===Returns
+#* EUI48 or EUI64 object
+#
+    def EUI.create(eui)
+        if (!eui.kind_of? String)
+            raise ArgumentError, "Expected String, but #{eui.class} provided."
+        end
+
+        # validate
+        NetAddr.validate_eui(eui)
+
+        # remove formatting characters
+        eui.gsub!(/[\.\:\-]/, '')
+
+        # split into oui & ei, pack, and store
+        if (eui.length == 12)
+            eui = NetAddr::EUI48.new(eui.to_i(16))
+        else
+            eui = NetAddr::EUI64.new(eui.to_i(16))
+        end
+        
+        return(eui)
+    end
+
+#==============================================================================#
+# address()
+#==============================================================================#
+
+#===Synopsis
+# Returns EUI address. The default address format is xxxx.xxxx.xxxx
+#
+# puts addr.address(:Delimiter => '.')   --> 'aabb.ccdd.eeff'
+#
+#===Arguments:
+#* Optional Hash with the following fields:
+#    :Delimiter -- delimitation character. valid values are (-,:,and .) (optional)
+#
+#===Returns:
+#* String
+#
+    def address(options=nil)
+        known_args = [:Delimiter]
+        delimiter = '-'
+
+        octets = []
+        octets.concat(unpack_oui)
+        octets.concat(unpack_ei)
+
+        if (options)
+            if (!options.kind_of? Hash)
+                raise ArgumentError, "Expected Hash, but #{options.class} provided."
+            end
+            NetAddr.validate_args(options.keys,known_args)
+
+            if (options.has_key?(:Delimiter))
+                delimiter = options[:Delimiter]
+                delimiter = '-' if (delimiter != '-' && delimiter != ':' && delimiter != '.' )
+            end
+        end
+
+        if (delimiter == '-' || delimiter == ':')
+                    address = octets.join(delimiter)
+        elsif (delimiter == '.')
+                toggle = 0
+                octets.each do |x|
+                    if (!address)
+                        address = x
+                        toggle = 1
+                    elsif (toggle == 0)
+                        address = address  << '.' << x
+                        toggle = 1
+                    else
+                        address = address << x
+                        toggle = 0
+                    end
+                end 
+
+        end
+
+        return(address)
+    end
+
+#==============================================================================#
+# ei()
+#==============================================================================#
+
+#===Synopsis
+#Returns Extended Identifier portion of an EUI address (the vendor assigned ID).
+#The default address format is xx-xx-xx
+#
+# puts addr.ei(:Delimiter => '-')
+#
+#===Arguments:
+#* Optional Hash with the following fields:
+#    :Delimiter -- delimitation character. valid values are (-, and :) (optional)
+#
+#===Returns:
+#* String
+#
+    def ei(options=nil)
+        known_args = [:Delimiter]
+        octets = unpack_ei()
+        delimiter = '-'
+
+        if (options)
+            if (!options.kind_of? Hash)
+                raise ArgumentError, "Expected Hash, but #{options.class} provided."
+            end
+            NetAddr.validate_args(options.keys,known_args)
+
+            if (options.has_key?(:Delimiter))
+                if (options[:Delimiter] == ':')
+                    delimiter = options[:Delimiter]
+                end
+            end
+        end
+        ei = octets.join(delimiter)
+
+        return(ei)
+    end
+
+#==============================================================================#
+# link_local()
+#==============================================================================#
+
+#===Synopsis
+# Provide an IPv6 Link Local address based on the current EUI address.
+#
+# puts addr.link_local()
+#
+#===Arguments:
+#* Optional Hash with the following fields:
+#    :Short -- if true, return IPv6 addresses in short-hand notation (optional)
+#    :Objectify -- if true, return CIDR objects (optional)
+#
+#===Returns:
+#* CIDR address String or an NetAddr::CIDR object
+#
+    def link_local(options=nil)
+        known_args = [:Short, :Objectify]
+        objectify = false
+        short = false
+
+        if (options)
+            if (!options.kind_of? Hash)
+                raise ArgumentError, "Expected Hash, but #{options.class} provided."
+            end
+            NetAddr.validate_args(options.keys,known_args)
+
+            if (options.has_key?(:Objectify) && options[:Objectify] == true)
+                objectify = true
+            end
+
+            if (options.has_key?(:Short) && options[:Short] == true)
+                short = true
+            end
+        end
+
+        if (self.kind_of?(NetAddr::EUI64))
+            link_local = @ei | (@oui << 40)
+        else
+            link_local = @ei | 0xfffe000000 | (@oui << 40)
+        end
+        link_local = link_local | (0xfe80 << 112)
+
+        if (!objectify)
+            link_local = NetAddr.unpack_ip_addr(link_local, :Version => 6)
+            link_local = NetAddr.shorten(link_local) if (short)
+        else
+            link_local = NetAddr::CIDR.create(link_local, :Version => 6)
+        end
+
+        return(link_local)
+    end
+
+#==============================================================================#
+# oui()
+#==============================================================================#
+
+#===Synopsis
+#Returns Organizationally Unique Identifier portion of an EUI address (the vendor ID).
+#The default address format is xx-xx-xx.
+#
+# puts addr.oui(:Delimiter => '-')
+#
+#===Arguments:
+#* Optional Hash with the following fields:
+#    :Delimiter -- delimitation character. valid values are (-, and :) (optional)
+#
+#===Returns:
+#* String
+#
+    def oui(options=nil)
+        known_args = [:Delimiter]
+        octets = unpack_oui()
+        delimiter = '-'
+
+        if (options)
+            if (!options.kind_of? Hash)
+                raise ArgumentError, "Expected Hash, but #{options.class} provided."
+            end
+            NetAddr.validate_args(options.keys,known_args)
+
+            if (options.has_key?(:Delimiter))
+                if (options[:Delimiter] == ':')
+                    delimiter = options[:Delimiter]
+                end
+            end
+        end
+        oui = octets.join(delimiter)
+
+        return(oui)
+    end
+
+
+# PRIVATE METHODS
+private
+
+#==============================================================================#
+# unpack_ei()
+#==============================================================================#
+
+    def unpack_ei()
+        hex = @ei
+        octets = []
+
+        if (self.kind_of?(NetAddr::EUI64))
+            length = 64
+        else
+            length = 48
+        end
+
+        loop_count = (length - 24)/8
+        loop_count.times do
+           octet = (hex & 0xff).to_s(16)
+           octet = '0' << octet if (octet.length != 2)
+           octets.unshift(octet)
+           hex = hex >> 8 
+        end
+        return(octets)
+    end
+
+#==============================================================================#
+# unpack_oui()
+#==============================================================================#
+
+    def unpack_oui()
+        hex = @oui
+        octets = []
+        3.times do
+           octet = (hex & 0xff).to_s(16)
+           octet = '0' << octet if (octet.length != 2)
+           octets.unshift(octet)
+           hex = hex >> 8 
+        end
+        return(octets)
+    end
+
+end # class EUI
+
+# EUI-48 Address - Inherits all methods from NetAddr::EUI. 
+# Addresses of this class have a 24-bit OUI and a 24-bit EI.
+class EUI48 < EUI
+
+public_class_method :new
+
+#==============================================================================#
+# initialize()
+#==============================================================================#
+
+#===Synopsis
+#Return an EUI48 object. PackedEUI takes precedence over EUI.
+#
+# addr = NetAddr::EUI48.new('aa-bb-cc-dd-ee-ff')
+# addr = NetAddr::EUI48.new('aa:bb:cc:dd:ee:ff')
+# addr = NetAddr::EUI48.new('aabb.ccdd.eeff')
+#
+#===Arguments:
+#* EUI as a String or Integer
+#
+    def initialize(eui)
+        
+        if (eui.kind_of?(Integer))
+            @oui = eui >> 24
+            @ei = eui & 0xffffff
+
+        elsif(eui.kind_of?(String))        
+            # validate
+            NetAddr.validate_eui(eui)
+
+            # remove formatting characters
+            eui.gsub!(/[\.\:\-]/, '')
+
+            # split into oui & ei, pack, and store
+            @oui = eui.slice!(0..5).to_i(16)
+            @ei = eui.to_i(16)
+        else
+            raise ArgumentError, "Expected String or Integer, but #{eui.class} provided."
+        end
+    end
+
+end
+
+# EUI-64 Address - Inherits all methods from NetAddr::EUI. 
+# Addresses of this class have a 24-bit OUI and a 40-bit EI.
+class EUI64 < EUI
+
+public_class_method :new
+
+#==============================================================================#
+# initialize()
+#==============================================================================#
+
+#===Synopsis
+#Return an EUI object. PackedEUI takes precedence over EUI.
+#
+# addr = NetAddr::EUI64.new('aa-bb-cc-dd-ee-ff-00-01')
+#
+#===Arguments:
+#* EUI as a String or Integer
+#
+    def initialize(eui)
+        
+        if (eui.kind_of?(Integer))
+            @oui = eui >> 40
+            @ei = eui & 0xffffffffffd
+
+        elsif(eui.kind_of?(String))            
+            # validate
+            NetAddr.validate_eui(eui)
+
+            # remove formatting characters
+            eui.gsub!(/[\.\:\-]/, '')
+
+            # split into oui & ei, pack, and store
+            @oui = eui.slice!(0..5).to_i(16)
+            @ei = eui.to_i(16)
+        else
+            raise ArgumentError, "Expected String or Integer, but #{eui.class} provided."
+        end
+    end
+
+end
+
+end # module NetAddr
+__END__

data/lib/methods.rb

@@ -0,0 +1,1273 @@
+=begin rdoc
+ Copyright (c) 2006 Dustin Spinhirne (www.spinhirne.com)
+  
+ Licensed under the same terms as Ruby, No Warranty is provided.
+=end
+
+module NetAddr
+
+#==============================================================================#
+# merge()
+#==============================================================================#
+
+#===Synopsis
+#Given a list of CIDR addresses or NetAddr::CIDR objects of the same version,
+#merge (summarize) them in the most efficient way possible. Summarization 
+#will only occur when the newly created supernets 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 be summarized into 
+#192.168.0.0/23 and 192.168.2.0/24 rather than into 192.168.0.0/22 
+#
+#I have designed this with enough flexibility that you can pass in CIDR 
+#addresses that arent even related (ex. 192.168.1.0/26, 192.168.1.64/27, 192.168.1.96/27
+#10.1.0.0/26, 10.1.0.64/26) and they will be merged properly (ie 192.168.1.0/25,
+#and 10.1.0.0/25 would be returned).
+#
+# Example:
+# supernets = NetAddr.merge(['192.168.1.0/27','192.168.1.32/27'])
+# supernets = NetAddr.merge([cidr1,cidr2])
+# supernets = NetAddr.merge(['192.168.1.0/27','192.168.1.32/27'], :Short => true)
+#
+#===Arguments:
+#* Array of CIDR addresses as Strings, or an Array of NetAddr::CIDR objects 
+#* Optional Hash with the following keys:
+#     :Objectify -- if true, return NetAddr::CIDR objects (optional)
+#     :Short -- if true, return IPv6 addresses in short-hand notation (optional)
+#
+#===Returns:
+#* Array of CIDR addresses as Strings, or an Array of NetAddr::CIDR objects
+#
+def merge(list,options=nil)
+    known_args = [:Objectify, :Short]
+    version = nil
+    all_f = nil
+    short = false
+    objectify = false
+
+    # validate list
+    raise ArgumentError, "Array expected for argument 'list' but #{list.class} provided." if (!list.kind_of?(Array) )
+    
+    # validate options
+    if (options)     
+        raise ArgumentError, "Hash expected for argument 'options' but #{options.class} provided." if (!options.kind_of?(Hash) )
+        NetAddr.validate_args(options.keys,known_args)
+    
+        if (options.has_key?(:Short) && options[:Short] == true)
+            short = true
+        end
+    
+        if (options.has_key?(:Objectify) && options[:Objectify] == true)
+            objectify = true
+        end        
+    end
+    
+    # make sure all are valid types of the same IP version
+    supernet_list = []
+    list.each do |obj|
+        if (!obj.kind_of?(NetAddr::CIDR))
+            begin
+                obj = NetAddr::CIDR.create(obj)
+            rescue Exception => error
+                raise ArgumentError, "An array element of :List raised the following " +
+                                     "errors: #{error}"
+            end
+        end
+
+        version = obj.version if (!version)
+        all_f = obj.all_f if (!all_f)
+        if (!obj.version == version)
+            raise VersionError, "Provided objects must be of the same IP version."
+        end 
+        supernet_list.push(obj)
+    end
+
+    # merge subnets by removing them from 'supernet_list',
+    # and categorizing them into hash of arrays ({packed_netmask => [packed_network,packed_network,etc...] ) 
+    # within each categorization we merge contiguous subnets
+    # and then remove them from that category & put them back into
+    # 'supernet_list'. we do this until supernet_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 |cidr|
+            netmask = cidr.packed_netmask
+            network = cidr.packed_network
+            if (categories.has_key?(netmask) )
+                categories[netmask].push(network)
+            else
+                categories[netmask] = [network]
+            end
+        end
+        supernet_list.clear
+
+        ordered_cats = categories.keys.sort        
+        ordered_cats.each do |netmask|
+            nets = categories[netmask].sort
+            bitstep = (all_f + 1) - netmask
+            
+            until (nets.length == 0)
+                # take the first network & create its supernet. this
+                # supernet will have x number of subnets, so we'll look
+                # & see if we have those subnets. if so, keep supernet & delete subnets.
+                to_merge = []
+                multiplier = 1
+                network1 = nets[0]
+                num_required = 2**multiplier
+                supermask = (netmask << multiplier) & all_f
+                supernet = supermask & network1
+                if (network1 == supernet)
+                    # we have the first half of the new supernet                   
+                    expected = network1
+                    nets.each do |network|
+                        if (network == expected)
+                            to_merge.push(network)
+                            expected = expected + bitstep
+                            if ( (to_merge.length == num_required) && (nets.length > num_required) )
+                                # we have all of our subnets for this round, but still have
+                                # more to look at
+                                multiplier += 1
+                                num_required = 2**multiplier
+                                supermask = (netmask << multiplier) & all_f
+                                supernet = supermask & network1
+                            end
+                        else
+                            break 
+                        end
+                    end
+                else
+                   # we have the second half of the new supernet only
+                   to_merge.push(network1)
+                end
+
+                
+                if (to_merge.length != num_required)
+                    # we dont have all of our subnets, so backstep 1 bit                    
+                    multiplier -= 1
+                    supermask = (netmask << multiplier) & all_f
+                    supernet = supermask & network1
+                end
+                
+                # save new supernet
+                supernet_list.push(NetAddr::CIDR.create(supernet,
+                                                        :PackedNetmask => supermask,
+                                                        :Version => version))
+                
+                # delete the subnets of the new supernet
+                (2**multiplier).times {nets.delete(to_merge.shift)}               
+            end
+        end
+        categories.clear
+        supernet_list = NetAddr.sort(supernet_list)
+    end
+
+    # decide what to return
+    if (!objectify)
+            supernets = []
+            supernet_list.each {|entry| supernets.push(entry.desc(:Short => short))}
+            return(supernets)
+    else
+            return(supernet_list)
+    end
+
+end
+module_function :merge
+
+#==============================================================================#
+# minimum_size()
+#==============================================================================#
+
+#===Synopsis
+#Given the number of IP addresses required in a subnet, return the minimum
+#netmask (in bits) required for that subnet. IP version is assumed to be 4 unless specified otherwise.
+#
+# Example:
+# netmask = NetAddr.minumum_size(14)
+# netmask = NetAddr.minumum_size(65536, :Version => 6)
+#
+#===Arguments:
+#* IP count as an Integer
+#* Optional Hash with the following keys:
+#     :Version -- IP version - Integer(optional)
+#
+#===Returns:
+#* Integer
+#
+def minimum_size(ipcount, options=nil)
+    version = 4
+    known_args = [:Version]
+
+    # validate ipcount
+    raise ArgumentError, "Integer expected for argument 'ipcount' but #{ipcount.class} provided." if (!ipcount.kind_of?(Integer))
+    
+    # validate options
+    if (options)
+        raise ArgumentError, "Hash expected for argument 'options' but #{options.class} provided." if (!options.kind_of?(Hash))
+    
+        NetAddr.validate_args(options.keys,known_args)
+    
+        if (options.has_key?(:Version))
+            version = options[:Version]
+        end
+    end
+    
+    if (version == 4)
+        max_bits = 32        
+    else
+        max_bits = 128
+    end
+    
+    
+    if (ipcount > 2**max_bits) 
+        raise BoundaryError, "Required IP count exceeds number of IP addresses available " +
+                             "for IPv#{version}."
+    end
+
+    
+    bits_needed = 0
+    until (2**bits_needed >= ipcount)
+        bits_needed += 1
+    end
+    subnet_bits = max_bits - bits_needed
+    
+    return(subnet_bits)
+end
+module_function :minimum_size
+
+#==============================================================================#
+# pack_ip_addr()
+#==============================================================================#
+
+#===Synopsis
+#Convert IP addresses into an Integer. Will attempt to auto-detect IP version if not provided.
+#
+# Example:
+# pack_ip_addr('192.168.1.1')
+# pack_ip_addr(ffff::1', :Version => 6)
+# pack_ip_addr(::192.168.1.1')
+#
+#===Arguments:
+#* IP address as a String
+#* Optional Hash with the following keys:
+#     :Version -- IP version - Integer
+#
+#===Returns:
+#* Integer
+#
+def pack_ip_addr(ip, options=nil)
+    known_args = [:Version]
+    to_validate = {}
+    
+    # validate options
+    if (options)
+        raise ArgumentError, "Hash expected for argument 'options' but #{options.class} provided." if (!options.kind_of?(Hash))
+        NetAddr.validate_args(options.keys,known_args)
+
+        if (options.has_key?(:Version))
+            version = options[:Version]
+            to_validate[:Version] = version
+            if (version != 4 && version != 6)
+                raise  VersionError, ":Version should be 4 or 6, but was '#{version}'."
+            end
+        end
+    end 
+    
+    if ( ip.kind_of?(String) )
+        
+        # validate
+        NetAddr.validate_ip_addr(ip, to_validate)
+        
+        # determine version if not provided
+        if (!version)
+            if ( ip =~ /\./ && ip !~ /:/ )
+                version = 4
+            else
+                version = 6
+            end
+        end
+        
+        packed_ip = 0
+        if ( version == 4)
+            octets = ip.split('.')            
+            (0..3).each do |x|
+                octet = octets.pop.to_i
+                octet = octet << 8*x 
+                packed_ip = packed_ip | octet
+            end
+            
+        else
+            # if ipv4-mapped ipv6 addr
+            if (ip =~ /\./)
+                dotted_dec = true                 
+            end            
+            
+            # split up by ':'
+            fields = []
+            if (ip =~ /::/)
+                shrthnd = ip.split( /::/ )
+                if (shrthnd.length == 0)
+                    return(0) 
+                else                    
+                    first_half = shrthnd[0].split( /:/ ) if (shrthnd[0])
+                    sec_half = shrthnd[1].split( /:/ ) if (shrthnd[1])
+                    first_half = [] if (!first_half)
+                    sec_half = [] if (!sec_half)
+                end
+                missing_fields = 8 - first_half.length - sec_half.length
+                missing_fields -= 1 if dotted_dec
+                fields = fields.concat(first_half)
+                missing_fields.times {fields.push('0')}
+                fields = fields.concat(sec_half)               
+                
+            else
+               fields = ip.split(':')  
+            end
+           
+            if (dotted_dec)
+                ipv4_addr = fields.pop
+                packed_v4 = NetAddr.pack_ip_addr(ipv4_addr, :Version => 4)
+                octets = []
+                2.times do
+                    octet = packed_v4 & 0xFFFF
+                    octets.unshift(octet.to_s(16))
+                    packed_v4 = packed_v4 >> 16
+                end
+                fields.concat(octets)
+            end
+
+            # pack
+            (0..7).each do |x|
+                field = fields.pop.to_i(16)
+                field = field << 16*x 
+                packed_ip = packed_ip | field
+            end
+            
+        end
+
+    else
+        raise ArgumentError, "String expected for argument 'ip' but #{ip.class} provided."    
+    end
+
+    return(packed_ip)
+end
+module_function :pack_ip_addr
+
+#==============================================================================#
+# pack_ip_netmask()
+#==============================================================================#
+
+#===Synopsis
+#Convert IP netmask into an Integer. Netmask may be in either CIDR (/yy) or
+#extended (y.y.y.y) format. CIDR formatted netmasks may either
+#be a String or an Integer. IP version defaults to 4. It may be necessary 
+#to specify the version if an IPv6 netmask of /32 or smaller is provided.
+#
+# Example:
+# packed = NetAddr.pack_ip_netmask('255.255.255.0')
+# packed = NetAddr.pack_ip_netmask('24')
+# packed = NetAddr.pack_ip_netmask(24)
+# packed = NetAddr.pack_ip_netmask('/24')
+# packed = NetAddr.pack_ip_netmask('32', :Version => 6)
+#
+#===Arguments
+#* Netmask as a String or Integer
+#* Optional Hash with the following keys:
+#     :Version -- IP version - Integer (optional)
+#
+#===Returns:
+#* Integer
+#
+def pack_ip_netmask(netmask, options=nil)
+    known_args = [:Version]
+    all_f = 2**32-1
+    to_validate = {}
+    
+    # validate options
+    if (options)
+        raise ArgumentError, "Hash expected for argument 'options' but #{options.class} provided." if (!options.kind_of?(Hash))
+        NetAddr.validate_args(options.keys,known_args)
+        
+        if (options.has_key?(:Version))
+            version = options[:Version]
+            if (version != 4 && version != 6)
+                raise VersionError, ":Version should be 4 or 6, but was '#{version}'."
+            elsif (version == 6)
+                all_f = 2**128-1
+            else
+                all_f = 2**32-1
+            end
+            to_validate[:Version] = version
+        end
+    end
+    
+    if (netmask.kind_of?(String))
+        NetAddr.validate_ip_netmask(netmask, to_validate)
+        
+        if(netmask =~ /\./)
+            packed_netmask = NetAddr.pack_ip_addr(netmask)
+
+        else
+            # remove '/' if present
+            if (netmask =~ /^\// )
+                netmask[0] = " "
+                netmask.lstrip!
+            end
+            netmask = netmask.to_i
+            packed_netmask = all_f ^ (all_f >> netmask)
+        end
+        
+    elsif (netmask.kind_of?(Integer))
+        to_validate[:Packed] = true
+        NetAddr.validate_ip_netmask(netmask, to_validate)
+        packed_netmask = all_f ^ (all_f >> netmask)
+    
+    else
+        raise ArgumentError, "String or Integer expected for argument 'netmask', " +
+                             "but #{netmask.class} provided." if (!netmask.kind_of?(Integer) && !netmask.kind_of?(String))    
+    end
+    
+    return(packed_netmask)
+end
+module_function :pack_ip_netmask
+
+#==============================================================================#
+# range()
+#==============================================================================#
+
+#===Synopsis
+#Given two CIDR addresses or NetAddr::CIDR objects of the same version,
+#return all IP addresses between them. NetAddr.range will use the original IP 
+#address passed during the initialization of the NetAddr::CIDR objects, or the 
+#base address of any CIDR addresses passed. The default behavior is to be 
+#non-inclusive (dont include boundaries as part of returned data)
+#
+# Example:
+# list = NetAddr.range(cidr1,cidr2, :Limit => 10)
+# list = NetAddr.range('192.168.1.0','192.168.1.10', :Inclusive => true)
+#
+#===Arguments:
+#* Lower boundary CIDR as a String or NetAddr::CIDR object
+#* Upper boundary CIDR as a String or NetAddr::CIDR object
+#* Optional Hash with the following keys:
+#     :Bitstep -- enumerate in X sized steps - Integer (optional)
+#     :Inclusive -- if true, include boundaries in returned data
+#     :Limit -- limit returned list to X number of items - Integer (optional)
+#     :Objectify -- if true, return CIDR objects (optional)
+#     :Short -- if true, return IPv6 addresses in short-hand notation (optional)
+#
+#===Returns:
+#* Array of Strings, or Array of NetAddr::CIDR objects
+#
+def range(cidr1, cidr2, options=nil)
+    known_args = [:Bitstep, :Inclusive, :Limit, :Objectify, :Short]
+    list = []
+    bitstep = 1
+    objectify = false
+    short = false
+    inclusive = false
+    limit = nil
+
+    # if cidr1/cidr2 are not CIDR objects, then attempt to create
+    # cidr objects from them
+    if ( !cidr1.kind_of?(NetAddr::CIDR) )
+        begin
+            cidr1 = NetAddr::CIDR.create(cidr1)
+        rescue Exception => error
+            raise ArgumentError, "Argument 'cidr1' raised the following " +
+                                 "errors: #{error}"
+        end
+    end
+    
+    if ( !cidr2.kind_of?(NetAddr::CIDR))
+        begin
+            cidr2 = NetAddr::CIDR.create(cidr2)
+        rescue Exception => error
+            raise ArgumentError, "Argument 'cidr2' raised the following " +
+                                 "errors: #{error}"
+        end
+    end
+        
+    # validate options
+    if (options)
+        raise ArgumentError, "Hash expected for argument 'options' but #{options.class} provided." if (!options.kind_of?(Hash))
+        NetAddr.validate_args(options.keys,known_args)
+
+        if( options.has_key?(:Bitstep) )
+            bitstep = options[:Bitstep]
+        end
+
+        if( options.has_key?(:Objectify) && options[:Objectify] == true )
+            objectify = true
+        end
+        
+        if( options.has_key?(:Short) && options[:Short] == true )
+            short = true
+        end
+        
+        if( options.has_key?(:Inclusive) && options[:Inclusive] == true )
+            inclusive = true
+        end
+
+        if( options.has_key?(:Limit) )
+            limit = options[:Limit]
+        end
+    end
+
+    # check version, store & sort
+    if (cidr1.version == cidr2.version)
+        version = cidr1.version
+        boundaries = [cidr1.packed_ip, cidr2.packed_ip]
+        boundaries.sort
+    else
+        raise VersionError, "Provided NetAddr::CIDR objects are of different IP versions."
+    end
+
+    # dump our range
+    if (!inclusive)
+        my_ip = boundaries[0] + 1
+        end_ip = boundaries[1]
+    else
+        my_ip = boundaries[0]
+        end_ip = boundaries[1] + 1
+    end
+    
+    until (my_ip >= end_ip) 
+        if (!objectify)
+            my_ip_s = NetAddr.unpack_ip_addr(my_ip, :Version => version)
+            my_ips = NetAddr.shorten(my_ips) if (short && version == 6)
+            list.push(my_ip_s)
+        else
+            list.push( NetAddr::CIDR.create(my_ip, :Version => version) )
+        end
+
+        my_ip = my_ip + bitstep
+        if (limit)
+            limit = limit -1
+            break if (limit == 0)
+        end
+    end
+
+    return(list)
+end
+module_function :range
+
+#==============================================================================#
+# shorten()
+#==============================================================================#
+
+#===Synopsis
+#Take a standard IPv6 address, and format it in short-hand notation.
+#The address should not contain a netmask.
+#
+# Example:
+# short = NetAddr.shorten('fec0:0000:0000:0000:0000:0000:0000:0001')
+#
+#===Arguments:
+#* String
+#
+#===Returns:
+#* String
+#
+def shorten(addr)
+
+    # is this a string?
+    if (!addr.kind_of? String)
+        raise ArgumentError, "Expected String, but #{addr.class} provided."
+    end
+
+    validate_ip_addr(addr, :Version => 6)
+
+    # make sure this isnt already shorthand
+    if (addr =~ /::/)
+        return(addr)
+    end
+
+    # split into fields
+    fields = addr.split(":")
+    
+    # check last field for ipv4-mapped addr
+    if (fields.last() =~ /\./ )
+        ipv4_mapped = fields.pop()
+    end
+    
+    # look for most consecutive '0' fields
+    start_field,end_field = nil,nil
+    start_end = []
+    consecutive,longest = 0,0
+        
+    (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 
+    fields.push(ipv4_mapped) if (ipv4_mapped)   
+    short = fields.join(':')    
+    short << ':' if (short =~ /:$/)
+    
+    return(short)
+end
+module_function :shorten
+
+#==============================================================================#
+# sort()
+#==============================================================================#
+
+#===Synopsis
+#Given a list of CIDR addresses or NetAddr::CIDR objects, 
+#sort them from lowest to highest by Network/Netmask. NetAddr.sort will use the
+#original IP address passed during the initialization of any NetAddr::CIDR 
+#objects, or the base address of any CIDR addresses passed
+#
+# Example:
+# sorted = NetAddr.sort([cidr1,cidr2])
+# sorted = NetAddr.sort(['192.168.1.32/27','192.168.1.0/27','192.168.2.0/24'])
+#
+#===Arguments:
+#* Array of CIDR addresses as Strings, or Array of NetAddr::CIDR objects
+#
+#===Returns:
+#* Array of Strings, or Array of NetAddr::CIDR objects
+#
+def sort(list)
+
+    # make sure list is an array
+    if ( !list.kind_of?(Array) )
+        raise ArgumentError, "Array of NetAddr::CIDR or NetStruct " +
+                             "objects expected, but #{list.class} provided."
+    end
+
+    # make sure all are valid types of the same IP version
+    version = nil
+    cidr_hash = {}
+    list.each do |cidr|
+        if (!cidr.kind_of?(NetAddr::CIDR))
+            begin
+                new_cidr = NetAddr::CIDR.create(cidr)
+            rescue Exception => error
+                raise ArgumentError, "An element of the provided Array " +
+                                     "raised the following errors: #{error}"
+            end
+        else
+            new_cidr = cidr
+        end
+        cidr_hash[new_cidr] = cidr
+        
+        version = new_cidr.version if (!version)
+        unless (new_cidr.version == version)
+            raise VersionError, "Provided CIDR addresses must all be of the same IP version."
+        end 
+    end
+
+    # sort by network. if networks are equal, sort by netmask.
+    sorted_list = []
+    cidr_hash.each_key do |entry|
+        index = 0
+        sorted_list.each do
+            if(entry.packed_network < (sorted_list[index]).packed_network)
+                break
+            elsif (entry.packed_network == (sorted_list[index]).packed_network)
+                if (entry.packed_netmask < (sorted_list[index]).packed_netmask)
+                    break
+                end
+            end
+            index += 1
+        end
+        sorted_list.insert(index, entry)
+    end
+    
+    # return original values passed
+    ret_list = []
+    sorted_list.each {|x| ret_list.push(cidr_hash[x])}
+
+    return(ret_list)
+end
+module_function :sort
+
+#==============================================================================#
+# unpack_ip_addr()
+#==============================================================================#
+
+#===Synopsis
+#Unack a packed IP address back into a printable string. Will attempt
+#to auto-detect IP version if not provided.
+#
+# Example:
+# unpacked = NetAddr.unpack_ip_addr(3232235906)
+# unpacked = NetAddr.unpack_ip_addr(packed, :Version => 6)
+#
+#===Arguments:
+#* Packed IP address as an Integer
+#* Optional Hash with the following keys:
+#     :Version -- IP version - Integer (optional)
+#     :IPv4Mapped -- if true, unpack IPv6 as an IPv4 mapped address (optional)
+#
+#===Returns:
+#* String
+#
+def unpack_ip_addr(packed_ip, options=nil)
+    known_args = [:Version, :IPv4Mapped]
+    ipv4_mapped = false
+    to_validate = {}
+    
+    # validate options
+    if (options)
+        raise ArgumentError, "Hash expected for argument 'options' but #{options.class} provided." if (!options.kind_of?(Hash))
+        NetAddr.validate_args(options.keys,known_args)
+        
+        if (options.has_key?(:Version))
+            version = options[:Version]
+            to_validate[:Version] = version
+            if (version != 4 && version != 6)
+                raise VersionError, ":Version should be 4 or 6, but was '#{version}'."
+            end
+        end
+    
+        if (options.has_key?(:IPv4Mapped) && options[:IPv4Mapped] == true)
+            ipv4_mapped = true
+        end
+    end
+    
+    # validate
+    raise ArgumentError, "Integer expected for argument 'packed_ip', " +
+                         "but #{packed_ip.class} provided." if (!packed_ip.kind_of?(Integer))
+    NetAddr.validate_ip_addr(packed_ip, to_validate)
+    
+    # set version if not set
+    if (!version)
+        if (packed_ip < 2**32)
+            version = 4
+        else
+            version = 6
+        end
+    end
+    
+    if (version == 4)
+        octets = []
+        4.times do
+            octet = packed_ip & 0xFF
+            octets.unshift(octet.to_s)
+            packed_ip = packed_ip >> 8
+        end
+        ip = octets.join('.')
+    else
+        fields = []
+        if (!ipv4_mapped)
+            loop_count = 8
+        else
+            loop_count = 6
+            packed_v4 = packed_ip & 0xffffffff
+            ipv4_addr = NetAddr.unpack_ip_addr(packed_v4, :Version => 4)
+            fields.unshift(ipv4_addr)
+            packed_ip = packed_ip >> 32
+        end
+        
+        loop_count.times do 
+            octet = packed_ip & 0xFFFF
+            octet = octet.to_s(16)
+            packed_ip = packed_ip >> 16
+
+            # if octet < 4 characters, then pad with 0's
+            (4 - octet.length).times do
+                octet = '0' << octet
+            end
+            fields.unshift(octet)
+        end        
+        ip = fields.join(':')
+    end
+    
+
+    return(ip)
+end
+module_function :unpack_ip_addr 
+
+#==============================================================================#
+# unpack_ip_netmask()
+#==============================================================================#
+
+#===Synopsis
+#Unpack a packed IP netmask into an Integer representing the number of
+#bits in the CIDR mask.
+#
+# Example:
+# unpacked = NetAddr.unpack_ip_netmask(0xfffffffe)
+#
+#===Arguments:
+#* Packed netmask as an Integer
+#
+#===Returns:
+#* Integer
+#
+def unpack_ip_netmask(packed_netmask)
+    
+    # validate packed_netmask
+    raise ArgumentError, "Integer expected for argument 'packed_netmask', " +
+                         "but #{packed_netmask.class} provided." if (!packed_netmask.kind_of?(Integer))    
+    
+    if (packed_netmask < 2**32)
+        mask = 32
+        NetAddr.validate_ip_netmask(packed_netmask, :Packed => true, :Version => 4)
+    else
+        NetAddr.validate_ip_netmask(packed_netmask, :Packed => true, :Version => 6)
+        mask = 128
+    end
+    
+    
+    mask.times do    
+        if ( (packed_netmask & 1) == 1)
+            break
+        end
+        packed_netmask = packed_netmask >> 1
+        mask = mask - 1
+    end
+
+    return(mask)
+end
+module_function :unpack_ip_netmask 
+
+#==============================================================================#
+# unshorten()
+#==============================================================================#
+
+#===Synopsis
+#Take an IPv6 address in short-hand format, and expand it into standard
+#notation. The address should not contain a netmask.
+#
+# Example:
+# long = NetAddr.unshorten('fec0::1')
+#
+#===Arguments:
+#* CIDR address as a String
+#
+#===Returns:
+#* String
+#
+def unshorten(ip)
+
+    # is this a string?
+    if (!ip.kind_of? String)
+        raise ArgumentError, "Expected String, but #{ip.class} provided."
+    end
+
+    validate_ip_addr(ip, :Version => 6)
+    ipv4_mapped = true if (ip =~ /\./)
+    
+    packed = pack_ip_addr(ip, :Version => 6)    
+    if (!ipv4_mapped)
+        long = unpack_ip_addr(packed, :Version => 6)
+    else
+        long = unpack_ip_addr(packed, :Version => 6, :IPv4Mapped => true)
+    end
+    
+    return(long)
+end
+module_function :unshorten
+
+#==============================================================================#
+# validate_eui()
+#==============================================================================#
+
+#===Synopsis
+#Validate an EUI-48 or EUI-64 address. Raises NetAddr::ValidationError on validation failure.
+#
+# Example:
+# NetAddr.validate_eui('01-00-5e-12-34-56')
+#
+# - Arguments
+#* EUI address as a String
+#
+#===Returns:
+#* True
+#
+def validate_eui(eui)
+    if (eui.kind_of?(String))
+        # check for invalid characters
+        if (eui =~ /[^0-9a-fA-f\.\-\:]/)
+            raise ValidationError, "#{eui} is invalid (contains invalid characters)."
+        end
+            
+        # split on formatting characters & check lengths
+        if (eui =~ /\-/)
+            fields = eui.split('-')
+            if (fields.length != 6 && fields.length != 8)
+                raise ValidationError, "#{eui} is invalid (unrecognized formatting)."
+            end
+            fields.each {|x| raise ValidationError, "#{eui} is invalid (missing characters)." if (x.length != 2)} 
+        elsif (eui =~ /\:/)
+            fields = eui.split(':')
+            if (fields.length != 6 && fields.length != 8)
+                raise ValidationError, "#{eui} is invalid (unrecognized formatting)."
+            end
+            fields.each {|x| raise ValidationError, "#{eui} is invalid (missing characters)." if (x.length != 2)}
+        elsif (eui =~ /\./)
+            fields = eui.split('.')
+            if (fields.length != 3 && fields.length != 4)
+                raise ValidationError, "#{eui} is invalid (unrecognized formatting)."
+            end
+            fields.each {|x| raise ValidationError, "#{eui} is invalid (missing characters)." if (x.length != 4)}
+        else
+            raise ValidationError, "#{eui} is invalid (unrecognized formatting)."
+        end
+
+    else
+        raise ArgumentError, "EUI address should be a String, but was a#{eui.class}."
+    end
+    return(true)
+end
+module_function :validate_eui
+
+#==============================================================================#
+# validate_ip_addr()
+#==============================================================================#
+
+#===Synopsis
+#Validate an IP address. The address should not contain a netmask.
+#IP version will attempt to be auto-detected if not provided. 
+#Raises NetAddr::ValidationError on validation failure.
+#
+# Example:
+# NetAddr.validate_ip_addr('192.168.1.1')
+# NetAddr.validate_ip_addr('ffff::1', :Version => 6)
+# NetAddr.validate_ip_addr('::192.168.1.1')
+# NetAddr.validate_ip_addr(0xFFFFFF)
+# NetAddr.validate_ip_addr(2**128-1)
+# NetAddr.validate_ip_addr(2**32-1, :Version => 4)
+#
+#===Arguments
+#* IP address as a String or Integer
+#* Optional Hash with the following keys:
+#     :Version -- IP version - Integer (optional)
+#
+#===Returns:
+#* True
+#
+def validate_ip_addr(ip, options=nil)
+    known_args = [:Version]
+    
+    # validate options
+    if (options)
+        raise ArgumentError, "Hash expected for argument 'options' but #{options.class} provided." if (!options.kind_of?(Hash))
+        NetAddr.validate_args(options.keys,known_args)
+        
+        if (options.has_key?(:Version))
+            version = options[:Version]
+            if (version != 4 && version != 6)
+                raise ArgumentError, ":Version should be 4 or 6, but was '#{version}'."
+            end
+        end
+    end
+    
+    if ( ip.kind_of?(String) )
+        
+        # check validity of charaters
+        if (ip =~ /[^0-9a-fA-F\.:]/)
+            raise ValidationError, "#{ip} is invalid (contains invalid characters)."
+        end
+        
+        # determine version if not specified
+        if (!version && (ip =~ /\./ && ip !~ /:/ ) )
+            version = 4
+        elsif (!version && ip =~ /:/)
+            version = 6
+        end        
+        
+        if (version == 4)
+            octets = ip.split('.')            
+            raise ValidationError, "#{ip} is invalid (IPv4 requires (4) octets)." if (octets.length != 4)
+            
+            # are octets in range 0..255?
+            octets.each do |octet|
+                raise ValidationError, "#{ip} is invalid (IPv4 dotted-decimal format " +
+                                       "should not contain non-numeric characters)." if (octet =~ /[^0-9]/ )                
+                octet = octet.to_i()                
+                if ( (octet < 0) || (octet >= 256) )
+                    raise ValidationError, "#{ip} is invalid (IPv4 octets should be between 0 and 255)."
+                end
+            end        
+        
+        elsif (version == 6)
+            # make sure we only have at most (2) colons in a row, and then only
+            # (1) instance of that
+            if ( (ip =~ /:{3,}/) || (ip.split("::").length > 2) )
+                raise ValidationError, "#{ip} is invalid (IPv6 field separators (:) are bad)."
+            end            
+            
+            # set flags
+            shorthand = false
+            if (ip =~ /\./)
+                dotted_dec = true 
+            else
+                dotted_dec = false
+            end            
+            
+            # split up by ':'
+            fields = []
+            if (ip =~ /::/)
+                shorthand = true
+                ip.split('::').each do |x|
+                    fields.concat( x.split(':') )
+                end
+            else
+               fields.concat( ip.split(':') ) 
+            end
+            
+            # make sure we have the correct number of fields
+            if (shorthand)
+                if ( (dotted_dec && fields.length > 6) || (!dotted_dec && fields.length > 7) )
+                    raise ValidationError, "#{ip} is invalid (IPv6 shorthand notation has " +
+                                           "incorrect number of fields)." 
+                end                
+            else
+                if ( (dotted_dec && fields.length != 7 ) || (!dotted_dec && fields.length != 8) )
+                    raise ValidationError, "#{ip} is invalid (IPv6 address has " +
+                                           "incorrect number of fields)." 
+                end
+            end
+            
+            # if dotted_dec then validate the last field
+            if (dotted_dec)
+                dotted = fields.pop()
+                octets = dotted.split('.')
+                raise ValidationError, "#{ip} is invalid (Legacy IPv4 portion of IPv6 " +
+                                       "address should contain (4) octets)." if (octets.length != 4)
+                octets.each do |x|
+                    raise ValidationError, "#{ip} is invalid (egacy IPv4 portion of IPv6 " +
+                                           "address should not contain non-numeric characters)." if (x =~ /[^0-9]/ )
+                    x = x.to_i
+                    if ( (x < 0) || (x >= 256) )
+                        raise ValidationError, "#{ip} is invalid (Octets of a legacy IPv4 portion of IPv6 " +
+                                               "address should be between 0 and 255)."
+                    end
+                end
+            end
+            
+            # validate hex fields
+            fields.each do |x|
+                if (x =~ /[^0-9a-fA-F]/)
+                    raise ValidationError, "#{ip} is invalid (IPv6 address contains invalid hex characters)."
+                else
+                    x = x.to_i(16)
+                    if ( (x < 0) || (x >= 2**16) )
+                        raise ValidationError, "#{ip} is invalid (Fields of an IPv6 address " +
+                                               "should be between 0x0 and 0xFFFF)."
+                    end
+                end
+            end
+            
+        else
+            raise ValidationError, "#{ip} is invalid (Did you mean to pass an Integer instead of a String?)."        
+        end
+
+    elsif ( ip.kind_of?(Integer) )
+        if (version && version == 4)
+            raise ValidationError, "#{ip} is invalid for IPv4 (Integer is out of bounds)." if ( (ip < 0) || (ip > 2**32-1) )
+        else
+            raise ValidationError, "#{ip} is invalid for IPv6 (Integer is out of bounds)." if ( (ip < 0) || (ip > 2**128-1) )
+        end
+        
+    else
+        raise ArgumentError, "Integer or String expected for argument 'ip' but " +
+                             "#{ip.class} provided." if (!ip.kind_of?(String) && !ip.kind_of?(Integer))
+    end
+
+    
+    return(true)
+end
+module_function :validate_ip_addr
+
+#==============================================================================#
+# validate_ip_netmask()
+#==============================================================================#
+
+#===Synopsis
+#Validate IP Netmask.Version defaults to 4 if not specified. 
+#Raises NetAddr::ValidationError on validation failure.
+#
+# Examples:
+# NetAddr.validate_ip_netmask('/32')
+# NetAddr.validate_ip_netmask(32)
+# NetAddr.validate_ip_netmask(0xffffffff, :Packed => true)
+#
+#===Arguments:
+#* Netmask as a String or Integer
+#* Optional Hash with the following keys:
+#     :Packed -- if true, the provided Netmask is a packed Integer
+#     :Version -- IP version - Integer (optional)
+#
+#===Returns:
+#* True
+#
+def validate_ip_netmask(netmask, options=nil)
+    known_args = [:Packed, :Version]
+    packed = false
+    version = 4
+    max_bits = 32
+    
+    # validate options
+    if (options)
+        raise ArgumentError, "Hash expected for argument 'options' but #{options.class} provided." if (!options.kind_of?(Hash))
+        NetAddr.validate_args(options.keys,known_args)
+        
+        if (options.has_key?(:Packed) && options[:Packed] == true)
+            packed = true
+        end
+    
+        if (options.has_key?(:Version))
+            version = options[:Version]
+            if (version != 4 && version != 6)
+                raise ArgumentError, ":Version should be 4 or 6, but was '#{version}'."
+            elsif (version == 6)
+                max_bits = 128
+            else
+                max_bits = 32
+            end
+        end    
+    end
+    
+    if (netmask.kind_of?(String))
+        if(netmask =~ /\./)
+            all_f = 2**32-1
+            packed_netmask = 0
+        
+            # validate & pack extended mask
+            begin
+                validate_ip_addr(netmask)
+                packed_netmask = pack_ip_addr(netmask)
+            rescue Exception
+                raise ValidationError, "#{netmask} is an improperly formed IPv4 address."
+            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 ValidationError, "#{netmask} contains '1' bits within the host portion of the 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 ValidationError, "#{netmask} contains invalid characters."
+            end
+
+            netmask = netmask.to_i
+            if (netmask > max_bits || netmask == 0 )
+                raise ValidationError, "Netmask, #{netmask}, is out of bounds for IPv#{version}." 
+            end
+
+        end
+        
+    elsif (netmask.kind_of?(Integer) )
+        if (!packed)
+            if (netmask > max_bits || netmask == 0 )
+                raise ValidationError, "Netmask, #{netmask}, is out of bounds for IPv#{version}." 
+            end
+        else
+            if (netmask >= 2**max_bits || netmask == 0 )
+                raise ValidationError, "Packed netmask, #{netmask}, is out of bounds for IPv#{version}."
+            end
+        end
+        
+    else
+        raise ArgumentError, "Integer or String expected for argument 'netmask' but " +
+                             "#{netmask.class} provided." if (!netmask.kind_of?(String) && !netmask.kind_of?(Integer))
+    end
+
+    return(true)
+end
+module_function :validate_ip_netmask
+
+#==============================================================================#
+# NetStruct
+#==============================================================================#
+
+#===NetStruct
+# Struct object used internally by NetAddr. It is not likely directly useful
+# to anyone.
+#
+# Description of fields:
+#   * cidr - NetAddr::CIDR object
+#   * parent - parent NetStruct in tree
+#   * children - Array of children NetStruct objects
+#
+NetStruct = Struct.new(:cidr, :parent, :children)
+
+
+# PRIVATE METHODS
+private
+
+
+#==============================================================================#
+# validate_args()
+#==============================================================================#
+
+# validate options hash 
+#
+def validate_args(to_validate,known_args)
+    to_validate.each do |x|
+        raise ArgumentError, "Unrecognized argument #{x}. Valid arguments are " +
+                             "#{known_args.join(',')}" if (!known_args.include?(x))
+    end
+end 
+module_function :validate_args
+
+end # module NetAddr
+
+__END__
+