ip 0.3.0 → 0.3.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c3086640a7e7397faa00f2ba00d9e819dcbc0283
+  data.tar.gz: 500578f6568f2efffa81e5059e0a1bf0c5161189
+SHA512:
+  metadata.gz: af8209509af45f35f3047d876e7a6417527d2c489f4ce6c17323fe1903a2a50fdc08f62e8b114e216c7b112897defbe197f2be0d8b28d807910989fdc63df22d
+  data.tar.gz: ac60f52cd2982a6445438cbd6ada38ca2ac814e8ec738e71485689f99b4ad8fcbfa1e544d83c6924f0ae6a2a35b91285757abd7700f18eef61a19d11482c2a97

data/lib/ip.rb

@@ -3,7 +3,7 @@
 #
 # Version:: 0.3.0
 # Author:: Erik Hollensbe
-# License:: BSD
+# License:: MIT
 # Contact:: erik@hollensbe.org
 # Copyright:: Copyright (c) 2005-2006 Erik Hollensbe
 #
@@ -30,36 +30,9 @@
 # 'trial by fire' as this package came out of it's shell. Writing new
 # methods that made code easier to understand and/or clearer, and
 # making plenty of suggestions made creating this module much easier.
-#
-#--
-#
-# The compilation of software known as ip.rb is distributed under the
-# following terms:
-# Copyright (C) 2005-2006 Erik Hollensbe. All rights reserved.
-#
-# Redistribution and use in source form, with or without
-# modification, are permitted provided that the following conditions
-# are met:
-# 1. Redistributions of source code must retain the above copyright
-#   notice, this list of conditions and the following disclaimer.
-#
-# THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
-# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-# ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
-# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
-# OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
-# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
-# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
-# OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
-# SUCH DAMAGE.
-#
-#++
 
 class IP
-
-  VERSION = "0.3.0"
+  VERSION = "0.3.1"
 
   #
   # A IP::AddressException is thrown when an IP address cannot be

data/lib/ip/address.rb

@@ -10,7 +10,7 @@ class IP::Address
   attr_reader :ip_address
   #
   # This returns an Array of Integer which contains the octets of
-  # the IP, in descending order. 
+  # the IP, in descending order.
   #
   attr_reader :octets
 
@@ -24,12 +24,12 @@ class IP::Address
     end
     return @octets[num]
   end
-  
+
   #
   # See [].
   #
   alias_method :octet, :[]
-  
+
   #
   # Returns a 128-bit integer representing the address.
   #
@@ -66,42 +66,42 @@ class IP::Address::IPv4 < IP::Address
       # unpack to generate a string, and parse that.
       # overwrites 'ip_address'
       # horribly inefficient, but general.
-      
+
       raw = IP::Address::Util.raw_unpack(ip_address)[0..1]
       octets = []
-      
+
       2.times do |x|
         octets.push(raw[x] & 0x00FF)
         octets.push((raw[x] & 0xFF00) >> 8)
       end
-      
+
       ip_address = octets.reverse.join(".")
     end
-    
+
     if ! ip_address.kind_of? String
       raise IP::AddressException.new("Fed IP address '#{ip_address}' is not String or Fixnum")
     end
-    
+
     @ip_address = ip_address
-    
+
     #
     # Unbeknowest by me, to_i will not throw an exception if the string
     # can't be converted cleanly - it just truncates, similar to atoi() and perl's int().
     #
     # Code below does a final sanity check.
     #
-    
+
     octets = ip_address.split(/\./)
     octets_i = octets.collect { |x| x.to_i }
-    
+
     0.upto(octets.length - 1) do |octet|
       if octets[octet] != octets_i[octet].to_s
         raise IP::AddressException.new("Integer conversion failed")
       end
     end
-    
+
     @octets = octets_i
-    
+
     # I made a design decision to allow 0.0.0.0 here.
     if @octets.length != 4 or @octets.find_all { |x| x > 255 }.length > 0
       raise IP::AddressException.new("IP address is improperly formed")
@@ -116,14 +116,14 @@ class IP::Address::IPv4 < IP::Address
     # that the IP address is of a certain size and has certain numeric limits.
     myip = self.octets
     packval = [0] * 6
-    
+
     #
     # this ensures that the octets are 8 bit, and combines the octets in order to
     # form two 16-bit integers suitable for pushing into the last places in 'packval'
     #
-    
+
     (0..3).step(2) { |x| packval.push(((myip[x] & 0xFF) << 8) | (myip[x+1] & 0xFF)) }
-    
+
     return IP::Address::Util.raw_pack(packval)
   end
 
@@ -151,7 +151,7 @@ class IP::Address::IPv6 < IP::Address
   #
   # * A string which contains a valid,  RFC4291-compliant IPv6 address
   #     (all forms are supported, including the
-  #     backwards-compatibility IPv4 methods) 
+  #     backwards-compatibility IPv4 methods)
   #
   # * A 128-bit integer which is a sum of all the octets, left-most
   #   octet being the highest 32-bit portion (see IP::Address::Util
@@ -163,20 +163,20 @@ class IP::Address::IPv6 < IP::Address
       # unpack to generate a string, and parse that.
       # overwrites 'ip_address'
       # horribly inefficient, but general.
-      
+
       raw = IP::Address::Util.raw_unpack(ip_address)
-      
+
       ip_address = format_address(raw.reverse)
     end
-    
+
     if ! ip_address.kind_of? String
       raise IP::AddressException.new("Fed IP address '#{ip_address}' is not String or Fixnum")
     end
-    
+
     @ip_address = ip_address
-    
+
     octets = parse_address(ip_address)
-    
+
     if octets.length != 8
       raise IP::AddressException.new("IPv6 address '#{ip_address}' does not have 8 octets or a floating range specifier")
     end
@@ -185,14 +185,14 @@ class IP::Address::IPv6 < IP::Address
     # Now we check the contents of the address, to be sure we have
     # proper hexidecimal values
     #
-    
+
     @octets = octets_atoi(octets)
   end
-  
+
   #
-  # parses an ip address and stores it as the current object. 
+  # parses an ip address and stores it as the current object.
   #
- 
+
   def IPv6.parse(ip_address)
     return IP::Address::IPv6.new(ip_address)
   end
@@ -212,7 +212,7 @@ class IP::Address::IPv6 < IP::Address
   #
   # IP::Address::IPv6.new("DEAD::BEEF").long_address => "DEAD:0:0:0:0:0:0:BEEF"
   #
-  
+
   def long_address
     return format_address
   end
@@ -220,7 +220,7 @@ class IP::Address::IPv6 < IP::Address
   #
   # Returns a shortened address using the :: range specifier.
   #
-  # This will replace any sequential octets that are equal to '0' with '::'. 
+  # This will replace any sequential octets that are equal to '0' with '::'.
   # It does this searching from right to left, looking for a sequence
   # of them. Per specification, only one sequence can be replaced in
   # this fashion. It will return a long address if it can't find
@@ -235,13 +235,13 @@ class IP::Address::IPv6 < IP::Address
 
     # short circuit: if less than 2 octets are equal to 0, don't
     # bother - return a long address.
-    
+
     if octets.find_all { |x| x == 0 }.length < 2
       return format_address(octets)
     end
 
     filling = false
-    
+
     left  = []
     right = []
 
@@ -259,18 +259,18 @@ class IP::Address::IPv6 < IP::Address
         right.push(octets[x])
       end
     end
-    
+
     return format_address(left.reverse) + "::" + format_address(right.reverse)
-    
+
   end
-  
+
   #
   # Returns a 128-bit integer representing the address.
   #
   def pack
     return IP::Address::Util.raw_pack(self.octets.dup)
   end
-  
+
   #
   # An IP Address is equal if the ip address match
   #
@@ -317,35 +317,35 @@ class IP::Address::IPv6 < IP::Address
     octets = address.split(":")
 
     if octets.length < 8
-      
+
       if octets[-1].index(".").nil? and address.match(/::/)
         octets = handle_wildcard_in_address(octets)
       elsif octets[-1].index(".")
         # we have a dotted quad IPv4 compatibility address.
         # create an IPv4 object, get the raw value and stuff it into
         # the lower two octets.
-        
+
         raw = IP::Address::IPv4.new(octets.pop).pack
         raw = raw & 0xFFFFFFFF
         low = raw & 0xFFFF
         high = (raw >> 16) & 0xFFFF
         octets = handle_wildcard_in_address(octets)[0..5] + ([high, low].collect { |x| format_octet(x) })
-      else 
+      else
         raise IP::AddressException.new("IPv6 address '#{address}' has less than 8 octets")
       end
-      
+
     elsif octets.length > 8
       raise IP::AddressException.new("IPv6 address '#{address}' has more than 8 octets")
     end
-    
+
     return octets
   end
-  
+
 
   #
   # This handles :: addressing in IPv6 and generates a full set of
   # octets in response.
-  # 
+  #
   # The series of octets handed to this routine are expected to be the
   # result of splitting the address by ':'.
   #
@@ -353,9 +353,9 @@ class IP::Address::IPv6 < IP::Address
   def handle_wildcard_in_address(octets)
     lhs = []
     rhs = []
-    
+
     i = octets.index("") # find ::
-    
+
     # easy out for xxxx:xxxx:: and so on
     if i.nil?
       lhs = octets.dup
@@ -367,14 +367,14 @@ class IP::Address::IPv6 < IP::Address
       lhs = octets[0..(i-1)]
       rhs = octets[(i+1)..-1]
     end
-    
+
     unless rhs.index("").nil?
       raise IP::AddressException.new("IPv6 address '#{ip_address}' has more than one floating range ('::') specifier")
     end
-    
+
     missing = (8 - (lhs.length + rhs.length))
     missing.times { lhs.push("0") }
-    
+
     octets = lhs + rhs
 
     return octets
@@ -386,7 +386,7 @@ class IP::Address::IPv6 < IP::Address
 
   def octets_atoi(octets)
     new_octets = []
-    
+
     octets.each do |x|
       if x.length > 4
         raise IP::AddressException.new("IPv6 address '#{ip_address}' has an octet that is larger than 32 bits")
@@ -395,7 +395,7 @@ class IP::Address::IPv6 < IP::Address
       octet = x.hex
 
       # normalize the octet to 4 places with leading zeroes, uppercase.
-      x = ("0" * (4 - x.length)) + x.upcase 
+      x = ("0" * (4 - x.length)) + x.upcase
 
       unless ("%0.4X" % octet) == x
         raise IP::AddressException.new("IPv6 address '#{ip_address}' has octets that contain non-hexidecimal data")
@@ -403,7 +403,7 @@ class IP::Address::IPv6 < IP::Address
 
       new_octets.push(octet)
     end
-    
+
     return new_octets
 
   end

data/lib/ip/cidr.rb

@@ -18,7 +18,7 @@ class IP::CIDR
   # integer.
   #
   attr_reader :mask
-  
+
   #
   # Given a string of format X.X.X.X/X, in standard CIDR notation,
   # this will construct a IP::CIDR object.
@@ -27,7 +27,7 @@ class IP::CIDR
     if !cidr.kind_of? String
       raise IP::AddressException.new("CIDR value is not of type String")
     end
-    
+
     @cidr = cidr
     @ip, @mask = cidr.split(/\//, 2)
 
@@ -36,8 +36,8 @@ class IP::CIDR
     if @ip.nil? or @mask.nil?
       raise IP::AddressException.new("CIDR is not valid - invalid format")
     end
-    
-    if @mask.length == 0 or /[^0-9.]/.match @mask or 
+
+    if @mask.length == 0 or /[^0-9.]/.match @mask or
         (@ip.kind_of? IP::Address::IPv6 and @mask.to_i.to_s != @mask)
       raise IP::AddressException.new("CIDR RHS is not valid - #{@mask}")
     end
@@ -46,15 +46,15 @@ class IP::CIDR
       # get the short netmask for IPv4 - this will throw an exception if the netmask is malformed.
       @mask = IP::Address::Util.short_netmask(IP::Address::IPv4.new(@mask))
     end
-    
+
     @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 long netmask (eg. 255.255.255.255) of the CIDR in an
   # IP::Address object.
@@ -65,19 +65,19 @@ class IP::CIDR
     if @ip.kind_of? IP::Address::IPv6
       raise IP::AddressException.new("IPv6 does not support a long netmask.")
     end
-    
+
     return IP::Address::Util.long_netmask_ipv4(@mask)
   end
-  
+
   #
   # This produces the short netmask (eg. 32) of the CIDR in an IP::Address
   # object.
   #
-  
+
   def short_netmask
     return @mask
   end
-  
+
   #
   # This produces a range ala IP::Range, but only for the subnet
   # defined by the CIDR object.
@@ -85,18 +85,18 @@ class IP::CIDR
   def range
     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.pack 
-    
+    rawip = @ip.pack
+
     #
     # since our actual mask calculation is done with the full 128 bits,
     # we have to shift calculations that we want in IPv4 to the left to
     # get proper return values.
-    # 
+    #
 
     if @ip.kind_of? IP::Address::IPv4
       rawip = rawip << 96
@@ -120,13 +120,13 @@ class IP::CIDR
     end
 
   end
-  
+
   #
   # This returns the last ip address of the cidr as an IP::Address object.
   #
   def last_ip
     rawip = @ip.pack
-    
+
     # see #first_ip for the reason that we shift this way for IPv4.
     if @ip.kind_of? IP::Address::IPv4
       rawip = rawip << 96
@@ -149,7 +149,7 @@ class IP::CIDR
       raise IP::AddressException.new("Cannot determine type of IP address")
     end
   end
-  
+
   #
   # This will take another IP::CIDR object as an argument and check to see
   # if it overlaps with this cidr object. Returns true/false on overlap.
@@ -158,13 +158,13 @@ class IP::CIDR
   #
   def overlaps?(other_cidr)
     raise TypeError.new("Expected object of type IP::CIDR") unless(other_cidr.kind_of?(IP::CIDR))
-    
+
     myfirst = self.first_ip.pack
     mylast = self.last_ip.pack
-    
+
     otherfirst = other_cidr.first_ip.pack
     otherlast = other_cidr.last_ip.pack
-    
+
     return ((myfirst >= otherfirst && myfirst <= otherlast) ||
               (mylast <= otherlast && mylast >= otherfirst) ||
               (otherfirst >= myfirst && otherfirst <= mylast)) ? true : false;
@@ -185,7 +185,7 @@ class IP::CIDR
     raw   = address.pack
     first = first_ip.pack
     last  = last_ip.pack
-    
+
     return (raw >= first) && (raw <= last)
   end
 

data/lib/ip/range.rb

@@ -14,22 +14,22 @@
 #
 
 class IP::Range
-  
+
   #
   # See the documentation for IP::Range for more information on this
   # method.
   #
-  
+
   def self.[](addr1, addr2)
     raw1, raw2 = [nil, nil]
     tmpip = nil
-    
+
     if addr1.kind_of? String
       addr1 = IP::Address::Util.string_to_ip(addr1)
     elsif ! addr1.kind_of? IP::Address
       raise IP::AddressException.new("IP Address is not type String or IP::Address")
     end
-    
+
     if addr2.kind_of? String
       addr2 = IP::Address::Util.string_to_ip(addr2)
     elsif ! addr2.kind_of? IP::Address
@@ -39,12 +39,12 @@ class IP::Range
     if addr2.class.name != addr1.class.name
       raise IP::AddressException.new("First and Second IP in range are not of the same type")
     end
-    
+
     raw1 = addr1.pack
     raw2 = addr2.pack
 
     range = []
-    
+
     # use the class we were given to force certain results, instead
     # of relying on the fairly inaccurate unpack facility.
     range = (raw1..raw2).collect { |x| addr1.class.new(x) }

data/lib/ip/util.rb

@@ -8,13 +8,13 @@ module IP::Address::Util
   # 'FixNum' type. Can take both IP::Address::IPv4 and
   # IP::Address::IPv6 objects.
   #
-  
+
   def pack(ip)
     return ip.pack
   end
-  
+
   module_function :pack
-  
+
   #
   # This routine takes an array of integers which are intended to be
   # an IP address, and joins them into a single integer used for easy
@@ -23,16 +23,16 @@ module IP::Address::Util
   # IPv4 and IPv6 objects are packed into the same size, a 128-bit
   # integer. This is done for easier processing within the library.
   #
-  
+
   def raw_pack(array)
     ret = 0
     myip = array.reverse
     8.times { |x| ret = ret | myip[x] << 16*x }
     return ret
   end
-  
+
   module_function :raw_pack
-  
+
   #
   # Take an 'Integer' type and return an IP::Address object.
   #
@@ -46,31 +46,31 @@ module IP::Address::Util
   #
   def unpack(ip)
     ret = raw_unpack(ip)
-    
+
     # any IPv6 address should meet this criteria.
     if ret[2..8].any? { |x| x > 0 }
       return IP::Address::IPv6.new(ip)
     end
-    
+
     return IP::Address::IPv4.new(ip)
   end
-  
+
   module_function :unpack
- 
+
   #
   # Take a 'FixNum' and return it's in-place octet
   # representation. This is mostly a helper method for the unpack
   # routines.
   #
-  
+
   def raw_unpack(ip)
     ret = []
     8.times { |x| ret.push((ip >> 16*x) & 0xFFFF) }
     return ret
   end
-  
+
   module_function :raw_unpack
-  
+
   #
   # Returns a short subnet mask - works for all IP::Address objects.
   #
@@ -78,7 +78,7 @@ module IP::Address::Util
   # short_netmask(IP::Address::IPv4.new("255.255.255.255")) => 32
   # short_netmask(IP::Address::IPv6.new("2001:0DB8:0000:CD30:0000:0000:0000:0000")) => 60
   #
-  
+
   def short_netmask(ip)
     #
     # This method handles 128-bit integers better for both types of
@@ -86,7 +86,7 @@ module IP::Address::Util
     #
     # TODO: there really is probably a better way to do this.
     #
- 
+
     s = ip.pack.to_s(2)
 
     pad = 0
@@ -102,16 +102,16 @@ module IP::Address::Util
 
     return s.rindex("1") + 1
   end
-  
+
   module_function :short_netmask
-  
+
   def long_netmask(short)
     warn "This function is deprecated, please use IP::Address::Util.long_netmask_ipv4 instead."
     return long_netmask_ipv4(short)
   end
-  
+
   module_function :long_netmask
-  
+
   #
   # Given a CIDR-notation "short" netmask, returns a IP::Address object containing
   # the equivalent "long" netmask.
@@ -120,14 +120,14 @@ module IP::Address::Util
   # 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_ipv4(short)
     raw = (0xFFFFFFFF << (32 - short)) & 0xFFFFFFFF
     return IP::Address::Util.unpack(raw)
   end
-  
+
   module_function :long_netmask_ipv4
-  
+
   #
   # This takes a string which supposedly contains an IP address, and
   # tries to figure out if it is a IPv6 or IPv4 address. Returns a

metadata

@@ -1,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ip
 version: !ruby/object:Gem::Version
-  version: 0.3.0
-  prerelease: 
+  version: 0.3.1
 platform: ruby
 authors:
 - Erik Hollensbe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-11 00:00:00.000000000 Z
+date: 2014-01-21 00:00:00.000000000 Z
 dependencies: []
 description: 
 email: erik@hollensbe.org
@@ -17,38 +16,33 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- Rakefile
-- examples/check-included.rb
-- examples/check-overlap.rb
-- examples/generate-a-records.rb
 - lib/ip.rb
-- test/test_ip.rb
 - lib/ip/address.rb
 - lib/ip/cidr.rb
 - lib/ip/range.rb
 - lib/ip/util.rb
 homepage: http://github.com/erikh/ip
-licenses: []
+licenses:
+- MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: ip-address
-rubygems_version: 1.8.15
+rubygems_version: 2.1.10
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Ruby classes to work with IP address, ranges, and netmasks
 test_files: []

data/Rakefile

@@ -1,76 +0,0 @@
-#
-# Please see the COPYING file in the source distribution for copyright information.
-# 
-
-begin
-    require 'rubygems'
-    gem 'test-unit'
-rescue LoadError
-end
-
-$:.unshift 'lib'
-require 'rake/testtask'
-require 'rake/packagetask'
-require 'rake/gempackagetask'
-require 'rake/rdoctask'
-require 'ip'
-
-task :default => [ :dist ]
-
-#
-# Tests
-#
-
-Rake::TestTask.new do |t|
-    t.libs << 'lib'
-    t.test_files = FileList['test/test*.rb']
-    t.verbose = true 
-end
-
-#
-# Distribution
-#
-
-task :dist      => [:test, :repackage, :gem, :rdoc]
-task :distclean => [:clobber_package, :clobber_rdoc]
-task :clean     => [:distclean]
-
-#
-# Documentation
-#
-
-Rake::RDocTask.new do |rd|
-    rd.rdoc_dir = "rdoc"
-    rd.main = "IP"
-    rd.rdoc_files.include("./lib/**/*.rb")
-    rd.options = %w(-ap)
-end
-
-#
-# Packaging
-# 
-
-spec = Gem::Specification.new do |s|
-    s.name = "ip"
-    s.version = IP::VERSION
-    s.author = "Erik Hollensbe"
-    s.email = "erik@hollensbe.org"
-    s.summary = "Ruby classes to work with IP address, ranges, and netmasks"
-    s.has_rdoc = true
-    s.files = Dir['Rakefile'] + Dir['examples/*.rb'] + Dir['lib/*.rb'] + Dir['test/*.rb'] + Dir['lib/ip/*.rb']
-    s.rubyforge_project = 'ip-address'
-    s.homepage = "http://github.com/erikh/ip"
-end
-
-Rake::GemPackageTask.new(spec) do |s|
-end
-
-Rake::PackageTask.new(spec.name, spec.version) do |p|
-    p.need_tar_gz = true
-    p.need_zip = true
-    p.package_files.include("./setup.rb")
-    p.package_files.include("./Rakefile")
-    p.package_files.include("./examples/**/*.rb")
-    p.package_files.include("./lib/**/*.rb")
-    p.package_files.include("./test/**/*")
-end

data/examples/check-included.rb

@@ -1,27 +0,0 @@
-#!/usr/bin/env ruby
-#
-# Checks if a given IP address exists in a subnet.
-#
-# Takes either IPv6 or IPv4.
-#
-
-begin
-  require 'rubygems'
-rescue LoadError => e
-end
-
-require 'ip'
-
-if !ARGV[0] or !ARGV[1]
-  $stderr.puts "usage: #{File.basename($0)} <cidr> <ip>"
-  exit -1
-end
-
-if IP::CIDR.new(ARGV[0]).includes? IP::Address::Util.string_to_ip(ARGV[1])
-  $stderr.puts "IP #{ARGV[1]} exists in the #{ARGV[0]} subnet"
-  exit 0
-else
-  $stderr.puts "IP #{ARGV[1]} does not exist in the #{ARGV[0]} subnet"
-  exit 1
-end
-

data/examples/check-overlap.rb

@@ -1,26 +0,0 @@
-#!/usr/bin/env ruby
-#
-# given two CIDR formatted addresses, check for overlaps.
-#
-# Takes either IPv6 or IPv4.
-#
-
-begin
-  require 'rubygems'
-rescue LoadError => e
-end
-
-require 'ip'
-
-if !ARGV[0] or !ARGV[1]
-  $stderr.puts "usage: #{File.basename($0)} <cidr> <cidr>"
-  exit -1
-end
-
-if IP::CIDR.new(ARGV[0]).overlaps? IP::CIDR.new(ARGV[1])
-  $stderr.puts "These address ranges overlap."
-  exit 1
-else
-  $stderr.puts "No overlaps"
-  exit 0
-end

data/examples/generate-a-records.rb

@@ -1,26 +0,0 @@
-#!/usr/bin/env ruby
-#
-# Generate a set of A records suitable for inclusion in a
-# zone.
-#
-# Takes two IP addresses as a range to generate.
-# 
-
-begin
-  require 'rubygems'
-rescue LoadError => e
-end
-
-require 'ip'
-
-if !ARGV[0] or !ARGV[1]
-  $stderr.puts "usage: #{File.basename($0)} <start ip> <end ip>"
-  exit -1
-end
-
-$fmt = "%15.15s    IN A    %15.15s"
-
-IP::Range[ARGV[0], ARGV[1]].each do |ip|
-  hostname = ip.ip_address.gsub(/\./, "-")
-  puts ($fmt % [hostname, ip.ip_address])
-end

data/test/test_ip.rb

@@ -1,313 +0,0 @@
-begin
-    require 'rubygems'
-    gem 'test-unit'
-rescue LoadError => e 
-end
-
-require 'test/unit'
-load 'lib/ip.rb'
-
-class CIDRTest < Test::Unit::TestCase
-
-  def name
-    return "IP::CIDR tests"
-  end
-
-  def test_init_generic
-    assert_raise(IP::AddressException) { IP::CIDR.new(Hash.new) }
-    assert_raise(IP::AddressException) { IP::CIDR.new("foomatic_wootmaster/32") } 
-  end
-
-  def test_init_ipv6
-    assert_raise(IP::AddressException) { IP::CIDR.new("F00F:DEAD:BEEF::") }
-    assert_raise(IP::AddressException) { IP::CIDR.new("F00F:DEAD:BEEF::/") }
-    assert_raise(IP::AddressException) { IP::CIDR.new("F00F:DEAD:BEEF::/asdf/32") }
-    assert_raise(IP::AddressException) { IP::CIDR.new("F00F:DEAD:BEEF::/foomatic_wootmaster") }
-    assert_raise(IP::AddressException) { IP::CIDR.new("F00F:DEAD:BEEF::/255.255.255.255") }
-
-    cidr = nil
-    assert_nothing_raised() { cidr = IP::CIDR.new("F00F:DEAD:BEEF::0001/128") } 
-
-    # this sort of indirectly tests the ipv6 address manipulation.
-    assert_equal("F00F:DEAD:BEEF::1", cidr.ip.short_address, "ipv6 object constructed clean")
-    assert_equal(128, cidr.mask, "mask is set properly")
-    assert_equal("F00F:DEAD:BEEF::0001/128", cidr.cidr, "original CIDR preserved")
-  end
-
-  def test_init_ipv4
-    assert_raise(IP::AddressException) { IP::CIDR.new("10.0.0.1") }
-    assert_raise(IP::AddressException) { IP::CIDR.new("10.0.0.1/") }
-    assert_raise(IP::AddressException) { IP::CIDR.new("10.0.0.1/asdf/32") }
-    assert_raise(IP::AddressException) { IP::CIDR.new("10.0.0.1/foomatic_wootmaster") }
-    assert_raise(IP::AddressException) { IP::CIDR.new("10.0.0.1/255") }
-
-    cidr = nil
-
-    assert_nothing_raised() { cidr = IP::CIDR.new("10.0.0.1/32") } 
-    
-    assert_equal("10.0.0.1", cidr.ip.ip_address, "ipv4 data integrity test #1")
-    assert_equal(32, cidr.mask, "ipv4 data integrity test #2")
-    assert_equal("10.0.0.1/32", cidr.cidr, "ipv4 data integrity test #3")
-
-    assert_nothing_raised() { cidr = IP::CIDR.new("10.0.0.1/255.255.255.255") }
-
-    assert_equal("10.0.0.1", cidr.ip.ip_address, "ipv4 data integrity test #4")
-    assert_equal(32, cidr.mask, "ipv4 data integrity test #5")
-    assert_equal("10.0.0.1/255.255.255.255", cidr.cidr, "ipv4 data integrity test #6")
-  end
-
-  def test_netmasks
-    cidr = nil 
-    assert_nothing_raised() { cidr = IP::CIDR.new("10.0.0.1/32") }
-    assert_equal(32, cidr.short_netmask, "ipv4 netmask test #1")
-    assert_equal("255.255.255.255", cidr.long_netmask.ip_address, "ipv4 netmask test #2")
-    
-    assert_nothing_raised() { cidr = IP::CIDR.new("10.0.0.1/255.255.255.248") }
-    assert_equal(29, cidr.short_netmask, "ipv4 netmask test #3")
-    assert_equal("255.255.255.248", cidr.long_netmask.ip_address, "ipv4 netmask test #4")
-
-    assert_nothing_raised() { cidr = IP::CIDR.new("F00F:DEAD::/16") }
-    assert_equal(16, cidr.short_netmask, "ipv6 has proper short netmask")
-    assert_raise(IP::AddressException) { cidr.long_netmask } 
-  end
-
-  def test_first_last
-    cidr = nil
-    assert_nothing_raised() { cidr = IP::CIDR.new("10.0.0.2/24") }
-    assert_equal("10.0.0.0", cidr.first_ip.ip_address, "ipv4 first/last test #1")
-    assert_equal("10.0.0.255", cidr.last_ip.ip_address, "ipv4 first/last test #2")
-  end
-
-  def test_range
-    cidr = nil
-    assert_nothing_raised() { cidr = IP::CIDR.new("10.0.0.2/24") }
-    assert_equal(1, cidr.range.find_all { |x| x.ip_address == "10.0.0.1" }.length, "ipv4 range test #1")
-    assert_equal(0, cidr.range.find_all { |x| x.ip_address == "10.0.1.0" }.length, "ipv4 range test #2")
-
-    assert_nothing_raised() { cidr = IP::CIDR.new("::0001/120") }
-    assert_equal(1, cidr.range.find_all { |x| x.ip_address == "0:0:0:0:0:0:0:00FF" }.length, "ipv6 range test (included)")
-    assert_equal(0, cidr.range.find_all { |x| x.ip_address ==" 0:0:0:0:0:0:0:0F00" }.length, "ipv6 range test (not included)")
-  end
-
-  def test_overlaps
-    cidr, cidr2 = [nil, nil]
-    
-    assert_nothing_raised() do 
-      cidr = IP::CIDR.new("10.0.0.2/24")
-      cidr2 = IP::CIDR.new("10.0.0.1/29")
-    end
-
-    assert(cidr.overlaps?(cidr2), "ipv4 overlaps test #1")
-
-    assert_nothing_raised() { cidr2 = IP::CIDR.new("10.0.0.1/16") }
-
-    assert(cidr2.overlaps?(cidr), "ipv4 overlaps test #2")
-    assert(cidr.overlaps?(cidr2), "ipv4 overlaps test #3")
-
-    assert_nothing_raised() do 
-      cidr  = IP::CIDR.new("F00F:DEAD::/16")
-      cidr2 = IP::CIDR.new("F00F:BEEF::/16")
-    end 
-
-    assert(cidr.overlaps?(cidr2), "ipv6 #overlaps? reports correctly #1")
-    assert(cidr2.overlaps?(cidr), "ipv6 #overlaps? reports correctly #2")
-  end
-  
-  def test_includes
-    cidr, ip = [nil, nil]
-    assert_nothing_raised() do 
-      cidr = IP::CIDR.new("10.0.0.2/24")
-      ip = IP::Address::IPv4.new("10.0.0.1")
-    end
-
-    assert(cidr.includes?(ip), "ipv4 #includes? reports correctly (included)")
-    
-    assert_nothing_raised() { ip = IP::Address::IPv4.new("10.0.1.0") }
-
-    assert(!cidr.includes?(ip), "ipv4 #includes? reports correctly (not included)")
-   
-    assert_nothing_raised() do 
-      cidr = IP::CIDR.new("FF00::/16")
-      ip = IP::Address::IPv6.new("FF00::DEAD")
-    end
-    assert(cidr.includes?(ip), "ipv6 #includes? reports correctly (included)")
-    
-    assert_nothing_raised() { ip = IP::Address::IPv6.new("F000::DEAD") } 
-
-    assert(!cidr.includes?(ip), "ipv6 #includes? reports correctly (not included)")
-  end
-
-end
-
-class RangeTest < Test::Unit::TestCase
-  def name
-    return "IP::Range tests"
-  end
-
-  def test_range_generic
-    assert_raise(IP::AddressException) { IP::Range[Hash.new, ""] } 
-    assert_raise(IP::AddressException) { IP::Range["", Hash.new] } 
-    assert_raise(IP::AddressException) { IP::Range[IP::Address::IPv6.new("F00F::"), IP::Address::IPv4.new("10.0.0.1")]  }
-    assert_raise(IP::AddressException) { IP::Range[IP::Address::IPv4.new("10.0.0.1"), IP::Address::IPv6.new("F00F::")] } 
-  end
-
-  def test_range_ipv6
-    assert_nothing_raised() do 
-      IP::Range["::0001", "::00F0"] 
-      IP::Range[IP::Address::IPv6.new("::0001"), IP::Address::IPv6.new("::00F0")]
-    end
-
-    range = nil
-    
-    assert_nothing_raised() { range = IP::Range["::0001", "::0010"] } 
-    
-    assert_equal(1, range.find_all { |x| x.short_address == "::1" }.length, "ipv6 range check #1")
-    assert_equal(1, range.find_all { |x| x.short_address == "::0010" }.length, "ipv6 range check #2")
-    assert_equal(1, range.find_all { |x| x.short_address == "::000A" }.length, "ipv6 range check #3")
-    assert_equal(0, range.find_all { |x| x.short_address == "::0011" }.length, "ipv6 range check #4")
-  end
-
-  def test_range_ipv4
-    assert_nothing_raised() do 
-      IP::Range["10.0.0.1", "10.0.0.2"]
-      IP::Range[IP::Address::IPv4.new("10.0.0.1"), IP::Address::IPv4.new("10.0.0.2")]
-    end
-
-    range = nil
-    assert_nothing_raised() { range = IP::Range["10.0.0.1", "10.0.0.10"] }
-
-    assert_equal(1, range.find_all { |x| x.ip_address == "10.0.0.1" }.length, "ipv4 range check #1")
-    assert_equal(1, range.find_all { |x| x.ip_address == "10.0.0.10" }.length, "ipv4 range check #2")
-    assert_equal(1, range.find_all { |x| x.ip_address == "10.0.0.7" }.length, "ipv4 range check #3")
-    assert_equal(0, range.find_all { |x| x.ip_address == "10.0.0.11" }.length, "ipv4 range check #4")
-  end
-
-end
-
-class IPv6AddressTest < Test::Unit::TestCase
-  def name
-    return "IP::Address::IPv6 tests"
-  end
-  
-  def test_init
-    assert_nothing_raised() do
-      IP::Address::IPv6.new("0000:0000:0000:0000:0000:0000:0000:0001")
-      IP::Address::IPv6.new("::0001")
-      IP::Address::IPv6.new("FF00::")
-      IP::Address::IPv6.new("FF00::0001")
-      IP::Address::IPv6.new("FF00:BEEF::0001")
-      IP::Address::IPv6.new("FF00::BEEF:0001")
-      IP::Address::IPv6.new("::1.2.3.4")
-      IP::Address::IPv6.new("FFFF::1.2.3.4")
-      IP::Address::IPv6.new("FFFF:0000:0000:0000:0000:0000:1.2.3.4")
-    end
-    
-    # now, the tests that should fail
-
-    assert_raise(IP::AddressException) { IP::Address::IPv6.new("FF00:BEEF:") } 
-    assert_raise(IP::AddressException) { IP::Address::IPv6.new("FF00::BEEF::") } 
-    assert_raise(IP::AddressException) { IP::Address::IPv6.new("FF00::BEEF::DEAD") }
-    assert_raise(IP::AddressException) { IP::Address::IPv6.new("HF00::0001") }
-    assert_raise(IP::AddressException) { IP::Address::IPv6.new("1.2.3.4::0001") } 
-  end
-
-  def test_accessors
-    ip = nil
-    assert_nothing_raised() { ip = IP::Address::IPv6.new("F00F::DEAD:BEEF") } 
-
-    assert_equal(ip[0], ip.octet(0), "ip[0] eq ip.octet(0)")
-    assert_equal(61455, ip[0], "ip[0] is correct")
-    assert_equal("F00F", ip.octet_as_hex(0), "octet converts to hex properly")
-    assert_equal("F00F::DEAD:BEEF", ip.ip_address, '#ip_address preserves original address')
-  end
-
-  def test_address
-    ip = nil
-    assert_nothing_raised() { ip = IP::Address::IPv6.new("F00F::DEAD:BEEF") }
-    assert_equal("F00F::DEAD:BEEF", ip.short_address, 'wildcard left - #short_address returns a compressed version')
-    assert_equal("F00F:0:0:0:0:0:DEAD:BEEF", ip.long_address, 'wildcard left - #long_address returns the right thing')
-
-    assert_nothing_raised() { ip = IP::Address::IPv6.new("F00F:DEAD::BEEF") }
-    assert_equal("F00F:DEAD::BEEF", ip.short_address, 'wildcard right - #short_address returns a compressed version')
-    assert_equal("F00F:DEAD:0:0:0:0:0:BEEF", ip.long_address, 'wildcard right - #long_address returns the right thing')
-
-    assert_nothing_raised() { ip = IP::Address::IPv6.new("F00F:DEAD:0:0:0:0:0:BEEF") }
-    assert_equal("F00F:DEAD::BEEF", ip.short_address, 'no wildcard - #short_address returns a compressed version')
-    assert_equal("F00F:DEAD:0:0:0:0:0:BEEF", ip.long_address, 'no wildcard - #long_address returns the right thing')
-
-    assert_nothing_raised() { ip = IP::Address::IPv6.new("F00F::DEAD:BEEF:0:0") }
-    assert_equal("F00F:0:0:0:DEAD:BEEF::", ip.short_address, '#short_address returns a compressed version with wildcard @ right')
-  end
-
-  def test_equal
-    assert_equal(IP::Address::IPv6.new("F00F::DEAD:BEEF"),IP::Address::IPv6.new("F00F::DEAD:BEEF"))
-    assert_equal(IP::Address::IPv6.new("F00F::DEAD:BEEF"), "F00F::DEAD:BEEF")
-    assert_equal(IP::Address::IPv6.new("F00F::DEAD:BEEF"), "F00F:0:0:0:0:0:DEAD:BEEF")
-    assert_equal(IP::Address::IPv6.new("F00F::DEAD:BEEF"), 319092603441257831911341651915956928239)
-    assert !(IP::Address::IPv6.new("F00D::DEAD:BEEF") == IP::Address::IPv6.new("F00F::DEAD:BEEF"))
-    assert !(IP::Address::IPv6.new("F00D::DEAD:BEEF") == :someting_else)
-  end
-end
-
-
-class IPv4AddressTest < Test::Unit::TestCase
-  def name
-    return "IP::Address::IPv4 tests"
-  end
-
-  def test_init
-    assert_raise(IP::AddressException) { IP::Address::IPv4.new(Hash.new) } 
-    assert_raise(IP::AddressException) { IP::Address::IPv4.new("asdf") }
-    assert_raise(IP::AddressException) { IP::Address::IPv4.new("0.0.0") }
-    assert_raise(IP::AddressException) { IP::Address::IPv4.new("256.255.255.255") } 
-    assert_raise(IP::AddressException) { IP::Address::IPv4.new("255.255.255.255aaaa") }
-    assert_raise(IP::AddressException) { IP::Address::IPv4.new("255.255.255.") }
-  end
-  
-  def test_accessor
-    ip = nil
-    assert_nothing_raised() { ip = IP::Address::IPv4.new("10.1.2.3") }
-    assert_equal("10.1.2.3", ip.ip_address, "accessor test #1")
-    assert_equal(10, ip.octets[0], "accessor test #2")
-    assert_equal(3, ip.octets[3], "accessor test #3")
-    assert_equal(nil, ip.octets[4], "accessor test #4")
-   
-    assert_equal(ip.octet(1), ip[1],  "accessor test #5") 
-    assert_equal(1, ip[1], "accessor test #5") 
-
-    assert_raise(IP::BoundaryException) { ip[4] }
-  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_equal("10.0.0.1", IP::Address::Util.unpack(IP::Address::Util.pack(IP::Address::IPv4.new(address))).ip_address, "pack/unpack test")
-  end
-  
-  def test_short_netmask
-    ip = nil
-    assert_nothing_raised() { ip = IP::Address::IPv4.new("255.255.255.255") }
-    assert_equal(32, IP::Address::Util.short_netmask(ip), "Short Netmask Test #1")
-    assert_nothing_raised() { ip = IP::Address::IPv4.new("255.255.255.248") }
-    assert_equal(29, IP::Address::Util.short_netmask(ip), "Short Netmask Test #2")
-  end
-
-  def test_long_netmask
-    assert_equal("255.255.255.255", IP::Address::Util.long_netmask_ipv4(32).ip_address, "Long Netmask Test #1")
-    assert_equal("255.255.255.248", IP::Address::Util.long_netmask_ipv4(29).ip_address, "Long Netmask Test #2")
-  end
-
-  def test_equal
-    assert_equal(IP::Address::IPv4.new("255.255.255.255"),IP::Address::IPv4.new("255.255.255.255"))
-    assert_equal(IP::Address::IPv4.new("255.255.255.255"), "255.255.255.255")
-    assert_equal(IP::Address::IPv4.new("255.255.255.255"), 4294967295) # 255.255.255.255
-    assert !(IP::Address::IPv4.new("255.255.255.255") == IP::Address::IPv4.new("255.255.255.254"))
-    assert !(IP::Address::IPv4.new("255.255.255.255") == :something_else)
-  end
-end