netaddr 1.1.0 → 1.2.0

data/lib/cidr_shortcuts.rb

@@ -0,0 +1,334 @@
+module NetAddr
+private
+
+# CIDR METHODS
+
+#==============================================================================#
+# cidr_build()
+#==============================================================================#
+
+# create either a CIDRv4 or CIDRv6 object
+#
+def cidr_build(version, ip, netmask=nil, tag={}, wildcard_mask=nil, wildcard_mask_bit_flipped=false)
+     return( NetAddr::CIDRv4.new(ip, netmask, tag, wildcard_mask, wildcard_mask_bit_flipped) ) if (version == 4)
+     return( NetAddr::CIDRv6.new(ip, netmask, tag, wildcard_mask, wildcard_mask_bit_flipped) )
+end
+module_function :cidr_build
+
+#==============================================================================#
+# cidr_compare()
+#==============================================================================#
+
+# compare 2 CIDR objects
+#
+#return:
+#* 1 if the cidr1 contains cidr2
+#* 0 if the cidr1 and cidr2 are equal
+#* -1 if cidr1 is a subnet of cidr2
+#* nil if the two are unrelated
+#
+def cidr_compare(cidr1,cidr2)
+    comparasin = nil
+    if ( (cidr1.packed_network == cidr2.packed_network))
+        # same network, check netmask
+        if (cidr1.packed_netmask == cidr2.packed_netmask)
+            comparasin = 0
+        elsif(cidr1.packed_netmask < cidr2.packed_netmask)
+            comparasin = 1
+        elsif(cidr1.packed_netmask > cidr2.packed_netmask)
+            comparasin = -1
+        end
+
+    elsif( (cidr2.packed_network | cidr1.packed_hostmask) == (cidr1.packed_network | cidr1.packed_hostmask) )
+        # cidr1 contains cidr2
+        comparasin = 1
+
+    elsif( (cidr2.packed_network | cidr2.packed_hostmask) == (cidr1.packed_network | cidr2.packed_hostmask) )
+        # cidr2 contains cidr1
+        comparasin = -1
+    end
+
+    return(comparasin)
+end
+module_function :cidr_compare
+
+#==============================================================================#
+# cidr_gt_lt()
+#==============================================================================#
+
+# given a pair of CIDRs, determine if first is greater than or less than the second
+#
+# return 1 if cidr1 > cidr2
+# return 0 if cidr1 == cidr2
+# return -1 if cidr1 < cidr2
+#
+def cidr_gt_lt(cidr1,cidr2)
+    gt_lt = 1
+    if(cidr1.packed_network < cidr2.packed_network)
+        gt_lt = -1
+    elsif (cidr1.packed_network == cidr2.packed_network)
+        if (cidr1.packed_netmask < cidr2.packed_netmask)
+            gt_lt = -1
+        elsif (cidr1.packed_netmask == cidr2.packed_netmask)
+            gt_lt = 0
+        end
+    end
+
+    return(gt_lt)
+end
+module_function :cidr_gt_lt
+
+#==============================================================================#
+# cidr_fill_in()
+#==============================================================================#
+
+#Given a list of subnets of supernet, return a new list with any
+#holes (missing subnets) filled in.
+#
+def cidr_fill_in(supernet,list)
+        # sort our cidr's and see what is missing
+        complete_list = []
+        expected = supernet.packed_network
+        all_f = supernet.all_f
+        version = supernet.version
+
+        NetAddr.cidr_sort(list).each do |cidr|
+            network = cidr.packed_network
+            bitstep = (all_f + 1) - cidr.packed_netmask
+
+            if (network > expected)
+                num_ips_missing = network - expected
+                sub_list = cidr_make_subnets_from_base_and_ip_count(supernet,expected,num_ips_missing)
+                complete_list.concat(sub_list)
+            elsif (network < expected)
+                next
+            end
+
+            complete_list.push(NetAddr.cidr_build(version,network,cidr.packed_netmask))
+            expected = network + bitstep
+        end
+
+        # if expected is not the next subnet, then we're missing subnets 
+        # at the end of the cidr
+        next_sub = supernet.next_subnet(:Objectify => true).packed_network
+        if (expected != next_sub)
+            num_ips_missing = next_sub - expected
+            sub_list = cidr_make_subnets_from_base_and_ip_count(supernet,expected,num_ips_missing)
+            complete_list.concat(sub_list)
+        end
+
+        return(complete_list)
+end
+module_function :cidr_fill_in
+
+#==============================================================================#
+# cidr_find_in_list()
+#==============================================================================#
+
+# evaluate cidr against list of cidrs.
+#
+# return entry from list if entry is supernet of cidr (first matching entry)
+# return index # of entry if entry is a duplicate of cidr
+# return nil if no match found
+#
+def cidr_find_in_list(cidr,list)
+    return(nil) if (list.length == 0)
+
+    match = nil
+    low = 0
+    high = list.length - 1
+    index = low + ( (high-low)/2 )
+    while ( low <= high)
+        cmp = cidr_gt_lt(cidr,list[index])
+        if ( cmp == -1 )
+            high = index - 1
+
+        elsif ( cmp == 1 )
+            if (cidr_compare(cidr,list[index]) == -1)
+                match = list[index]
+                break
+            end
+            low = index + 1
+
+        else
+            match = index
+            break
+        end
+        index = low + ( (high-low)/2 )
+    end
+    return(match)
+end
+module_function :cidr_find_in_list
+
+#==============================================================================#
+# cidr_make_subnets_from_base_and_ip_count()
+#==============================================================================#
+
+# Make CIDR addresses from a base addr and an number of ip's to encapsulate.
+#
+#===Arguments:
+#   * base ip as packed integer
+#   * number of ip's required
+#
+#===Returns:
+#   * array of NetAddr::CIDR objects
+#
+    def cidr_make_subnets_from_base_and_ip_count(cidr,base_addr,ip_count)
+        list = []
+        until (ip_count == 0)
+            mask = cidr.all_f
+            multiplier = 0
+            bitstep = 0
+            last_addr = base_addr
+            done = false
+            until (done == true)
+                if (bitstep < ip_count && (base_addr & mask == last_addr & mask) )
+                    multiplier += 1
+                elsif (bitstep > ip_count || (base_addr & mask != last_addr & mask) )
+                    multiplier -= 1
+                    done = true
+                else
+                    done = true
+                end
+                bitstep = 2**multiplier
+                mask = cidr.all_f << multiplier & cidr.all_f
+                last_addr = base_addr + bitstep - 1
+            end
+
+            list.push(NetAddr.cidr_build(cidr.version,base_addr,mask))
+            ip_count -= bitstep
+            base_addr += bitstep
+        end
+
+        return(list)
+    end
+module_function :cidr_make_subnets_from_base_and_ip_count
+
+#==============================================================================#
+# cidr_sort()
+#==============================================================================#
+
+# given a list of NetAddr::CIDRs, return them as a sorted list
+#
+def cidr_sort(list)
+    # uses simple quicksort algorithm
+    sorted_list = []
+    if (list.length < 1)
+        sorted_list = list
+    else
+        less_list = []
+        greater_list = []
+        equal_list = []
+        pivot = list[rand(list.length)]
+        list.each do |x|
+            gt_lt = cidr_gt_lt(pivot,x)
+            if (gt_lt == 1)
+                less_list.push(x)
+            elsif (gt_lt == -1)
+                greater_list.push(x)
+            else
+                equal_list.push(x)
+            end
+        end
+        sorted_list.concat( cidr_sort(less_list) )
+        sorted_list.concat(equal_list)
+        sorted_list.concat( cidr_sort(greater_list) )
+    end
+
+    return(sorted_list)
+end
+module_function :cidr_sort
+
+#==============================================================================#
+# cidr_summarize()
+#==============================================================================#
+
+# given a list of NetAddr::CIDRs (of the same version) summarize them
+#
+# return a hash, with the key = summary address and val = array of original cidrs
+#
+def cidr_summarize(subnet_list)
+    all_f = subnet_list[0].all_f
+    version = subnet_list[0].version
+    subnet_list = cidr_sort(subnet_list)
+
+    # continue summarization attempts until sorted_list stops getting shorter
+    sorted_list = subnet_list.dup
+    sorted_list_len = sorted_list.length
+    while (1)
+        summarized_list = []
+        until (sorted_list.length == 0)
+            cidr = sorted_list.shift
+            network, netmask = cidr.packed_network, cidr.packed_netmask
+            supermask = (netmask << 1) & all_f
+            supernet = supermask & network
+
+            if (network == supernet && sorted_list.length > 0)
+                # network is lower half of supernet, so see if we have the upper half
+                bitstep = (all_f + 1) - netmask
+                expected = network + bitstep
+                next_cidr = sorted_list.shift
+                next_network, next_netmask = next_cidr.packed_network, next_cidr.packed_netmask
+
+                if ( (next_network == expected) && (next_netmask == netmask) )
+                    # we do indeed have the upper half. store new supernet.
+                    summarized_list.push( cidr_build(version,supernet,supermask) )
+                else
+                    # we do not have the upper half. put next_cidr back into sorted_list
+                    # and store only the original network
+                    sorted_list.unshift(next_cidr)
+                    summarized_list.push(cidr)
+                end
+            else
+                # network is upper half of supernet, so save original network only
+                summarized_list.push(cidr)
+            end
+
+        end
+
+        sorted_list = summarized_list.dup
+        break if (sorted_list.length == sorted_list_len)
+        sorted_list_len = sorted_list.length
+    end
+
+    # clean up summarized_list
+    unique_list = {}
+    summarized_list.reverse.each do |supernet|
+        next if ( unique_list.has_key?(supernet.desc) )
+        # remove duplicates
+        unique_list[supernet.desc] = supernet
+
+        # remove any summary blocks that are children of other summary blocks
+        index = 0
+        until (index >= summarized_list.length)
+            subnet = summarized_list[index]
+            if (subnet &&  cidr_compare(supernet,subnet) == 1 )
+                subnet_list[index] = nil
+            end
+            index += 1
+        end
+    end
+    summarized_list = unique_list.values
+
+    # map original blocks to their summaries
+    summarized_list.each do |supernet|
+        supernet.tag[:Subnets] = []
+        index = 0
+        until (index >= subnet_list.length)
+            subnet = subnet_list[index]
+            if (subnet && cidr_compare(supernet,subnet) == 1 )
+                subnet_list[index] = nil
+                supernet.tag[:Subnets].push(subnet)
+            end
+            index += 1
+        end
+    end
+
+    return( NetAddr.cidr_sort(summarized_list) )
+end
+module_function :cidr_summarize
+
+
+end # module NetAddr
+
+__END__

data/lib/eui.rb

@@ -40,7 +40,7 @@ private_class_method :new
 # addr = NetAddr::EUI.new('aa-bb-cc-dd-ee-ff-00-01')
 #
 #===Arguments
-#* EUI as a String
+#* eui = EUI as a String
 #
 #===Returns
 #* EUI48 or EUI64 object
@@ -62,7 +62,7 @@ private_class_method :new
         else
             eui = NetAddr::EUI64.new(eui.to_i(16))
         end
-        
+
         return(eui)
     end
 
@@ -76,8 +76,8 @@ private_class_method :new
 # puts addr.address(:Delimiter => '.')   --> 'aabb.ccdd.eeff'
 #
 #===Arguments:
-#* Optional Hash with the following fields:
-#    :Delimiter -- delimitation character. valid values are (-,:,and .) (optional)
+#* options = Hash with the following fields:
+#    :Delimiter -- delimitation character. valid values are (-,:,and .)
 #
 #===Returns:
 #* String
@@ -135,8 +135,8 @@ private_class_method :new
 # puts addr.ei(:Delimiter => '-')
 #
 #===Arguments:
-#* Optional Hash with the following fields:
-#    :Delimiter -- delimitation character. valid values are (-, and :) (optional)
+#* options = Hash with the following fields:
+#    :Delimiter -- delimitation character. valid values are (-, and :)
 #
 #===Returns:
 #* String
@@ -173,9 +173,9 @@ private_class_method :new
 # 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)
+#* options = Hash with the following fields:
+#    :Short -- if true, return IPv6 addresses in short-hand notation
+#    :Objectify -- if true, return CIDR objects
 #
 #===Returns:
 #* CIDR address String or an NetAddr::CIDR object
@@ -228,8 +228,8 @@ private_class_method :new
 # puts addr.oui(:Delimiter => '-')
 #
 #===Arguments:
-#* Optional Hash with the following fields:
-#    :Delimiter -- delimitation character. valid values are (-, and :) (optional)
+#* options = Hash with the following fields:
+#    :Delimiter -- delimitation character. valid values are (-, and :) 
 #
 #===Returns:
 #* String
@@ -323,12 +323,12 @@ public_class_method :new
 #* 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))        
+        elsif(eui.kind_of?(String))
             # validate
             NetAddr.validate_eui(eui)
 
@@ -361,15 +361,15 @@ public_class_method :new
 # addr = NetAddr::EUI64.new('aa-bb-cc-dd-ee-ff-00-01')
 #
 #===Arguments:
-#* EUI as a String or Integer
+#* eui = 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))            
+        elsif(eui.kind_of?(String))
             # validate
             NetAddr.validate_eui(eui)
 

data/lib/ip_math.rb

@@ -0,0 +1,241 @@
+module NetAddr
+private
+
+
+# IP MATH METHODS
+
+#==============================================================================#
+# bits_to_mask()
+#==============================================================================#
+
+# convert a netmask (in bits) to an integer mask
+#
+def bits_to_mask(netmask,version)
+    return(0) if (netmask == 0)
+    all_f = 2**32-1
+    all_f = 2**128-1 if (version == 6)
+    return( all_f ^ (all_f >> netmask) )
+end
+module_function :bits_to_mask
+
+#==============================================================================#
+# detect_ip_version()
+#==============================================================================#
+
+# determine the ip version from ip address string.
+#
+# return 4, 6, or nil
+#
+def detect_ip_version(ip)
+    version = nil
+    if ( ip =~ /\./ && ip !~ /:/ )
+        version = 4
+    elsif (ip =~ /:/)
+        version = 6
+    else
+        raise ValidationError, "Count not auto-detect IP version for '#{ip}'."
+    end
+    return(version)
+end
+module_function :detect_ip_version
+
+#==============================================================================#
+# ip_count_to_size()
+#==============================================================================#
+
+# given an ip count, determine the most appropriate mask (in bits)
+#
+def ip_count_to_size(ipcount,version,extended=false)
+    address_len = 32
+    address_len = 128 if (version == 6 )
+
+    if (ipcount > 2**address_len) 
+        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 = address_len - bits_needed
+
+    return( ip_int_to_str(bits_to_mask(subnet_bits, 4), 4) ) if (extended && version == 4)
+    return(subnet_bits)
+end
+module_function :ip_count_to_size
+
+#==============================================================================#
+# ip_int_to_str()
+#==============================================================================#
+
+# unpack an int into an ip address string
+#
+def ip_int_to_str(packed_ip, version, ipv4_mapped=nil)
+    ip = nil
+    version = 4 if (!version && packed_ip < 2**32)
+    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 = ip_int_to_str(packed_v4, 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 :ip_int_to_str
+
+#==============================================================================#
+# ip_str_to_int()
+#==============================================================================#
+
+# convert an ip string into an int
+#
+def ip_str_to_int(ip,version)
+    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
+    return(packed_ip)
+end
+module_function :ip_str_to_int
+
+#==============================================================================#
+# mask_to_bits()
+#==============================================================================#
+
+# convert integer into a cidr formatted netmask (bits)
+#
+def mask_to_bits(packed_netmask)
+    return(packed_netmask) if (packed_netmask == 0)
+
+    mask = nil
+    if (packed_netmask < 2**32)
+        mask = 32
+        validate_netmask_int(packed_netmask, 4, true)
+    else
+        mask = 128
+        validate_netmask_int(packed_netmask, 6, true)
+    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 :mask_to_bits
+
+#==============================================================================#
+# netmask_str_to_int()
+#==============================================================================#
+
+# convert string into integer mask
+#
+def netmask_str_to_int(netmask,version)
+    packed_netmask = nil
+    all_f = 2**32-1
+    all_f = 2**128-1 if (version == 6)
+    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
+    return(packed_netmask)
+end
+module_function :netmask_str_to_int
+
+
+
+end # module NetAddr
+
+__END__
+