ip 0.0.3 → 0.1.0

data/lib/ip.rb

@@ -1,7 +1,7 @@
 #
 # IP - Collection of Tools to work with IP addresses
 #
-# Version:: 0.0.2
+# Version:: 0.1.0
 # Author:: Erik Hollensbe
 # License:: BSD
 # Contact:: erik@hollensbe.org
@@ -95,24 +95,24 @@ class IP
       raw1, raw2 = [nil, nil]
 
       if addr1.kind_of? String
-        raw1 = IP::Address.pack(IP::Address.new(addr1))
+        raw1 = IP::Address::Util.pack(IP::Address.new(addr1))
       elsif addr1.kind_of? IP::Address
-        raw1 = IP::Address.pack(addr1)
+        raw1 = IP::Address::Util.pack(addr1)
       else
         raise IP::AddressException("IP Address is not type String or IP::Address")
       end
 
       if addr2.kind_of? String
-        raw2 = IP::Address.pack(IP::Address.new(addr2))
+        raw2 = IP::Address::Util.pack(IP::Address.new(addr2))
       elsif addr2.kind_of? IP::Address
-        raw2 = IP::Address.pack(addr2)
+        raw2 = IP::Address::Util.pack(addr2)
       else
         raise IP::AddressException("IP Address is not type String or IP::Address")
       end
       
       range = []
 
-      (raw1..raw2).each { |x| range.push(IP::Address.unpack(x)) }
+      (raw1..raw2).each { |x| range.push(IP::Address::Util.unpack(x)) }
 
       return range
     end
@@ -120,13 +120,9 @@ class IP
 
   #
   # IP::CIDR - Works with Classless Inter-Domain Routing formats, such
-  # as 10.0.0.1/32. 
+  # as 10.0.0.1/32 or 10.0.0.1/255.255.255.255
   #
-  # Note: this class does not work with expanded RHS
-  # netmasks, such as 10.0.0.1/255.255.255.255. This is to be
-  # corrected in a later release.
-  #
-
+ 
   class CIDR
     #
     # Contains the original CIDR you fed it, returned as a string.
@@ -138,7 +134,7 @@ class IP
     #
     attr_reader :ip
     #
-    # Contains the integer-based netmask (RHS) only. Returned as an
+    # Contains the integer-based (short) netmask (RHS) only. Returned as an
     # integer.
     #
     attr_reader :mask
@@ -149,26 +145,49 @@ class IP
     #
     def initialize(cidr)
       if !cidr.kind_of? String
-        raise IP::AddressException("CIDR value is not of type String")
+        raise IP::AddressException.new("CIDR value is not of type String")
       end
         
       @cidr = cidr
-      @ip, @mask = cidr.split(/\//)
+      @ip, @mask = cidr.split(/\//, 2)
+
+      if @ip.nil? or @mask.nil?
+        raise IP::AddressException.new("CIDR is not valid - invalid format")
+      end
 
-      if @mask.length == 0 or @mask.length > 2 or /\D/.match @mask
-        raise IP::AddressException("CIDR RHS is not valid - #{@mask}")
+      if @mask.length == 0 or /[^0-9.]/.match @mask
+        raise IP::AddressException.new("CIDR RHS is not valid - #{@mask}")
+      end
+
+      if @mask.length > 2
+        # this will throw an exception if the netmask is malformed.
+        @mask = IP::Address::Util.short_netmask(IP::Address.new(@mask))
       end
 
       @ip = IP::Address.new(@ip)
       @mask = @mask.to_i
     end
 
+    def netmask
+      warn "IP::CIDR#netmask is deprecated. Please use IP::CIDR#long_netmask instead."
+      return self.long_netmask
+    end
+
     #
-    # This produces the netmask of the CIDR in an IP::Address object.
+    # This produces the long netmask (eg. 255.255.255.255) of the CIDR in an
+    # IP::Address object.
     #
-    def netmask
-      raw = 0xFFFFFFFF << (32 - @mask)
-      return IP::Address.unpack(raw)
+    def long_netmask
+      return IP::Address::Util.long_netmask(@mask)
+    end
+
+    #
+    # This produces the short netmask (eg. 32) of the CIDR in an IP::Address
+    # object.
+    #
+    
+    def short_netmask
+      return @mask
     end
 
     #
@@ -176,31 +195,27 @@ class IP
     # defined by the CIDR object.
     #
     def range
-      rawip = IP::Address.pack(@ip)
-      rawnm = 0xFFFFFFFF << (32 - @mask)
-      upper = rawip | ~rawnm
-      lower = rawip & rawnm
-      return IP::Range[IP::Address.unpack(lower), IP::Address.unpack(upper)]
+      return IP::Range[self.first_ip, self.last_ip]
     end
 
     #
     # This returns the first ip address of the cidr as an IP::Address object.
     #
     def first_ip
-      rawip = IP::Address.pack(@ip)
+      rawip = IP::Address::Util.pack(@ip)
       rawnm = 0xFFFFFFFF << (32 - @mask)
       lower = rawip & rawnm
-      return IP::Address.unpack(lower)
+      return IP::Address::Util.unpack(lower)
     end
 
     #
     # This returns the last ip address of the cidr as an IP::Address object.
     #
     def last_ip
-      rawip = IP::Address.pack(@ip)
+      rawip = IP::Address::Util.pack(@ip)
       rawnm = 0xFFFFFFFF << (32 - @mask)
       upper = rawip | ~rawnm
-      return IP::Address.unpack(upper)
+      return IP::Address::Util.unpack(upper)
     end
 
     #
@@ -210,13 +225,13 @@ class IP
     # This also throws a TypeError if passed invalid data.
     #
     def overlaps?(other_cidr)
-      fail TypeError.new("Expected object of type IP::Address") unless(other_cidr.kind_of?(IP::CIDR))
+      raise TypeError.new("Expected object of type IP::CIDR") unless(other_cidr.kind_of?(IP::CIDR))
 
-      myfirst = IP::Address.pack(self.first_ip)
-      mylast = IP::Address.pack(self.last_ip)
+      myfirst = IP::Address::Util.pack(self.first_ip)
+      mylast = IP::Address::Util.pack(self.last_ip)
       
-      otherfirst = IP::Address.pack(other_cidr.first_ip)
-      otherlast = IP::Address.pack(other_cidr.last_ip)
+      otherfirst = IP::Address::Util.pack(other_cidr.first_ip)
+      otherlast = IP::Address::Util.pack(other_cidr.last_ip)
 
       return ((myfirst >= otherfirst && myfirst <= otherlast) ||
         (mylast <= otherlast && mylast >= otherfirst) ||
@@ -244,7 +259,7 @@ class IP
     #
     def initialize(ip_address)
       if ! ip_address.kind_of? String
-        raise IP::AddressException("Fed IP address is not String")
+        raise IP::AddressException.new("Fed IP address is not String")
       end
       @ip_address = ip_address
       @octets = ip_address.split(/\./).collect { |x| x.to_i }
@@ -275,23 +290,106 @@ class IP
     # Class method to pack an IP::Address object into a long integer
     # used for calculation. Returns a 'FixNum' type.
     #
+    # This method is deprecated. Please use IP::Address::Util#pack instead.
+    #
     def Address.pack(ip)
-      ret = 0
-      myip = ip.octets.reverse
-      4.times { |x| ret = ret | (myip[x] & 0xFF) << 8*x }
-      return ret
+      warn "IP::Address#pack is deprecated. Please use IP::Address::Util#pack instead."
+      return IP::Address::Util.pack(ip)
     end
 
     #
     # Class method to take a 'FixNum' type and return an IP::Address
     # object.
     #
+    # This method is deprecated. Please use IP::Address::Util#unpack instead.
+    #
     def Address.unpack(ip)
-      ret = []
-      4.times { |x| ret.push((ip >> 8*x) & 0xFF) }
-      return IP::Address.new(ret.reverse.join("."))
+      warn "IP::Address#unpack is deprecated. Please use IP::Address::Util#unpack instead."
+      return IP::Address::Util.unpack(ip)
     end
       
   end
 
 end
+
+module IP::Address::Util
+  #
+  # Pack an IP::Address object into a long integer
+  # used for calculation. Returns a 'FixNum' type.
+  #
+  def pack(ip)
+    ret = 0
+    myip = ip.octets.reverse
+    4.times { |x| ret = ret | (myip[x] & 0xFF) << 8*x }
+    return ret
+  end
+  
+  module_function :pack
+  
+  #
+  # Take a 'FixNum' type and return an IP::Address object.
+  #
+  def unpack(ip)
+    ret = []
+    4.times { |x| ret.push((ip >> 8*x) & 0xFF) }
+    return IP::Address.new(ret.reverse.join("."))
+  end
+  
+  module_function :unpack
+
+  #
+  # Given an IP::Address object suitable for a netmask, returns the CIDR-notation
+  # "short" netmask.
+  #
+  # ex:
+  # short_netmask(IP::Address.new("255.255.255.255")) => 32
+  # short_netmask(IP::Address.new("255.255.255.240")) => 28
+  #
+
+  def short_netmask(ip)
+    a = []
+    (0..3).each do |x|
+      if x < 3 && ip[x] < 255 && ip[x+1] > 0
+        raise IP::BoundaryException.new("Invalid Netmask")
+      end
+      a += binary_vector(ip[x])
+    end
+    retval = 0
+    a.each { |x| retval += x }
+    return retval
+  end
+
+  module_function :short_netmask
+
+  #
+  # Given a CIDR-notation "short" netmask, returns a IP::Address object containing
+  # the equivalent "long" netmask.
+  #
+  # ex:
+  # long_netmask(32) => IP::Address object of "255.255.255.255"
+  # long_netmask(28) => IP::Address object of "255.255.255.240"
+  #
+
+  def long_netmask(short)
+    raw = 0xFFFFFFFF << (32 - short)
+    return IP::Address::Util.unpack(raw)
+  end
+
+  module_function :long_netmask
+
+  #
+  # Given a number (presumably an octet), will produce a binary vector indicating the
+  # on/off positions as 1 or 0.
+  #
+  # ex:
+  # binary_vector(255) => [1, 1, 1, 1, 1, 1, 1, 1]
+  # binary_vector(240) => [1, 1, 1, 1, 0, 0, 0, 0]
+  #
+
+  def binary_vector(octet)
+    return octet.to_i.to_s(2).split(//).collect { |x| x.to_i }
+  end
+
+  module_function :binary_vector
+
+end

data/test/ip.rb

@@ -0,0 +1,274 @@
+require 'test/unit'
+load 'lib/ip.rb'
+
+class CIDRTest < Test::Unit::TestCase
+
+  def name
+    return "IP::CIDR tests"
+  end
+
+  def test_init
+    a = nil
+    begin
+      IP::CIDR.new(Hash.new)
+      a = false
+    rescue IP::AddressException => e
+      a = true
+    end
+
+    assert(a, "data types test #1")
+    
+    begin
+      IP::CIDR.new("10.0.0.1")
+      a = false
+    rescue IP::AddressException => e
+      a = true
+    end
+    
+    assert(a, "data types test #2")
+    
+    begin
+      IP::CIDR.new("10.0.0.1/")
+      a = false
+    rescue IP::AddressException => e
+      a = true
+    end
+    
+    assert(a, "data types test #3")
+    
+    begin
+      IP::CIDR.new("10.0.0.1/asdf/32")
+      a = false
+    rescue IP::AddressException => e
+      a = true
+    end
+
+    assert(a, "data type test #4")
+    
+    begin
+      IP::CIDR.new("10.0.0.1/foomatic_wootmaster")
+      a = false
+    rescue IP::AddressException => e
+      a = true
+    end
+
+    assert(a, "data types test #5")
+
+    begin
+      IP::CIDR.new("foomatic_wootmaster/32")
+      a = false
+    rescue IP::AddressException => e
+      a = true
+    end
+    
+    assert(a, "data types test #6")
+
+    begin
+      IP::CIDR.new("10.0.0.1/255")
+      a = false
+    rescue IP::AddressException => e
+      a = true
+    end
+
+    assert(a, "data types test #7")
+
+    cidr = IP::CIDR.new("10.0.0.1/32")
+    
+    assert(cidr.ip.ip_address == "10.0.0.1", "data integrity test #1")
+    assert(cidr.mask == 32, "data integrity test #2")
+    assert(cidr.cidr == "10.0.0.1/32", "data integrity test #3")
+
+    cidr = IP::CIDR.new("10.0.0.1/255.255.255.255")
+
+    assert(cidr.ip.ip_address == "10.0.0.1", "data integrity test #4")
+    assert(cidr.mask == 32, "data integrity test #5")
+    assert(cidr.cidr == "10.0.0.1/255.255.255.255", "data integrity test #6")
+  end
+
+  def test_netmasks
+    cidr = IP::CIDR.new("10.0.0.1/32")
+    assert(cidr.short_netmask == 32, "netmask test #1")
+    assert(cidr.long_netmask.ip_address == "255.255.255.255", "netmask test #2")
+    
+    cidr = IP::CIDR.new("10.0.0.1/255.255.255.241")
+    assert(cidr.short_netmask == 29, "netmask test #3")
+    assert(cidr.long_netmask.ip_address == "255.255.255.248", "netmask test #4")
+  end
+
+  def test_first_last
+    cidr = IP::CIDR.new("10.0.0.2/24")
+    assert(cidr.first_ip.ip_address == "10.0.0.0", "first/last test #1")
+    assert(cidr.last_ip.ip_address == "10.0.0.255", "first/last test #2")
+  end
+
+  def test_range
+    cidr = IP::CIDR.new("10.0.0.2/24")
+    assert(cidr.range.find_all { |x| x.ip_address == "10.0.0.1" }.length == 1, "range test #1")
+    assert(cidr.range.find_all { |x| x.ip_address == "10.0.1.0" }.length == 0, "range test #2")
+  end
+
+  def test_overlaps
+    cidr = IP::CIDR.new("10.0.0.2/24")
+    cidr2 = IP::CIDR.new("10.0.0.1/29")
+
+    assert(cidr.overlaps?(cidr2), "overlaps test #1")
+
+    cidr2 = IP::CIDR.new("10.0.0.1/16")
+
+    assert(cidr2.overlaps?(cidr), "overlaps test #2")
+    assert(cidr.overlaps?(cidr2), "overlaps test #3")
+  end
+end
+
+class RangeTest < Test::Unit::TestCase
+  def name
+    return "IP::Range tests"
+  end
+
+  def test_range
+    a = nil
+    begin
+      IP::Range["10.0.0.1", "10.0.0.2"]
+      a = true
+    rescue Exception => e
+      a = false
+    end
+    
+    assert(a, "data types test #1")
+    
+    begin
+      IP::Range[IP::Address.new("10.0.0.1"), IP::Address.new("10.0.0.2")]
+      a = true
+    rescue Exception => e
+      a = false
+    end
+
+    assert(a, "data types test #2")
+
+    range = IP::Range["10.0.0.1", "10.0.0.10"]
+
+    assert(range.find_all { |x| x.ip_address == "10.0.0.1" }.length == 1, "range check #1")
+    assert(range.find_all { |x| x.ip_address == "10.0.0.10" }.length == 1, "range check #2")
+    assert(range.find_all { |x| x.ip_address == "10.0.0.7" }.length == 1, "range check #3")
+    assert(range.find_all { |x| x.ip_address == "10.0.0.11" }.length == 0, "range check #4")
+
+  end
+
+end
+
+class AddressTest < Test::Unit::TestCase
+  def name
+    return "IP::Address tests"
+  end
+
+  def test_init
+    ip = nil
+    begin
+      ip = IP::Address.new(Hash.new)
+    rescue IP::AddressException => e
+      assert(true, "init test #1")
+    end
+
+    assert(false, "init test #2") if ip
+
+    ip = nil
+
+    begin
+      ip = IP::Address.new("asdf")
+    rescue IP::AddressException => e
+      assert(true, "init test #2")
+    end
+
+    assert(false, "init test #2") if ip
+    ip = nil
+
+    begin
+      ip = IP::Address.new("0.0.0")
+    rescue IP::AddressException => e
+      assert(true, "init test #3")
+    end
+
+    assert(false, "init test #3") if ip
+    ip = nil
+    
+    begin
+      ip = IP::Address.new("256.255.255.255")
+    rescue IP::AddressException => e
+      assert(true, "init test #4")
+    end
+
+    assert(false, "init test #4") if ip
+  end
+  
+  def test_accessor
+    ip = IP::Address.new("10.1.2.3")
+    assert(ip.ip_address == "10.1.2.3", "accessor test #1")
+    assert(ip.octets[0] == 10, "accessor test #2")
+    assert(ip.octets[3] == 3, "accessor test #3")
+    assert(ip.octets[4] == nil, "accessor test #4")
+    
+    assert(ip.octet(1) == ip[1] && ip[1] == 1, "accessor test #5")
+
+    oct = nil
+
+    begin
+      oct = ip[4]
+    rescue IP::BoundaryException => e
+      assert(true, "accessor test #6")
+    end
+    
+    assert(false, "accessor test #6") if oct
+  end
+
+end
+
+class UtilTest < Test::Unit::TestCase
+  def name
+    return "IP::Address::Util tests"
+  end
+  
+  def test_pack_unpack
+    address = "10.0.0.1"
+    assert(IP::Address::Util.unpack(IP::Address::Util.pack(IP::Address.new(address))).ip_address == address, "pack/unpack test")
+  end
+  
+  def test_short_netmask
+    ip = IP::Address.new("255.255.255.255")
+    assert(IP::Address::Util.short_netmask(ip) == 32, "Short Netmask Test #1")
+    ip = IP::Address.new("255.255.255.241")
+    assert(IP::Address::Util.short_netmask(ip) == 29, "Short Netmask Test #2")
+    
+    nm = nil
+
+    begin
+      nm = IP::Address::Util.short_netmask(IP::Address.new("255.255.0.255"))
+    rescue IP::BoundaryException => e
+      assert(true, "Short Netmask BoundaryException Check #1")
+    end
+
+    assert(false, "Short Netmask BoundaryException Check #1") if nm
+    
+    nm = nil
+
+    begin
+      nm = IP::Address::Util.short_netmask(IP::Address.new("255.255.240.255"))
+    rescue IP::BoundaryException => e
+      assert(true, "Short Netmask BoundaryException check #2")
+    end
+    
+    assert(false, "Short Netmask BoundaryException check #2") if nm
+  end
+
+  def test_long_netmask
+    assert(IP::Address::Util.long_netmask(32).ip_address == "255.255.255.255", "Long Netmask Test #1")
+    assert(IP::Address::Util.long_netmask(29).ip_address == "255.255.255.248", "Long Netmask Test #2")
+  end
+
+  def test_binary_vector
+    assert(IP::Address::Util.binary_vector(255).length == 8, "Binary Vector Test #1")
+    assert(IP::Address::Util.binary_vector(240).find_all { |x| x == 1 }.length == 4, "Binary Vector Test #2")
+    assert(IP::Address::Util.binary_vector(241).find_all { |x| x == 1 }.length == 5, "Binary Vector Test #3")
+    assert(IP::Address::Util.binary_vector(240)[0] == 1, "Binary Vector Test #4")
+  end
+
+end

metadata

@@ -3,14 +3,14 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: ip
 version: !ruby/object:Gem::Version 
-  version: 0.0.3
-date: 2006-01-03 00:00:00 -08:00
+  version: 0.1.0
+date: 2006-01-20 00:00:00 -08:00
 summary: "Ruby classes to work with IP address, ranges, and netmasks"
 require_paths: 
   - lib
 email: erik@hollensbe.org
 homepage: 
-rubyforge_project: 
+rubyforge_project: ip-address
 description: 
 autorequire: ip
 default_executable: 
@@ -30,7 +30,8 @@ authors:
   - Erik Hollensbe
 files: 
   - lib/ip.rb
-test_files: []
+test_files: 
+  - test/ip.rb
 rdoc_options: []
 extra_rdoc_files: []
 executables: []