Initial commit

vendor/league/uri-interfaces/IPv4/BCMathCalculator.php

@@ -0,0 +1,85 @@
+<?php
+
+/**
+ * League.Uri (https://uri.thephpleague.com)
+ *
+ * (c) Ignace Nyamagana Butera <nyamsprod@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace League\Uri\IPv4;
+
+use function bcadd;
+use function bccomp;
+use function bcdiv;
+use function bcmod;
+use function bcmul;
+use function bcpow;
+use function bcsub;
+use function str_split;
+
+final class BCMathCalculator implements Calculator
+{
+    private const SCALE = 0;
+    private const CONVERSION_TABLE = [
+        '0' => '0', '1' => '1', '2' => '2', '3' => '3',
+        '4' => '4', '5' => '5', '6' => '6', '7' => '7',
+        '8' => '8', '9' => '9', 'a' => '10', 'b' => '11',
+        'c' => '12', 'd' => '13', 'e' => '14', 'f' => '15',
+    ];
+
+    public function baseConvert(mixed $value, int $base): string
+    {
+        $value = (string) $value;
+        if (10 === $base) {
+            return $value;
+        }
+
+        $base = (string) $base;
+        $decimal = '0';
+        foreach (str_split($value) as $char) {
+            $decimal = bcadd($this->multiply($decimal, $base), self::CONVERSION_TABLE[$char], self::SCALE);
+        }
+
+        return $decimal;
+    }
+
+    public function pow(mixed $value, int $exponent): string
+    {
+        return bcpow((string) $value, (string) $exponent, self::SCALE);
+    }
+
+    public function compare(mixed $value1, $value2): int
+    {
+        return bccomp((string) $value1, (string) $value2, self::SCALE);
+    }
+
+    public function multiply(mixed $value1, $value2): string
+    {
+        return bcmul((string) $value1, (string) $value2, self::SCALE);
+    }
+
+    public function div(mixed $value, mixed $base): string
+    {
+        return bcdiv((string) $value, (string) $base, self::SCALE);
+    }
+
+    public function mod(mixed $value, mixed $base): string
+    {
+        return bcmod((string) $value, (string) $base, self::SCALE);
+    }
+
+    public function add(mixed $value1, mixed $value2): string
+    {
+        return bcadd((string) $value1, (string) $value2, self::SCALE);
+    }
+
+    public function sub(mixed $value1, mixed $value2): string
+    {
+        return bcsub((string) $value1, (string) $value2, self::SCALE);
+    }
+}

vendor/league/uri-interfaces/IPv4/Calculator.php

@@ -0,0 +1,95 @@
+<?php
+
+/**
+ * League.Uri (https://uri.thephpleague.com)
+ *
+ * (c) Ignace Nyamagana Butera <nyamsprod@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace League\Uri\IPv4;
+
+interface Calculator
+{
+    /**
+     * Add numbers.
+     *
+     * @param mixed $value1 a number that will be added to $value2
+     * @param mixed $value2 a number that will be added to $value1
+     *
+     * @return mixed the addition result
+     */
+    public function add(mixed $value1, mixed $value2);
+
+    /**
+     * Subtract one number from another.
+     *
+     * @param mixed $value1 a number that will be subtracted of $value2
+     * @param mixed $value2 a number that will be subtracted to $value1
+     *
+     * @return mixed the subtraction result
+     */
+    public function sub(mixed $value1, mixed $value2);
+
+    /**
+     * Multiply numbers.
+     *
+     * @param mixed $value1 a number that will be multiplied by $value2
+     * @param mixed $value2 a number that will be multiplied by $value1
+     *
+     * @return mixed the multiplication result
+     */
+    public function multiply(mixed $value1, mixed $value2);
+
+    /**
+     * Divide numbers.
+     *
+     * @param mixed $value The number being divided.
+     * @param mixed $base The number that $value is being divided by.
+     *
+     * @return mixed the result of the division
+     */
+    public function div(mixed $value, mixed $base);
+
+    /**
+     * Raise an number to the power of exponent.
+     *
+     * @param mixed $value scalar, the base to use
+     *
+     * @return mixed the value raised to the power of exp.
+     */
+    public function pow(mixed $value, int $exponent);
+
+    /**
+     * Returns the int point remainder (modulo) of the division of the arguments.
+     *
+     * @param mixed $value The dividend
+     * @param mixed $base The divisor
+     *
+     * @return mixed the remainder
+     */
+    public function mod(mixed $value, mixed $base);
+
+    /**
+     * Number comparison.
+     *
+     * @param mixed $value1 the first value
+     * @param mixed $value2 the second value
+     *
+     * @return int Returns < 0 if value1 is less than value2; > 0 if value1 is greater than value2, and 0 if they are equal.
+     */
+    public function compare(mixed $value1, mixed $value2): int;
+
+    /**
+     * Get the decimal integer value of a variable.
+     *
+     * @param mixed $value The scalar value being converted to an integer
+     *
+     * @return mixed the integer value
+     */
+    public function baseConvert(mixed $value, int $base);
+}

vendor/league/uri-interfaces/IPv4/Converter.php

@@ -0,0 +1,303 @@
+<?php
+
+/**
+ * League.Uri (https://uri.thephpleague.com)
+ *
+ * (c) Ignace Nyamagana Butera <nyamsprod@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace League\Uri\IPv4;
+
+use League\Uri\Exceptions\MissingFeature;
+use League\Uri\FeatureDetection;
+use Stringable;
+
+use function array_pop;
+use function count;
+use function explode;
+use function extension_loaded;
+use function ltrim;
+use function preg_match;
+use function str_ends_with;
+use function substr;
+
+use const FILTER_FLAG_IPV4;
+use const FILTER_FLAG_IPV6;
+use const FILTER_VALIDATE_IP;
+
+final class Converter
+{
+    private const REGEXP_IPV4_HOST = '/
+        (?(DEFINE) # . is missing as it is used to separate labels
+            (?<hexadecimal>0x[[:xdigit:]]*)
+            (?<octal>0[0-7]*)
+            (?<decimal>\d+)
+            (?<ipv4_part>(?:(?&hexadecimal)|(?&octal)|(?&decimal))*)
+        )
+        ^(?:(?&ipv4_part)\.){0,3}(?&ipv4_part)\.?$
+    /x';
+    private const REGEXP_IPV4_NUMBER_PER_BASE = [
+        '/^0x(?<number>[[:xdigit:]]*)$/' => 16,
+        '/^0(?<number>[0-7]*)$/' => 8,
+        '/^(?<number>\d+)$/' => 10,
+    ];
+
+    private const IPV6_6TO4_PREFIX = '2002:';
+    private const IPV4_MAPPED_PREFIX = '::ffff:';
+
+    private readonly mixed $maxIPv4Number;
+
+    public function __construct(
+        private readonly Calculator $calculator
+    ) {
+        $this->maxIPv4Number = $calculator->sub($calculator->pow(2, 32), 1);
+    }
+
+    /**
+     * Returns an instance using a GMP calculator.
+     */
+    public static function fromGMP(): self
+    {
+        return new self(new GMPCalculator());
+    }
+
+    /**
+     * Returns an instance using a Bcmath calculator.
+     */
+    public static function fromBCMath(): self
+    {
+        return new self(new BCMathCalculator());
+    }
+
+    /**
+     * Returns an instance using a PHP native calculator (requires 64bits PHP).
+     */
+    public static function fromNative(): self
+    {
+        return new self(new NativeCalculator());
+    }
+
+    /**
+     * Returns an instance using a detected calculator depending on the PHP environment.
+     *
+     * @throws MissingFeature If no Calculator implementing object can be used on the platform
+     *
+     * @codeCoverageIgnore
+     */
+    public static function fromEnvironment(): self
+    {
+        FeatureDetection::supportsIPv4Conversion();
+
+        return match (true) {
+            extension_loaded('gmp') => self::fromGMP(),
+            extension_loaded('bcmath') => self::fromBCMath(),
+            default => self::fromNative(),
+        };
+    }
+
+    public function isIpv4(Stringable|string|null $host): bool
+    {
+        if (null === $host) {
+            return false;
+        }
+
+        if (null !== $this->toDecimal($host)) {
+            return true;
+        }
+
+        $host = (string) $host;
+        if (false === filter_var($host, FILTER_VALIDATE_IP, FILTER_FLAG_IPV6)) {
+            return false;
+        }
+
+        $ipAddress = strtolower((string) inet_ntop((string) inet_pton($host)));
+        if (str_starts_with($ipAddress, self::IPV4_MAPPED_PREFIX)) {
+            return false !== filter_var(substr($ipAddress, 7), FILTER_VALIDATE_IP, FILTER_FLAG_IPV4);
+        }
+
+        if (!str_starts_with($ipAddress, self::IPV6_6TO4_PREFIX)) {
+            return false;
+        }
+
+        $hexParts = explode(':', substr($ipAddress, 5, 9));
+
+        return count($hexParts) > 1
+            && false !== long2ip((int) hexdec($hexParts[0]) * 65536 + (int) hexdec($hexParts[1]));
+    }
+
+    public function toIPv6Using6to4(Stringable|string|null $host): ?string
+    {
+        $host = $this->toDecimal($host);
+        if (null === $host) {
+            return null;
+        }
+
+        /** @var array<string> $parts */
+        $parts = array_map(
+            fn (string $part): string => sprintf('%02x', $part),
+            explode('.', $host)
+        );
+
+        return '['.self::IPV6_6TO4_PREFIX.$parts[0].$parts[1].':'.$parts[2].$parts[3].'::]';
+    }
+
+    public function toIPv6UsingMapping(Stringable|string|null $host): ?string
+    {
+        $host = $this->toDecimal($host);
+        if (null === $host) {
+            return null;
+        }
+
+        return '['.self::IPV4_MAPPED_PREFIX.$host.']';
+    }
+
+    public function toOctal(Stringable|string|null $host): ?string
+    {
+        $host = $this->toDecimal($host);
+
+        return match (null) {
+            $host => null,
+            default => implode('.', array_map(
+                fn ($value) => str_pad(decoct((int) $value), 4, '0', STR_PAD_LEFT),
+                explode('.', $host)
+            )),
+        };
+    }
+
+    public function toHexadecimal(Stringable|string|null $host): ?string
+    {
+        $host = $this->toDecimal($host);
+
+        return match (null) {
+            $host => null,
+            default => '0x'.implode('', array_map(
+                fn ($value) => dechex((int) $value),
+                explode('.', $host)
+            )),
+        };
+    }
+
+    /**
+     * Tries to convert a IPv4 hexadecimal or a IPv4 octal notation into a IPv4 dot-decimal notation if possible
+     * otherwise returns null.
+     *
+     * @see https://url.spec.whatwg.org/#concept-ipv4-parser
+     */
+    public function toDecimal(Stringable|string|null $host): ?string
+    {
+        $host = (string) $host;
+        if (str_starts_with($host, '[') && str_ends_with($host, ']')) {
+            $host = substr($host, 1, -1);
+            if (false === filter_var($host, FILTER_VALIDATE_IP, FILTER_FLAG_IPV6)) {
+                return null;
+            }
+
+            $ipAddress = strtolower((string) inet_ntop((string) inet_pton($host)));
+            if (str_starts_with($ipAddress, self::IPV4_MAPPED_PREFIX)) {
+                return substr($ipAddress, 7);
+            }
+
+            if (!str_starts_with($ipAddress, self::IPV6_6TO4_PREFIX)) {
+                return null;
+            }
+
+            $hexParts = explode(':', substr($ipAddress, 5, 9));
+
+            return (string) match (true) {
+                count($hexParts) < 2 => null,
+                default => long2ip((int) hexdec($hexParts[0]) * 65536 + (int) hexdec($hexParts[1])),
+            };
+        }
+
+        if (1 !== preg_match(self::REGEXP_IPV4_HOST, $host)) {
+            return null;
+        }
+
+        if (str_ends_with($host, '.')) {
+            $host = substr($host, 0, -1);
+        }
+
+        $numbers = [];
+        foreach (explode('.', $host) as $label) {
+            $number = $this->labelToNumber($label);
+            if (null === $number) {
+                return null;
+            }
+
+            $numbers[] = $number;
+        }
+
+        $ipv4 = array_pop($numbers);
+        $max = $this->calculator->pow(256, 6 - count($numbers));
+        if ($this->calculator->compare($ipv4, $max) > 0) {
+            return null;
+        }
+
+        foreach ($numbers as $offset => $number) {
+            if ($this->calculator->compare($number, 255) > 0) {
+                return null;
+            }
+
+            $ipv4 = $this->calculator->add($ipv4, $this->calculator->multiply(
+                $number,
+                $this->calculator->pow(256, 3 - $offset)
+            ));
+        }
+
+        return $this->long2Ip($ipv4);
+    }
+
+    /**
+     * Converts a domain label into a IPv4 integer part.
+     *
+     * @see https://url.spec.whatwg.org/#ipv4-number-parser
+     *
+     * @return mixed returns null if it cannot correctly convert the label
+     */
+    private function labelToNumber(string $label): mixed
+    {
+        foreach (self::REGEXP_IPV4_NUMBER_PER_BASE as $regexp => $base) {
+            if (1 !== preg_match($regexp, $label, $matches)) {
+                continue;
+            }
+
+            $number = ltrim($matches['number'], '0');
+            if ('' === $number) {
+                return 0;
+            }
+
+            $number = $this->calculator->baseConvert($number, $base);
+            if (0 <= $this->calculator->compare($number, 0) && 0 >= $this->calculator->compare($number, $this->maxIPv4Number)) {
+                return $number;
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Generates the dot-decimal notation for IPv4.
+     *
+     * @see https://url.spec.whatwg.org/#concept-ipv4-parser
+     *
+     * @param mixed $ipAddress the number representation of the IPV4address
+     */
+    private function long2Ip(mixed $ipAddress): string
+    {
+        $output = '';
+        for ($offset = 0; $offset < 4; $offset++) {
+            $output = $this->calculator->mod($ipAddress, 256).$output;
+            if ($offset < 3) {
+                $output = '.'.$output;
+            }
+            $ipAddress = $this->calculator->div($ipAddress, 256);
+        }
+
+        return $output;
+    }
+}

vendor/league/uri-interfaces/IPv4/GMPCalculator.php

@@ -0,0 +1,70 @@
+<?php
+
+/**
+ * League.Uri (https://uri.thephpleague.com)
+ *
+ * (c) Ignace Nyamagana Butera <nyamsprod@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace League\Uri\IPv4;
+
+use GMP;
+
+use function gmp_add;
+use function gmp_cmp;
+use function gmp_div_q;
+use function gmp_init;
+use function gmp_mod;
+use function gmp_mul;
+use function gmp_pow;
+use function gmp_sub;
+
+use const GMP_ROUND_MINUSINF;
+
+final class GMPCalculator implements Calculator
+{
+    public function baseConvert(mixed $value, int $base): GMP
+    {
+        return gmp_init($value, $base);
+    }
+
+    public function pow(mixed $value, int $exponent): GMP
+    {
+        return gmp_pow($value, $exponent);
+    }
+
+    public function compare(mixed $value1, mixed $value2): int
+    {
+        return gmp_cmp($value1, $value2);
+    }
+
+    public function multiply(mixed $value1, mixed $value2): GMP
+    {
+        return gmp_mul($value1, $value2);
+    }
+
+    public function div(mixed $value, mixed $base): GMP
+    {
+        return gmp_div_q($value, $base, GMP_ROUND_MINUSINF);
+    }
+
+    public function mod(mixed $value, mixed $base): GMP
+    {
+        return gmp_mod($value, $base);
+    }
+
+    public function add(mixed $value1, mixed $value2): GMP
+    {
+        return gmp_add($value1, $value2);
+    }
+
+    public function sub(mixed $value1, mixed $value2): GMP
+    {
+        return gmp_sub($value1, $value2);
+    }
+}

vendor/league/uri-interfaces/IPv4/NativeCalculator.php

@@ -0,0 +1,60 @@
+<?php
+
+/**
+ * League.Uri (https://uri.thephpleague.com)
+ *
+ * (c) Ignace Nyamagana Butera <nyamsprod@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace League\Uri\IPv4;
+
+use function floor;
+use function intval;
+
+final class NativeCalculator implements Calculator
+{
+    public function baseConvert(mixed $value, int $base): int
+    {
+        return intval((string) $value, $base);
+    }
+
+    public function pow(mixed $value, int $exponent)
+    {
+        return $value ** $exponent;
+    }
+
+    public function compare(mixed $value1, mixed $value2): int
+    {
+        return $value1 <=> $value2;
+    }
+
+    public function multiply(mixed $value1, mixed $value2): int
+    {
+        return $value1 * $value2;
+    }
+
+    public function div(mixed $value, mixed $base): int
+    {
+        return (int) floor($value / $base);
+    }
+
+    public function mod(mixed $value, mixed $base): int
+    {
+        return $value % $base;
+    }
+
+    public function add(mixed $value1, mixed $value2): int
+    {
+        return $value1 + $value2;
+    }
+
+    public function sub(mixed $value1, mixed $value2): int
+    {
+        return $value1 - $value2;
+    }
+}