ipadmin 0.1.0 → 0.1.1

data/README

@@ -103,8 +103,8 @@
  puts "cidr4 size is #{cidr4.size()}"
  puts "cidr6 size is #{cidr6.size()}"
  
- cidr4.enumerate(:Limit => 4, :BitStep => 32) {|addr| puts addr}
- cidr6.enumerate(:Limit => 4, :BitStep => 32, :Objectify => 1) {|addr| puts  addr.desc()}
+ cidr4.enumerate(:Limit => 4, :Bitstep => 32) {|addr| puts addr}
+ cidr6.enumerate(:Limit => 4, :Bitstep => 32, :Objectify => 1) {|addr| puts  addr.desc()}
  
  cidr4.subnet(:Subnet => 28, :MinCount => 3) {|cidr| puts cidr.desc()}
  cidr6.subnet(:Subnet => 66, :MinCount => 4) {|cidr| puts cidr.desc()}
@@ -216,6 +216,17 @@
  
  puts "192.168.1.0/24 and 192.168.0.0/24 merge into #{IPAdmin.merge_cidr([cidr4_1,cidr4_2]).desc}"
  puts "fec0::0/128 and fec0::1/128 merge into #{IPAdmin.merge_cidr([cidr6_1,cidr6_2]).desc}"
+
+ ip1 = IPAdmin::IPAddr.new(:IPAddr => '192.168.1.0')
+ ip2 = IPAdmin::IPAddr.new(:IPAddr => '192.168.1.50')
+
+
+ list = IPAdmin.range(:Boundaries => [ip1,ip2], :Bitstep => 20 )
+ puts "ip's between #{ip1.desc} and #{ip2.desc}"
+ list.each do |x|
+  puts "  #{x}"
+ end
+
  
  print "\n\n\n"
  #=====================================#

data/lib/ip_admin.rb

@@ -392,6 +392,139 @@ module_function :pack_ipv6_netmask
 
 
 
+#============================================================================#
+# range()
+#============================================================================#
+
+# Given two IPAdmin::IPAddr objects of the same version, return all IP 
+# addresses between them (non-inclusive).
+# 
+# - Arguments:
+#   * Hash with the following fields
+#   - :Bitstep -- enumerate in X sized steps
+#   - :Boundaries -- array of (2) IPAdmin::IPAddr objects
+#   - :Limit -- limit returned list to X number of items
+#   - :Objectify -- return IPAdmin::IPAddr objects
+# 
+# - Returns:
+#   * array of IP addresses or IPAdmin::IPAddr objects
+#
+def range(options)
+    list = []
+    bitstep = 1
+    objectify = nil
+    limit = nil
+    v4_all_f = (2**32)-1
+    v6_all_f = (2**128)-1
+    
+    # check options    
+    if (options)
+        unless ( options.has_key?(:Boundaries) ) 
+            raise ArgumentError, "Missing arguments: Boundaries."
+        end
+        
+        if (options[:Boundaries].length == 2)
+            (ip1,ip2) = options[:Boundaries]
+        else
+            raise ArgumentError, "Two IPAdmin::IPAddr ojects are required. " +
+                                 "as Boundaries."
+        end
+        
+        if( options.has_key?(:Bitstep) )
+            bitstep = options[:Bitstep]
+        end
+        
+        if( options.has_key?(:Objectify) )
+            objectify = 1
+        end
+            
+        if( options.has_key?(:Limit) )
+            limit = options[:Limit]
+        end        
+    end
+    
+    
+    
+    # check our ipaddr objects
+    unless ((ip1.kind_of? IPAdmin::IPAddr) && (ip2.kind_of? IPAdmin::IPAddr))
+        raise "One or more values provided under :Boundaries "+
+              "is not a valid IPAdmin::IPAddr object."
+    end
+    
+    if (ip1.version == ip2.version)
+        version = ip1.version
+        boundaries = [ip1.packed_ip, ip2.packed_ip]
+        boundaries.sort
+    else
+        raise "Provided IPAdmin::IPAddr objects are of different versions."  
+    end
+    
+    
+    
+    # dump our range
+    if ( (version == 4) && !objectify)
+        my_ip = boundaries[0] + 1       
+
+        until (my_ip >= boundaries[1]) 
+            list.push( IPAdmin.unpack_ipv4_addr(my_ip) )
+            my_ip = my_ip + bitstep
+            if (limit)
+                limit = limit -1
+                break if (limit == 0)
+            end
+        end
+        
+    elsif ( (version == 4) && objectify)
+            my_ip = boundaries[0] + 1
+
+            until (my_ip >= boundaries[1])
+                my_ip_s = IPAdmin.unpack_ipv4_addr(my_ip)                
+                list.push( IPAdmin::IPAddr.new(:IPAddr => my_ip_s) )
+                my_ip = my_ip + bitstep
+                if (limit)
+                    limit = limit -1
+                    break if (limit == 0)
+                end
+            end
+        
+    elsif ( (version >= 6) && !objectify)
+        my_ip = boundaries[0] + 1       
+
+        until (my_ip == boundaries[1]) 
+            list.push( IPAdmin.unpack_ipv6_addr(my_ip) )
+            my_ip = my_ip + bitstep
+            if (limit)
+                limit = limit -1
+                break if (limit == 0)
+            end
+        end
+
+    elsif ( (version >= 6) && objectify)
+            my_ip = boundaries[0] + 1
+
+            until (my_ip == boundaries[1])
+                my_ip_s = IPAdmin.unpack_ipv6_addr(my_ip)
+                list.push( IPAdmin::IPAddr.new(:IPAddr => my_ip_s) )
+                my_ip = my_ip + bitstep
+                if (limit)
+                    limit = limit -1
+                    break if (limit == 0)
+                end
+            end 
+            
+    end
+    
+          
+    return(list)
+end
+module_function :range
+  
+#=====================================#
+#     
+#=====================================#
+
+
+
 #============================================================================#
 # unpack_ipv4_addr()
 #============================================================================#
@@ -1014,7 +1147,7 @@ class CIDR
 # 
 # - Arguments:
 #   * Hash with the following fields
-#   - :BitStep -- enumerate in X sized steps
+#   - :Bitstep -- enumerate in X sized steps
 #   - :Objectify -- return IPAdmin::IPAddr objects
 #   - :Limit -- limit returned list to X number of items
 # 
@@ -1029,8 +1162,8 @@ class CIDR
         v6_all_f = (2**128)-1
         
         if (options)
-            if( options.has_key?(:BitStep) )
-                bitstep = options[:BitStep]
+            if( options.has_key?(:Bitstep) )
+                bitstep = options[:Bitstep]
             end
         
             if( options.has_key?(:Objectify) )
@@ -1455,7 +1588,7 @@ class CIDR
         
         # list all 'subnet' sized subnets of this cidr block       
         bitstep = 2**(max_bits - subnet)
-        subs = self.enumerate(:BitStep => bitstep)
+        subs = self.enumerate(:Bitstep => bitstep)
         subs.each do |sub|
             cidr = "#{sub}/#{subnet}"
             new_subnets.push(IPAdmin::CIDR.new(:CIDR => cidr))

data/tests/cidr_test.rb

@@ -54,8 +54,8 @@ class TestCIDR < Test::Unit::TestCase
         assert_equal(['fec0:0000:0000:0000:0000:0000:0000:0000'],cidr6.enumerate(:Limit => 1) )
         
         
-        enums4 = cidr4.enumerate(:Limit => 2, :BitStep => 5)
-        enums6 = cidr6.enumerate(:Limit => 2, :BitStep => 5)
+        enums4 = cidr4.enumerate(:Limit => 2, :Bitstep => 5)
+        enums6 = cidr6.enumerate(:Limit => 2, :Bitstep => 5)
         assert_equal('192.168.1.5', enums4[1] )
         assert_equal('fec0:0000:0000:0000:0000:0000:0000:0005', enums6[1] )
         

data/tests/functions_test.rb

@@ -105,6 +105,7 @@ class TestIPAdmin < Test::Unit::TestCase
         cidr4_2 = IPAdmin::CIDR.new(:CIDR => '192.168.1.0/25')
         cidr4_3 = IPAdmin::CIDR.new(:CIDR => '192.168.2.0/24')
         cidr4_4 = IPAdmin::CIDR.new(:CIDR => '192.168.2.64/26')
+        cidr4_5 = IPAdmin::CIDR.new(:CIDR => '192.168.1.128/25')
         
         cidr6_1 = IPAdmin::CIDR.new(:CIDR => 'fec0::0/10')
         cidr6_2 = IPAdmin::CIDR.new(:CIDR => 'fec0::0/64')
@@ -114,12 +115,12 @@ class TestIPAdmin < Test::Unit::TestCase
         comp1 = IPAdmin.compare_cidr(cidr4_1,cidr4_2)
         comp2 = IPAdmin.compare_cidr(cidr4_4,cidr4_3)
         comp3 = IPAdmin.compare_cidr(cidr4_1,cidr4_1)
-        comp4 = IPAdmin.compare_cidr(cidr4_1,cidr4_3)
-        
+        comp4 = IPAdmin.compare_cidr(cidr4_1,cidr4_3)                
         comp5 = IPAdmin.compare_cidr(cidr6_1,cidr6_2)
         comp6 = IPAdmin.compare_cidr(cidr6_4,cidr6_3)
         comp7 = IPAdmin.compare_cidr(cidr6_1,cidr6_1)
-        comp8 = IPAdmin.compare_cidr(cidr6_1,cidr6_3)
+        comp8 = IPAdmin.compare_cidr(cidr6_1,cidr6_3)        
+        comp9 = IPAdmin.compare_cidr(cidr4_2,cidr4_5)
         
         assert_equal([cidr4_1,cidr4_2],comp1)
         assert_equal([cidr4_3,cidr4_4],comp2)
@@ -129,6 +130,7 @@ class TestIPAdmin < Test::Unit::TestCase
         assert_equal([cidr6_3,cidr6_4],comp6)
         assert_equal(1,comp7)
         assert_nil(comp8)
+        assert_nil(comp9)
     end
     
     
@@ -147,6 +149,24 @@ class TestIPAdmin < Test::Unit::TestCase
         assert_raise(RuntimeError){ IPAdmin.merge_cidr([cidr6_1,cidr6_3]) }
     end
     
+    def test_range
+        ip4_1 = IPAdmin::IPAddr.new(:IPAddr => '192.168.1.0')
+        ip4_2 = IPAdmin::IPAddr.new(:IPAddr => '192.168.1.50')
+        ip6_1 = IPAdmin::IPAddr.new(:IPAddr => 'fec0::0')
+        ip6_2 = IPAdmin::IPAddr.new(:IPAddr => 'fec0::32')        
+        
+        assert_equal(['192.168.1.1'], IPAdmin.range(:Boundaries => [ip4_1,ip4_2], :Limit => 1) )
+        assert_equal(['fec0:0000:0000:0000:0000:0000:0000:0001'], IPAdmin.range(:Boundaries => [ip6_1,ip6_2], :Limit => 1) )
+        
+        list = IPAdmin.range(:Boundaries => [ip4_1,ip4_2], :Bitstep => 2)
+        
+        assert_equal(25, list.length)
+        assert_equal('192.168.1.49', list[24])
+        
+        assert_raise(ArgumentError){ IPAdmin.range(:Limit => 1) }
+        assert_raise(RuntimeError){ IPAdmin.range(:Boundaries => [1,2]) }
+    end
+    
 end
 
 

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: ipadmin
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
-date: 2006-01-17 00:00:00 -06:00
+  version: 0.1.1
+date: 2006-01-22 00:00:00 -06:00
 summary: A package for manipulating IPv4/IPv6 address space.
 require_paths: 
   - lib