ip 0.0.1

data/lib/ip.rb

@@ -0,0 +1,232 @@
+#
+# IP - Collection of Tools to work with IP addresses
+#
+# Version:: 0.0.1
+# Author:: Erik Hollensbe
+# License:: BSD
+# Contact:: erik@hollensbe.org
+#
+# IP is, as mentioned above, a collection of tools to work
+# with IP addresses. There are three major classes included
+# in the IP namespace, IP::Address, which works with standard
+# dotted-quad IP addresses, IP::Range, which can calculate and return
+# a range of IP::Address objects, and IP::CIDR, which can work with
+# Classless Inter-Domain Routing address formats.
+#
+# The IP module uses long integers and bit-flipping per <netinet/in.h>
+# to achieve fairly efficient performance, as opposed to a purely
+# iterative approach. This is most true when calculating ranges and
+# netmasks.
+#
+# Please see the documentation for each of these classes for usage
+# information.
+#
+# Note: there is no IPv6 support as of current, but this is planned in
+# perhaps a distant, future release. Any patches that can correct this
+# issue are most welcome.
+#
+
+class IP
+
+  #
+  # A IP::AddressException is thrown when an IP address cannot be
+  # parsed.
+  #
+
+  class AddressException < Exception
+  end
+
+  #
+  # A IP::BoundaryException is thrown when an index is being used out of
+  # it's pre-defined boundary. This is most relevant when using the []
+  # method in IP::Address.
+  #
+
+  class BoundaryException < Exception
+  end
+
+  #
+  # IP::Range - Calculates a range of IP addresses, and returns an
+  # Array of IP::Address objects.
+  #
+  # Usage::
+  #
+  # IP::Range['10.0.0.1', '10.0.0.2'] => IP::Address objects between
+  # 10.0.0.1 and 10.0.0.2 (inclusive)
+  #
+  # IP::Range can also take two IP::Address objects.
+  #
+  # Will throw a IP::AddressException if for some reason addresses
+  # cannot be parsed.
+  #
+
+  class Range
+
+    #
+    # See the documentation for IP::Range for more information on this
+    # method.
+    #
+
+    def Range.[](addr1, addr2)
+      raw1, raw2 = [nil, nil]
+
+      if addr1.kind_of? String
+        raw1 = IP::Address.pack(IP::Address.new(addr1))
+      elsif addr1.kind_of? IP::Address
+        raw1 = IP::Address.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))
+      elsif addr2.kind_of? IP::Address
+        raw2 = IP::Address.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)) }
+
+      return range
+    end
+  end
+
+  #
+  # IP::CIDR - Works with Classless Inter-Domain Routing formats, such
+  # as 10.0.0.1/32. 
+  #
+  # 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.
+    #
+    attr_reader :cidr
+    #
+    # Contains the IP address (LHS) only. Returned as an IP::Address
+    # object.
+    #
+    attr_reader :ip
+    #
+    # Contains the integer-based netmask (RHS) only. Returned as an
+    # 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.
+    #
+    def initialize(cidr)
+      if !cidr.kind_of? String
+        raise IP::AddressException("CIDR value is not of type String")
+      end
+        
+      @cidr = cidr
+      @ip, @mask = cidr.split(/\//)
+
+      if @mask.length == 0 or @mask.length > 2 or /\D/.match @mask
+        raise IP::AddressException("CIDR RHS is not valid - #{@mask}")
+      end
+
+      @ip = IP::Address.new(@ip)
+      @mask = @mask.to_i
+    end
+
+    #
+    # This produces the netmask of the CIDR in an IP::Address object.
+    #
+    def netmask
+      raw = 0xFFFFFFFF << (32 - @mask)
+      return IP::Address.unpack(raw)
+    end
+
+    #
+    # This produces a range ala IP::Range, but only for the subnet
+    # defined by the CIDR object.
+    #
+    def range
+      rawip = IP::Address.pack(@ip)
+      rawnm = 0xFFFFFFFF << (32 - @mask)
+      upper = rawip | ~rawnm
+      return IP::Range[IP::Address.unpack(rawip), IP::Address.unpack(upper)]
+    end
+      
+  end
+
+  #
+  # IP::Address - utility class to work with dotted-quad IP addresses.
+  #
+  class Address
+    #
+    # This original IP Address you passed it, returned as a string.
+    #
+    attr_reader :ip_address
+    #
+    # This returns an Array of Integer which contains the octets of
+    # the IP, in descending order. 
+    #
+    attr_reader :octets
+
+    #
+    # When given a string, constructs an IP::Address object.
+    #
+    def initialize(ip_address)
+      if ! ip_address.kind_of? String
+        raise IP::AddressException("Fed IP address is not String")
+      end
+      @ip_address = ip_address
+      @octets = ip_address.split(/\./).collect { |x| x.to_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")
+      end
+    end
+    
+    #
+    # Returns an octet given the proper index. The octets returned are
+    # Integer types.
+    #
+    def [](num)
+      if num > 3
+        raise IP::BoundaryException.new("Max octet number is 3")
+      end
+      return @octets[num]
+    end
+    
+    #
+    # See [].
+    #
+    alias_method :octet, :[]
+
+    #
+    # Class method to pack an IP::Address object into a long integer
+    # used for calculation. Returns a 'FixNum' type.
+    #
+    def Address.pack(ip)
+      ret = 0
+      myip = ip.octets.reverse
+      4.times { |x| ret = ret | (myip[x] & 0xFF) << 8*x }
+      return ret
+    end
+
+    #
+    # Class method to take a 'FixNum' type and return an IP::Address
+    # object.
+    #
+    def Address.unpack(ip)
+      ret = []
+      4.times { |x| ret.push((ip >> 8*x) & 0xFF) }
+      return IP::Address.new(ret.reverse.join("."))
+    end
+      
+  end
+
+end

metadata

@@ -0,0 +1,39 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.11
+specification_version: 1
+name: ip
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+date: 2005-10-17 00:00:00 -07:00
+summary: "Ruby classes to work with IP address, ranges, and netmasks"
+require_paths: 
+  - lib
+email: erik@hollensbe.org
+homepage: 
+rubyforge_project: 
+description: 
+autorequire: ip
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+    - 
+      - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+authors: 
+  - Erik Hollensbe
+files: 
+  - lib/ip.rb
+test_files: []
+rdoc_options: []
+extra_rdoc_files: []
+executables: []
+extensions: []
+requirements: []
+dependencies: []