ruby-ip2 0.10.0

data/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,58 @@
+Ruby is copyrighted free software by Yukihiro Matsumoto <matz@netlab.co.jp>.
+You can redistribute it and/or modify it under either the terms of the GPL
+(see COPYING.txt file), or the conditions below:
+
+  1. You may make and give away verbatim copies of the source form of the
+     software without restriction, provided that you duplicate all of the
+     original copyright notices and associated disclaimers.
+
+  2. You may modify your copy of the software in any way, provided that
+     you do at least ONE of the following:
+
+       a) place your modifications in the Public Domain or otherwise
+          make them Freely Available, such as by posting said
+	  modifications to Usenet or an equivalent medium, or by allowing
+	  the author to include your modifications in the software.
+
+       b) use the modified software only within your corporation or
+          organization.
+
+       c) rename any non-standard executables so the names do not conflict
+	  with standard executables, which must also be provided.
+
+       d) make other distribution arrangements with the author.
+
+  3. You may distribute the software in object code or executable
+     form, provided that you do at least ONE of the following:
+
+       a) distribute the executables and library files of the software,
+	  together with instructions (in the manual page or equivalent)
+	  on where to get the original distribution.
+
+       b) accompany the distribution with the machine-readable source of
+	  the software.
+
+       c) give non-standard executables non-standard names, with
+          instructions on where to get the original software distribution.
+
+       d) make other distribution arrangements with the author.
+
+  4. You may modify and include the part of the software into any other
+     software (possibly commercial).  But some files in the distribution
+     are not written by the author, so that they are not under this terms.
+
+     They are gc.c(partly), utils.c(partly), regex.[ch], st.[ch] and some
+     files under the ./missing directory.  See each file for the copying
+     condition.
+
+  5. The scripts and library files supplied as input to or produced as 
+     output from the software do not automatically fall under the
+     copyright of the software, but belong to whomever generated them, 
+     and may be sold commercially, and may be aggregated with this
+     software.
+
+  6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
+     IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+     PURPOSE.
+

data/README.rdoc

@@ -0,0 +1,198 @@
+= ruby-ip library
+
+This is a library for manipulating IP addresses.
+
+{<img src="https://travis-ci.org/G7M3/ruby-ip2.svg?branch=master" alt="Build Status" />}[https://travis-ci.org/G7M3/ruby-ip2]
+{<img src="https://coveralls.io/repos/github/G7M3/ruby-ip2/badge.svg?branch=master" alt="Coverage Status" />}[https://coveralls.io/github/G7M3/ruby-ip2?branch=master]
+
+
+== Installation
+
+Gem:: <tt>gem install ruby-ip</tt>
+Source:: <tt>git clone git://github.com/G7M3/ruby-ip2.git</tt>
+
+== Feature overview
+
+* Create from string and to string
+
+    require 'ip'
+    ip = IP.new("192.0.2.53/24")
+    ip.to_s       # "192.0.2.53/24"
+    ip.to_i       # 3221226037
+    ip.to_b       # 11000000000000000000001000110101
+    ip.to_hex     # "c0000235"
+    ip.to_addr    # "192.0.2.53"
+    ip.to_arpa    # "53.2.0.192.in-addr.arpa."
+    ip.pfxlen     # 24
+
+* Convert from IPAddr to IP and back to IPAddr
+
+    # new IPAddr
+    ipaddr = IPAddr.new('192.168.2.1')
+    # => #<IPAddr: IPv4:192.168.2.1/255.255.255.255>
+
+    # convert it to IP
+    ip_from_ipaddr = IP.new_ntoh(ipaddr.hton)
+    # => <IP::V4 192.168.2.1>
+
+    # and back to IPAddr
+    ipaddr_from_ip = IPAddr.new_ntoh(ip_from_ipaddr.hton)
+    # => #<IPAddr: IPv4:192.168.2.1/255.255.255.255>
+
+* Qualify IP address with "routing context" (VRF)
+
+    ip = IP.new("192.0.2.53/24@cust1")
+    ip.to_s       # "192.0.2.53/24@cust1"
+    ip.to_addrlen # "192.0.2.53/24"
+    ip.ctx        # "cust1"
+
+* Clean implementation of IP::V4 and IP::V6 as subclasses of IP
+
+    ip1 = IP.new("192.0.2.53/24")       #<IP::V4 192.0.2.53/24>
+    ip2 = IP.new("2001:db8:be00::/48")  #<IP::V6 2001:db8:be00::/48>
+    ip1.is_a?(IP::V4)                   # true
+
+* Create directly from integers or hex
+
+    ip = IP::V4.new(3221226037, 24, "cust1")
+    ip = IP::V4.new("c0000235", 24, "cust1")
+
+* Netmask manipulation
+
+    ip = IP.new("192.0.2.53/24")
+    ip.network         #<IP::V4 192.0.2.0/24>
+    ip.network(1)      #<IP::V4 192.0.2.1/24>
+    ip.broadcast       #<IP::V4 192.0.2.255/24>
+    ip.broadcast(-1)   #<IP::V4 192.0.2.254/24>
+    ip.mask            # 255
+    ip.size            # 256
+    ip.netmask.to_s    # "255.255.255.0"
+    ip.wildmask.to_s   # "0.0.0.255"
+
+* Address masking
+
+    ip = IP.new("192.0.2.53/24")
+    ip.offset?         # true
+    ip.offset          # 53
+    ip.mask!
+    ip.to_s            # "192.0.2.0/24"
+    ip.offset?         # false
+
+* Simple IP arithmetic
+
+    ip = IP.new("192.0.2.53/24")
+    ip + 4             #<IP::V4 192.0.2.57/24>
+    ip | 7             #<IP::V4 192.0.2.55/24>
+    ip ^ 7             #<IP::V4 192.0.2.50/24>
+    ~ip                #<IP::V4 63.255.253.202/24>
+
+* Advanced Subnet Operations
+    sn = IP.new('192.168.0.0/24')
+    ip = IP.new('192.168.0.48/32')
+    sn.split                    [#<IP::V4 192.168.0.0/25>,
+                                #<IP::V4 192.168.0.128/25>] (2 evenly divided subnets)
+    sn.divide_by_subnets(3)     [#<IP::V4 192.168.0.0/26>,
+                                #<IP::V4 192.168.0.64/26>,
+                                #<IP::V4 192.168.0.128/26>,
+                                #<IP::V4 192.168.0.192/26>] (4 evenly divided subnets)
+    #keep in mind this always takes into account a network and broadcast address
+    sn.divide_by_hosts(100)     [#<IP::V4 192.168.0.0/25>,
+                                #<IP::V4 192.168.0.128/25>] (128 hosts each)
+    ip = IP.new('192.168.0.48/32')
+    ip.is_in?(sn)
+    => true
+
+* Deaggregate subnets from range
+
+    IP.new('1.2.0.0').deaggregate(IP.new('1.3.255.255'))
+      => [#<IP::V4 1.2.0.0/15>]
+    IP.new('1.2.0.0').deaggregate(IP.new('1.4.255.255'))
+      => [#<IP::V4 1.2.0.0/15>, #<IP::V4 1.4.0.0/16>]
+    IP.new('2001:db8:85a3:8d3::').deaggregate(IP.new('2001:0db8:85a3:08d3:ffff:ffff:ffff:ffff'))
+      => [#<IP::V6 2001:db8:85a3:8d3::/64>]
+    IP.new('2001:db8:85a3:8d3::').deaggregate(IP.new('2001:db8:85a3:8d3:1::'))
+      => [#<IP::V6 2001:db8:85a3:8d3::/80>, #<IP::V6 2001:db8:85a3:8d3:1::>]
+
+* Convert to and from a compact Array representation
+
+    ip1 = IP.new("192.0.2.53/24@cust1")
+    ip1.to_a     # ["v4", 3221226037, 24, "cust1"]
+
+    ip2 = IP.new(["v4", 3221226037, 24, "cust1"])
+    ip1 == ip2   # true
+
+* Hex array representation, useful when talking to languages which don't
+  have Bignum support
+
+    ip1 = IP.new("2001:db8:be00::/48@cust1")
+    ip1.to_ah    # ["v6", "20010db8be0000000000000000000000", 48, "cust1"]
+
+    ip2 = IP.new(["v6", "20010db8be0000000000000000000000", 48, "cust1"])
+    ip1 == ip2   # true
+
+* Addresses are Comparable, sortable, and can be used as Hash keys
+
+* Addresses can be stored in a VARBINARY(16) database column as string of bytes
+
+    # == Schema Information
+    #
+    # Table name: ipaddresses
+    #
+    #  id         :integer          not null, primary key
+    #  address    :binary(16)
+    #  pfxlen     :integer
+    #  created_at :datetime         not null
+    #  updated_at :datetime         not null
+    #
+    # Indexes
+    #
+    #  index_ipaddresses_on_address  (address)
+    #  index_ipaddresses_on_pfxlen   (pfxlen)
+    #
+
+    require 'ip'
+    class IpAddress < ActiveRecord::Base
+      validates_uniqueness_of :address, scope: [:pfxlen]
+      validates_presence_of :address, :pfxlen
+
+      # IpAddress.last.address returns an IP object
+      def address
+        IP.new("#{IP.new_ntoh(super).to_s}/#{pfxlen}")
+      end
+
+      # Address can be set with string:
+      # ipaddress = IpAddress.new({address: '2001:db8:be00::/128'})
+      # Or IP object:
+      # ip = IP.new('2001:db8:be00::/128')
+      # ipaddress = IpAddress.new({address: ip})
+      def address=(arg)
+        ip = IP.new(arg)
+        self.pfxlen = ip.pfxlen
+        super(ip.hton)
+      end
+    end
+
+== Why not IPAddr?
+
+Ruby bundles an IPAddr class (ipaddr.rb). However there are a number of
+serious problems with this library.
+
+1. Given an IP address with a netmask or prefix (e.g. 192.0.2.0/24) it's
+   very hard to get access to the netmask part. It involves digging around
+   instance variables.
+
+2. It's impossible to deal with an off-base address with prefix, because
+   IPAddr forcibly masks it to the base. e.g. 192.0.2.53/24 is stored as
+   192.0.2.0/24
+
+3. IPAddr uses calls to the socket library to validate IP addresses, and
+   this can trigger spurious DNS lookups when given an invalid IP address.
+   ruby-ip does not depend on the socket library at all, unless you
+   require 'ip/socket' to have access to the Socket::AF_INET and
+   Socket::AF_INET6 constants.
+
+== Copying
+
+You may use, distribute and modify this software under the same terms as
+ruby itself (see LICENSE.txt and COPYING.txt)
+

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task default: :test

data/lib/ip.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require 'ip/version'
+require 'ip/base'

data/lib/ip/base.rb

@@ -0,0 +1,559 @@
+# frozen_string_literal: false
+
+# Copyright (C) 2009-2010 Brian Candler <http://www.deploy2.net/>
+# Licensed under the same terms as ruby. See LICENCE.txt and COPYING.txt
+
+# The IP Class is the base class for the module
+class IP
+  PROTO_TO_CLASS = {}
+
+  class << self
+    alias orig_new new
+    # Examples:
+    #   IP.new("1.2.3.4")
+    #   IP.new("1.2.3.4/28")
+    #   IP.new("1.2.3.4/28@routing_context")
+    #
+    # Array form (inverse of to_a and to_ah):
+    #   IP.new(["v4", 0x01020304])
+    #   IP.new(["v4", 0x01020304, 28])
+    #   IP.new(["v4", 0x01020304, 28, "routing_context"])
+    #   IP.new(["v4", "01020304", 28, "routing_context"])
+    #
+    # Note that this returns an instance of IP::V4 or IP::V6. IP is the
+    # base class of both of those, but cannot be instantiated itself.
+    def new(src)
+      case src
+      when String
+        parse(src) || (raise ArgumentError, 'invalid address')
+      when Array
+        (PROTO_TO_CLASS[src[0]] ||
+         (raise ArgumentError, 'invalid protocol')).new(*src[1..-1])
+      when IP
+        src.dup
+      else
+        raise ArgumentError, 'invalid address'
+      end
+    end
+
+    # Parse a string as an IP address - return a V4/V6 object or nil
+    def parse(str)
+      V4.parse(str) || V6.parse(str)
+    end
+  end
+
+  # Length of prefix (network portion) of address
+  attr_reader :pfxlen
+
+  # Routing Context indicates the scope of this address (e.g. virtual router)
+  attr_accessor :ctx
+
+  # Examples:
+  #   IP::V4.new(0x01020304)
+  #   IP::V4.new("01020304")
+  #   IP::V4.new(0x01020304, 28)
+  #   IP::V4.new(0x01020304, 28, "routing_context")
+  def initialize(addr, pfxlen = nil, ctx = nil)
+    @addr = addr.is_a?(String) ? addr.to_i(16) : addr.to_i
+    raise ArgumentError, 'Invalid address value' if @addr < 0 || @addr > self.class::MASK
+
+    self.pfxlen = pfxlen
+    self.ctx = ctx
+  end
+
+  # Return the protocol in string form, "v4" or "v6"
+  def proto
+    self.class::PROTO
+  end
+
+  # Creates a new ip containing the given network byte ordered
+  # string form of an IP address.
+  def self.new_ntoh(addr)
+    IP.new(IP.ntop(addr))
+  end
+
+  # Convert a network byte ordered string form of an IP address into
+  # human readable form.
+  def self.ntop(addr)
+    case addr.size
+    when 4
+      s = addr.unpack('C4').join('.')
+    when 16
+      s = (['%.4x'] * 8).join(':') % addr.unpack('n8')
+    else
+      raise ArgumentError, 'Invalid address value'
+    end
+    s
+  end
+
+  # Return the string representation of the address, x.x.x.x[/pfxlen][@ctx]
+  def to_s
+    ctx ? "#{to_addrlen}@#{ctx}" : to_addrlen
+  end
+
+  # Return the string representation of the IP address and prefix, or
+  # just the IP address if it's a single address
+  def to_addrlen
+    pfxlen == self.class::ADDR_BITS ? to_addr : "#{to_addr}/#{pfxlen}"
+  end
+
+  # Return the address as an Integer
+  def to_i
+    @addr
+  end
+
+  # returns the address in Binary
+  def to_b
+    @addr.to_s(2).to_i
+  end
+
+  # Return the address as a hexadecimal string (8 or 32 digits)
+  def to_hex
+    @addr.to_s(16).rjust(self.class::ADDR_BITS >> 2, '0')
+  end
+
+  # Return an array representation of the address, with 3 or 4 elements
+  # depending on whether there is a routing context set.
+  #    ["v4", 16909060, 28]
+  #    ["v4", 16909060, 28, "context"]
+  # (Removing the last element makes them Comparable, as nil.<=> doesn't exist)
+  def to_a
+    if @ctx
+      [self.class::PROTO, @addr, @pfxlen, @ctx]
+    else
+      [self.class::PROTO, @addr, @pfxlen]
+    end
+  end
+
+  # Return an array representation of the address, with 3 or 4 elements
+  # depending on whether there is a routing context set, using hexadecimal.
+  #    ["v4", "01020304", 28]
+  #    ["v4", "01020304", 28, "context"]
+  def to_ah
+    if @ctx
+      [self.class::PROTO, to_hex, @pfxlen, @ctx]
+    else
+      [self.class::PROTO, to_hex, @pfxlen]
+    end
+  end
+
+  # Change the prefix length. If nil, the maximum is used (32 or 128)
+  def pfxlen=(pfxlen)
+    @mask = nil
+    if pfxlen
+      pfxlen = pfxlen.to_i
+      raise ArgumentError, 'Invalid prefix length' if pfxlen < 0 || pfxlen > self.class::ADDR_BITS
+
+      @pfxlen = pfxlen
+    else
+      @pfxlen = self.class::ADDR_BITS
+    end
+  end
+
+  # Return the mask for this pfxlen as an integer. For example,
+  # a V4 /24 address has a mask of 255 (0x000000ff)
+  def mask
+    @mask ||= (1 << (self.class::ADDR_BITS - @pfxlen)) - 1
+  end
+
+  # Return a new IP object at the base of the subnet, with an optional
+  # offset applied.
+  #    IP.new("1.2.3.4/24").network    =>  #<IP::V4 1.2.3.0/24>
+  #    IP.new("1.2.3.4/24").network(7) =>  #<IP::V4 1.2.3.7/24>
+  def network(offset = 0)
+    self.class.new((@addr & ~mask) + offset, @pfxlen, @ctx)
+  end
+
+  # Return a new IP object at the top of the subnet, with an optional
+  # offset applied.
+  #    IP.new("1.2.3.4/24").broadcast     =>  #<IP::V4 1.2.3.255/24>
+  #    IP.new("1.2.3.4/24").broadcast(-1) =>  #<IP::V4 1.2.3.254/24>
+  def broadcast(offset = 0)
+    self.class.new((@addr | mask) + offset, @pfxlen, @ctx)
+  end
+
+  # Return a new IP object representing the netmask
+  #    IP.new("1.2.3.4/24").netmask  =>  #<IP::V4 255.255.255.0>
+  def netmask
+    self.class.new(self.class::MASK & ~mask)
+  end
+
+  # Return a new IP object representing the wildmask (inverse netmask)
+  #    IP.new("1.2.3.4/24").netmask  =>  #<IP::V4 0.0.0.255>
+  def wildmask
+    self.class.new(mask)
+  end
+
+  # Masks the address such that it is the base of the subnet
+  #    IP.new("1.2.3.4/24").mask!    => #<IP::V4 1.2.3.0/24>
+  def mask!
+    @addr &= ~mask
+    self
+  end
+
+  # Returns true if this is not the base address of the subnet implied
+  # from the prefix length (e.g. 1.2.3.4/24 is offset, because the base
+  # is 1.2.3.0/24)
+  def offset?
+    @addr != (@addr & ~mask)
+  end
+
+  # Returns offset from base of subnet to this address
+  #    IP.new("1.2.3.4/24").offset   => 4
+  def offset
+    @addr - (@addr & ~mask)
+  end
+
+  # If the address is not on the base, turn it into a single IP.
+  #    IP.new("1.2.3.4/24").reset_pfxlen!  =>  <IP::V4 1.2.3.4>
+  #    IP.new("1.2.3.0/24").reset_pfxlen!  =>  <IP::V4 1.2.3.0/24>
+  def reset_pfxlen!
+    self.pfxlen = nil if offset?
+    self
+  end
+
+  def to_irange
+    a1 = @addr & ~mask
+    a2 = a1 | mask
+    (a1..a2)
+  end
+
+  # QUERY: IPAddr (1.9) turns 1.2.3.0/24 into 1.2.3.0/24..1.2.3.255/24
+  # Here I turn it into 1.2.3.0..1.2.3.255. Which is better?
+  def to_range
+    self.class.new(@addr & ~mask, self.class::ADDR_BITS, @ctx)..self.class.new(@addr | mask, self.class::ADDR_BITS, @ctx)
+  end
+
+  # test if the address is in the provided subnet
+  def is_in?(subnet)
+    subnet.network.to_i <= network.to_i &&
+      subnet.broadcast.to_i >= broadcast.to_i
+  end
+
+  # this function sub-divides a subnet into two subnets of equal size
+  def split
+    nets = []
+    if pfxlen < self.class::ADDR_BITS
+      if self.class::ADDR_BITS == 32
+        new_base = IP::V4.new(network.to_i, (pfxlen + 1))
+        nets = [new_base, IP::V4.new((new_base.broadcast + 1).to_i, (pfxlen + 1))]
+      end
+      if self.class::ADDR_BITS == 128
+        new_base = IP::V6.new(network.to_i, (pfxlen + 1))
+        nets = [new_base, IP::V6.new((new_base.broadcast + 1).to_i, (pfxlen + 1))]
+      end
+    end
+    nets
+  end
+
+  # subdivide a larger subnet into smaller subnets by number of subnets of equal size,
+  # stop when subnets reach their smallest possible size (i.e. 31 for IP4)
+  def divide_by_subnets(number_subnets)
+    nets = []
+    return nets if split.empty?
+
+    nets << self
+    loop do
+      new_nets = []
+      nets.each do |net|
+        new_nets |= net.split
+      end
+      nets = new_nets
+      break if number_subnets <= nets.length &&
+               nets[0].pfxlen <= (self.class::ADDR_BITS - 1)
+    end
+    nets
+  end
+
+  # subdivide a larger subnet into smaller subnets by number of hosts
+  def divide_by_hosts(number_hosts)
+    nets = []
+    return nets if split.empty?
+
+    nets << self
+    while number_hosts <= (nets[0].split[0].size - 2) &&
+          nets[0].pfxlen <= (self.class::ADDR_BITS - 1)
+      new_nets = []
+      nets.each do |net|
+        new_nets |= net.split
+      end
+      nets = new_nets
+    end
+    nets
+  end
+
+  # deaggregate address range
+  #   IP.new('1.2.0.0').deaggregate(IP.new('1.3.255.255'))
+  #     => [#<IP::V4 1.2.0.0/15>]
+  #   IP.new('1.2.0.0').deaggregate(IP.new('1.4.255.255'))
+  #     => [#<IP::V4 1.2.0.0/15>, #<IP::V4 1.4.0.0/16>]
+  #   IP.new('2001:db8:85a3:8d3::').deaggregate(IP.new('2001:0db8:85a3:08d3:ffff:ffff:ffff:ffff'))
+  #     => [#<IP::V6 2001:db8:85a3:8d3::/64>]
+  #   IP.new('2001:db8:85a3:8d3::').deaggregate(IP.new('2001:db8:85a3:8d3:1::'))
+  #     => [#<IP::V6 2001:db8:85a3:8d3::/80>, #<IP::V6 2001:db8:85a3:8d3:1::>]
+  def deaggregate(other)
+    nets = []
+    base = to_i
+    while base <= other.to_i
+      step = 0
+      while (base | (1 << step)) != base
+        break if (base | (((~0) & self.class::ADDR_MAX) >> (self.class::ADDR_BITS - 1 - step))) > other.to_i
+
+        step += 1
+      end
+      nets << self.class.new(base, self.class::ADDR_BITS - step, @ctx)
+      base += 1 << step
+    end
+    nets
+  end
+
+  # The number of IP addresses in subnet
+  #    IP.new("1.2.3.4/24").size   => 256
+  def size
+    mask + 1
+  end
+
+  def +(other)
+    self.class.new(@addr + other.to_i, @pfxlen, @ctx)
+  end
+
+  def -(other)
+    self.class.new(@addr - other.to_i, @pfxlen, @ctx)
+  end
+
+  def &(other)
+    self.class.new(@addr & other.to_i, @pfxlen, @ctx)
+  end
+
+  def |(other)
+    self.class.new(@addr | other.to_i, @pfxlen, @ctx)
+  end
+
+  def ^(other)
+    self.class.new(@addr ^ other.to_i, @pfxlen, @ctx)
+  end
+
+  def ~
+    self.class.new(~@addr & self.class::MASK, @pfxlen, @ctx)
+  end
+
+  def succ
+    self.class.new(@addr + size, @pfxlen, @ctx)
+  end
+
+  def succ!
+    @addr += size
+    self
+  end
+
+  def inspect
+    "#<#{self.class} #{self}>"
+  end
+
+  def ipv4_mapped?
+    false
+  end
+
+  def ipv4_compat?
+    false
+  end
+
+  def native
+    self
+  end
+
+  def hash
+    to_a.hash
+  end
+
+  def freeze
+    mask
+    super
+  end
+
+  def eql?(other)
+    to_a.eql?(other.to_a)
+  end
+
+  def <=>(other)
+    to_a <=> other.to_a
+  end
+  include Comparable
+
+  class V4 < IP
+    class << self; alias new orig_new; end
+    PROTO = 'v4'
+    PROTO_TO_CLASS[PROTO] = self
+    ADDR_MAX = 4_294_967_295
+    ADDR_BITS = 32
+    MASK = (1 << ADDR_BITS) - 1
+    ARPA = '.in-addr.arpa.'
+
+    # Parse a string; return an V4 instance if it's a valid IPv4 address,
+    # nil otherwise
+    def self.parse(str)
+      if str =~ %r{\A(\d+)\.(\d+)\.(\d+)\.(\d+)(?:/(\d+))?(?:@(.*))?\z}
+        pfxlen = (Regexp.last_match[5] || ADDR_BITS).to_i
+        return nil if pfxlen > 32
+
+        addrs = [Regexp.last_match[1].to_i,
+                 Regexp.last_match[2].to_i,
+                 Regexp.last_match[3].to_i,
+                 Regexp.last_match[4].to_i]
+        return nil if addrs.find { |n| n > 255 }
+
+        addr = (((((addrs[0] << 8) | addrs[1]) << 8) | addrs[2]) << 8) | addrs[3]
+        new(addr, pfxlen, Regexp.last_match[6])
+      end
+    end
+
+    # Return just the address part as a String in dotted decimal form
+    def to_addr
+      format('%d.%d.%d.%d',
+             (@addr >> 24) & 0xff,
+             (@addr >> 16) & 0xff,
+             (@addr >> 8) & 0xff,
+             @addr & 0xff)
+    end
+
+    # return the arpa version of the address for reverse DNS: http://en.wikipedia.org/wiki/Reverse_DNS_lookup
+    def to_arpa
+      format("%d.%d.%d.%d#{ARPA}",
+             @addr & 0xff,
+             (@addr >> 8) & 0xff,
+             (@addr >> 16) & 0xff,
+             (@addr >> 24) & 0xff)
+    end
+
+    # Returns a network byte ordered string form of the IP address.
+    def hton
+      [@addr].pack('N')
+    end
+  end
+
+  class V6 < IP
+    class << self; alias new orig_new; end
+    PROTO = 'v6'
+    PROTO_TO_CLASS[PROTO] = self
+    ADDR_MAX = 340_282_366_920_938_463_463_374_607_431_768_211_455
+    ADDR_BITS = 128
+    MASK = (1 << ADDR_BITS) - 1
+    ARPA = '.ip6.arpa'
+
+    # Parse a string; return an V6 instance if it's a valid IPv6 address,
+    # nil otherwise
+    #--
+    # FIXME: allow larger variations of mapped addrs like 0:0:0:0:ffff:1.2.3.4
+    #++
+    def self.parse(str)
+      case str
+      when %r{\A\[?::(ffff:)?(\d+\.\d+\.\d+\.\d+)\]?(?:/(\d+))?(?:@(.*))?\z}i
+        mapped = Regexp.last_match[1]
+        pfxlen = (Regexp.last_match[3] || 128).to_i
+        ctx = Regexp.last_match[4]
+        return nil if pfxlen > 128
+
+        v4 = (V4.parse(Regexp.last_match[2]) || return).to_i
+        v4 |= 0xffff00000000 if mapped
+        new(v4, pfxlen, ctx)
+      when %r{\A\[?([0-9a-f:]+)\]?(?:/(\d+))?(?:@(.*))?\z}i
+        addr = Regexp.last_match[1]
+        pfxlen = (Regexp.last_match[2] || 128).to_i
+        return nil if pfxlen > 128
+
+        ctx = Regexp.last_match[3]
+        return nil if pfxlen > 128
+
+        if addr =~ /\A(.*?)::(.*)\z/
+          left = Regexp.last_match[1]
+          right = Regexp.last_match[2]
+          l = left.split(':', -1)
+          r = right.split(':', -1)
+          rest = 8 - l.length - r.length
+          return nil if rest < 0
+        else
+          l = addr.split(':')
+          r = []
+          rest = 0
+          return nil if l.length != 8
+        end
+        out = ''
+        l.each do |quad|
+          return nil unless (1..4).include?(quad.length)
+
+          out << quad.rjust(4, '0')
+        end
+        rest.times { out << '0000' }
+        r.each do |quad|
+          return nil unless (1..4).include?(quad.length)
+
+          out << quad.rjust(4, '0')
+        end
+        new(out, pfxlen, ctx)
+      end
+    end
+
+    # Return just the address part as a String in compact decimal form
+    def to_addr
+      if ipv4_compat?
+        "::#{native.to_addr}"
+      elsif ipv4_mapped?
+        "::ffff:#{native.to_addr}"
+      elsif @addr.zero?
+        '::'
+      else
+        res = to_hex.scan(/..../).join(':')
+        res.gsub!(/\b0{1,3}/, '')
+        res.sub!(/\b0:0:0:0(:0)*\b/, ':') ||
+          res.sub!(/\b0:0:0\b/, ':') ||
+          res.sub!(/\b0:0\b/, ':')
+        res.sub!(/:::+/, '::')
+        res
+      end
+    end
+
+    # Return just the address in non-compact form, required for reverse IP.
+    def to_addr_full
+      if ipv4_compat?
+        "::#{native.to_addr}"
+      elsif ipv4_mapped?
+        "::ffff:#{native.to_addr}"
+      elsif @addr.zero?
+        '::'
+      else
+        to_hex.scan(/..../).join(':')
+      end
+    end
+
+    # Returns a network byte ordered string form of the IP address.
+    def hton
+      (0..7).map { |i| (@addr >> (112 - 16 * i)) & 0xffff }.pack('n8')
+    end
+
+    # Returns the address broken into an array of 32 nibbles.  Useful for
+    # to_arpa and use in SPF - http://tools.ietf.org/html/rfc7208#section-7.3
+    def to_nibbles
+      to_hex.rjust(32, '0').split(//)
+    end
+
+    # return the arpa version of the address for reverse DNS: http://en.wikipedia.org/wiki/Reverse_DNS_lookup
+    def to_arpa
+      to_nibbles.reverse.join('.') + ARPA
+    end
+
+    def ipv4_mapped?
+      (@addr >> 32) == 0xffff
+    end
+
+    def ipv4_compat?
+      @addr > 1 && (@addr >> 32) == 0
+    end
+
+    # Convert an IPv6 mapped/compat address to a V4 native address
+    def native
+      return self unless (ipv4_mapped? || ipv4_compat?) && (@pfxlen >= 96)
+
+      V4.new(@addr & V4::MASK, @pfxlen - 96, @ctx)
+    end
+  end
+end