imported mlocati/ip-lib version 1.14.0

vendor/mlocati/ip-lib/src/Address/AddressInterface.php

@@ -0,0 +1,125 @@
+<?php
+
+namespace IPLib\Address;
+
+use IPLib\Range\RangeInterface;
+
+/**
+ * Interface of all the IP address types.
+ */
+interface AddressInterface
+{
+    /**
+     * Get the short string representation of this address.
+     *
+     * @return string
+     */
+    public function __toString();
+
+    /**
+     * Get the number of bits representing this address type.
+     *
+     * @return int
+     *
+     * @example 32 for IPv4
+     * @example 128 for IPv6
+     */
+    public static function getNumberOfBits();
+
+    /**
+     * Get the string representation of this address.
+     *
+     * @param bool $long set to true to have a long/full representation, false otherwise
+     *
+     * @return string
+     *
+     * @example If $long is true, you'll get '0000:0000:0000:0000:0000:0000:0000:0001', '::1' otherwise.
+     */
+    public function toString($long = false);
+
+    /**
+     * Get the byte list of the IP address.
+     *
+     * @return int[]
+     *
+     * @example For localhost: for IPv4 you'll get array(127, 0, 0, 1), for IPv6 array(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1)
+     */
+    public function getBytes();
+
+    /**
+     * Get the full bit list the IP address.
+     *
+     * @return string
+     *
+     * @example For localhost: For IPv4 you'll get '01111111000000000000000000000001' (32 digits), for IPv6 '00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001' (128 digits)
+     */
+    public function getBits();
+
+    /**
+     * Get the type of the IP address.
+     *
+     * @return int One of the \IPLib\Address\Type::T_... constants
+     */
+    public function getAddressType();
+
+    /**
+     * Get the default RFC reserved range type.
+     *
+     * @return int One of the \IPLib\Range\Type::T_... constants
+     */
+    public static function getDefaultReservedRangeType();
+
+    /**
+     * Get the RFC reserved ranges (except the ones of type getDefaultReservedRangeType).
+     *
+     * @return \IPLib\Address\AssignedRange[] ranges are sorted
+     */
+    public static function getReservedRanges();
+
+    /**
+     * Get the type of range of the IP address.
+     *
+     * @return int One of the \IPLib\Range\Type::T_... constants
+     */
+    public function getRangeType();
+
+    /**
+     * Get a string representation of this address than can be used when comparing addresses and ranges.
+     *
+     * @return string
+     */
+    public function getComparableString();
+
+    /**
+     * Check if this address is contained in an range.
+     *
+     * @param \IPLib\Range\RangeInterface $range
+     *
+     * @return bool
+     */
+    public function matches(RangeInterface $range);
+
+    /**
+     * Get the address right after this IP address (if available).
+     *
+     * @return \IPLib\Address\AddressInterface|null
+     */
+    public function getNextAddress();
+
+    /**
+     * Get the address right before this IP address (if available).
+     *
+     * @return \IPLib\Address\AddressInterface|null
+     */
+    public function getPreviousAddress();
+
+    /**
+     * Get the Reverse DNS Lookup Address of this IP address.
+     *
+     * @return string
+     *
+     * @example for IPv4 it returns something like x.x.x.x.in-addr.arpa
+     * @example for IPv6 it returns something like x.x.x.x..x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.ip6.arpa
+     */
+    public function getReverseDNSLookupName();
+}

vendor/mlocati/ip-lib/src/Address/AssignedRange.php

@@ -0,0 +1,138 @@
+<?php
+
+namespace IPLib\Address;
+
+use IPLib\Range\RangeInterface;
+
+/**
+ * Represents an IP address range with an assigned range type.
+ */
+class AssignedRange
+{
+    /**
+     * The range definition.
+     *
+     * @var \IPLib\Range\RangeInterface
+     */
+    protected $range;
+
+    /**
+     * The range type.
+     *
+     * @var int one of the \IPLib\Range\Type::T_ constants
+     */
+    protected $type;
+
+    /**
+     * The list of exceptions for this range type.
+     *
+     * @var \IPLib\Address\AssignedRange[]
+     */
+    protected $exceptions;
+
+    /**
+     * Initialize the instance.
+     *
+     * @param \IPLib\Range\RangeInterface $range the range definition
+     * @param int $type The range type (one of the \IPLib\Range\Type::T_ constants)
+     * @param \IPLib\Address\AssignedRange[] $exceptions the list of exceptions for this range type
+     */
+    public function __construct(RangeInterface $range, $type, array $exceptions = array())
+    {
+        $this->range = $range;
+        $this->type = $type;
+        $this->exceptions = $exceptions;
+    }
+
+    /**
+     * Get the range definition.
+     *
+     * @return \IPLib\Range\RangeInterface
+     */
+    public function getRange()
+    {
+        return $this->range;
+    }
+
+    /**
+     * Get the range type.
+     *
+     * @return int one of the \IPLib\Range\Type::T_ constants
+     */
+    public function getType()
+    {
+        return $this->type;
+    }
+
+    /**
+     * Get the list of exceptions for this range type.
+     *
+     * @return \IPLib\Address\AssignedRange[]
+     */
+    public function getExceptions()
+    {
+        return $this->exceptions;
+    }
+
+    /**
+     * Get the assigned type for a specific address.
+     *
+     * @param \IPLib\Address\AddressInterface $address
+     *
+     * @return int|null return NULL of the address is outside this address; a \IPLib\Range\Type::T_ constant otherwise
+     */
+    public function getAddressType(AddressInterface $address)
+    {
+        $result = null;
+        if ($this->range->contains($address)) {
+            foreach ($this->exceptions as $exception) {
+                $result = $exception->getAddressType($address);
+                if ($result !== null) {
+                    break;
+                }
+            }
+            if ($result === null) {
+                $result = $this->type;
+            }
+        }
+
+        return $result;
+    }
+
+    /**
+     * Get the assigned type for a specific address range.
+     *
+     * @param \IPLib\Range\RangeInterface $range
+     *
+     * @return int|false|null return NULL of the range is fully outside this range; false if it's partly crosses this range (or it contains mixed types); a \IPLib\Range\Type::T_ constant otherwise
+     */
+    public function getRangeType(RangeInterface $range)
+    {
+        $myStart = $this->range->getComparableStartString();
+        $rangeEnd = $range->getComparableEndString();
+        if ($myStart > $rangeEnd) {
+            $result = null;
+        } else {
+            $myEnd = $this->range->getComparableEndString();
+            $rangeStart = $range->getComparableStartString();
+            if ($myEnd < $rangeStart) {
+                $result = null;
+            } elseif ($rangeStart < $myStart || $rangeEnd > $myEnd) {
+                $result = false;
+            } else {
+                $result = null;
+                foreach ($this->exceptions as $exception) {
+                    $result = $exception->getRangeType($range);
+                    if ($result !== null) {
+                        break;
+                    }
+                }
+                if ($result === null) {
+                    $result = $this->getType();
+                }
+            }
+        }
+
+        return $result;
+    }
+}

vendor/mlocati/ip-lib/src/Address/IPv4.php

@@ -0,0 +1,465 @@
+<?php
+
+namespace IPLib\Address;
+
+use IPLib\Range\RangeInterface;
+use IPLib\Range\Subnet;
+use IPLib\Range\Type as RangeType;
+
+/**
+ * An IPv4 address.
+ */
+class IPv4 implements AddressInterface
+{
+    /**
+     * The string representation of the address.
+     *
+     * @var string
+     *
+     * @example '127.0.0.1'
+     */
+    protected $address;
+
+    /**
+     * The byte list of the IP address.
+     *
+     * @var int[]|null
+     */
+    protected $bytes;
+
+    /**
+     * The type of the range of this IP address.
+     *
+     * @var int|null
+     */
+    protected $rangeType;
+
+    /**
+     * A string representation of this address than can be used when comparing addresses and ranges.
+     *
+     * @var string
+     */
+    protected $comparableString;
+
+    /**
+     * An array containing RFC designated address ranges.
+     *
+     * @var array|null
+     */
+    private static $reservedRanges = null;
+
+    /**
+     * Initializes the instance.
+     *
+     * @param string $address
+     */
+    protected function __construct($address)
+    {
+        $this->address = $address;
+        $this->bytes = null;
+        $this->rangeType = null;
+        $this->comparableString = null;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Address\AddressInterface::__toString()
+     */
+    public function __toString()
+    {
+        return $this->address;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Address\AddressInterface::getNumberOfBits()
+     */
+    public static function getNumberOfBits()
+    {
+        return 32;
+    }
+
+    /**
+     * Parse a string and returns an IPv4 instance if the string is valid, or null otherwise.
+     *
+     * @param string|mixed $address the address to parse
+     * @param bool $mayIncludePort set to false to avoid parsing addresses with ports
+     * @param bool $supportNonDecimalIPv4 set to true to support parsing non decimal (that is, octal and hexadecimal) IPv4 addresses
+     *
+     * @return static|null
+     */
+    public static function fromString($address, $mayIncludePort = true, $supportNonDecimalIPv4 = false)
+    {
+        if (!is_string($address) || !strpos($address, '.')) {
+            return null;
+        }
+        $rxChunk = '0?[0-9]{1,3}';
+        if ($supportNonDecimalIPv4) {
+            $rxChunk = "(?:0[Xx]0*[0-9A-Fa-f]{1,2})|(?:{$rxChunk})";
+        }
+        $rx = "0*?({$rxChunk})\.0*?({$rxChunk})\.0*?({$rxChunk})\.0*?({$rxChunk})";
+        if ($mayIncludePort) {
+            $rx .= '(?::\d+)?';
+        }
+        $matches = null;
+        if (!preg_match('/^' . $rx . '$/', $address, $matches)) {
+            return null;
+        }
+        $nums = array();
+        for ($i = 1; $i <= 4; $i++) {
+            $s = $matches[$i];
+            if ($supportNonDecimalIPv4) {
+                if (stripos($s, '0x') === 0) {
+                    $n = hexdec(substr($s, 2));
+                } elseif ($s[0] === '0') {
+                    if (!preg_match('/^[0-7]+$/', $s)) {
+                        return null;
+                    }
+                    $n = octdec(substr($s, 1));
+                } else {
+                    $n = (int) $s;
+                }
+            } else {
+                $n = (int) $s;
+            }
+            if ($n < 0 || $n > 255) {
+                return null;
+            }
+            $nums[] = (string) $n;
+        }
+
+        return new static(implode('.', $nums));
+    }
+
+    /**
+     * Parse an array of bytes and returns an IPv4 instance if the array is valid, or null otherwise.
+     *
+     * @param int[]|array $bytes
+     *
+     * @return static|null
+     */
+    public static function fromBytes(array $bytes)
+    {
+        $result = null;
+        if (count($bytes) === 4) {
+            $chunks = array_map(
+                function ($byte) {
+                    return (is_int($byte) && $byte >= 0 && $byte <= 255) ? (string) $byte : false;
+                },
+                $bytes
+            );
+            if (in_array(false, $chunks, true) === false) {
+                $result = new static(implode('.', $chunks));
+            }
+        }
+
+        return $result;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Address\AddressInterface::toString()
+     */
+    public function toString($long = false)
+    {
+        if ($long) {
+            return $this->getComparableString();
+        }
+
+        return $this->address;
+    }
+
+    /**
+     * Get the octal representation of this IP address.
+     *
+     * @param bool $long
+     *
+     * @return string
+     *
+     * @example if $long == false: if the decimal representation is '0.7.8.255': '0.7.010.0377'
+     * @example if $long == true: if the decimal representation is '0.7.8.255': '0000.0007.0010.0377'
+     */
+    public function toOctal($long = false)
+    {
+        $chunks = array();
+        foreach ($this->getBytes() as $byte) {
+            if ($long) {
+                $chunks[] = sprintf('%04o', $byte);
+            } else {
+                $chunks[] = '0' . decoct($byte);
+            }
+        }
+
+        return implode('.', $chunks);
+    }
+
+    /**
+     * Get the hexadecimal representation of this IP address.
+     *
+     * @param bool $long
+     *
+     * @return string
+     *
+     * @example if $long == false: if the decimal representation is '0.9.10.255': '0.9.0xa.0xff'
+     * @example if $long == true: if the decimal representation is '0.9.10.255': '0x00.0x09.0x0a.0xff'
+     */
+    public function toHexadecimal($long = false)
+    {
+        $chunks = array();
+        foreach ($this->getBytes() as $byte) {
+            if ($long) {
+                $chunks[] = sprintf('0x%02x', $byte);
+            } else {
+                $chunks[] = '0x' . dechex($byte);
+            }
+        }
+
+        return implode('.', $chunks);
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Address\AddressInterface::getBytes()
+     */
+    public function getBytes()
+    {
+        if ($this->bytes === null) {
+            $this->bytes = array_map(
+                function ($chunk) {
+                    return (int) $chunk;
+                },
+                explode('.', $this->address)
+            );
+        }
+
+        return $this->bytes;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Address\AddressInterface::getBits()
+     */
+    public function getBits()
+    {
+        $parts = array();
+        foreach ($this->getBytes() as $byte) {
+            $parts[] = sprintf('%08b', $byte);
+        }
+
+        return implode('', $parts);
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Address\AddressInterface::getAddressType()
+     */
+    public function getAddressType()
+    {
+        return Type::T_IPv4;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Address\AddressInterface::getDefaultReservedRangeType()
+     */
+    public static function getDefaultReservedRangeType()
+    {
+        return RangeType::T_PUBLIC;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Address\AddressInterface::getReservedRanges()
+     */
+    public static function getReservedRanges()
+    {
+        if (self::$reservedRanges === null) {
+            $reservedRanges = array();
+            foreach (array(
+                // RFC 5735
+                '0.0.0.0/8' => array(RangeType::T_THISNETWORK, array('0.0.0.0/32' => RangeType::T_UNSPECIFIED)),
+                // RFC 5735
+                '10.0.0.0/8' => array(RangeType::T_PRIVATENETWORK),
+                // RFC 6598
+                '100.64.0.0/10' => array(RangeType::T_CGNAT),
+                // RFC 5735
+                '127.0.0.0/8' => array(RangeType::T_LOOPBACK),
+                // RFC 5735
+                '169.254.0.0/16' => array(RangeType::T_LINKLOCAL),
+                // RFC 5735
+                '172.16.0.0/12' => array(RangeType::T_PRIVATENETWORK),
+                // RFC 5735
+                '192.0.0.0/24' => array(RangeType::T_RESERVED),
+                // RFC 5735
+                '192.0.2.0/24' => array(RangeType::T_RESERVED),
+                // RFC 5735
+                '192.88.99.0/24' => array(RangeType::T_ANYCASTRELAY),
+                // RFC 5735
+                '192.168.0.0/16' => array(RangeType::T_PRIVATENETWORK),
+                // RFC 5735
+                '198.18.0.0/15' => array(RangeType::T_RESERVED),
+                // RFC 5735
+                '198.51.100.0/24' => array(RangeType::T_RESERVED),
+                // RFC 5735
+                '203.0.113.0/24' => array(RangeType::T_RESERVED),
+                // RFC 5735
+                '224.0.0.0/4' => array(RangeType::T_MULTICAST),
+                // RFC 5735
+                '240.0.0.0/4' => array(RangeType::T_RESERVED, array('255.255.255.255/32' => RangeType::T_LIMITEDBROADCAST)),
+            ) as $range => $data) {
+                $exceptions = array();
+                if (isset($data[1])) {
+                    foreach ($data[1] as $exceptionRange => $exceptionType) {
+                        $exceptions[] = new AssignedRange(Subnet::fromString($exceptionRange), $exceptionType);
+                    }
+                }
+                $reservedRanges[] = new AssignedRange(Subnet::fromString($range), $data[0], $exceptions);
+            }
+            self::$reservedRanges = $reservedRanges;
+        }
+
+        return self::$reservedRanges;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Address\AddressInterface::getRangeType()
+     */
+    public function getRangeType()
+    {
+        if ($this->rangeType === null) {
+            $rangeType = null;
+            foreach (static::getReservedRanges() as $reservedRange) {
+                $rangeType = $reservedRange->getAddressType($this);
+                if ($rangeType !== null) {
+                    break;
+                }
+            }
+            $this->rangeType = $rangeType === null ? static::getDefaultReservedRangeType() : $rangeType;
+        }
+
+        return $this->rangeType;
+    }
+
+    /**
+     * Create an IPv6 representation of this address (in 6to4 notation).
+     *
+     * @return \IPLib\Address\IPv6
+     */
+    public function toIPv6()
+    {
+        $myBytes = $this->getBytes();
+
+        return IPv6::fromString('2002:' . sprintf('%02x', $myBytes[0]) . sprintf('%02x', $myBytes[1]) . ':' . sprintf('%02x', $myBytes[2]) . sprintf('%02x', $myBytes[3]) . '::');
+    }
+
+    /**
+     * Create an IPv6 representation of this address (in IPv6 IPv4-mapped notation).
+     *
+     * @return \IPLib\Address\IPv6
+     */
+    public function toIPv6IPv4Mapped()
+    {
+        return IPv6::fromBytes(array_merge(array(0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff), $this->getBytes()));
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Address\AddressInterface::getComparableString()
+     */
+    public function getComparableString()
+    {
+        if ($this->comparableString === null) {
+            $chunks = array();
+            foreach ($this->getBytes() as $byte) {
+                $chunks[] = sprintf('%03d', $byte);
+            }
+            $this->comparableString = implode('.', $chunks);
+        }
+
+        return $this->comparableString;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Address\AddressInterface::matches()
+     */
+    public function matches(RangeInterface $range)
+    {
+        return $range->contains($this);
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Address\AddressInterface::getNextAddress()
+     */
+    public function getNextAddress()
+    {
+        $overflow = false;
+        $bytes = $this->getBytes();
+        for ($i = count($bytes) - 1; $i >= 0; $i--) {
+            if ($bytes[$i] === 255) {
+                if ($i === 0) {
+                    $overflow = true;
+                    break;
+                }
+                $bytes[$i] = 0;
+            } else {
+                $bytes[$i]++;
+                break;
+            }
+        }
+
+        return $overflow ? null : static::fromBytes($bytes);
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Address\AddressInterface::getPreviousAddress()
+     */
+    public function getPreviousAddress()
+    {
+        $overflow = false;
+        $bytes = $this->getBytes();
+        for ($i = count($bytes) - 1; $i >= 0; $i--) {
+            if ($bytes[$i] === 0) {
+                if ($i === 0) {
+                    $overflow = true;
+                    break;
+                }
+                $bytes[$i] = 255;
+            } else {
+                $bytes[$i]--;
+                break;
+            }
+        }
+
+        return $overflow ? null : static::fromBytes($bytes);
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Address\AddressInterface::getReverseDNSLookupName()
+     */
+    public function getReverseDNSLookupName()
+    {
+        return implode(
+            '.',
+            array_reverse($this->getBytes())
+        ) . '.in-addr.arpa';
+    }
+}

vendor/mlocati/ip-lib/src/Address/IPv6.php

@@ -0,0 +1,568 @@
+<?php
+
+namespace IPLib\Address;
+
+use IPLib\Range\RangeInterface;
+use IPLib\Range\Subnet;
+use IPLib\Range\Type as RangeType;
+
+/**
+ * An IPv6 address.
+ */
+class IPv6 implements AddressInterface
+{
+    /**
+     * The long string representation of the address.
+     *
+     * @var string
+     *
+     * @example '0000:0000:0000:0000:0000:0000:0000:0001'
+     */
+    protected $longAddress;
+
+    /**
+     * The long string representation of the address.
+     *
+     * @var string|null
+     *
+     * @example '::1'
+     */
+    protected $shortAddress;
+
+    /**
+     * The byte list of the IP address.
+     *
+     * @var int[]|null
+     */
+    protected $bytes;
+
+    /**
+     * The word list of the IP address.
+     *
+     * @var int[]|null
+     */
+    protected $words;
+
+    /**
+     * The type of the range of this IP address.
+     *
+     * @var int|null
+     */
+    protected $rangeType;
+
+    /**
+     * An array containing RFC designated address ranges.
+     *
+     * @var array|null
+     */
+    private static $reservedRanges = null;
+
+    /**
+     * Initializes the instance.
+     *
+     * @param string $longAddress
+     */
+    public function __construct($longAddress)
+    {
+        $this->longAddress = $longAddress;
+        $this->shortAddress = null;
+        $this->bytes = null;
+        $this->words = null;
+        $this->rangeType = null;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Address\AddressInterface::__toString()
+     */
+    public function __toString()
+    {
+        return $this->toString();
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Address\AddressInterface::getNumberOfBits()
+     */
+    public static function getNumberOfBits()
+    {
+        return 128;
+    }
+
+    /**
+     * Parse a string and returns an IPv6 instance if the string is valid, or null otherwise.
+     *
+     * @param string|mixed $address the address to parse
+     * @param bool $mayIncludePort set to false to avoid parsing addresses with ports
+     * @param bool $mayIncludeZoneID set to false to avoid parsing addresses with zone IDs (see RFC 4007)
+     *
+     * @return static|null
+     */
+    public static function fromString($address, $mayIncludePort = true, $mayIncludeZoneID = true)
+    {
+        $result = null;
+        if (is_string($address) && strpos($address, ':') !== false && strpos($address, ':::') === false) {
+            $matches = null;
+            if ($mayIncludePort && $address[0] === '[' && preg_match('/^\[(.+)]:\d+$/', $address, $matches)) {
+                $address = $matches[1];
+            }
+            if ($mayIncludeZoneID) {
+                $percentagePos = strpos($address, '%');
+                if ($percentagePos > 0) {
+                    $address = substr($address, 0, $percentagePos);
+                }
+            }
+            if (preg_match('/^((?:[0-9a-f]*:+)+)(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})$/i', $address, $matches)) {
+                $address6 = static::fromString($matches[1] . '0:0', false);
+                if ($address6 !== null) {
+                    $address4 = IPv4::fromString($matches[2], false);
+                    if ($address4 !== null) {
+                        $bytes4 = $address4->getBytes();
+                        $address6->longAddress = substr($address6->longAddress, 0, -9) . sprintf('%02x%02x:%02x%02x', $bytes4[0], $bytes4[1], $bytes4[2], $bytes4[3]);
+                        $result = $address6;
+                    }
+                }
+            } else {
+                if (strpos($address, '::') === false) {
+                    $chunks = explode(':', $address);
+                } else {
+                    $chunks = array();
+                    $parts = explode('::', $address);
+                    if (count($parts) === 2) {
+                        $before = ($parts[0] === '') ? array() : explode(':', $parts[0]);
+                        $after = ($parts[1] === '') ? array() : explode(':', $parts[1]);
+                        $missing = 8 - count($before) - count($after);
+                        if ($missing >= 0) {
+                            $chunks = $before;
+                            if ($missing !== 0) {
+                                $chunks = array_merge($chunks, array_fill(0, $missing, '0'));
+                            }
+                            $chunks = array_merge($chunks, $after);
+                        }
+                    }
+                }
+                if (count($chunks) === 8) {
+                    $nums = array_map(
+                        function ($chunk) {
+                            return preg_match('/^[0-9A-Fa-f]{1,4}$/', $chunk) ? hexdec($chunk) : false;
+                        },
+                        $chunks
+                    );
+                    if (!in_array(false, $nums, true)) {
+                        $longAddress = implode(
+                            ':',
+                            array_map(
+                                function ($num) {
+                                    return sprintf('%04x', $num);
+                                },
+                                $nums
+                            )
+                        );
+                        $result = new static($longAddress);
+                    }
+                }
+            }
+        }
+
+        return $result;
+    }
+
+    /**
+     * Parse an array of bytes and returns an IPv6 instance if the array is valid, or null otherwise.
+     *
+     * @param int[]|array $bytes
+     *
+     * @return static|null
+     */
+    public static function fromBytes(array $bytes)
+    {
+        $result = null;
+        if (count($bytes) === 16) {
+            $address = '';
+            for ($i = 0; $i < 16; $i++) {
+                if ($i !== 0 && $i % 2 === 0) {
+                    $address .= ':';
+                }
+                $byte = $bytes[$i];
+                if (is_int($byte) && $byte >= 0 && $byte <= 255) {
+                    $address .= sprintf('%02x', $byte);
+                } else {
+                    $address = null;
+                    break;
+                }
+            }
+            if ($address !== null) {
+                $result = new static($address);
+            }
+        }
+
+        return $result;
+    }
+
+    /**
+     * Parse an array of words and returns an IPv6 instance if the array is valid, or null otherwise.
+     *
+     * @param int[]|array $words
+     *
+     * @return static|null
+     */
+    public static function fromWords(array $words)
+    {
+        $result = null;
+        if (count($words) === 8) {
+            $chunks = array();
+            for ($i = 0; $i < 8; $i++) {
+                $word = $words[$i];
+                if (is_int($word) && $word >= 0 && $word <= 0xffff) {
+                    $chunks[] = sprintf('%04x', $word);
+                } else {
+                    $chunks = null;
+                    break;
+                }
+            }
+            if ($chunks !== null) {
+                $result = new static(implode(':', $chunks));
+            }
+        }
+
+        return $result;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Address\AddressInterface::toString()
+     */
+    public function toString($long = false)
+    {
+        if ($long) {
+            $result = $this->longAddress;
+        } else {
+            if ($this->shortAddress === null) {
+                if (strpos($this->longAddress, '0000:0000:0000:0000:0000:ffff:') === 0) {
+                    $lastBytes = array_slice($this->getBytes(), -4);
+                    $this->shortAddress = '::ffff:' . implode('.', $lastBytes);
+                } else {
+                    $chunks = array_map(
+                        function ($word) {
+                            return dechex($word);
+                        },
+                        $this->getWords()
+                    );
+                    $shortAddress = implode(':', $chunks);
+                    $matches = null;
+                    for ($i = 8; $i > 1; $i--) {
+                        $search = '(?:^|:)' . rtrim(str_repeat('0:', $i), ':') . '(?:$|:)';
+                        if (preg_match('/^(.*?)' . $search . '(.*)$/', $shortAddress, $matches)) {
+                            $shortAddress = $matches[1] . '::' . $matches[2];
+                            break;
+                        }
+                    }
+                    $this->shortAddress = $shortAddress;
+                }
+            }
+            $result = $this->shortAddress;
+        }
+
+        return $result;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Address\AddressInterface::getBytes()
+     */
+    public function getBytes()
+    {
+        if ($this->bytes === null) {
+            $bytes = array();
+            foreach ($this->getWords() as $word) {
+                $bytes[] = $word >> 8;
+                $bytes[] = $word & 0xff;
+            }
+            $this->bytes = $bytes;
+        }
+
+        return $this->bytes;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Address\AddressInterface::getBits()
+     */
+    public function getBits()
+    {
+        $parts = array();
+        foreach ($this->getBytes() as $byte) {
+            $parts[] = sprintf('%08b', $byte);
+        }
+
+        return implode('', $parts);
+    }
+
+    /**
+     * Get the word list of the IP address.
+     *
+     * @return int[]
+     */
+    public function getWords()
+    {
+        if ($this->words === null) {
+            $this->words = array_map(
+                function ($chunk) {
+                    return hexdec($chunk);
+                },
+                explode(':', $this->longAddress)
+            );
+        }
+
+        return $this->words;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Address\AddressInterface::getAddressType()
+     */
+    public function getAddressType()
+    {
+        return Type::T_IPv6;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Address\AddressInterface::getDefaultReservedRangeType()
+     */
+    public static function getDefaultReservedRangeType()
+    {
+        return RangeType::T_RESERVED;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Address\AddressInterface::getReservedRanges()
+     */
+    public static function getReservedRanges()
+    {
+        if (self::$reservedRanges === null) {
+            $reservedRanges = array();
+            foreach (array(
+                // RFC 4291
+                '::/128' => array(RangeType::T_UNSPECIFIED),
+                // RFC 4291
+                '::1/128' => array(RangeType::T_LOOPBACK),
+                // RFC 4291
+                '100::/8' => array(RangeType::T_DISCARD, array('100::/64' => RangeType::T_DISCARDONLY)),
+                //'2002::/16' => array(RangeType::),
+                // RFC 4291
+                '2000::/3' => array(RangeType::T_PUBLIC),
+                // RFC 4193
+                'fc00::/7' => array(RangeType::T_PRIVATENETWORK),
+                // RFC 4291
+                'fe80::/10' => array(RangeType::T_LINKLOCAL_UNICAST),
+                // RFC 4291
+                'ff00::/8' => array(RangeType::T_MULTICAST),
+                // RFC 4291
+                //'::/8' => array(RangeType::T_RESERVED),
+                // RFC 4048
+                //'200::/7' => array(RangeType::T_RESERVED),
+                // RFC 4291
+                //'400::/6' => array(RangeType::T_RESERVED),
+                // RFC 4291
+                //'800::/5' => array(RangeType::T_RESERVED),
+                // RFC 4291
+                //'1000::/4' => array(RangeType::T_RESERVED),
+                // RFC 4291
+                //'4000::/3' => array(RangeType::T_RESERVED),
+                // RFC 4291
+                //'6000::/3' => array(RangeType::T_RESERVED),
+                // RFC 4291
+                //'8000::/3' => array(RangeType::T_RESERVED),
+                // RFC 4291
+                //'a000::/3' => array(RangeType::T_RESERVED),
+                // RFC 4291
+                //'c000::/3' => array(RangeType::T_RESERVED),
+                // RFC 4291
+                //'e000::/4' => array(RangeType::T_RESERVED),
+                // RFC 4291
+                //'f000::/5' => array(RangeType::T_RESERVED),
+                // RFC 4291
+                //'f800::/6' => array(RangeType::T_RESERVED),
+                // RFC 4291
+                //'fe00::/9' => array(RangeType::T_RESERVED),
+                // RFC 3879
+                //'fec0::/10' => array(RangeType::T_RESERVED),
+            ) as $range => $data) {
+                $exceptions = array();
+                if (isset($data[1])) {
+                    foreach ($data[1] as $exceptionRange => $exceptionType) {
+                        $exceptions[] = new AssignedRange(Subnet::fromString($exceptionRange), $exceptionType);
+                    }
+                }
+                $reservedRanges[] = new AssignedRange(Subnet::fromString($range), $data[0], $exceptions);
+            }
+            self::$reservedRanges = $reservedRanges;
+        }
+
+        return self::$reservedRanges;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Address\AddressInterface::getRangeType()
+     */
+    public function getRangeType()
+    {
+        if ($this->rangeType === null) {
+            $ipv4 = $this->toIPv4();
+            if ($ipv4 !== null) {
+                $this->rangeType = $ipv4->getRangeType();
+            } else {
+                $rangeType = null;
+                foreach (static::getReservedRanges() as $reservedRange) {
+                    $rangeType = $reservedRange->getAddressType($this);
+                    if ($rangeType !== null) {
+                        break;
+                    }
+                }
+                $this->rangeType = $rangeType === null ? static::getDefaultReservedRangeType() : $rangeType;
+            }
+        }
+
+        return $this->rangeType;
+    }
+
+    /**
+     * Create an IPv4 representation of this address (if possible, otherwise returns null).
+     *
+     * @return \IPLib\Address\IPv4|null
+     */
+    public function toIPv4()
+    {
+        if (strpos($this->longAddress, '2002:') === 0) {
+            // 6to4
+            return IPv4::fromBytes(array_slice($this->getBytes(), 2, 4));
+        }
+        if (strpos($this->longAddress, '0000:0000:0000:0000:0000:ffff:') === 0) {
+            // IPv4-mapped IPv6 addresses
+            return IPv4::fromBytes(array_slice($this->getBytes(), -4));
+        }
+
+        return null;
+    }
+
+    /**
+     * Render this IPv6 address in the "mixed" IPv6 (first 12 bytes) + IPv4 (last 4 bytes) mixed syntax.
+     *
+     * @param bool $ipV6Long render the IPv6 part in "long" format?
+     * @param bool $ipV4Long render the IPv4 part in "long" format?
+     *
+     * @return string
+     *
+     * @example '::13.1.68.3'
+     * @example '0000:0000:0000:0000:0000:0000:13.1.68.3' when $ipV6Long is true
+     * @example '::013.001.068.003' when $ipV4Long is true
+     * @example '0000:0000:0000:0000:0000:0000:013.001.068.003' when $ipV6Long and $ipV4Long are true
+     *
+     * @see https://tools.ietf.org/html/rfc4291#section-2.2 point 3.
+     */
+    public function toMixedIPv6IPv4String($ipV6Long = false, $ipV4Long = false)
+    {
+        $myBytes = $this->getBytes();
+        $ipv6Bytes = array_merge(array_slice($myBytes, 0, 12), array(0xff, 0xff, 0xff, 0xff));
+        $ipv6String = static::fromBytes($ipv6Bytes)->toString($ipV6Long);
+        $ipv4Bytes = array_slice($myBytes, 12, 4);
+        $ipv4String = IPv4::fromBytes($ipv4Bytes)->toString($ipV4Long);
+
+        return preg_replace('/((ffff:ffff)|(\d+(\.\d+){3}))$/i', $ipv4String, $ipv6String);
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Address\AddressInterface::getComparableString()
+     */
+    public function getComparableString()
+    {
+        return $this->longAddress;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Address\AddressInterface::matches()
+     */
+    public function matches(RangeInterface $range)
+    {
+        return $range->contains($this);
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Address\AddressInterface::getNextAddress()
+     */
+    public function getNextAddress()
+    {
+        $overflow = false;
+        $words = $this->getWords();
+        for ($i = count($words) - 1; $i >= 0; $i--) {
+            if ($words[$i] === 0xffff) {
+                if ($i === 0) {
+                    $overflow = true;
+                    break;
+                }
+                $words[$i] = 0;
+            } else {
+                $words[$i]++;
+                break;
+            }
+        }
+
+        return $overflow ? null : static::fromWords($words);
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Address\AddressInterface::getPreviousAddress()
+     */
+    public function getPreviousAddress()
+    {
+        $overflow = false;
+        $words = $this->getWords();
+        for ($i = count($words) - 1; $i >= 0; $i--) {
+            if ($words[$i] === 0) {
+                if ($i === 0) {
+                    $overflow = true;
+                    break;
+                }
+                $words[$i] = 0xffff;
+            } else {
+                $words[$i]--;
+                break;
+            }
+        }
+
+        return $overflow ? null : static::fromWords($words);
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Address\AddressInterface::getReverseDNSLookupName()
+     */
+    public function getReverseDNSLookupName()
+    {
+        return implode(
+            '.',
+            array_reverse(str_split(str_replace(':', '', $this->toString(true)), 1))
+        ) . '.ip6.arpa';
+    }
+}

vendor/mlocati/ip-lib/src/Address/Type.php

@@ -0,0 +1,42 @@
+<?php
+
+namespace IPLib\Address;
+
+/**
+ * Types of IP addresses.
+ */
+class Type
+{
+    /**
+     * IPv4 address.
+     *
+     * @var int
+     */
+    const T_IPv4 = 4;
+
+    /**
+     * IPv6 address.
+     *
+     * @var int
+     */
+    const T_IPv6 = 6;
+
+    /**
+     * Get the name of a type.
+     *
+     * @param int $type
+     *
+     * @return string
+     */
+    public static function getName($type)
+    {
+        switch ($type) {
+            case static::T_IPv4:
+                return 'IP v4';
+            case static::T_IPv6:
+                return 'IP v6';
+            default:
+                return sprintf('Unknown type (%s)', $type);
+        }
+    }
+}