netaddr 1.1.0 → 1.2.0

data/lib/net_addr.rb

@@ -4,7 +4,9 @@
  Licensed under the same terms as Ruby, No Warranty is provided.
 =end
 
-
+require File.join(File.dirname(__FILE__), 'validation_shortcuts.rb')
+require File.join(File.dirname(__FILE__), 'ip_math.rb')
+require File.join(File.dirname(__FILE__), 'cidr_shortcuts.rb')
 require File.join(File.dirname(__FILE__), 'methods.rb')
 require File.join(File.dirname(__FILE__), 'cidr.rb')
 require File.join(File.dirname(__FILE__), 'tree.rb')

data/lib/tree.rb

@@ -1,6 +1,6 @@
 =begin rdoc
  Copyleft (c) 2006 Dustin Spinhirne (www.spinhirne.com) 
- 
+
  Licensed under the same terms as Ruby, No Warranty is provided.
 =end
 
@@ -43,7 +43,8 @@ class Tree
 #
     def initialize()
         # root of our ordered IP tree
-        @root = NetStruct.new(nil, nil, [])
+        @v4_root = NetAddr::CIDRv4.new(0,0,{:Subnets => []})
+        @v6_root = NetAddr::CIDRv6.new(0,0,{:Subnets => []})
     end
 
 #==============================================================================#
@@ -64,8 +65,6 @@ class Tree
 #* nil
 #
     def add!(new)
-        duplicate = false
-
         # validate object
         if ( !new.kind_of?(NetAddr::CIDR) )
             begin
@@ -78,34 +77,8 @@ class Tree
             cidr = new.dup
         end
 
-        version = cidr.version
-        new_entry = NetStruct.new(cidr, nil, [])
-
-        # find cidr's parent
-        new_entry.parent = find_parent(cidr, @root)
-
-        # check parent for subnets of cidr
-        new_entry.parent.children.each do |old_entry|
-            if (old_entry.cidr.version == version)
-                comp = cidr.cmp(old_entry.cidr)
-                if (comp && comp == 1)
-                    old_entry.parent = new_entry
-                    new_entry.children.push(old_entry)
-                elsif (comp && comp == 0)
-                    duplicate = true
-                    break
-                end
-            end
-        end
-
-        if (!duplicate)
-            new_entry.children.each do |old_entry|
-                new_entry.parent.children.delete(old_entry)
-            end
-
-            # add new object as an ordered entry to parent.children
-            add_to_parent(new_entry,new_entry.parent)
-        end
+        cidr.tag[:Subnets] = []
+        add_to_tree(cidr)
 
         return(nil)
     end
@@ -135,13 +108,12 @@ class Tree
                                      "errors: #{error}"
             end
         end
-        
+
         list = []
-        parent = find_parent(cidr,@root)
-        
-        until (parent == @root)
-            list.push(parent.cidr)
-            parent = parent.parent
+        parent = find_parent(cidr)
+        until (!parent.tag[:Parent])
+            list.push(parent)
+            parent = parent.tag[:Parent]
         end
 
         return(list)
@@ -174,9 +146,8 @@ class Tree
         end
 
         list = []
-        find_me(cidr).children.each do |child|
-            list.push(child.cidr)
-        end
+        me = find_me(cidr)
+        me.tag[:Subnets].each {|child| list.push(child) } if (me)
 
         return(list)
     end
@@ -198,7 +169,7 @@ class Tree
 #
     def descendants(cidr)
         list = []
-        
+
         # validate object
         if ( !cidr.kind_of?(NetAddr::CIDR) )
             begin
@@ -209,8 +180,8 @@ class Tree
             end
         end
 
-        me = find_me(cidr)        
-        dump_children(me).each {|x| list.push(x[:NetStruct].cidr)} if (me)
+        me = find_me(cidr)
+        dump_children(me).each {|x| list.push(x[:CIDR])} if (me)
 
         return(list)
     end
@@ -232,7 +203,7 @@ class Tree
 #
     def delete!(cidr)
         removed = false
-        
+
         # validate object
         if ( !cidr.kind_of?(NetAddr::CIDR) )
             begin
@@ -245,12 +216,12 @@ class Tree
 
         # find matching
         me = find_me(cidr)
-        
+
         # remove
         if (me)
-            parent = me.parent
-            children = me.children 
-            parent.children.delete(me)
+            parent = me.tag[:Parent]
+            children = me.tag[:Subnets] 
+            parent.tag[:Subnets].delete(me)
             children.each {|x| add_to_parent(x,parent)}
             removed = true
         end
@@ -276,15 +247,8 @@ class Tree
 #    :Depth => (depth level in tree)
 #
     def dump()
-        list = []
-        dumped = dump_children(@root)
-
-        dumped.each do |entry|
-            depth = entry[:Depth]
-            net_struct = entry[:NetStruct]
-            list.push({:Depth => depth, :CIDR => net_struct.cidr})
-        end
-
+        list = dump_children(@v4_root)
+        list.concat( dump_children(@v6_root) )
         return(list)
     end
 
@@ -348,13 +312,9 @@ class Tree
             end
         end
 
-        me = find_me(cidr)        
-        if (me && me.children.length != 0)
-            list = []
-            me.children.each {|x| list.push(x.cidr)}
-            me.cidr.fill_in(list, :Objectify => true).each do |cidr|
-                self.add!(cidr)
-            end
+        me = find_me(cidr)
+        if (me && me.tag[:Subnets].length != 0)
+            me.tag[:Subnets] = NetAddr.cidr_fill_in(me, me.tag[:Subnets])
             filled = true
         end
         return(filled)
@@ -385,7 +345,7 @@ class Tree
             end
         end
 
-        return(find_me(cidr).cidr)
+        return(find_me(cidr))
     end
 
 #==============================================================================#
@@ -433,28 +393,23 @@ class Tree
             raise "Integer or Hash expected, but #{options.class} provided."
         end
 
-        list4 = []
-        list6 = []
-        dump_children(@root).each do |entry|
-            netstruct = entry[:NetStruct]
-            if (netstruct.cidr.version == 4)
-                if ( (netstruct.children.length == 0) && (netstruct.cidr.bits <= bits4) )
-                    list4.push(netstruct.cidr)
-                end
-            else
-                if ( (netstruct.children.length == 0) && (netstruct.cidr.bits <= bits6) )
-                    list6.push(netstruct.cidr)
+        list = []
+        if (!version || version == 4)
+            dump_children(@v4_root).each do |entry|
+                cidr = entry[:CIDR]
+                if ( (cidr.tag[:Subnets].length == 0) && (cidr.bits <= bits4) )
+                    list.push(cidr)
                 end
             end
         end
-        
-        list = []
-        if (!version)
-            list.concat(list4)
-            list.concat(list6)
-        else
-            list.concat(list4) if (version == 4)
-            list.concat(list6) if (version == 6)
+
+        if (!version || version == 6)
+            dump_children(@v6_root).each do |entry|
+                cidr = entry[:CIDR]
+                if ( (cidr.tag[:Subnets].length == 0) && (cidr.bits <= bits6) )
+                    list.push(cidr)
+                end
+            end
         end
 
         return(list)
@@ -474,7 +429,7 @@ class Tree
 #* String or NetAddr::CIDR object
 #
 #===Returns:
-#* NetAddr::CIDR object, or nil
+#* NetAddr::CIDR object
 #
     def longest_match(cidr)
         if ( !cidr.kind_of?(NetAddr::CIDR) )
@@ -485,53 +440,11 @@ class Tree
                                      "errors: #{error}"
             end
         end
-        
-        found = find_me(cidr)
-        found = find_parent(cidr, @root) if !found
-
-        return(found.cidr)
-    end
-
-#==============================================================================#
-# merge_subnets!()
-#==============================================================================#
 
-#===Synopsis
-# Merge (summarize) all subnets of the provided CIDR address.
-#
-# tree.merge_subnets!('192.168.1.0/24')
-#
-#===Arguments:
-#* String or NetAddr::CIDR object
-#
-#===Returns:
-#* true on success or false on fail
-#
-    def merge_subnets!(cidr)
-        merged = false
-        
-        # validate object
-        if ( !cidr.kind_of?(NetAddr::CIDR) )
-            begin
-                cidr = NetAddr::CIDR.create(cidr)
-            rescue Exception => error
-                raise ArgumentError, "Provided argument raised the following " +
-                                     "errors: #{error}"
-            end
-        end
-
-        me = find_me(cidr)
-        
-        if (me)
-            to_merge = []
-            me.children.each {|x| to_merge.push(x.cidr)}
-            to_merge.each {|x| delete!(x)}
-
-            NetAddr.merge(to_merge).each {|x| add!(x)}            
-            merged = true
-        end
+        found = find_me(cidr)
+        found = find_parent(cidr) if !found
 
-        return(merged)
+        return(found)
     end
 
 #==============================================================================#
@@ -551,7 +464,7 @@ class Tree
 #
     def prune!(cidr)
         pruned = false
-        
+
         # validate object
         if ( !cidr.kind_of?(NetAddr::CIDR) )
             begin
@@ -563,9 +476,9 @@ class Tree
         end
 
         me = find_me(cidr)
-        
+
         if (me)
-            me.children.clear
+            me.tag[:Subnets].clear
             pruned = true
         end
 
@@ -590,7 +503,7 @@ class Tree
     def remove!(cidr)
         removed = false
         found = nil
-        
+
         # validate object
         if ( !cidr.kind_of?(NetAddr::CIDR) )
             begin
@@ -602,13 +515,13 @@ class Tree
         end
 
         me = find_me(cidr)
-        
+
         if (me)
-            parent = me.parent
-            parent.children.delete(me)
+            parent = me.tag[:Parent]
+            parent.tag[:Subnets].delete(me)
             removed = true
         end
-        
+
         return(removed)
     end
 
@@ -630,7 +543,7 @@ class Tree
 #
     def resize!(cidr,bits)
         resized = false
-        
+
         # validate cidr
         if ( !cidr.kind_of?(NetAddr::CIDR) )
             begin
@@ -642,14 +555,14 @@ class Tree
         end
 
         me = find_me(cidr)
-        
+
         if (me)
-            new = me.cidr.resize(bits)
-            delete!(me.cidr)
+            new = me.resize(bits)
+            delete!(me)
             add!(new)
             resized = true
         end
-        
+
         return(resized)
     end
 
@@ -678,16 +591,17 @@ class Tree
                                      "errors: #{error}"
             end
         end
-        
-        parent = find_parent(cidr,@root)
-        
-        if (parent && parent != @root)
-            until (parent.parent == @root)
-                parent = parent.parent
+
+        parent = find_parent(cidr)
+        if (parent.tag.has_key?(:Parent)) # if parent is not 0/0
+            while(1)
+                grandparent = parent.tag[:Parent]
+                break if (!grandparent.tag.has_key?(:Parent)) # if grandparent is 0/0
+                parent = grandparent
             end
         end
 
-        return(parent.cidr)
+        return(parent)
     end
 
 #==============================================================================#
@@ -706,11 +620,27 @@ class Tree
 #* String
 #
     def show()
-        printed = ""
-        list = dump_children(@root)
+        printed = "IPv4 Tree\n---------\n"
+        list4 = dump_children(@v4_root)
+        list6 = dump_children(@v6_root)
+
+        list4.each do |entry|
+            cidr = entry[:CIDR]
+            depth = entry[:Depth]
+
+            if (depth == 0)
+                indent = ""
+            else
+                indent = " " * (depth*3)
+            end
+
+            printed << "#{indent}#{cidr.desc}\n"
+        end
 
-        list.each do |entry|
-            cidr = entry[:NetStruct].cidr
+        printed << "\n\nIPv6 Tree\n---------\n" if (list6.length != 0)
+
+       list6.each do |entry|
+            cidr = entry[:CIDR]
             depth = entry[:Depth]
 
             if (depth == 0)
@@ -750,17 +680,58 @@ class Tree
                                      "errors: #{error}"
             end
         end
-        
+
         list = []
-        find_parent(cidr,@root).children.each do |entry|
-            if (!cidr.cmp(entry.cidr))
-                list.push(entry.cidr)
+        find_parent(cidr).tag[:Subnets].each do |entry|
+            if (!cidr.cmp(entry))
+                list.push(entry)
             end
         end
 
         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.
+#
+# tree.summarize_subnets!('192.168.1.0/24')
+#
+#===Arguments:
+#* String or NetAddr::CIDR object
+#
+#===Returns:
+#* true on success or false on fail
+#
+    def summarize_subnets!(cidr)
+        merged = false
+
+        # validate object
+        if ( !cidr.kind_of?(NetAddr::CIDR) )
+            begin
+                cidr = NetAddr::CIDR.create(cidr)
+            rescue Exception => error
+                raise ArgumentError, "Provided argument raised the following " +
+                                     "errors: #{error}"
+            end
+        end
+
+        me = find_me(cidr)
+
+        if (me)
+            merged = NetAddr.cidr_summarize(me.tag[:Subnets])
+            me.tag[:Subnets] = merged
+            merged = true
+        end
+
+        return(merged)
+    end
+    alias :merge_subnets! :summarize_subnets!
+
 #==============================================================================#
 # supernets()
 #==============================================================================#
@@ -778,7 +749,8 @@ class Tree
 #
     def supernets()
        supernets = []
-       @root.children.each {|x| supernets.push(x.cidr)}
+       @v4_root.tag[:Subnets].each {|x| supernets.push(x)}
+       @v6_root.tag[:Subnets].each {|x| supernets.push(x)}
        return (supernets)
     end
 
@@ -787,27 +759,56 @@ class Tree
 private
 
 #==============================================================================#
-# add_to_parent() private
+# add_to_parent()
 #==============================================================================#
 
 # Add NetStruct object to an array of NetStruct's
 #
-    def add_to_parent(new_entry, parent)       
-        index = 0
-        parent.children.each do
-            if(new_entry.cidr.packed_network < parent.children[index].cidr.packed_network)
-                break
+    def add_to_parent(cidr, parent)
+        duplicate = false
+        duplicate = true if (NetAddr.cidr_find_in_list(cidr,parent.tag[:Subnets]).kind_of?(Integer))
+
+        if (!duplicate)
+        # check parent for subnets of cidr
+            parent.tag[:Subnets].length.times do |index|
+                index -= 1
+                old_cidr = parent.tag[:Subnets][index]
+                cmp = NetAddr.cidr_compare(cidr, old_cidr)
+                if (cmp && cmp == 1)
+                    old_cidr.tag[:Parent] = cidr
+                    cidr.tag[:Subnets].push(old_cidr)
+                    parent.tag[:Subnets][index] = nil
+                end
             end
-            index += 1
+
+            cidr.tag[:Parent] = parent
+            parent.tag[:Subnets].compact!
+            parent.tag[:Subnets].push(cidr)
+            parent.tag[:Subnets] = NetAddr.cidr_sort(parent.tag[:Subnets])
         end
 
-        parent.children.insert(index, new_entry)
+        return(nil)
+    end
 
-        return()
+#==============================================================================#
+# add_to_tree()
+#==============================================================================#
+
+# Add CIDR to a Tree
+#
+    def add_to_tree(cidr,root=nil)
+
+        # find cidr's parent
+        parent = find_parent(cidr)
+        if (parent)
+            add_to_parent(cidr,parent)
+        end
+
+        return(nil)
     end
 
 #==============================================================================#
-# dump_children() private
+# dump_children()
 #==============================================================================#
 
 #  Dump contents of an Array of NetStruct objects
@@ -816,10 +817,10 @@ private
         list = []
         depth = 0 if (!depth)
 
-        parent.children.each do |entry|
-            list.push({:NetStruct => entry, :Depth => depth})
+        parent.tag[:Subnets].each do |entry|
+            list.push({:CIDR => entry, :Depth => depth})
 
-            if (entry.children.length > 0)
+            if (entry.tag[:Subnets].length > 0)
                 list.concat( dump_children(entry, (depth+1) ) )
             end
         end
@@ -828,46 +829,51 @@ private
     end
 
 #==============================================================================#
-# find_me() private
+# find_me()
 #==============================================================================#
 
 # Find the NetStruct to which a cidr belongs.
 #
     def find_me(cidr)
         me = nil
-        
-        # find matching
-        parent = find_parent(cidr,@root)
-        parent.children.each do |entry|
-            if (entry.cidr.version == cidr.version)
-                if (entry.cidr.cmp(cidr) == 0)
-                    me = entry
-                    break
-                end
-            end
+        root = nil
+        if (cidr.version == 4)
+            root = @v4_root
+        else
+            root = @v6_root
         end
 
+        # find matching
+        parent = find_parent(cidr,root)
+        index = NetAddr.cidr_find_in_list(cidr,parent.tag[:Subnets])
+        me = parent.tag[:Subnets][index] if (index.kind_of?(Integer))
+
         return(me)
     end
 
 #==============================================================================#
-# find_parent() private
+# find_parent()
 #==============================================================================#
 
 # Find the parent NetStruct to which a child NetStruct belongs.
 #
-    def find_parent(cidr,parent)
-        version = cidr.version
-
-        parent.children.each do |entry|
-            if (entry.cidr.version == version && entry.cidr.contains?(cidr))
-                parent = entry
+    def find_parent(cidr,parent=nil)
+        if (!parent)
+            if (cidr.version == 4)
+                parent = @v4_root
+            else
+                parent = @v6_root
+            end
+        end
+        bit_diff = cidr.bits - parent.bits
 
-                if (parent.children.length > 0)
-                    search_results = find_parent(cidr,parent)
-                    parent = search_results if (search_results)
-                end
-                break
+        # if netmask of cidr is greater by 1 bit position, then this is the parent.
+        # if not then check to make sure that one of the children is the actual parent.
+        if (bit_diff > 1 && parent.tag[:Subnets].length != 0)
+            list = parent.tag[:Subnets]
+            found = NetAddr.cidr_find_in_list(cidr,list)
+            if (found.kind_of?(NetAddr::CIDR))
+                parent = find_parent(cidr,found)
             end
         end