ipaddress 0.7.5 → 0.8.0

data/lib/ipaddress/ipv6.rb

@@ -22,7 +22,7 @@ module IPAddress;
   # bits or two octect. For example, the following is a valid IPv6
   # address:
   #
-  #   1080:0000:0000:0000:0008:0800:200c:417a
+  #   2001:0db8:0000:0000:0008:0800:200c:417a
   #
   # Letters in an IPv6 address are usually written downcase, as per
   # RFC. You can create a new IPv6 object using uppercase letters, but
@@ -42,7 +42,7 @@ module IPAddress;
   # Using compression, the IPv6 address written above can be shorten into
   # the following, equivalent, address
   #
-  #   1080::8:800:200c:417a
+  #   2001:db8::8:800:200c:417a
   #
   # This short version is often used in human representation.
   #
@@ -51,7 +51,7 @@ module IPAddress;
   # As we used to do with IPv4 addresses, an IPv6 address can be written
   # using the prefix notation to specify the subnet mask:
   #
-  #   1080::8:800:200c:417a/64
+  #   2001:db8::8:800:200c:417a/64
   #
   # The /64 part means that the first 64 bits of the address are
   # representing the network portion, and the last 64 bits are the host
@@ -75,9 +75,9 @@ module IPAddress;
     #
     # An IPv6 address can be expressed in any of the following forms:
     # 
-    # * "1080:0000:0000:0000:0008:0800:200C:417A": IPv6 address with no compression
-    # * "1080:0:0:0:8:800:200C:417A": IPv6 address with leading zeros compression 
-    # * "1080::8:800:200C:417A": IPv6 address with full compression
+    # * "2001:0db8:0000:0000:0008:0800:200C:417A": IPv6 address with no compression
+    # * "2001:db8:0:0:8:800:200C:417A": IPv6 address with leading zeros compression 
+    # * "2001:db8::8:800:200C:417A": IPv6 address with full compression
     #
     # In all these 3 cases, a new IPv6 address object will be created, using the default
     # subnet mask /128
@@ -328,6 +328,36 @@ module IPAddress;
       to_u128 & @prefix.to_u128
     end
 
+    #
+    # Returns the broadcast address in Unsigned 128bits format
+    #
+    #   ip6 = IPAddress "2001:db8::8:800:200c:417a/64"
+    #
+    #   ip6.broadcast_u128
+    #     #=> 42540766411282592875350729025363378175
+    #
+    # Please note that there is no Broadcast concept in IPv6
+    # addresses as in IPv4 addresses, and this method is just 
+    # an helper to other functions.
+    #
+    def broadcast_u128
+      network_u128 + size - 1
+    end
+
+    #
+    # Returns the number of IP addresses included
+    # in the network. It also counts the network
+    # address and the broadcast address.
+    #
+    #   ip6 = IPAddress("2001:db8::8:800:200c:417a/64")
+    #
+    #   ip6.size
+    #     #=> 18446744073709551616
+    #
+    def size
+      2 ** @prefix.host_prefix
+    end
+
     #
     # Checks whether a subnet includes the given IP address.
     #
@@ -384,7 +414,74 @@ module IPAddress;
     def mapped?
       to_u128 >> 32 == 0xffff
     end
-    
+
+    #
+    # Iterates over all the IP addresses for the given
+    # network (or IP address).
+    #
+    # The object yielded is a new IPv6 object created
+    # from the iteration.
+    #
+    #   ip6 = IPAddress("2001:db8::4/125")
+    #
+    #   ip6.each do |i|
+    #     p i.compressed
+    #   end
+    #     #=> "2001:db8::"
+    #     #=> "2001:db8::1"
+    #     #=> "2001:db8::2"
+    #     #=> "2001:db8::3"
+    #     #=> "2001:db8::4"
+    #     #=> "2001:db8::5"
+    #     #=> "2001:db8::6"
+    #     #=> "2001:db8::7"
+    #
+    # WARNING: if the host portion is very large, this method 
+    # can be very slow and possibly hang your system!
+    #
+    def each
+      (network_u128..broadcast_u128).each do |i|
+        yield self.class.parse_u128(i, @prefix)
+      end
+    end
+
+    #
+    # Spaceship operator to compare IPv6 objects
+    #
+    # Comparing IPv6 addresses is useful to ordinate
+    # them into lists that match our intuitive 
+    # perception of ordered IP addresses.
+    # 
+    # The first comparison criteria is the u128 value.
+    # For example, 2001:db8:1::1 will be considered 
+    # to be less than 2001:db8:2::1, because, in a ordered list,
+    # we expect 2001:db8:1::1 to come before 2001:db8:2::1.
+    #
+    # The second criteria, in case two IPv6 objects 
+    # have identical addresses, is the prefix. An higher
+    # prefix will be considered greater than a lower
+    # prefix. This is because we expect to see
+    # 2001:db8:1::1/64 come before 2001:db8:1::1/65
+    #
+    # Example:
+    #
+    #   ip1 = IPAddress "2001:db8:1::1/64"
+    #   ip2 = IPAddress "2001:db8:2::1/64"
+    #   ip3 = IPAddress "2001:db8:1::1/65"
+    #
+    #   ip1 < ip2
+    #     #=> true
+    #   ip1 < ip3
+    #     #=> false
+    #
+    #   [ip1,ip2,ip3].sort.map{|i| i.to_string}
+    #     #=> ["2001:db8:1::1/64","2001:db8:1::1/65","2001:db8:2::1/64"]
+    #
+    def <=>(oth)
+      return prefix <=> oth.prefix if to_u128 == oth.to_u128  
+      to_u128 <=> oth.to_u128
+    end
+
     #
     # Returns the address portion of an IP in binary format,
     # as a string containing a sequence of 0 and 1
@@ -430,6 +527,19 @@ module IPAddress;
       @address.gsub(":","-") + ".ipv6-literal.net"
     end
 
+    #
+    # Returns a new IPv6 object with the network number 
+    # for the given IP.
+    #
+    #   ip = IPAddress "2001:db8:1:1:1:1:1:1/32" 
+    #
+    #   ip.network.to_string
+    #     #=> "2001:db8::/32"
+    #
+    def network
+      self.class.parse_u128(network_u128, @prefix)
+    end
+
     #
     # Extract 16 bits groups from a string
     #
@@ -470,18 +580,18 @@ module IPAddress;
     # Creates a new IPv6 object from an
     # unsigned 128 bits integer.
     #
-    #   ip6 = IPAddress::IPv6::parse_u128(21932261930451111902915077091070067066)
+    #   ip6 = IPAddress::IPv6::parse_u128(42540766411282592856906245548098208122)
     #   ip6.prefix = 64
     #
-    #   ip6.to_s
-    #     #=> "1080::8:800:200c:417a/64"
+    #   ip6.to_string
+    #     #=> "2001:db8::8:800:200c:417a/64"
     #
     # The +prefix+ parameter is optional:
     #
-    #   ip6 = IPAddress::IPv6::parse_u128(21932261930451111902915077091070067066, 64)
+    #   ip6 = IPAddress::IPv6::parse_u128(42540766411282592856906245548098208122, 64)
     #
-    #   ip6.to_s
-    #     #=> "1080::8:800:200c:417a/64"
+    #   ip6.to_string
+    #     #=> "2001:db8::8:800:200c:417a/64"
     #
     def self.parse_u128(u128, prefix=128)
       str = IN6FORMAT % (0..7).map{|i| (u128>>(112-16*i))&0xffff}
@@ -495,15 +605,15 @@ module IPAddress;
     #   ip6 = IPAddress::IPv6::parse_hex("20010db80000000000080800200c417a")
     #   ip6.prefix = 64
     #
-    #   ip6.to_s
+    #   ip6.to_string
     #     #=> "2001:db8::8:800:200c:417a/64"
     #
     # The +prefix+ parameter is optional:
     #
     #   ip6 = IPAddress::IPv6::parse_hex("20010db80000000000080800200c417a", 64)
     #
-    #   ip6.to_s
-    #     #=> "1080::8:800:200c:417a/64"
+    #   ip6.to_string
+    #     #=> "2001:db8::8:800:200c:417a/64"
     #
     def self.parse_hex(hex, prefix=128)
       self.parse_u128(hex.hex, prefix)
@@ -605,14 +715,14 @@ module IPAddress;
   #
   #   ip = IPAddress::IPv6::Loopback.new
   #
-  #   ip.to_s
+  #   ip.to_string
   #     #=> "::1/128"
   #
   # or by using the wrapper:
   #
   #   ip = IPAddress "::1"
   #
-  #   ip.to_s
+  #   ip.to_string
   #     #=> "::1/128"
   #
   # Checking if an address is loopback is easy with the IPv6#loopback?
@@ -629,7 +739,7 @@ module IPAddress;
     #
     #   ip = IPAddress::IPv6::Loopback.new
     #
-    #   ip.to_s
+    #   ip.to_string
     #     #=> "::1/128"
     #
     def initialize
@@ -668,7 +778,7 @@ module IPAddress;
   #   ip6.mapped?
   #     #=> true
   #
-  #   ip6.to_s
+  #   ip6.to_string
   #     #=> "::FFFF:172.16.10.1/128"
   #
   # Now with the +ipv4+ attribute, we can easily access the IPv4 portion
@@ -695,7 +805,7 @@ module IPAddress;
   # That is, two colons and the IPv4 address. However, as by RFC, the ffff
   # group will be automatically added at the beginning
   #
-  #   ip6.to_s
+  #   ip6.to_string
   #     => "::ffff:172.16.10.1/128"
   #
   # making it a mapped IPv6 compatible address.
@@ -718,7 +828,7 @@ module IPAddress;
     #
     #   ip6 = IPAddress::IPv6::Mapped.new "::0d01:4403"
     #
-    #   ip6.to_s
+    #   ip6.to_string
     #     #=> "::ffff:13.1.68.3"
     #
     def initialize(str)

data/lib/ipaddress/prefix.rb

@@ -18,7 +18,7 @@ module IPAddress
   # IPAddress::Prefix shouldn't be accesses directly, unless
   # for particular needs.
   #
-  class Prefix
+  class Prefix 
 
     include Comparable
 
@@ -247,6 +247,19 @@ module IPAddress
       bits.to_i(2)
     end
 
+    #
+    # Returns the length of the host portion
+    # of a netmask. 
+    #
+    #   prefix = Prefix128.new 96
+    #
+    #   prefix.host_prefix
+    #     #=> 32
+    #
+    def host_prefix
+      128 - @prefix
+    end
+
   end # class Prefix123 < Prefix
 
 end # module IPAddress

data/test/ipaddress/ipv4_test.rb

@@ -304,20 +304,20 @@ class IPv4Test < Test::Unit::TestCase
     assert_equal "1.10.16.172.in-addr.arpa", @ip.reverse
   end
   
-  def test_method_comparabble
+  def test_method_compare
     ip1 = @klass.new("10.1.1.1/8")
     ip2 = @klass.new("10.1.1.1/16")
     ip3 = @klass.new("172.16.1.1/14")
     ip4 = @klass.new("10.1.1.1/8")
 
-    # ip1 should be major than ip2
-    assert_equal true, ip1 > ip2
-    assert_equal false, ip1 < ip2
-    assert_equal false, ip2 > ip1        
-    # ip2 should be minor than ip3
+    # ip2 should be greater than ip1
+    assert_equal true, ip1 < ip2
+    assert_equal false, ip1 > ip2
+    assert_equal false, ip2 < ip1        
+    # ip2 should be less than ip3
     assert_equal true, ip2 < ip3
     assert_equal false, ip2 > ip3
-    # ip1 should be minor than ip3
+    # ip1 should be less than ip3
     assert_equal true, ip1 < ip3
     assert_equal false, ip1 > ip3
     assert_equal false, ip3 < ip1
@@ -326,7 +326,13 @@ class IPv4Test < Test::Unit::TestCase
     # ip1 should be equal to ip4
     assert_equal true, ip1 == ip4
     # test sorting
-    arr = ["10.1.1.1/16","10.1.1.1/8","172.16.1.1/14"]
+    arr = ["10.1.1.1/8","10.1.1.1/16","172.16.1.1/14"]
+    assert_equal arr, [ip1,ip2,ip3].sort.map{|s| s.to_string}
+    # test same prefix
+    ip1 = @klass.new("10.0.0.0/24")
+    ip2 = @klass.new("10.0.0.0/16")
+    ip3 = @klass.new("10.0.0.0/8")
+    arr = ["10.0.0.0/8","10.0.0.0/16","10.0.0.0/24"]
     assert_equal arr, [ip1,ip2,ip3].sort.map{|s| s.to_string}
   end
 
@@ -371,41 +377,57 @@ class IPv4Test < Test::Unit::TestCase
     assert_equal 24, ip.prefix.to_i
   end
 
-   def test_method_subnet
-     assert_raise(ArgumentError) {@ip.subnet(0)}
-     assert_raise(ArgumentError) {@ip.subnet(257)}
-
-     arr = ["172.16.10.0/27", "172.16.10.32/27", "172.16.10.64/27", 
-            "172.16.10.96/27", "172.16.10.128/27", "172.16.10.160/27", 
-            "172.16.10.192/27", "172.16.10.224/27"]
-     assert_equal arr, @network.subnet(8).map {|s| s.to_string}
-     arr = ["172.16.10.0/27", "172.16.10.32/27", "172.16.10.64/27", 
-            "172.16.10.96/27", "172.16.10.128/27", "172.16.10.160/27", 
-            "172.16.10.192/26"]
-     assert_equal arr, @network.subnet(7).map {|s| s.to_string}
-     arr = ["172.16.10.0/27", "172.16.10.32/27", "172.16.10.64/27", 
-            "172.16.10.96/27", "172.16.10.128/26", "172.16.10.192/26"]
-     assert_equal arr, @network.subnet(6).map {|s| s.to_string}
-     arr = ["172.16.10.0/27", "172.16.10.32/27", "172.16.10.64/27", 
-            "172.16.10.96/27", "172.16.10.128/25"]
-     assert_equal arr, @network.subnet(5).map {|s| s.to_string}
-     arr = ["172.16.10.0/26", "172.16.10.64/26", "172.16.10.128/26", 
-            "172.16.10.192/26"]
-     assert_equal arr, @network.subnet(4).map {|s| s.to_string}
-     arr = ["172.16.10.0/26", "172.16.10.64/26", "172.16.10.128/25"]
-     assert_equal arr, @network.subnet(3).map {|s| s.to_string}
-     arr = ["172.16.10.0/25", "172.16.10.128/25"]
-     assert_equal arr, @network.subnet(2).map {|s| s.to_string}
-     arr = ["172.16.10.0/24"]
-     assert_equal arr, @network.subnet(1).map {|s| s.to_string}
-   end
-
-   def test_method_supernet
-     assert_raise(ArgumentError) {@ip.supernet(0)}
-     assert_raise(ArgumentError) {@ip.supernet(24)}     
-     assert_equal "172.16.10.0/23", @ip.supernet(23).to_string
-     assert_equal "172.16.8.0/22", @ip.supernet(22).to_string
-   end
+  def test_method_split
+    assert_raise(ArgumentError) {@ip.split(0)}
+    assert_raise(ArgumentError) {@ip.split(257)}
+    
+    assert_equal @ip.network, @ip.split(1).first
+    
+    arr = ["172.16.10.0/27", "172.16.10.32/27", "172.16.10.64/27", 
+           "172.16.10.96/27", "172.16.10.128/27", "172.16.10.160/27", 
+           "172.16.10.192/27", "172.16.10.224/27"]
+    assert_equal arr, @network.split(8).map {|s| s.to_string}
+    arr = ["172.16.10.0/27", "172.16.10.32/27", "172.16.10.64/27", 
+           "172.16.10.96/27", "172.16.10.128/27", "172.16.10.160/27", 
+           "172.16.10.192/26"]
+    assert_equal arr, @network.split(7).map {|s| s.to_string}
+    arr = ["172.16.10.0/27", "172.16.10.32/27", "172.16.10.64/27", 
+           "172.16.10.96/27", "172.16.10.128/26", "172.16.10.192/26"]
+    assert_equal arr, @network.split(6).map {|s| s.to_string}
+    arr = ["172.16.10.0/27", "172.16.10.32/27", "172.16.10.64/27", 
+           "172.16.10.96/27", "172.16.10.128/25"]
+    assert_equal arr, @network.split(5).map {|s| s.to_string}
+    arr = ["172.16.10.0/26", "172.16.10.64/26", "172.16.10.128/26", 
+           "172.16.10.192/26"]
+    assert_equal arr, @network.split(4).map {|s| s.to_string}
+    arr = ["172.16.10.0/26", "172.16.10.64/26", "172.16.10.128/25"]
+    assert_equal arr, @network.split(3).map {|s| s.to_string}
+    arr = ["172.16.10.0/25", "172.16.10.128/25"]
+    assert_equal arr, @network.split(2).map {|s| s.to_string}
+    arr = ["172.16.10.0/24"]
+    assert_equal arr, @network.split(1).map {|s| s.to_string}
+  end
+
+  def test_method_subnet
+    assert_raise(ArgumentError) {@network.subnet(23)}
+    assert_raise(ArgumentError) {@network.subnet(33)}
+    assert_nothing_raised {@ip.subnet(30)}
+    arr = ["172.16.10.0/26", "172.16.10.64/26", "172.16.10.128/26", 
+           "172.16.10.192/26"]
+    assert_equal arr, @network.subnet(26).map {|s| s.to_string}
+    arr = ["172.16.10.0/25", "172.16.10.128/25"]
+    assert_equal arr, @network.subnet(25).map {|s| s.to_string}
+    arr = ["172.16.10.0/24"]
+    assert_equal arr, @network.subnet(24).map {|s| s.to_string}
+  end
+  
+  def test_method_supernet
+    assert_raise(ArgumentError) {@ip.supernet(24)}     
+    assert_equal "0.0.0.0/0", @ip.supernet(0).to_string
+    assert_equal "0.0.0.0/0", @ip.supernet(-2).to_string
+    assert_equal "172.16.10.0/23", @ip.supernet(23).to_string
+    assert_equal "172.16.8.0/22", @ip.supernet(22).to_string
+  end
 
   def test_classmethod_parse_u32
     @decimal_values.each do  |addr,int|

data/test/ipaddress/ipv6_test.rb

@@ -32,6 +32,11 @@ class IPv6Test < Test::Unit::TestCase
       
     @invalid_ipv6 = [":1:2:3:4:5:6:7",
                      ":1:2:3:4:5:6:7"]
+
+    @networks = {
+      "2001:db8:1:1:1:1:1:1/32" => "2001:db8::/32",
+      "2001:db8:1:1:1:1:1::/32" => "2001:db8::/32",
+      "2001:db8::1/64" => "2001:db8::/64"}
     
     @ip = @klass.new "2001:db8::8:800:200c:417a/64"
     @network = @klass.new "2001:db8:8:800::/64"
@@ -122,7 +127,22 @@ class IPv6Test < Test::Unit::TestCase
   def test_method_network_u128
     assert_equal 42540766411282592856903984951653826560, @ip.network_u128
   end
-  
+
+  def test_method_broadcast_u128
+    assert_equal 42540766411282592875350729025363378175, @ip.broadcast_u128
+  end
+
+  def test_method_size
+    ip = @klass.new("2001:db8::8:800:200c:417a/64")
+    assert_equal 2**64, ip.size
+    ip = @klass.new("2001:db8::8:800:200c:417a/32")
+    assert_equal 2**96, ip.size
+    ip = @klass.new("2001:db8::8:800:200c:417a/120")
+    assert_equal 2**8, ip.size
+    ip = @klass.new("2001:db8::8:800:200c:417a/124")
+    assert_equal 2**4, ip.size
+  end
+
   def test_method_include?
     assert_equal true, @ip.include?(@ip)
     # test prefix on same address
@@ -186,7 +206,53 @@ class IPv6Test < Test::Unit::TestCase
     assert_equal true, @klass.new("::1").loopback?
     assert_equal false, @ip.loopback?        
   end
-  
+
+  def test_method_network
+    @networks.each do |addr,net|
+      ip = @klass.new addr
+      assert_instance_of @klass, ip.network
+      assert_equal net, ip.network.to_string
+    end
+  end
+
+  def test_method_each
+    ip = @klass.new("2001:db8::4/125")
+    arr = []
+    ip.each {|i| arr << i.compressed}
+    expected = ["2001:db8::","2001:db8::1","2001:db8::2",
+                "2001:db8::3","2001:db8::4","2001:db8::5",
+                "2001:db8::6","2001:db8::7"]
+    assert_equal expected, arr
+  end
+
+  def test_method_compare
+    ip1 = @klass.new("2001:db8:1::1/64")
+    ip2 = @klass.new("2001:db8:2::1/64")
+    ip3 = @klass.new("2001:db8:1::2/64")
+    ip4 = @klass.new("2001:db8:1::1/65")
+
+    # ip2 should be greater than ip1
+    assert_equal true, ip2 > ip1
+    assert_equal false, ip1 > ip2
+    assert_equal false, ip2 < ip1        
+    # ip3 should be less than ip2
+    assert_equal true, ip2 > ip3
+    assert_equal false, ip2 < ip3
+    # ip1 should be less than ip3
+    assert_equal true, ip1 < ip3
+    assert_equal false, ip1 > ip3
+    assert_equal false, ip3 < ip1
+    # ip1 should be equal to itself
+    assert_equal true, ip1 == ip1
+    # ip4 should be greater than ip1
+    assert_equal true, ip1 < ip4
+    assert_equal false, ip1 > ip4
+    # test sorting
+    arr = ["2001:db8:1::1/64","2001:db8:1::1/65",
+           "2001:db8:1::2/64","2001:db8:2::1/64"]
+    assert_equal arr, [ip1,ip2,ip3,ip4].sort.map{|s| s.to_string}
+  end
+
   def test_classmethod_expand
     compressed = "2001:db8:0:cd30::"
     expanded = "2001:0db8:0000:cd30:0000:0000:0000:0000"