ipaddr 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e0852ad74f0bf3001f4c3bc91c8f4709066469b3
+  data.tar.gz: e7207467627207e243b6764fd80cb9d27c4690e9
+SHA512:
+  metadata.gz: 6819559510a3f7e073dc08ecba98679efd9bed002cb780b4efdb925477af41d1c36bfeb8c2057826bab94b3196ea4769886299cecd5a661273651c88d54a1c0f
+  data.tar.gz: 8fa05f41fe8712d9641dd03515341611dd46ee2fdd9a0deb886942a8e17fed97c6e01f9d0d007d40cc554dea7bf0870e9896ad8cd0ffc857c1cc802807187377

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.travis.yml

@@ -0,0 +1,6 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.4.1
+  - ruby-head
+before_install: gem install bundler

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in ipaddr.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,23 @@
+Copyright (c) 2002 Hajimu UMEMOTO <ume@mahoroba.org>
+Copyright (c) 2007-2017 Akinori MUSHA <knu@iDaemons.org>
+
+Redistribution and use in source and binary forms, 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.
+2. Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE 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 THE 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.

data/README.md

@@ -0,0 +1,54 @@
+# IPAddr
+
+IPAddr provides a set of methods to manipulate an IP address.  Both
+IPv4 and IPv6 are supported.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'ipaddr'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ipaddr
+
+## Usage
+
+```ruby
+require 'ipaddr'
+
+ipaddr1 = IPAddr.new "3ffe:505:2::1"
+
+p ipaddr1                   #=> #<IPAddr: IPv6:3ffe:0505:0002:0000:0000:0000:0000:0001/ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff>
+
+p ipaddr1.to_s              #=> "3ffe:505:2::1"
+
+ipaddr2 = ipaddr1.mask(48)  #=> #<IPAddr: IPv6:3ffe:0505:0002:0000:0000:0000:0000:0000/ffff:ffff:ffff:0000:0000:0000:0000:0000>
+
+p ipaddr2.to_s              #=> "3ffe:505:2::"
+
+ipaddr3 = IPAddr.new "192.168.2.0/24"
+
+p ipaddr3                   #=> #<IPAddr: IPv4:192.168.2.0/255.255.255.0>
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/ruby/ipaddr.
+
+## License
+
+The gem is available as open source under the terms of the [2-Clause BSD License](https://opensource.org/licenses/BSD-2-Clause).

data/Rakefile

@@ -0,0 +1,10 @@
+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/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "ipaddr"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/ipaddr.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name          = "ipaddr"
+  spec.version       = "1.0.0"
+  spec.authors       = ["Akinori MUSHA", "Hajimu UMEMOTO"]
+  spec.email         = ["knu@idaemons.org", "ume@mahoroba.org"]
+
+  spec.summary       = %q{A class to manipulate an IP address in ruby}
+  spec.description   = <<-'DESCRIPTION'
+IPAddr provides a set of methods to manipulate an IP address.
+Both IPv4 and IPv6 are supported.
+  DESCRIPTION
+  spec.homepage      = "https://github.com/ruby/ipaddr"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.15"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "test-unit"
+end

data/lib/ipaddr.rb

@@ -0,0 +1,662 @@
+# frozen_string_literal: false
+#
+# ipaddr.rb - A class to manipulate an IP address
+#
+# Copyright (c) 2002 Hajimu UMEMOTO <ume@mahoroba.org>.
+# Copyright (c) 2007, 2009, 2012 Akinori MUSHA <knu@iDaemons.org>.
+# All rights reserved.
+#
+# You can redistribute and/or modify it under the same terms as Ruby.
+#
+# $Id$
+#
+# Contact:
+#   - Akinori MUSHA <knu@iDaemons.org> (current maintainer)
+#
+# TODO:
+#   - scope_id support
+#
+require 'socket'
+
+# IPAddr provides a set of methods to manipulate an IP address.  Both IPv4 and
+# IPv6 are supported.
+#
+# == Example
+#
+#   require 'ipaddr'
+#
+#   ipaddr1 = IPAddr.new "3ffe:505:2::1"
+#
+#   p ipaddr1                   #=> #<IPAddr: IPv6:3ffe:0505:0002:0000:0000:0000:0000:0001/ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff>
+#
+#   p ipaddr1.to_s              #=> "3ffe:505:2::1"
+#
+#   ipaddr2 = ipaddr1.mask(48)  #=> #<IPAddr: IPv6:3ffe:0505:0002:0000:0000:0000:0000:0000/ffff:ffff:ffff:0000:0000:0000:0000:0000>
+#
+#   p ipaddr2.to_s              #=> "3ffe:505:2::"
+#
+#   ipaddr3 = IPAddr.new "192.168.2.0/24"
+#
+#   p ipaddr3                   #=> #<IPAddr: IPv4:192.168.2.0/255.255.255.0>
+
+class IPAddr
+
+  # 32 bit mask for IPv4
+  IN4MASK = 0xffffffff
+  # 128 bit mask for IPv6
+  IN6MASK = 0xffffffffffffffffffffffffffffffff
+  # Format string for IPv6
+  IN6FORMAT = (["%.4x"] * 8).join(':')
+
+  # Regexp _internally_ used for parsing IPv4 address.
+  RE_IPV4ADDRLIKE = %r{
+    \A
+    (\d+) \. (\d+) \. (\d+) \. (\d+)
+    \z
+  }x
+
+  # Regexp _internally_ used for parsing IPv6 address.
+  RE_IPV6ADDRLIKE_FULL = %r{
+    \A
+    (?:
+      (?: [\da-f]{1,4} : ){7} [\da-f]{1,4}
+    |
+      ( (?: [\da-f]{1,4} : ){6} )
+      (\d+) \. (\d+) \. (\d+) \. (\d+)
+    )
+    \z
+  }xi
+
+  # Regexp _internally_ used for parsing IPv6 address.
+  RE_IPV6ADDRLIKE_COMPRESSED = %r{
+    \A
+    ( (?: (?: [\da-f]{1,4} : )* [\da-f]{1,4} )? )
+    ::
+    ( (?:
+      ( (?: [\da-f]{1,4} : )* )
+      (?:
+        [\da-f]{1,4}
+      |
+        (\d+) \. (\d+) \. (\d+) \. (\d+)
+      )
+    )? )
+    \z
+  }xi
+
+  # Generic IPAddr related error. Exceptions raised in this class should
+  # inherit from Error.
+  class Error < ArgumentError; end
+
+  # Raised when the provided IP address is an invalid address.
+  class InvalidAddressError < Error; end
+
+  # Raised when the address family is invalid such as an address with an
+  # unsupported family, an address with an inconsistent family, or an address
+  # who's family cannot be determined.
+  class AddressFamilyError < Error; end
+
+  # Raised when the address is an invalid length.
+  class InvalidPrefixError < InvalidAddressError; end
+
+  # Returns the address family of this IP address.
+  attr_reader :family
+
+  # Creates a new ipaddr containing the given network byte ordered
+  # string form of an IP address.
+  def IPAddr::new_ntoh(addr)
+    return IPAddr.new(IPAddr::ntop(addr))
+  end
+
+  # Convert a network byte ordered string form of an IP address into
+  # human readable form.
+  def IPAddr::ntop(addr)
+    case addr.size
+    when 4
+      s = addr.unpack('C4').join('.')
+    when 16
+      s = IN6FORMAT % addr.unpack('n8')
+    else
+      raise AddressFamilyError, "unsupported address family"
+    end
+    return s
+  end
+
+  # Returns a new ipaddr built by bitwise AND.
+  def &(other)
+    return self.clone.set(@addr & coerce_other(other).to_i)
+  end
+
+  # Returns a new ipaddr built by bitwise OR.
+  def |(other)
+    return self.clone.set(@addr | coerce_other(other).to_i)
+  end
+
+  # Returns a new ipaddr built by bitwise right-shift.
+  def >>(num)
+    return self.clone.set(@addr >> num)
+  end
+
+  # Returns a new ipaddr built by bitwise left shift.
+  def <<(num)
+    return self.clone.set(addr_mask(@addr << num))
+  end
+
+  # Returns a new ipaddr built by bitwise negation.
+  def ~
+    return self.clone.set(addr_mask(~@addr))
+  end
+
+  # Returns true if two ipaddrs are equal.
+  def ==(other)
+    other = coerce_other(other)
+  rescue
+    false
+  else
+    @family == other.family && @addr == other.to_i
+  end
+
+  # Returns a new ipaddr built by masking IP address with the given
+  # prefixlen/netmask. (e.g. 8, 64, "255.255.255.0", etc.)
+  def mask(prefixlen)
+    return self.clone.mask!(prefixlen)
+  end
+
+  # Returns true if the given ipaddr is in the range.
+  #
+  # e.g.:
+  #   require 'ipaddr'
+  #   net1 = IPAddr.new("192.168.2.0/24")
+  #   net2 = IPAddr.new("192.168.2.100")
+  #   net3 = IPAddr.new("192.168.3.0")
+  #   p net1.include?(net2)     #=> true
+  #   p net1.include?(net3)     #=> false
+  def include?(other)
+    other = coerce_other(other)
+    if ipv4_mapped?
+      if (@mask_addr >> 32) != 0xffffffffffffffffffffffff
+        return false
+      end
+      mask_addr = (@mask_addr & IN4MASK)
+      addr = (@addr & IN4MASK)
+      family = Socket::AF_INET
+    else
+      mask_addr = @mask_addr
+      addr = @addr
+      family = @family
+    end
+    if other.ipv4_mapped?
+      other_addr = (other.to_i & IN4MASK)
+      other_family = Socket::AF_INET
+    else
+      other_addr = other.to_i
+      other_family = other.family
+    end
+
+    if family != other_family
+      return false
+    end
+    return ((addr & mask_addr) == (other_addr & mask_addr))
+  end
+  alias === include?
+
+  # Returns the integer representation of the ipaddr.
+  def to_i
+    return @addr
+  end
+
+  # Returns a string containing the IP address representation.
+  def to_s
+    str = to_string
+    return str if ipv4?
+
+    str.gsub!(/\b0{1,3}([\da-f]+)\b/i, '\1')
+    loop do
+      break if str.sub!(/\A0:0:0:0:0:0:0:0\z/, '::')
+      break if str.sub!(/\b0:0:0:0:0:0:0\b/, ':')
+      break if str.sub!(/\b0:0:0:0:0:0\b/, ':')
+      break if str.sub!(/\b0:0:0:0:0\b/, ':')
+      break if str.sub!(/\b0:0:0:0\b/, ':')
+      break if str.sub!(/\b0:0:0\b/, ':')
+      break if str.sub!(/\b0:0\b/, ':')
+      break
+    end
+    str.sub!(/:{3,}/, '::')
+
+    if /\A::(ffff:)?([\da-f]{1,4}):([\da-f]{1,4})\z/i =~ str
+      str = sprintf('::%s%d.%d.%d.%d', $1, $2.hex / 256, $2.hex % 256, $3.hex / 256, $3.hex % 256)
+    end
+
+    str
+  end
+
+  # Returns a string containing the IP address representation in
+  # canonical form.
+  def to_string
+    return _to_string(@addr)
+  end
+
+  # Returns a network byte ordered string form of the IP address.
+  def hton
+    case @family
+    when Socket::AF_INET
+      return [@addr].pack('N')
+    when Socket::AF_INET6
+      return (0..7).map { |i|
+        (@addr >> (112 - 16 * i)) & 0xffff
+      }.pack('n8')
+    else
+      raise AddressFamilyError, "unsupported address family"
+    end
+  end
+
+  # Returns true if the ipaddr is an IPv4 address.
+  def ipv4?
+    return @family == Socket::AF_INET
+  end
+
+  # Returns true if the ipaddr is an IPv6 address.
+  def ipv6?
+    return @family == Socket::AF_INET6
+  end
+
+  # Returns true if the ipaddr is an IPv4-mapped IPv6 address.
+  def ipv4_mapped?
+    return ipv6? && (@addr >> 32) == 0xffff
+  end
+
+  # Returns true if the ipaddr is an IPv4-compatible IPv6 address.
+  def ipv4_compat?
+    if !ipv6? || (@addr >> 32) != 0
+      return false
+    end
+    a = (@addr & IN4MASK)
+    return a != 0 && a != 1
+  end
+
+  # Returns a new ipaddr built by converting the native IPv4 address
+  # into an IPv4-mapped IPv6 address.
+  def ipv4_mapped
+    if !ipv4?
+      raise InvalidAddressError, "not an IPv4 address"
+    end
+    return self.clone.set(@addr | 0xffff00000000, Socket::AF_INET6)
+  end
+
+  # Returns a new ipaddr built by converting the native IPv4 address
+  # into an IPv4-compatible IPv6 address.
+  def ipv4_compat
+    if !ipv4?
+      raise InvalidAddressError, "not an IPv4 address"
+    end
+    return self.clone.set(@addr, Socket::AF_INET6)
+  end
+
+  # Returns a new ipaddr built by converting the IPv6 address into a
+  # native IPv4 address.  If the IP address is not an IPv4-mapped or
+  # IPv4-compatible IPv6 address, returns self.
+  def native
+    if !ipv4_mapped? && !ipv4_compat?
+      return self
+    end
+    return self.clone.set(@addr & IN4MASK, Socket::AF_INET)
+  end
+
+  # Returns a string for DNS reverse lookup.  It returns a string in
+  # RFC3172 form for an IPv6 address.
+  def reverse
+    case @family
+    when Socket::AF_INET
+      return _reverse + ".in-addr.arpa"
+    when Socket::AF_INET6
+      return ip6_arpa
+    else
+      raise AddressFamilyError, "unsupported address family"
+    end
+  end
+
+  # Returns a string for DNS reverse lookup compatible with RFC3172.
+  def ip6_arpa
+    if !ipv6?
+      raise InvalidAddressError, "not an IPv6 address"
+    end
+    return _reverse + ".ip6.arpa"
+  end
+
+  # Returns a string for DNS reverse lookup compatible with RFC1886.
+  def ip6_int
+    if !ipv6?
+      raise InvalidAddressError, "not an IPv6 address"
+    end
+    return _reverse + ".ip6.int"
+  end
+
+  # Returns the successor to the ipaddr.
+  def succ
+    return self.clone.set(@addr + 1, @family)
+  end
+
+  # Compares the ipaddr with another.
+  def <=>(other)
+    other = coerce_other(other)
+  rescue
+    nil
+  else
+    @addr <=> other.to_i if other.family == @family
+  end
+  include Comparable
+
+  # Checks equality used by Hash.
+  def eql?(other)
+    return self.class == other.class && self.hash == other.hash && self == other
+  end
+
+  # Returns a hash value used by Hash, Set, and Array classes
+  def hash
+    return ([@addr, @mask_addr].hash << 1) | (ipv4? ? 0 : 1)
+  end
+
+  # Creates a Range object for the network address.
+  def to_range
+    begin_addr = (@addr & @mask_addr)
+
+    case @family
+    when Socket::AF_INET
+      end_addr = (@addr | (IN4MASK ^ @mask_addr))
+    when Socket::AF_INET6
+      end_addr = (@addr | (IN6MASK ^ @mask_addr))
+    else
+      raise AddressFamilyError, "unsupported address family"
+    end
+
+    return clone.set(begin_addr, @family)..clone.set(end_addr, @family)
+  end
+
+  # Returns a string containing a human-readable representation of the
+  # ipaddr. ("#<IPAddr: family:address/mask>")
+  def inspect
+    case @family
+    when Socket::AF_INET
+      af = "IPv4"
+    when Socket::AF_INET6
+      af = "IPv6"
+    else
+      raise AddressFamilyError, "unsupported address family"
+    end
+    return sprintf("#<%s: %s:%s/%s>", self.class.name,
+                   af, _to_string(@addr), _to_string(@mask_addr))
+  end
+
+  protected
+
+  # Set +@addr+, the internal stored ip address, to given +addr+. The
+  # parameter +addr+ is validated using the first +family+ member,
+  # which is +Socket::AF_INET+ or +Socket::AF_INET6+.
+  def set(addr, *family)
+    case family[0] ? family[0] : @family
+    when Socket::AF_INET
+      if addr < 0 || addr > IN4MASK
+        raise InvalidAddressError, "invalid address"
+      end
+    when Socket::AF_INET6
+      if addr < 0 || addr > IN6MASK
+        raise InvalidAddressError, "invalid address"
+      end
+    else
+      raise AddressFamilyError, "unsupported address family"
+    end
+    @addr = addr
+    if family[0]
+      @family = family[0]
+    end
+    return self
+  end
+
+  # Set current netmask to given mask.
+  def mask!(mask)
+    if mask.kind_of?(String)
+      if mask =~ /\A\d+\z/
+        prefixlen = mask.to_i
+      else
+        m = IPAddr.new(mask)
+        if m.family != @family
+          raise InvalidPrefixError, "address family is not same"
+        end
+        @mask_addr = m.to_i
+        @addr &= @mask_addr
+        return self
+      end
+    else
+      prefixlen = mask
+    end
+    case @family
+    when Socket::AF_INET
+      if prefixlen < 0 || prefixlen > 32
+        raise InvalidPrefixError, "invalid length"
+      end
+      masklen = 32 - prefixlen
+      @mask_addr = ((IN4MASK >> masklen) << masklen)
+    when Socket::AF_INET6
+      if prefixlen < 0 || prefixlen > 128
+        raise InvalidPrefixError, "invalid length"
+      end
+      masklen = 128 - prefixlen
+      @mask_addr = ((IN6MASK >> masklen) << masklen)
+    else
+      raise AddressFamilyError, "unsupported address family"
+    end
+    @addr = ((@addr >> masklen) << masklen)
+    return self
+  end
+
+  private
+
+  # Creates a new ipaddr object either from a human readable IP
+  # address representation in string, or from a packed in_addr value
+  # followed by an address family.
+  #
+  # In the former case, the following are the valid formats that will
+  # be recognized: "address", "address/prefixlen" and "address/mask",
+  # where IPv6 address may be enclosed in square brackets (`[' and
+  # `]').  If a prefixlen or a mask is specified, it returns a masked
+  # IP address.  Although the address family is determined
+  # automatically from a specified string, you can specify one
+  # explicitly by the optional second argument.
+  #
+  # Otherwise an IP address is generated from a packed in_addr value
+  # and an address family.
+  #
+  # The IPAddr class defines many methods and operators, and some of
+  # those, such as &, |, include? and ==, accept a string, or a packed
+  # in_addr value instead of an IPAddr object.
+  def initialize(addr = '::', family = Socket::AF_UNSPEC)
+    if !addr.kind_of?(String)
+      case family
+      when Socket::AF_INET, Socket::AF_INET6
+        set(addr.to_i, family)
+        @mask_addr = (family == Socket::AF_INET) ? IN4MASK : IN6MASK
+        return
+      when Socket::AF_UNSPEC
+        raise AddressFamilyError, "address family must be specified"
+      else
+        raise AddressFamilyError, "unsupported address family: #{family}"
+      end
+    end
+    prefix, prefixlen = addr.split('/')
+    if prefix =~ /\A\[(.*)\]\z/i
+      prefix = $1
+      family = Socket::AF_INET6
+    end
+    # It seems AI_NUMERICHOST doesn't do the job.
+    #Socket.getaddrinfo(left, nil, Socket::AF_INET6, Socket::SOCK_STREAM, nil,
+    #                  Socket::AI_NUMERICHOST)
+    @addr = @family = nil
+    if family == Socket::AF_UNSPEC || family == Socket::AF_INET
+      @addr = in_addr(prefix)
+      if @addr
+        @family = Socket::AF_INET
+      end
+    end
+    if !@addr && (family == Socket::AF_UNSPEC || family == Socket::AF_INET6)
+      @addr = in6_addr(prefix)
+      @family = Socket::AF_INET6
+    end
+    if family != Socket::AF_UNSPEC && @family != family
+      raise AddressFamilyError, "address family mismatch"
+    end
+    if prefixlen
+      mask!(prefixlen)
+    else
+      @mask_addr = (@family == Socket::AF_INET) ? IN4MASK : IN6MASK
+    end
+  end
+
+  def coerce_other(other)
+    case other
+    when IPAddr
+      other
+    when String
+      self.class.new(other)
+    else
+      self.class.new(other, @family)
+    end
+  end
+
+  def in_addr(addr)
+    case addr
+    when Array
+      octets = addr
+    else
+      m = RE_IPV4ADDRLIKE.match(addr) or return nil
+      octets = m.captures
+    end
+    octets.inject(0) { |i, s|
+      (n = s.to_i) < 256 or raise InvalidAddressError, "invalid address"
+      s.match(/\A0./) and raise InvalidAddressError, "zero-filled number in IPv4 address is ambiguous"
+      i << 8 | n
+    }
+  end
+
+  def in6_addr(left)
+    case left
+    when RE_IPV6ADDRLIKE_FULL
+      if $2
+        addr = in_addr($~[2,4])
+        left = $1 + ':'
+      else
+        addr = 0
+      end
+      right = ''
+    when RE_IPV6ADDRLIKE_COMPRESSED
+      if $4
+        left.count(':') <= 6 or raise InvalidAddressError, "invalid address"
+        addr = in_addr($~[4,4])
+        left = $1
+        right = $3 + '0:0'
+      else
+        left.count(':') <= ($1.empty? || $2.empty? ? 8 : 7) or
+          raise InvalidAddressError, "invalid address"
+        left = $1
+        right = $2
+        addr = 0
+      end
+    else
+      raise InvalidAddressError, "invalid address"
+    end
+    l = left.split(':')
+    r = right.split(':')
+    rest = 8 - l.size - r.size
+    if rest < 0
+      return nil
+    end
+    (l + Array.new(rest, '0') + r).inject(0) { |i, s|
+      i << 16 | s.hex
+    } | addr
+  end
+
+  def addr_mask(addr)
+    case @family
+    when Socket::AF_INET
+      return addr & IN4MASK
+    when Socket::AF_INET6
+      return addr & IN6MASK
+    else
+      raise AddressFamilyError, "unsupported address family"
+    end
+  end
+
+  def _reverse
+    case @family
+    when Socket::AF_INET
+      return (0..3).map { |i|
+        (@addr >> (8 * i)) & 0xff
+      }.join('.')
+    when Socket::AF_INET6
+      return ("%.32x" % @addr).reverse!.gsub!(/.(?!$)/, '\&.')
+    else
+      raise AddressFamilyError, "unsupported address family"
+    end
+  end
+
+  def _to_string(addr)
+    case @family
+    when Socket::AF_INET
+      return (0..3).map { |i|
+        (addr >> (24 - 8 * i)) & 0xff
+      }.join('.')
+    when Socket::AF_INET6
+      return (("%.32x" % addr).gsub!(/.{4}(?!$)/, '\&:'))
+    else
+      raise AddressFamilyError, "unsupported address family"
+    end
+  end
+
+end
+
+unless Socket.const_defined? :AF_INET6
+  class Socket < BasicSocket
+    # IPv6 protocol family
+    AF_INET6 = Object.new
+  end
+
+  class << IPSocket
+    private
+
+    def valid_v6?(addr)
+      case addr
+      when IPAddr::RE_IPV6ADDRLIKE_FULL
+        if $2
+          $~[2,4].all? {|i| i.to_i < 256 }
+        else
+          true
+        end
+      when IPAddr::RE_IPV6ADDRLIKE_COMPRESSED
+        if $4
+          addr.count(':') <= 6 && $~[4,4].all? {|i| i.to_i < 256}
+        else
+          addr.count(':') <= 7
+        end
+      else
+        false
+      end
+    end
+
+    alias getaddress_orig getaddress
+
+    public
+
+    # Returns a +String+ based representation of a valid DNS hostname,
+    # IPv4 or IPv6 address.
+    #
+    #   IPSocket.getaddress 'localhost'         #=> "::1"
+    #   IPSocket.getaddress 'broadcasthost'     #=> "255.255.255.255"
+    #   IPSocket.getaddress 'www.ruby-lang.org' #=> "221.186.184.68"
+    #   IPSocket.getaddress 'www.ccc.de'        #=> "2a00:1328:e102:ccc0::122"
+    def getaddress(s)
+      if valid_v6?(s)
+        s
+      else
+        getaddress_orig(s)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: ipaddr
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Akinori MUSHA
+- Hajimu UMEMOTO
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-08-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |
+  IPAddr provides a set of methods to manipulate an IP address.
+  Both IPv4 and IPv6 are supported.
+email:
+- knu@idaemons.org
+- ume@mahoroba.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- ipaddr.gemspec
+- lib/ipaddr.rb
+homepage: https://github.com/ruby/ipaddr
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.11
+signing_key: 
+specification_version: 4
+summary: A class to manipulate an IP address in ruby
+test_files: []