netaddr 1.4.0 → 1.5.3

data/lib/cidr_shortcuts.rb

@@ -3,10 +3,6 @@ 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)
@@ -15,9 +11,6 @@ def cidr_build(version, ip, netmask=nil, tag={}, wildcard_mask=nil, wildcard_mas
 end
 module_function :cidr_build
 
-#==============================================================================#
-# cidr_compare()
-#==============================================================================#
 
 # compare 2 CIDR objects
 #
@@ -52,10 +45,6 @@ def cidr_compare(cidr1,cidr2)
 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
@@ -78,10 +67,6 @@ def cidr_gt_lt(cidr1,cidr2)
 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.
 #
@@ -120,10 +105,6 @@ def cidr_fill_in(supernet,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)
@@ -159,10 +140,6 @@ def cidr_find_in_list(cidr,list)
 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:
@@ -204,10 +181,6 @@ module_function :cidr_find_in_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, desc=false)
@@ -258,10 +231,6 @@ def cidr_sort(list, desc=false)
 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
@@ -322,7 +291,7 @@ def cidr_summarize(subnet_list)
         until (index >= summarized_list.length)
             subnet = summarized_list[index]
             if (subnet &&  cidr_compare(supernet,subnet) == 1 )
-                subnet_list[index] = nil
+                unique_list.delete(subnet.desc)
             end
             index += 1
         end
@@ -347,9 +316,30 @@ def cidr_summarize(subnet_list)
 end
 module_function :cidr_summarize
 
-#==============================================================================#
-# netmask_sort()
-#==============================================================================#
+# given a list of NetAddr::CIDRs (of the same version), return only the 'top level' blocks (i.e. blocks not
+# contained by other blocks
+
+def cidr_supernets(subnet_list)
+    summary_list = []
+    subnet_list = netmask_sort(subnet_list)
+    subnet_list.each do |child|
+        is_parent = true
+        summary_list.each do |parent|
+            if (NetAddr.cidr_compare(parent,child) == 1)
+                is_parent = false
+                parent.tag[:Subnets].push(child)
+            end
+        end
+
+        if (is_parent)
+            child.tag[:Subnets] = []
+            summary_list.push(child)
+        end
+    end
+
+    return(summary_list)
+end
+module_function :cidr_supernets
 
 # given a list of NetAddr::CIDRs, return them as a sorted (by netmask) list
 #

data/lib/eui.rb

@@ -1,9 +1,3 @@
-=begin rdoc
- Copyleft (c) 2006 Dustin Spinhirne
-
- Licensed under the same terms as Ruby, No Warranty is provided.
-=end
-
 module NetAddr
 
 #=EUI - Extended Unique Identifier
@@ -27,10 +21,6 @@ class EUI
 
 private_class_method :new
 
-#==============================================================================#
-# initialize()
-#==============================================================================#
-
 #===Synopsis
 # This method performs absolutely no error checking, and is meant to be used only by
 # other internal methods for the sake of the speedier creation of EUI objects.
@@ -71,10 +61,6 @@ private_class_method :new
 
     end
 
-#==============================================================================#
-# create()
-#==============================================================================#
-
 #===Synopsis
 #Create a new EUI48 or EUI64 object.
 #
@@ -95,7 +81,8 @@ private_class_method :new
             raise ArgumentError, "Expected String, but #{eui.class} provided."
         end
 
-        # validate
+        # create local copy & validate
+        eui = eui.dup
         NetAddr.validate_eui(eui)
 
         # remove formatting characters
@@ -110,10 +97,6 @@ private_class_method :new
         return(eui)
     end
 
-#==============================================================================#
-# address()
-#==============================================================================#
-
 #===Synopsis
 # Returns EUI address. The default address format is xxxx.xxxx.xxxx
 #
@@ -146,30 +129,14 @@ private_class_method :new
         end
 
         if (delimiter == '-' || delimiter == ':')
-                    addr = octets.join(delimiter)
+            addr = octets.join(delimiter)
         elsif (delimiter == '.')
-                toggle = 0
-                octets.each do |x|
-                    if (!addr)
-                        addr = x
-                        toggle = 1
-                    elsif (toggle == 0)
-                        addr = addr  << '.' << x
-                        toggle = 1
-                    else
-                        addr = addr << x
-                        toggle = 0
-                    end
-                end
+            addr = octets.each_slice(2).to_a.map(&:join).join('.')
         end
 
         return(addr)
     end
 
-#==============================================================================#
-# ei()
-#==============================================================================#
-
 #===Synopsis
 #Returns Extended Identifier portion of an EUI address (the vendor assigned ID).
 #The default address format is xx-xx-xx
@@ -211,10 +178,6 @@ private_class_method :new
         return(ei)
     end
 
-#==============================================================================#
-# link_local()
-#==============================================================================#
-
 #===Synopsis
 # Provide an IPv6 Link Local address based on the current EUI address.
 #
@@ -231,45 +194,9 @@ private_class_method :new
 #* 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 = 'fe80000000000000' << @eui
-        else
-            link_local = 'fe80000000000000' << @oui << 'fffe' << @ei
-        end
-
-        if (!objectify)
-            link_local = NetAddr.i_to_ip(link_local.to_i(16), :Version => 6)
-            link_local = NetAddr.shorten(link_local) if (short)
-        else
-            link_local = NetAddr::CIDRv6.new(link_local.to_i(16))
-        end
-
-        return(link_local)
+        return( self.to_ipv6('fe80::/64', options) )
     end
 
-#==============================================================================#
-# oui()
-#==============================================================================#
-
 #===Synopsis
 #Returns Organizationally Unique Identifier portion of an EUI address (the vendor ID).
 #The default address format is xx-xx-xx.
@@ -280,7 +207,7 @@ private_class_method :new
 #
 #===Arguments:
 #* options = Hash with the following fields:
-#    :Delimiter -- delimitation character. valid values are (-, and :) 
+#    :Delimiter -- delimitation character. valid values are (-, and :)
 #
 #===Returns:
 #* String
@@ -306,10 +233,6 @@ private_class_method :new
         return(oui)
     end
 
-#==============================================================================#
-# to_i()
-#==============================================================================#
-
 #===Synopsis
 #Returns the EUI as an Integer.
 #
@@ -327,9 +250,77 @@ private_class_method :new
         return(@eui_i)
     end
 
-#==============================================================================#
-# to_s()
-#==============================================================================#
+#===Synopsis
+# Given a valid IPv6 subnet, return an IPv6 address based on the current EUI.
+#
+# Example:
+# addr = NetAddr::EUI.create('aabb.ccdd.eeff')
+# addr.to_ipv6('3ffe::/64') => "3ffe:0000:0000:0000:a8bb:ccff:fedd:eeff"
+#
+#===Arguments:
+#* options = Hash with the following fields:
+#    :Short -- if true, return IPv6 addresses in short-hand notation
+#    :Objectify -- if true, return CIDR objects
+#
+#===Returns:
+#* IPv6 address String or an NetAddr::CIDRv6 object
+#
+    def to_ipv6(cidr, options=nil)
+        known_args = [:Short, :Objectify]
+        objectify = false
+        short = false
+
+        if ( !cidr.kind_of?(NetAddr::CIDR) )
+            begin
+                cidr = NetAddr::CIDR.create(cidr)
+            rescue Exception => error
+                raise ArgumentError, "CIDR raised the following errors: #{error}"
+            end
+        elsif (cidr.kind_of?(NetAddr::CIDRv4)  )
+            raise ArgumentError, "Expected CIDRv6, but #{cidr.class} provided."
+        end
+
+        if (cidr.bits > 64)
+            raise ValidationError, "Prefix length of provided CIDR must be /64 or less but was #{cidr.netmask}."
+        end
+
+        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
+
+        # get integer equiv of addr. conver eui48 to eui64 if needed
+        if ( self.kind_of?(NetAddr::EUI48) )
+            eui_i = self.to_eui64.to_i
+        else
+            eui_i = self.to_i
+        end
+      
+        # toggle u/l bit
+        eui_i = eui_i ^ 0x0200000000000000
+
+        # create ipv6 address
+        ipv6 = cidr.to_i | eui_i
+
+        if (!objectify)
+            ipv6 = NetAddr.i_to_ip(ipv6, :Version => 6)
+            ipv6 = NetAddr.shorten(ipv6) if (short)
+        else
+            ipv6 = NetAddr::CIDRv6.new(ipv6)
+        end
+
+        return(ipv6)
+    end
 
 #===Synopsis
 #Returns the EUI as an unformatted String.
@@ -350,10 +341,6 @@ private_class_method :new
 
 private
 
-#==============================================================================#
-# octets()
-#==============================================================================#
-
 #Returns array with each element representing a single octet of the eui.
 #
     def octets()
@@ -382,10 +369,6 @@ class EUI48 < EUI
 
     public_class_method :new
 
-#==============================================================================#
-# to_eui64()
-#==============================================================================#
-
 #===Synopsis
 #Return an EUI64 address based on the current EUI48 address.
 #
@@ -400,7 +383,7 @@ class EUI48 < EUI
 #* NetAddr::EUI64 object
 #
     def to_eui64()
-        eui = @oui << 'fffe' << @ei
+        eui = @oui + 'fffe' + @ei
         return( NetAddr::EUI64.new(eui.to_i(16)) )
     end
 

data/lib/ip_math.rb

@@ -4,10 +4,6 @@ private
 
 # IP MATH METHODS
 
-#==============================================================================#
-# binary_mirror()
-#==============================================================================#
-
 # given an integer and number of bits to consider, return its binary mirror
 #
 def binary_mirror(num, bit_count)
@@ -22,10 +18,6 @@ def binary_mirror(num, bit_count)
 end
 module_function :binary_mirror
 
-#==============================================================================#
-# bits_to_mask()
-#==============================================================================#
-
 # convert a netmask (in bits) to an integer mask
 #
 def bits_to_mask(netmask,version)
@@ -36,10 +28,6 @@ def bits_to_mask(netmask,version)
 end
 module_function :bits_to_mask
 
-#==============================================================================#
-# detect_ip_version()
-#==============================================================================#
-
 # determine the ip version from ip address string.
 #
 # return 4, 6, or nil
@@ -57,10 +45,6 @@ def detect_ip_version(ip)
 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)
@@ -83,10 +67,6 @@ def ip_count_to_size(ipcount,version,extended=false)
 end
 module_function :ip_count_to_size
 
-#==============================================================================#
-# ip_int_to_str()
-#==============================================================================#
-
 # unpack an int into an ip address string
 #
 def ip_int_to_str(ip_int, version, ipv4_mapped=nil)
@@ -129,10 +109,6 @@ def ip_int_to_str(ip_int, version, ipv4_mapped=nil)
 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)
@@ -197,10 +173,6 @@ def ip_str_to_int(ip,version)
 end
 module_function :ip_str_to_int
 
-#==============================================================================#
-# mask_to_bits()
-#==============================================================================#
-
 # convert integer into a cidr formatted netmask (bits)
 #
 def mask_to_bits(netmask_int)
@@ -226,10 +198,6 @@ def mask_to_bits(netmask_int)
 end
 module_function :mask_to_bits
 
-#==============================================================================#
-# netmask_str_to_int()
-#==============================================================================#
-
 # convert string into integer mask
 #
 def netmask_str_to_int(netmask,version)