netaddr 1.2.0 → 1.3.0

data/lib/cidr_shortcuts.rb

@@ -29,21 +29,21 @@ module_function :cidr_build
 #
 def cidr_compare(cidr1,cidr2)
     comparasin = nil
-    if ( (cidr1.packed_network == cidr2.packed_network))
+    if ( cidr1.to_i(:network) == cidr2.to_i(:network) )
         # same network, check netmask
-        if (cidr1.packed_netmask == cidr2.packed_netmask)
+        if (cidr1.to_i(:netmask) == cidr2.to_i(:netmask) )
             comparasin = 0
-        elsif(cidr1.packed_netmask < cidr2.packed_netmask)
+        elsif(cidr1.to_i(:netmask) < cidr2.to_i(:netmask))
             comparasin = 1
-        elsif(cidr1.packed_netmask > cidr2.packed_netmask)
+        elsif(cidr1.to_i(:netmask) > cidr2.to_i(:netmask))
             comparasin = -1
         end
 
-    elsif( (cidr2.packed_network | cidr1.packed_hostmask) == (cidr1.packed_network | cidr1.packed_hostmask) )
+    elsif( (cidr2.to_i(:network) | cidr1.to_i(:hostmask)) == (cidr1.to_i(:network) | cidr1.to_i(:hostmask)) )
         # cidr1 contains cidr2
         comparasin = 1
 
-    elsif( (cidr2.packed_network | cidr2.packed_hostmask) == (cidr1.packed_network | cidr2.packed_hostmask) )
+    elsif( (cidr2.to_i(:network) | cidr2.to_i(:hostmask)) == (cidr1.to_i(:network) | cidr2.to_i(:hostmask)) )
         # cidr2 contains cidr1
         comparasin = -1
     end
@@ -64,12 +64,12 @@ module_function :cidr_compare
 #
 def cidr_gt_lt(cidr1,cidr2)
     gt_lt = 1
-    if(cidr1.packed_network < cidr2.packed_network)
+    if(cidr1.to_i(:network) < cidr2.to_i(:network))
         gt_lt = -1
-    elsif (cidr1.packed_network == cidr2.packed_network)
-        if (cidr1.packed_netmask < cidr2.packed_netmask)
+    elsif (cidr1.to_i(:network) == cidr2.to_i(:network))
+        if (cidr1.to_i(:netmask) < cidr2.to_i(:netmask))
             gt_lt = -1
-        elsif (cidr1.packed_netmask == cidr2.packed_netmask)
+        elsif (cidr1.to_i(:netmask) == cidr2.to_i(:netmask))
             gt_lt = 0
         end
     end
@@ -88,15 +88,14 @@ module_function :cidr_gt_lt
 def cidr_fill_in(supernet,list)
         # sort our cidr's and see what is missing
         complete_list = []
-        expected = supernet.packed_network
+        expected = supernet.to_i(: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
+            network = cidr.to_i(:network)
+            bitstep = (all_f + 1) - cidr.to_i(:netmask)
 
-            if (network > expected)
+            if (network > expected) # missing space at beginning of supernet, so fill in the hole
                 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)
@@ -104,13 +103,13 @@ def cidr_fill_in(supernet,list)
                 next
             end
 
-            complete_list.push(NetAddr.cidr_build(version,network,cidr.packed_netmask))
+            complete_list.push(cidr)
             expected = network + bitstep
         end
 
-        # if expected is not the next subnet, then we're missing subnets 
+        # 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
+        next_sub = supernet.next_subnet(:Objectify => true).to_i(: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)
@@ -167,7 +166,8 @@ module_function :cidr_find_in_list
 # Make CIDR addresses from a base addr and an number of ip's to encapsulate.
 #
 #===Arguments:
-#   * base ip as packed integer
+#   * cidr
+#   * base ip as integer
 #   * number of ip's required
 #
 #===Returns:
@@ -259,7 +259,7 @@ def cidr_summarize(subnet_list)
         summarized_list = []
         until (sorted_list.length == 0)
             cidr = sorted_list.shift
-            network, netmask = cidr.packed_network, cidr.packed_netmask
+            network, netmask = cidr.to_i(:network), cidr.to_i(:netmask)
             supermask = (netmask << 1) & all_f
             supernet = supermask & network
 
@@ -268,7 +268,7 @@ def cidr_summarize(subnet_list)
                 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
+                next_network, next_netmask = next_cidr.to_i(:network), next_cidr.to_i(:netmask)
 
                 if ( (next_network == expected) && (next_netmask == netmask) )
                     # we do indeed have the upper half. store new supernet.

data/lib/eui.rb

@@ -1,23 +1,23 @@
 =begin rdoc
- Copyleft (c) 2006 Dustin Spinhirne (www.spinhirne.com)
-  
+ Copyleft (c) 2006 Dustin Spinhirne
+
  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). 
-# 
+#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
@@ -27,6 +27,50 @@ 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.
+# Please consider using #create unless you know what you are doing with 100% certainty.
+#
+# Example:
+# NetAddr::EUI48.new('aabbccddeeff')
+#
+#===Arguments:
+#* EUI as a String or Integer. Strings should contain no formatting characters.
+#
+    def initialize(eui)
+
+        if (eui.kind_of?(Integer))
+            @eui_i = eui
+            @eui = eui.to_s(16)
+            if ( self.kind_of?(NetAddr::EUI48) )
+                @eui = '0' * (12 - @eui.length) << @eui if (@eui.length < 12)
+            else
+                @eui = '0' * (16 - @eui.length) << @eui if (@eui.length < 16)
+            end
+
+        elsif(eui.kind_of?(String))
+            @eui = eui
+            @eui_i = eui.to_i(16)
+        else
+            raise ArgumentError, "Expected String or Integer, but #{eui.class} provided."
+        end
+
+        # set ei & oui
+        if ( self.kind_of?(NetAddr::EUI48) )
+            @ei = @eui.slice(6..11)
+        else
+            @ei = @eui.slice(6..15)
+        end
+
+        @oui = @eui.slice(0..5)
+
+    end
+
 #==============================================================================#
 # create()
 #==============================================================================#
@@ -34,10 +78,11 @@ private_class_method :new
 #===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')
+# Example:
+# addr = NetAddr::EUI.create('aa-bb-cc-dd-ee-ff')
+# addr = NetAddr::EUI.create('aa:bb:cc:dd:ee:ff')
+# addr = NetAddr::EUI.create('aabb.ccdd.eeff')
+# addr = NetAddr::EUI.create('aa-bb-cc-dd-ee-ff-00-01')
 #
 #===Arguments
 #* eui = EUI as a String
@@ -56,11 +101,10 @@ private_class_method :new
         # remove formatting characters
         eui.gsub!(/[\.\:\-]/, '')
 
-        # split into oui & ei, pack, and store
         if (eui.length == 12)
-            eui = NetAddr::EUI48.new(eui.to_i(16))
+            eui = NetAddr::EUI48.new(eui)
         else
-            eui = NetAddr::EUI64.new(eui.to_i(16))
+            eui = NetAddr::EUI64.new(eui)
         end
 
         return(eui)
@@ -73,11 +117,14 @@ private_class_method :new
 #===Synopsis
 # Returns EUI address. The default address format is xxxx.xxxx.xxxx
 #
-# puts addr.address(:Delimiter => '.')   --> 'aabb.ccdd.eeff'
+# Example:
+# addr = NetAddr::EUI.create('aabb.ccdd.eeff')
+# addr.address(:Delimiter => '-') => "aa-bb-cc-dd-ee-ff"
+# addr.address(:Delimiter => ':') => "aa:bb:cc:dd:ee:ff"
 #
 #===Arguments:
 #* options = Hash with the following fields:
-#    :Delimiter -- delimitation character. valid values are (-,:,and .)
+#    :Delimiter -- delimitation character. valid values are (- : .)
 #
 #===Returns:
 #* String
@@ -86,10 +133,6 @@ private_class_method :new
         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."
@@ -98,30 +141,29 @@ private_class_method :new
 
             if (options.has_key?(:Delimiter))
                 delimiter = options[:Delimiter]
-                delimiter = '-' if (delimiter != '-' && delimiter != ':' && delimiter != '.' )
+                delimiter = '-' if (delimiter != ':' && delimiter != '.')
             end
         end
 
         if (delimiter == '-' || delimiter == ':')
-                    address = octets.join(delimiter)
+                    addr = octets.join(delimiter)
         elsif (delimiter == '.')
                 toggle = 0
                 octets.each do |x|
-                    if (!address)
-                        address = x
+                    if (!addr)
+                        addr = x
                         toggle = 1
                     elsif (toggle == 0)
-                        address = address  << '.' << x
+                        addr = addr  << '.' << x
                         toggle = 1
                     else
-                        address = address << x
+                        addr = addr << x
                         toggle = 0
                     end
-                end 
-
+                end
         end
 
-        return(address)
+        return(addr)
     end
 
 #==============================================================================#
@@ -132,7 +174,9 @@ private_class_method :new
 #Returns Extended Identifier portion of an EUI address (the vendor assigned ID).
 #The default address format is xx-xx-xx
 #
-# puts addr.ei(:Delimiter => '-')
+# Example:
+# addr = NetAddr::EUI.create('aabb.ccdd.eeff')
+# addr.ei(:Delimiter => '-') => "dd-ee-ff"
 #
 #===Arguments:
 #* options = Hash with the following fields:
@@ -143,7 +187,6 @@ private_class_method :new
 #
     def ei(options=nil)
         known_args = [:Delimiter]
-        octets = unpack_ei()
         delimiter = '-'
 
         if (options)
@@ -158,7 +201,12 @@ private_class_method :new
                 end
             end
         end
-        ei = octets.join(delimiter)
+
+        if ( self.kind_of?(NetAddr::EUI48) )
+            ei = octets[3..5].join(delimiter)
+        else
+            ei = octets[3..7].join(delimiter)
+        end
 
         return(ei)
     end
@@ -170,7 +218,9 @@ private_class_method :new
 #===Synopsis
 # Provide an IPv6 Link Local address based on the current EUI address.
 #
-# puts addr.link_local()
+# Example:
+# addr = NetAddr::EUI.create('aabb.ccdd.eeff')
+# addr.link_local() => "fe80:0000:0000:0000:aabb:ccff:fedd:eeff"
 #
 #===Arguments:
 #* options = Hash with the following fields:
@@ -201,17 +251,16 @@ private_class_method :new
         end
 
         if (self.kind_of?(NetAddr::EUI64))
-            link_local = @ei | (@oui << 40)
+            link_local = 'fe80000000000000' << @eui
         else
-            link_local = @ei | 0xfffe000000 | (@oui << 40)
+            link_local = 'fe80000000000000' << @oui << 'fffe' << @ei
         end
-        link_local = link_local | (0xfe80 << 112)
 
         if (!objectify)
-            link_local = NetAddr.unpack_ip_addr(link_local, :Version => 6)
+            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::CIDR.create(link_local, :Version => 6)
+            link_local = NetAddr::CIDRv6.new(link_local.to_i(16))
         end
 
         return(link_local)
@@ -225,7 +274,9 @@ private_class_method :new
 #Returns Organizationally Unique Identifier portion of an EUI address (the vendor ID).
 #The default address format is xx-xx-xx.
 #
-# puts addr.oui(:Delimiter => '-')
+# Example:
+# addr = NetAddr::EUI.create('aabb.ccdd.eeff')
+# addr.oui(:Delimiter => '-') => "aa-bb-cc"
 #
 #===Arguments:
 #* options = Hash with the following fields:
@@ -236,7 +287,6 @@ private_class_method :new
 #
     def oui(options=nil)
         known_args = [:Delimiter]
-        octets = unpack_oui()
         delimiter = '-'
 
         if (options)
@@ -251,140 +301,119 @@ private_class_method :new
                 end
             end
         end
-        oui = octets.join(delimiter)
+        oui = octets[0..2].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()
+# to_i()
 #==============================================================================#
 
-    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)
+#===Synopsis
+#Returns the EUI as an Integer.
+#
+# Example:
+# addr = NetAddr::EUI.create('aabb.ccdd.eeff')
+# addr.to_i => 187723572702975
+#
+#===Arguments:
+#* none
+#
+#===Returns:
+#* Integer
+#
+    def to_i()
+        return(@eui_i)
     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()
+# to_s()
 #==============================================================================#
 
 #===Synopsis
-#Return an EUI48 object. PackedEUI takes precedence over EUI.
+#Returns the EUI as an unformatted String.
 #
-# 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')
+# Example:
+# addr = NetAddr::EUI.create('aabb.ccdd.eeff')
+# addr.to_s => "aabbccddeeff"
 #
 #===Arguments:
-#* EUI as a String or Integer
+#* none
 #
-    def initialize(eui)
-
-        if (eui.kind_of?(Integer))
-            @oui = eui >> 24
-            @ei = eui & 0xffffff
+#===Returns:
+#* String
+#
+    def to_s()
+        return(@eui)
+    end
 
-        elsif(eui.kind_of?(String))
-            # validate
-            NetAddr.validate_eui(eui)
+private
 
-            # remove formatting characters
-            eui.gsub!(/[\.\:\-]/, '')
+#==============================================================================#
+# octets()
+#==============================================================================#
 
-            # 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."
+#Returns array with each element representing a single octet of the eui.
+#
+    def octets()
+        return(@octets) if (@octets)
+
+        @octets = []
+        str = ''
+        @eui.each_byte do |chr|
+            str = str << chr
+            if (str.length == 2)
+                @octets.push(str)
+                str = ''
+            end
         end
+
+        return(@octets)
     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
+
+# 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()
+# to_eui64()
 #==============================================================================#
 
 #===Synopsis
-#Return an EUI object. PackedEUI takes precedence over EUI.
+#Return an EUI64 address based on the current EUI48 address.
 #
-# addr = NetAddr::EUI64.new('aa-bb-cc-dd-ee-ff-00-01')
+# Example:
+# addr = NetAddr::EUI.create('aabb.ccdd.eeff')
+# addr.to_eui64 => NetAddr::EUI64
 #
 #===Arguments:
-#* eui = EUI as a String or Integer
+#* none
 #
-    def initialize(eui)
-
-        if (eui.kind_of?(Integer))
-            @oui = eui >> 40
-            @ei = eui & 0xffffffffffd
+#===Returns:
+#* NetAddr::EUI64 object
+#
+    def to_eui64()
+        eui = @oui << 'fffe' << @ei
+        return( NetAddr::EUI64.new(eui.to_i(16)) )
+    end
 
-        elsif(eui.kind_of?(String))
-            # validate
-            NetAddr.validate_eui(eui)
+end
 
-            # 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
 
+# 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
 end
 
+
 end # module NetAddr
 __END__