netaddr 1.4.0 → 1.5.0

data/changelog

@@ -1,3 +1,19 @@
+==Version
+====1.5.0
+
+===Changes
+* fixed bug with EUI48#to_eui64 (credit to Erik Kline)
+* fixed bug with u/l bit toggle on EUI#link_local (credit to Erik Kline)
+* added EUI#to_ipv6
+* added NetAddr#supernets
+
+
+==Version
+====1.4.0
+
+===Changes
+* Added additional options to NetAddr#sort
+
 
 ==Version
 ====1.3.0

data/lib/cidr.rb

@@ -737,52 +737,10 @@ end
 #==============================================================================#
 
 #===Synopsis
-#Returns network/netmask in CIDR format.
-#
-# Example:
-# cidr4 = NetAddr::CIDR.create('192.168.1.1/24')
-# cidr6 = NetAddr::CIDR.create('fec0::/64')
-# cidr4.desc(:IP => true) => "192.168.1.1/24"
-# cidr4.desc() => "192.168.1.0/24"
-# cidr6.desc(:Short => true) => "fec0::/64"
-#
-#===Arguments:
-#* options = Optional hash with the following keys:
-#    :IP -- if true, return the original ip/netmask passed during initialization
-#    :Short -- if true, return IPv6 addresses in short-hand notation
-#
-#===Returns:
-#* String
+#See to_s
 #
     def desc(options=nil)
-        known_args = [:IP, :Short]
-        short = false
-        orig_ip = 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?(:Short) && options[:Short] == true)
-                short = true
-            end
-
-            if (options.has_key?(:IP) && options[:IP] == true)
-                orig_ip = true
-            end
-        end
-
-        if (!orig_ip)
-            ip = NetAddr.ip_int_to_str(@network, @version)
-        else
-            ip = NetAddr.ip_int_to_str(@ip, @version)
-        end
-        ip = NetAddr.shorten(ip) if (short && @version == 6)
-        mask = NetAddr.mask_to_bits(@netmask)
-
-        return("#{ip}/#{mask}")
+        to_s(options)
     end
 
 #==============================================================================#
@@ -1995,6 +1953,59 @@ end
         end
     end
 
+#==============================================================================#
+# to_s()
+#==============================================================================#
+
+#===Synopsis
+#Returns network/netmask in CIDR format.
+#
+# Example:
+# cidr4 = NetAddr::CIDR.create('192.168.1.1/24')
+# cidr6 = NetAddr::CIDR.create('fec0::/64')
+# cidr4.desc(:IP => true) => "192.168.1.1/24"
+# cidr4.to_s => "192.168.1.0/24"
+# cidr6.to_s(:Short => true) => "fec0::/64"
+#
+#===Arguments:
+#* options = Optional hash with the following keys:
+#    :IP -- if true, return the original ip/netmask passed during initialization
+#    :Short -- if true, return IPv6 addresses in short-hand notation
+#
+#===Returns:
+#* String
+#
+    def to_s(options=nil)
+        known_args = [:IP, :Short]
+        short = false
+        orig_ip = 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?(:Short) && options[:Short] == true)
+                short = true
+            end
+
+            if (options.has_key?(:IP) && options[:IP] == true)
+                orig_ip = true
+            end
+        end
+
+        if (!orig_ip)
+            ip = NetAddr.ip_int_to_str(@network, @version)
+        else
+            ip = NetAddr.ip_int_to_str(@ip, @version)
+        end
+        ip = NetAddr.shorten(ip) if (short && @version == 6)
+        mask = NetAddr.mask_to_bits(@netmask)
+
+        return("#{ip}/#{mask}")
+    end
+
 #==============================================================================#
 # wildcard_mask()
 #==============================================================================#

data/lib/cidr_shortcuts.rb

@@ -347,6 +347,35 @@ def cidr_summarize(subnet_list)
 end
 module_function :cidr_summarize
 
+#==============================================================================#
+# cidr_supernets()
+#==============================================================================#
+
+# 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
+
 #==============================================================================#
 # netmask_sort()
 #==============================================================================#

data/lib/eui.rb

@@ -146,7 +146,7 @@ private_class_method :new
         end
 
         if (delimiter == '-' || delimiter == ':')
-                    addr = octets.join(delimiter)
+            addr = octets.join(delimiter)
         elsif (delimiter == '.')
                 toggle = 0
                 octets.each do |x|
@@ -231,39 +231,7 @@ 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
 
 #==============================================================================#
@@ -280,7 +248,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
@@ -327,6 +295,82 @@ private_class_method :new
         return(@eui_i)
     end
 
+#==============================================================================#
+# to_ipv6
+#==============================================================================#
+
+#===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
+
 #==============================================================================#
 # to_s()
 #==============================================================================#
@@ -400,7 +444,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/methods.rb

@@ -680,6 +680,106 @@ def sort(list, options=nil)
 end
 module_function :sort
 
+#==============================================================================#
+# supernets()
+#==============================================================================#
+
+#===Synopsis
+#Given a list of CIDR addresses or NetAddr::CIDR objects,
+#return only the top-level supernet CIDR addresses.
+#
+#
+#If the :Objectify option is enabled, then returned CIDR objects will
+#store the more specific CIDRs (i.e. subnets of those CIDRs) within the tag value :Subnets
+#For example, cidr_x.tag[:Subnets] would be an Array of CIDR subnets of cidr_x.
+#
+# Example:
+# NetAddr.supernets(['192.168.0.0', '192.168.0.1', '192.168.0.0/31'])
+#
+#===Arguments:
+#* list = Array of CIDR addresses as Strings, or an Array of NetAddr::CIDR objects 
+#* options = Hash with the following keys:
+#     :Objectify -- if true, return NetAddr::CIDR objects
+#     :Short -- if true, return IPv6 addresses in short-hand notation
+#
+#===Returns:
+#* Array of CIDR addresses or NetAddr::CIDR objects
+#
+def supernets(list,options=nil)
+    known_args = [:Objectify, :Short]
+    short = false
+    objectify = false
+    verbose = 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?(:Objectify) && options[:Objectify] == true)
+            objectify = true
+        end
+
+        if (options.has_key?(:Short) && options[:Short] == true)
+            short = true 
+        end
+    end
+
+    # make sure all are valid types of the same IP version
+    v4_list = []
+    v6_list = []
+    list.each do |obj|
+        if (!obj.kind_of?(NetAddr::CIDR))
+            begin
+                obj = NetAddr::CIDR.create(obj)
+            rescue Exception => error
+                raise ArgumentError, "One of the provided CIDR addresses raised the following " +
+                                     "errors: #{error}"
+            end
+        end
+
+        if (obj.version == 4)
+            v4_list.push(obj)
+        else
+            v6_list.push(obj)
+        end
+    end
+
+    # do summary calcs
+    v4_summary = []
+    v6_summary = []
+    if (v4_list.length != 0)
+        v4_summary = NetAddr.cidr_supernets(v4_list)
+    end
+
+    if (v6_list.length != 0)
+        v6_summary = NetAddr.cidr_supernets(v6_list)
+    end
+
+    # decide what to return
+    summarized_list = []
+    if (!objectify)
+        summarized_list = []
+        if (v4_summary.length != 0)
+            v4_summary.each {|x| summarized_list.push(x.desc())}
+        end
+
+        if (v6_summary.length != 0)
+            v6_summary.each {|x| summarized_list.push(x.desc(:Short => short))}
+        end
+
+    else
+        summarized_list.concat(v4_summary) if (v4_summary.length != 0)
+        summarized_list.concat(v6_summary) if (v6_summary.length != 0)
+    end
+
+    return(summarized_list)
+end
+module_function :supernets
+
 #==============================================================================#
 # unshorten()
 #==============================================================================#

data/tests/eui_test.rb

@@ -65,13 +65,13 @@ class TestEUI < Test::Unit::TestCase
 
     def test_link_local
         mac = NetAddr::EUI.create('aa-bb-cc-dd-ee-ff')
-        assert_equal('fe80:0000:0000:0000:aabb:ccff:fedd:eeff', mac.link_local )
+        assert_equal('fe80:0000:0000:0000:a8bb:ccff:fedd:eeff', mac.link_local )
 
         mac = NetAddr::EUI.create('1234.5678.9abc')
-        assert_equal('fe80:0000:0000:0000:1234:56ff:fe78:9abc', mac.link_local )
+        assert_equal('fe80:0000:0000:0000:1034:56ff:fe78:9abc', mac.link_local )
 
         mac = NetAddr::EUI.create('1234.5678.9abc.def0')
-        assert_equal('fe80:0000:0000:0000:1234:5678:9abc:def0', mac.link_local(:Objectify => true).ip )
+        assert_equal('fe80:0000:0000:0000:1034:5678:9abc:def0', mac.link_local(:Objectify => true).ip )
         assert_raise(ArgumentError) {mac.link_local(:test => true)}
     end
 
@@ -79,6 +79,23 @@ class TestEUI < Test::Unit::TestCase
         mac = NetAddr::EUI.create('aa-bb-cc-dd-ee-ff')
         assert_equal('aa-bb-cc-ff-fe-dd-ee-ff', mac.to_eui64.address )
 
+        # check that to_eui64 has no side effects
+        b = mac.to_eui64
+        c = mac.to_eui64
+        assert_equal(b.to_s, c.to_s)
+    end
+
+    def test_to_ipv6
+        mac = NetAddr::EUI.create('aa-bb-cc-dd-ee-ff')
+        assert_equal('fe80:0000:0000:0000:a8bb:ccff:fedd:eeff', mac.to_ipv6('fe80::/64') )
+
+        mac = NetAddr::EUI.create('1234.5678.9abc')
+        assert_equal('fe80:0000:0000:0000:1034:56ff:fe78:9abc', mac.to_ipv6('fe80::/64') )
+
+        mac = NetAddr::EUI.create('1234.5678.9abc.def0')
+        assert_equal('fe80:0000:0000:0000:1034:5678:9abc:def0', mac.to_ipv6('fe80::/64', :Objectify => true).ip )
+        assert_raise(ArgumentError) {mac.link_local(:test => true)}
+        assert_raise(NetAddr::ValidationError) {mac.to_ipv6('fe80::/65')}
     end
 
 end

data/tests/methods_test.rb

@@ -187,6 +187,22 @@ class TestMethods < Test::Unit::TestCase
         assert_equal([cidr4_4,cidr4_3,cidr4_2,cidr4_1,cidr4_5], sort5)
     end
 
+    def test_supernets
+        assert_raise(ArgumentError){ NetAddr.supernets(1) }
+        assert_raise(ArgumentError){ NetAddr.supernets({}) }
+
+        list4 = ['192.168.1.0', '192.168.1.1', '192.168.1.0/31', '10.1.1.0/24', '10.1.1.32/27']
+        list6 = ['fec0::/64', 'fec0::', 'fe80::/32', 'fe80::1']
+        assert_equal(['10.1.1.0/24','192.168.1.0/31'], NetAddr.supernets(list4) )
+        assert_equal(['fe80:0000:0000:0000:0000:0000:0000:0000/32', 'fec0:0000:0000:0000:0000:0000:0000:0000/64'], NetAddr.supernets(list6) )
+        assert_equal(['fe80::/32', 'fec0::/64'], NetAddr.supernets(list6, :Short => true) )
+
+        list4.push( NetAddr::CIDR.create('192.168.0.0/23') )
+        list6.push( NetAddr::CIDR.create('fec0::/48') )
+        summ = NetAddr.supernets(list4.concat(list6), :Objectify => true)
+        assert_equal('192.168.1.0/31', summ[0].tag[:Subnets][0].desc)
+    end
+
     def test_unshorten
         assert_equal('fec0:0000:0000:0000:0000:0000:0000:0000', NetAddr.unshorten('fec0::') )
         assert_equal('fec0:0000:0000:0000:0002:0000:0000:0001', NetAddr.unshorten('fec0::2:0:0:1') )

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: netaddr
 version: !ruby/object:Gem::Version 
-  version: 1.4.0
+  version: 1.5.0
 platform: ruby
 authors: 
 - Dustin Spinhirne
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-02-15 00:00:00 -06:00
+date: 2008-11-07 00:00:00 -06:00
 default_executable: 
 dependencies: []
 
@@ -57,7 +57,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.0.1
+rubygems_version: 1.2.0
 signing_key: 
 specification_version: 2
 summary: A package for manipulating network addresses.