ipaddress_2 0.11.0

data/lib/ipaddress_2/mongoid.rb

@@ -0,0 +1,75 @@
+module IPAddress
+
+  #
+  # Mongoid field serialization
+  #
+  # IPAddress objects are converted to String
+  #
+  #   IPAddress.mongoize IPAddress.parse("172.16.10.1")
+  #     #=> "172.16.10.1"
+  #
+  # Prefix will be removed from host adresses
+  #
+  #   IPAddress.mongoize "172.16.10.1/32"
+  #     #=> "172.16.10.1"
+  #
+  # Prefix will be kept for network addresses
+  #
+  #   IPAddress.mongoize "172.16.10.1/24"
+  #     #=> "172.16.10.1/24"
+  #
+  # IPv6 addresses will be stored uncompressed to ease DB search and sorting
+  #
+  #   IPAddress.mongoize "2001:db8::8:800:200c:417a"
+  #     #=> "2001:0db8:0000:0000:0008:0800:200c:417a"
+  #   IPAddress.mongoize "2001:db8::8:800:200c:417a/64"
+  #     #=> "2001:0db8:0000:0000:0008:0800:200c:417a/64"
+  #
+  # Invalid addresses will be serialized as nil
+  #
+  #   IPAddress.mongoize "invalid"
+  #     #=> nil
+  #   IPAddress.mongoize ""
+  #     #=> nil
+  #   IPAddress.mongoize 1
+  #     #=> nil
+  #   IPAddress.mongoize nil
+  #     #=> nil
+  #
+  def self.mongoize(ipaddress)
+    ipaddress = self.parse(ipaddress) unless ipaddress.is_a?(IPAddress)
+    if ipaddress.bits.length == ipaddress.prefix
+      ipaddress.address
+    elsif ipaddress.is_a?(IPAddress::IPv6)
+      ipaddress.to_string_uncompressed
+    else
+      ipaddress.to_string
+    end
+  rescue ArgumentError
+    nil
+  end
+
+  #
+  # Mongoid field deserialization
+  #
+  def self.demongoize(string)
+    parse(string)
+  rescue ArgumentError
+    nil
+  end
+
+  #
+  # Delegates to IPAddress.mongoize
+  #
+  def self.evolve(ipaddress)
+    mongoize(ipaddress)
+  end
+
+  #
+  # Sends self object to IPAddress#mongoize
+  #
+  def mongoize
+    IPAddress.mongoize(self)
+  end
+
+end

data/lib/ipaddress_2/prefix.rb

@@ -0,0 +1,285 @@
+module IPAddress
+  
+  #
+  # =NAME
+  #   
+  # IPAddress::Prefix
+  #
+  # =SYNOPSIS
+  #  
+  # Parent class for Prefix32 and Prefix128
+  #
+  # =DESCRIPTION
+  #
+  # IPAddress::Prefix is the parent class for IPAddress::Prefix32 
+  # and IPAddress::Prefix128, defining some modules in common for
+  # both the subclasses.
+  #
+  # IPAddress::Prefix shouldn't be accesses directly, unless
+  # for particular needs.
+  #
+  class Prefix 
+
+    include Comparable
+
+    attr_reader :prefix
+
+    #
+    # Creates a new general prefix
+    #
+    def initialize(num)
+      @prefix = num.to_i
+    end
+
+    #
+    # Returns a string with the prefix 
+    #
+    def to_s
+      "#@prefix"
+    end
+    alias_method :inspect, :to_s
+
+    # 
+    # Returns the prefix
+    #
+    def to_i
+      @prefix
+    end
+    alias_method :to_int, :to_i
+
+    #
+    # Provides support for Ruby type coercion
+    #
+    def coerce(other)
+      case other
+      when Integer
+        [other, @prefix]
+      else
+        other.coerce(@prefix).reverse!
+      end
+    end
+
+    # 
+    # Compare the prefix
+    #
+    def <=>(oth)
+      if oth.is_a? Integer
+        @prefix <=> oth
+      else
+        x, y = oth.coerce(@prefix)
+        x <=> y
+      end
+    end
+
+    #
+    # Sums two prefixes or a prefix to a 
+    # number, returns a Integer
+    #
+    def +(oth)
+      if oth.is_a? Integer
+        self.prefix + oth
+      else
+        x, y = oth.coerce(@prefix)
+        x + y
+      end
+    end
+
+    #
+    # Returns the difference between two
+    # prefixes, or a prefix and a number,
+    # as a Integer
+    #
+    def -(oth)
+      if oth.is_a? Integer
+        self.prefix - oth
+      else
+        x, y = oth.coerce(@prefix)
+        x - y
+      end
+    end
+    
+  end # class Prefix
+
+
+  class Prefix32 < Prefix
+
+    IN4MASK = 0xffffffff
+    
+    #
+    # Creates a new prefix object for 32 bits IPv4 addresses
+    #
+    #   prefix = IPAddress::Prefix32.new 24
+    #     #=> 24
+    #
+    def initialize(num)
+      unless (0..32).include? num
+        raise ArgumentError, "Prefix must be in range 0..32, got: #{num}"
+      end
+      super(num)
+    end
+
+    #
+    # Returns the length of the host portion
+    # of a netmask. 
+    #
+    #   prefix = Prefix32.new 24
+    #
+    #   prefix.host_prefix
+    #     #=> 8
+    #
+    def host_prefix
+      32 - @prefix
+    end
+    
+    #
+    # Transforms the prefix into a string of bits
+    # representing the netmask
+    #
+    #   prefix = IPAddress::Prefix32.new 24
+    # 
+    #   prefix.bits 
+    #     #=> "11111111111111111111111100000000"
+    #
+    def bits
+      "%.32b" % to_u32
+    end
+
+    #
+    # Gives the prefix in IPv4 dotted decimal format, 
+    # i.e. the canonical netmask we're all used to
+    #
+    #   prefix = IPAddress::Prefix32.new 24
+    #
+    #   prefix.to_ip
+    #     #=> "255.255.255.0"
+    #
+    def to_ip
+      [bits].pack("B*").unpack("CCCC").join(".")
+    end
+
+    #
+    # An array of octets of the IPv4 dotted decimal 
+    # format 
+    #
+    #   prefix = IPAddress::Prefix32.new 24
+    #
+    #   prefix.octets
+    #     #=> [255, 255, 255, 0]
+    #
+    def octets
+      to_ip.split(".").map{|i| i.to_i}
+    end
+
+    #
+    # Unsigned 32 bits decimal number representing
+    # the prefix
+    #
+    #   prefix = IPAddress::Prefix32.new 24
+    #
+    #   prefix.to_u32
+    #     #=> 4294967040
+    #
+    def to_u32
+      (IN4MASK >> host_prefix) << host_prefix
+    end
+    
+    #
+    # Shortcut for the octecs in the dotted decimal 
+    # representation
+    #
+    #   prefix = IPAddress::Prefix32.new 24
+    #
+    #   prefix[2]
+    #     #=> 255
+    #
+    def [](index)
+      octets[index]
+    end
+
+    #
+    # The hostmask is the contrary of the subnet mask,
+    # as it shows the bits that can change within the
+    # hosts
+    #
+    #   prefix = IPAddress::Prefix32.new 24
+    #
+    #   prefix.hostmask
+    #     #=> "0.0.0.255"
+    #
+    def hostmask
+      [~to_u32].pack("N").unpack("CCCC").join(".")
+    end
+    
+    #
+    # Creates a new prefix by parsing a netmask in 
+    # dotted decimal form
+    #
+    #   prefix = IPAddress::Prefix32::parse_netmask "255.255.255.0"
+    #     #=> 24
+    #
+    def self.parse_netmask(netmask)
+      octets = netmask.split(".").map{|i| i.to_i}
+      num = octets.pack("C"*octets.size).unpack("B*").first.count "1"
+      return self.new(num)
+    end
+    
+  end # class Prefix32 < Prefix
+
+  class Prefix128 < Prefix
+
+    #
+    # Creates a new prefix object for 128 bits IPv6 addresses
+    #
+    #   prefix = IPAddress::Prefix128.new 64
+    #     #=> 64
+    #
+    def initialize(num=128)
+      unless (0..128).include? num.to_i
+        raise ArgumentError, "Prefix must be in range 0..128, got: #{num}"
+      end
+      super(num.to_i)
+    end
+
+    #
+    # Transforms the prefix into a string of bits
+    # representing the netmask
+    #
+    #   prefix = IPAddress::Prefix128.new 64
+    #
+    #   prefix.bits
+    #     #=> "1111111111111111111111111111111111111111111111111111111111111111"
+    #         "0000000000000000000000000000000000000000000000000000000000000000"
+    #
+    def bits
+      "1" * @prefix + "0" * (128 - @prefix)
+    end
+
+    #
+    # Unsigned 128 bits decimal number representing
+    # the prefix
+    #
+    #   prefix = IPAddress::Prefix128.new 64
+    #
+    #   prefix.to_u128
+    #     #=> 340282366920938463444927863358058659840
+    #
+    def to_u128
+      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/lib/ipaddress_2/version.rb

@@ -0,0 +1,3 @@
+module IPAddress
+  VERSION = "0.11.0"
+end

data/lib/ipaddress_2.rb

@@ -0,0 +1,293 @@
+#
+# = IPAddress
+#
+# A ruby library to manipulate IPv4 and IPv6 addresses
+#
+#
+# Package::     IPAddress
+# Author::      Marco Ceresa <ceresa@ieee.org>
+# License::     Ruby License
+#
+#--
+#
+#++
+
+require 'ipaddress_2/ipv4'
+require 'ipaddress_2/ipv6'
+require 'ipaddress_2/mongoid' if defined?(Mongoid)
+
+module IPAddress
+
+  NAME            = "IPAddress"
+  GEM             = "ipaddress_2"
+  AUTHORS         = ["Marco Ceresa <ceresa@ieee.org>"]
+
+  #
+  # Parse the argument string to create a new
+  # IPv4, IPv6 or Mapped IP object
+  #
+  #   ip  = IPAddress.parse 167837953 # 10.1.1.1  
+  #   ip  = IPAddress.parse "172.16.10.1/24"
+  #   ip6 = IPAddress.parse "2001:db8::8:800:200c:417a/64"
+  #   ip_mapped = IPAddress.parse "::ffff:172.16.10.1/128"
+  #
+  # All the object created will be instances of the 
+  # correct class:
+  #
+  #  ip.class
+  #    #=> IPAddress::IPv4
+  #  ip6.class
+  #    #=> IPAddress::IPv6
+  #  ip_mapped.class
+  #    #=> IPAddress::IPv6::Mapped
+  #
+  def IPAddress::parse(str)
+    
+    # Check if an int was passed
+    if str.kind_of? Integer
+      return IPAddress::IPv4.new(ntoa(str))  
+    end
+
+    case str
+    when /:.+\./
+      IPAddress::IPv6::Mapped.new(str)
+    when /\./
+      IPAddress::IPv4.new(str) 
+    when /:/
+      IPAddress::IPv6.new(str)
+    else
+      raise ArgumentError, "Unknown IP Address #{str}"
+    end
+  end
+
+  #
+  # Converts a unit32 to IPv4
+  #
+  #   IPAddress::ntoa(167837953)
+  #     #-> "10.1.1.1"
+  #
+  def self.ntoa(uint)
+    unless(uint.is_a? Numeric and uint <= 0xffffffff and uint >= 0)
+      raise(::ArgumentError, "not a long integer: #{uint.inspect}")
+    end
+    ret = []
+    4.times do 
+      ret.unshift(uint & 0xff)
+      uint >>= 8
+    end
+    ret.join('.')
+  end
+
+  #
+  # True if the object is an IPv4 address
+  #
+  #   ip = IPAddress("192.168.10.100/24")
+  #
+  #   ip.ipv4?
+  #     #-> true
+  #
+  def ipv4?
+    self.kind_of? IPAddress::IPv4
+  end
+  
+  #
+  # True if the object is an IPv6 address
+  #
+  #   ip = IPAddress("192.168.10.100/24")
+  #
+  #   ip.ipv6?
+  #     #-> false
+  #
+  def ipv6?
+    self.kind_of? IPAddress::IPv6
+  end
+
+
+  #
+  # Checks if the given string is either a valid IP, either a valid IPv4 subnet
+  #
+  # Example:
+  #
+  #   IPAddress::valid? "10.0.0.0/24"
+  #     #=> true
+  #
+  #   IPAddress::valid? "2002::1"
+  #     #=> true
+  #
+  #   IPAddress::valid? "10.0.0.256"
+  #     #=> false
+  #
+  #   IPAddress::valid? "10.0.0.0/999"
+  #     #=> false
+  #
+  def self.valid?(addr)
+    valid_ip?(addr) || valid_ipv4_subnet?(addr) || valid_ipv6_subnet?(addr)
+  end
+
+  # 
+  # Checks if the given string is a valid IP address,
+  # either IPv4 or IPv6
+  #
+  # Example:
+  #
+  #   IPAddress::valid_ip? "2002::1"
+  #     #=> true
+  #
+  #   IPAddress::valid_ip? "10.0.0.256"
+  #     #=> false
+  #
+  def self.valid_ip?(addr)
+    valid_ipv4?(addr) || valid_ipv6?(addr)
+  end
+
+  #
+  # Checks if the given string is a valid IPv4 subnet
+  #
+  # Example:
+  #
+  #   IPAddress::valid_ipv4_subnet? "10.0.0.0/24"
+  #     #=> true
+  #
+  #   IPAddress::valid_ipv4_subnet? "10.0.0.0/255.255.255.0"
+  #     #=> true
+  #
+  #   IPAddress::valid_ipv4_subnet? "10.0.0.0/64"
+  #     #=> false
+  #
+  def self.valid_ipv4_subnet?(addr)
+    ip, netmask = addr.split("/")
+
+    valid_ipv4?(ip) && (!(netmask =~ /\A([12]?\d|3[0-2])\z/).nil? || valid_ipv4_netmask?(netmask))
+  end
+
+  #
+  # Checks if the given string is a valid IPv6 subnet
+  #
+  # Example:
+  #
+  #   IPAddress::valid_ipv6_subnet? "::/0"
+  #     #=> true
+  #
+  #   IPAddress::valid_ipv6_subnet? "dead:beef:cafe:babe::/64"
+  #     #=> true
+  #
+  #   IPAddress::valid_ipv6_subnet? "2001::1/129"
+  #     #=> false
+  #
+  def self.valid_ipv6_subnet?(addr)
+    ip, netmask = addr.split("/")
+
+    netmask = Integer(netmask, 10)
+
+    valid_ipv6?(ip) && netmask >= 0 && netmask <= 128
+  rescue ArgumentError
+    false
+  end
+
+  #
+  # Checks if the given string is a valid IPv4 address
+  #
+  # Example:
+  #
+  #   IPAddress::valid_ipv4? "2002::1"
+  #     #=> false
+  #
+  #   IPAddress::valid_ipv4? "172.16.10.1"
+  #     #=> true
+  #
+  def self.valid_ipv4?(addr)
+    if /\A(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})\Z/ =~ addr
+      return $~.captures.all? {|i| i.to_i < 256}
+    end
+    false
+  end
+  
+  #
+  # Checks if the argument is a valid IPv4 netmask
+  # expressed in dotted decimal format.
+  #
+  #   IPAddress.valid_ipv4_netmask? "255.255.0.0"
+  #     #=> true
+  #
+  def self.valid_ipv4_netmask?(addr)
+    arr = addr.split(".").map{|i| i.to_i}.pack("CCCC").unpack("B*").first.scan(/01/)
+    arr.empty? && valid_ipv4?(addr)
+  rescue
+    return false
+  end
+  
+  #
+  # Checks if the given string is a valid IPv6 address
+  #
+  # Example:
+  #
+  #   IPAddress::valid_ipv6? "2002::1"
+  #     #=> true
+  #
+  #   IPAddress::valid_ipv6? "2002::DEAD::BEEF"
+  #     #=> false
+  #
+  def self.valid_ipv6?(addr) 
+    # https://gist.github.com/cpetschnig/294476
+    # http://forums.intermapper.com/viewtopic.php?t=452
+    return true if /^\s*((([0-9A-Fa-f]{1,4}:){7}([0-9A-Fa-f]{1,4}|:))|(([0-9A-Fa-f]{1,4}:){6}(:[0-9A-Fa-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){5}(((:[0-9A-Fa-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){4}(((:[0-9A-Fa-f]{1,4}){1,3})|((:[0-9A-Fa-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){3}(((:[0-9A-Fa-f]{1,4}){1,4})|((:[0-9A-Fa-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){2}(((:[0-9A-Fa-f]{1,4}){1,5})|((:[0-9A-Fa-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){1}(((:[0-9A-Fa-f]{1,4}){1,6})|((:[0-9A-Fa-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9A-Fa-f]{1,4}){1,7})|((:[0-9A-Fa-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))(%.+)?\s*$/ =~ addr
+    false
+  end
+
+  # 
+  # Deprecate method
+  #
+  def self.deprecate(message = nil) # :nodoc:
+    message ||= "You are using deprecated behavior which will be removed from the next major or minor release."
+    warn("DEPRECATION WARNING: #{message}")
+  end
+  
+end # module IPAddress
+
+#
+# IPAddress is a wrapper method built around 
+# IPAddress's library classes. Its purpouse is to 
+# make you indipendent from the type of IP address 
+# you're going to use.
+#
+# For example, instead of creating the three types 
+# of IP addresses using their own contructors
+#
+#   ip  = IPAddress::IPv4.new "172.16.10.1/24"
+#   ip6 = IPAddress::IPv6.new "2001:db8::8:800:200c:417a/64"
+#   ip_mapped = IPAddress::IPv6::Mapped "::ffff:172.16.10.1/128" 
+#
+# you can just use the IPAddress wrapper:
+#
+#   ip  = IPAddress "172.16.10.1/24"
+#   ip6 = IPAddress "2001:db8::8:800:200c:417a/64"
+#   ip_mapped = IPAddress "::ffff:172.16.10.1/128"
+#
+# All the object created will be instances of the 
+# correct class:
+#
+#  ip.class
+#    #=> IPAddress::IPv4
+#  ip6.class
+#    #=> IPAddress::IPv6
+#  ip_mapped.class
+#    #=> IPAddress::IPv6::Mapped
+#
+def IPAddress(str)
+  IPAddress::parse str
+end
+
+#
+# Compatibility with Ruby 1.8
+#
+if RUBY_VERSION =~ /^1\.8/
+  class Hash # :nodoc:
+    alias :key :index
+  end
+  module Math # :nodoc:
+    def Math.log2(n) 
+      log(n) / log(2) 
+    end
+  end
+end
+