netaddr 1.4.0 → 1.5.3

data/lib/methods.rb

@@ -1,15 +1,5 @@
-=begin rdoc
- Copyleft (c) 2006 Dustin Spinhirne
-
- Licensed under the same terms as Ruby, No Warranty is provided.
-=end
-
 module NetAddr
 
-#==============================================================================#
-# i_to_bits()
-#==============================================================================#
-
 #===Synopsis
 #Convert an Integer representing a binary netmask into an Integer representing
 #the number of bits in that netmask.
@@ -35,10 +25,6 @@ def i_to_bits(netmask_int)
 end
 module_function :i_to_bits
 
-#==============================================================================#
-# i_to_ip()
-#==============================================================================#
-
 #===Synopsis
 #Convert an Integer into an IP address. This method will attempt to auto-detect the IP version
 #if not provided, however, a slight speed increase is realized if version is provided.
@@ -88,10 +74,6 @@ def i_to_ip(ip_int, options=nil)
 end
 module_function :i_to_ip
 
-#==============================================================================#
-# ip_to_i()
-#==============================================================================#
-
 #===Synopsis
 #Convert IP addresses into an Integer. This method will attempt to auto-detect the IP version
 #if not provided, however a slight speed increase is realized if version is provided.
@@ -141,10 +123,6 @@ def ip_to_i(ip, options=nil)
 end
 module_function :ip_to_i
 
-#==============================================================================#
-# merge()
-#==============================================================================#
-
 #===Synopsis
 #Given a list of CIDR addresses or NetAddr::CIDR objects,
 #merge (summarize) them in the most efficient way possible. Summarization 
@@ -253,10 +231,6 @@ def merge(list,options=nil)
 end
 module_function :merge
 
-#==============================================================================#
-# minimum_size()
-#==============================================================================#
-
 #===Synopsis
 #Given the number of IP addresses required in a subnet, return the minimum
 #netmask (bits by default) required for that subnet. IP version is assumed to be 4 unless specified otherwise.
@@ -301,10 +275,6 @@ def minimum_size(ipcount, options=nil)
 end
 module_function :minimum_size
 
-#==============================================================================#
-# netmask_to_i()
-#==============================================================================#
-
 #===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
@@ -361,10 +331,6 @@ def netmask_to_i(netmask, options=nil)
 end
 module_function :netmask_to_i
 
-#==============================================================================#
-# 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 
@@ -492,7 +458,7 @@ def range(lower, upper, options=nil)
 
             my_ip = my_ip + bitstep
             if (limit)
-                limit = limit -1
+                limit = limit - 1
                 break if (limit == 0)
             end
         end
@@ -504,10 +470,6 @@ def range(lower, upper, options=nil)
 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.
@@ -596,10 +558,6 @@ def shorten(addr)
 end
 module_function :shorten
 
-#==============================================================================#
-# sort()
-#==============================================================================#
-
 #===Synopsis
 #Sort a list of CIDR addresses or NetAddr::CIDR objects,
 #
@@ -680,9 +638,101 @@ def sort(list, options=nil)
 end
 module_function :sort
 
-#==============================================================================#
-# unshorten()
-#==============================================================================#
+#===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
 
 #===Synopsis
 #Take an IPv6 address in short-hand format, and expand it into standard
@@ -718,10 +768,6 @@ def unshorten(ip)
 end
 module_function :unshorten
 
-#==============================================================================#
-# validate_eui()
-#==============================================================================#
-
 #===Synopsis
 #Validate an EUI-48 or EUI-64 address. Raises NetAddr::ValidationError on validation failure.
 #
@@ -771,10 +817,6 @@ def validate_eui(eui)
 end
 module_function :validate_eui
 
-#==============================================================================#
-# validate_ip_addr()
-#==============================================================================#
-
 #===Synopsis
 #Validate an IP address. The address should not contain a netmask.
 #This method will attempt to auto-detect the IP version
@@ -830,10 +872,6 @@ def validate_ip_addr(ip, options=nil)
 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.
@@ -888,10 +926,6 @@ def validate_ip_netmask(netmask, options=nil)
 end
 module_function :validate_ip_netmask
 
-#==============================================================================#
-# wildcard()
-#==============================================================================#
-
 #===Synopsis
 #Convert a wildcard IP into a valid CIDR address. Wildcards must always be at
 #the end of the address. Any data located after the first wildcard will be lost.

data/lib/netaddr.rb

@@ -1,9 +1,3 @@
-=begin rdoc
- Copyleft (c) 2006 Dustin Spinhirne
-  
- Licensed under the same terms as Ruby, No Warranty is provided.
-=end
-
 require 'time'
 require 'digest/sha1'
 require File.join(File.dirname(__FILE__), 'validation_shortcuts.rb')
@@ -16,14 +10,14 @@ require File.join(File.dirname(__FILE__), 'eui.rb')
 
 module NetAddr
 
-class BoundaryError < StandardError #:nodoc:
-end
+  class BoundaryError < StandardError #:nodoc:
+  end
 
-class ValidationError < StandardError #:nodoc:
-end
+  class ValidationError < StandardError #:nodoc:
+  end
 
-class VersionError < StandardError #:nodoc:
-end
+  class VersionError < StandardError #:nodoc:
+  end
 
 end # module NetAddr
 

data/lib/tree.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
 
 #=Tree
@@ -29,10 +23,6 @@ module NetAddr
 #
 class Tree
 
-#==============================================================================#
-# initialize()
-#==============================================================================#
-
 #===Synopsis
 #Create a new Tree object.
 #
@@ -48,10 +38,6 @@ class Tree
         @v6_root = NetAddr::CIDRv6.new(0,0,{:Subnets => []})
     end
 
-#==============================================================================#
-# add!()
-#==============================================================================#
-
 #===Synopsis
 # Add a CIDR address or NetAddr::CIDR object to the tree.
 # Example:
@@ -84,10 +70,6 @@ class Tree
         return(nil)
     end
 
-#==============================================================================#
-# ancestors()
-#==============================================================================#
-
 #===Synopsis
 # Returns all the ancestors of the provided CIDR addresses.
 #
@@ -121,10 +103,6 @@ class Tree
         return(list)
     end
 
-#==============================================================================#
-# children()
-#==============================================================================#
-
 #===Synopsis
 # Returns all the immediate children of the provided CIDR addresses.
 #
@@ -159,10 +137,6 @@ class Tree
         return(list)
     end
 
-#==============================================================================#
-# descendants
-#==============================================================================#
-
 #===Synopsis
 # Return all descendants of the provided CIDR address.
 #
@@ -199,10 +173,6 @@ class Tree
         return(list)
     end
 
-#==============================================================================#
-# delete!()
-#==============================================================================#
-
 #===Synopsis
 # Remove the provided CIDR address from the tree.
 #
@@ -243,10 +213,6 @@ class Tree
         return(removed)
     end
 
-#==============================================================================#
-# dump
-#==============================================================================#
-
 #===Synopsis
 # Dump the contents of this tree.
 #
@@ -268,10 +234,6 @@ class Tree
         return(list)
     end
 
-#==============================================================================#
-# exists?()
-#==============================================================================#
-
 #===Synopsis
 # Has a CIDR address already been added to the tree?
 #
@@ -301,10 +263,6 @@ class Tree
         return(found)
     end
 
-#==============================================================================#
-# fill_in!()
-#==============================================================================#
-
 #===Synopsis
 # Fill in the missing subnets of a particular CIDR.
 #
@@ -341,10 +299,6 @@ class Tree
         return(filled)
     end
 
-#==============================================================================#
-# find()
-#==============================================================================#
-
 #===Synopsis
 # Find and return a CIDR from within the tree.
 #
@@ -375,10 +329,6 @@ class Tree
         return(me)
     end
 
-#==============================================================================#
-# find_space()
-#==============================================================================#
-
 #===Synopsis
 # Find subnets that are of at least size X. Only subnets that are not themselves 
 # subnetted will be returned. :Subnet takes precedence over :IPCount
@@ -446,10 +396,6 @@ class Tree
         return(new_list)
     end
 
-#==============================================================================#
-# longest_match()
-#==============================================================================#
-
 #===Synopsis
 #Find the longest matching branch of our tree to which a 
 #CIDR address belongs. Useful for performing 'routing table' style lookups.
@@ -479,10 +425,6 @@ class Tree
         return( NetAddr.cidr_build(found.version, found.to_i(:network), found.to_i(:netmask)) )
     end
 
-#==============================================================================#
-# prune!()
-#==============================================================================#
-
 #===Synopsis
 # Remove all subnets of the provided CIDR address.
 #
@@ -518,10 +460,6 @@ class Tree
         return(pruned)
     end
 
-#==============================================================================#
-# remove!()
-#==============================================================================#
-
 #===Synopsis
 # Remove the provided CIDR address, and all of its subnets from the tree.
 #
@@ -559,10 +497,6 @@ class Tree
         return(removed)
     end
 
-#==============================================================================#
-# resize!()
-#==============================================================================#
-
 #===Synopsis
 # Resize the provided CIDR address.
 #
@@ -601,10 +535,6 @@ class Tree
         return(resized)
     end
 
-#==============================================================================#
-# root()
-#==============================================================================#
-
 #===Synopsis
 # Returns the root of the provided CIDR address.
 #
@@ -640,10 +570,6 @@ class Tree
         return( NetAddr.cidr_build(parent.version, parent.to_i(:network), parent.to_i(:netmask)) )
     end
 
-#==============================================================================#
-# show()
-#==============================================================================#
-
 #===Synopsis
 # Print the tree as a formatted string.
 #
@@ -692,10 +618,6 @@ class Tree
         return(printed)
     end
 
-#==============================================================================#
-# siblings()
-#==============================================================================#
-
 #===Synopsis
 # Return list of the sibling CIDRs of the provided CIDR address.
 #
@@ -729,10 +651,6 @@ class Tree
         return(list)
     end
 
-#==============================================================================#
-# summarize_subnets!()
-#==============================================================================#
-
 #===Synopsis
 # Summarize all subnets of the provided CIDR address. The subnets will be
 # placed under the new summary address within the tree.
@@ -771,10 +689,6 @@ class Tree
     end
     alias :merge_subnets! :summarize_subnets!
 
-#==============================================================================#
-# supernets()
-#==============================================================================#
-
 #===Synopsis
 # Return list of the top-level supernets of this tree.
 #
@@ -795,12 +709,9 @@ class Tree
     end
 
 
-# PRIVATE INSTANCE METHODS
-private
 
-#==============================================================================#
-# add_to_parent()
-#==============================================================================#
+    
+private
 
 # Add NetStruct object to an array of NetStruct's
 #
@@ -831,10 +742,6 @@ private
         return(nil)
     end
 
-#==============================================================================#
-# add_to_tree()
-#==============================================================================#
-
 # Add CIDR to a Tree
 #
     def add_to_tree(cidr,root=nil)
@@ -844,10 +751,6 @@ private
         return(nil)
     end
 
-#==============================================================================#
-# dump_children()
-#==============================================================================#
-
 #  Dump contents of an Array of NetStruct objects
 #
     def dump_children(parent,depth=0)
@@ -864,10 +767,6 @@ private
         return(list)
     end
 
-#==============================================================================#
-# find_me()
-#==============================================================================#
-
 # Find the NetStruct to which a cidr belongs.
 #
     def find_me(cidr)
@@ -887,10 +786,6 @@ private
         return(me)
     end
 
-#==============================================================================#
-# find_parent()
-#==============================================================================#
-
 # Find the parent NetStruct to which a child NetStruct belongs.
 #
     def find_parent(cidr,parent=nil)

data/lib/validation_shortcuts.rb

@@ -1,10 +1,6 @@
 module NetAddr
 private
 
-#==============================================================================#
-# validate_args()
-#==============================================================================#
-
 # validate options hash 
 #
 def validate_args(to_validate,known_args)
@@ -15,10 +11,6 @@ def validate_args(to_validate,known_args)
 end 
 module_function :validate_args
 
-#==============================================================================#
-# validate_ip_int()
-#==============================================================================#
-
 def validate_ip_int(ip,version)
     version = 4 if (!version && ip < 2**32)
     if (version == 4)
@@ -31,10 +23,6 @@ def validate_ip_int(ip,version)
 end
 module_function :validate_ip_int
 
-#==============================================================================#
-# validate_ip_str()
-#==============================================================================#
-
 def validate_ip_str(ip,version)
     # check validity of charaters
     if (ip =~ /[^0-9a-fA-F\.:]/)
@@ -129,9 +117,6 @@ def validate_ip_str(ip,version)
 end
 module_function :validate_ip_str
 
-#==============================================================================#
-# validate_netmask_int()
-#==============================================================================#
 def validate_netmask_int(netmask,version,is_int=false)
     address_len = 32
     address_len = 128 if (version == 6)
@@ -149,9 +134,6 @@ def validate_netmask_int(netmask,version,is_int=false)
 end
 module_function :validate_netmask_int
 
-#==============================================================================#
-# validate_netmask_str()
-#==============================================================================#
 def validate_netmask_str(netmask,version)
     address_len = 32
     address_len = 128 if (version == 6)

data/license

@@ -0,0 +1,13 @@
+Copyright Dustin L. Spinhirne
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/{tests → test}/cidr_test.rb

@@ -1,6 +1,7 @@
 #!/usr/bin/ruby
 
-require 'lib/netaddr.rb'
+#require 'lib/netaddr.rb'
+require_relative "../lib/netaddr.rb"
 require 'test/unit'
 
 

data/{tests → test}/eui_test.rb

@@ -1,6 +1,6 @@
 #!/usr/bin/ruby
 
-require 'lib/netaddr.rb'
+require_relative "../lib/netaddr.rb"
 require 'test/unit'
 
 
@@ -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