Subversion-Projekte lars-tiefland.laravel_shop

<?php

/*

 * This file is part of the Symfony package.

 *

 * (c) Fabien Potencier <fabien@symfony.com>

 *

 * For the full copyright and license information, please view the LICENSE

 * file that was distributed with this source code.

 */

namespace Symfony\Polyfill\Uuid;

/**

 * @internal

 *

 * @author Grégoire Pineau <lyrixx@lyrixx.info>

 */

final class Uuid

{

    public const UUID_VARIANT_NCS = 0;

    public const UUID_VARIANT_DCE = 1;

    public const UUID_VARIANT_MICROSOFT = 2;

    public const UUID_VARIANT_OTHER = 3;

    public const UUID_TYPE_DEFAULT = 0;

    public const UUID_TYPE_TIME = 1;

    public const UUID_TYPE_MD5 = 3;

    public const UUID_TYPE_DCE = 4; // Deprecated alias

    public const UUID_TYPE_NAME = 1; // Deprecated alias

    public const UUID_TYPE_RANDOM = 4;

    public const UUID_TYPE_SHA1 = 5;

    public const UUID_TYPE_NULL = -1;

    public const UUID_TYPE_INVALID = -42;

    // https://tools.ietf.org/html/rfc4122#section-4.1.4

    // 0x01b21dd213814000 is the number of 100-ns intervals between the

    // UUID epoch 1582-10-15 00:00:00 and the Unix epoch 1970-01-01 00:00:00.

    public const TIME_OFFSET_INT = 0x01B21DD213814000;

    public const TIME_OFFSET_BIN = "\x01\xb2\x1d\xd2\x13\x81\x40\x00";

    public const TIME_OFFSET_COM = "\xfe\x4d\xe2\x2d\xec\x7e\xc0\x00";

    public static function uuid_create($uuid_type = \UUID_TYPE_DEFAULT)

    {

        if (!is_numeric($uuid_type) && null !== $uuid_type) {

            trigger_error(sprintf('uuid_create() expects parameter 1 to be int, %s given', \gettype($uuid_type)), \E_USER_WARNING);

            return null;

        }

        switch ((int) $uuid_type) {

            case self::UUID_TYPE_NAME:

            case self::UUID_TYPE_TIME:

                return self::uuid_generate_time();

            case self::UUID_TYPE_DCE:

            case self::UUID_TYPE_RANDOM:

            case self::UUID_TYPE_DEFAULT:

                return self::uuid_generate_random();

            default:

                trigger_error(sprintf("Unknown/invalid UUID type '%d' requested, using default type instead", $uuid_type), \E_USER_WARNING);

                return self::uuid_generate_random();

        }

    }

    public static function uuid_generate_md5($uuid_ns, $name)

    {

        if (!\is_string($uuid_ns = self::toString($uuid_ns))) {

            trigger_error(sprintf('uuid_generate_md5() expects parameter 1 to be string, %s given', \gettype($uuid_ns)), \E_USER_WARNING);

            return null;

        }

        if (!\is_string($name = self::toString($name))) {

            trigger_error(sprintf('uuid_generate_md5() expects parameter 2 to be string, %s given', \gettype($name)), \E_USER_WARNING);

            return null;

        }

        if (!self::isValid($uuid_ns)) {

            if (80000 > \PHP_VERSION_ID) {

                return false;

            }

            throw new \ValueError('uuid_generate_md5(): Argument #1 ($uuid_ns) UUID expected');

        }

        $hash = md5(hex2bin(str_replace('-', '', $uuid_ns)).$name);

        return sprintf('%08s-%04s-3%03s-%04x-%012s',

            // 32 bits for "time_low"

            substr($hash, 0, 8),

            // 16 bits for "time_mid"

            substr($hash, 8, 4),

            // 16 bits for "time_hi_and_version",

            // four most significant bits holds version number 3

            substr($hash, 13, 3),

            // 16 bits:

            // * 8 bits for "clk_seq_hi_res",

            // * 8 bits for "clk_seq_low",

            hexdec(substr($hash, 16, 4)) & 0x3FFF | 0x8000,

            // 48 bits for "node"

            substr($hash, 20, 12)

        );

    }

    public static function uuid_generate_sha1($uuid_ns, $name)

    {

        if (!\is_string($uuid_ns = self::toString($uuid_ns))) {

            trigger_error(sprintf('uuid_generate_sha1() expects parameter 1 to be string, %s given', \gettype($uuid_ns)), \E_USER_WARNING);

            return null;

        }

        if (!\is_string($name = self::toString($name))) {

            trigger_error(sprintf('uuid_generate_sha1() expects parameter 2 to be string, %s given', \gettype($name)), \E_USER_WARNING);

            return null;

        }

        if (!self::isValid($uuid_ns)) {

            if (80000 > \PHP_VERSION_ID) {

                return false;

            }

            throw new \ValueError('uuid_generate_sha1(): Argument #1 ($uuid_ns) UUID expected');

        }

        $hash = sha1(hex2bin(str_replace('-', '', $uuid_ns)).$name);

        return sprintf('%08s-%04s-5%03s-%04x-%012s',

            // 32 bits for "time_low"

            substr($hash, 0, 8),

            // 16 bits for "time_mid"

            substr($hash, 8, 4),

            // 16 bits for "time_hi_and_version",

            // four most significant bits holds version number 5

            substr($hash, 13, 3),

            // 16 bits:

            // * 8 bits for "clk_seq_hi_res",

            // * 8 bits for "clk_seq_low",

            // WARNING: On old libuuid version, there is a bug. 0x0fff is used instead of 0x3fff

            // See https://github.com/karelzak/util-linux/commit/d6ddf07d31dfdc894eb8e7e6842aa856342c526e

            hexdec(substr($hash, 16, 4)) & 0x3FFF | 0x8000,

            // 48 bits for "node"

            substr($hash, 20, 12)

        );

    }

    public static function uuid_is_valid($uuid)

    {

        if (!\is_string($uuid = self::toString($uuid))) {

            trigger_error(sprintf('uuid_is_valid() expects parameter 1 to be string, %s given', \gettype($uuid)), \E_USER_WARNING);

            return null;

        }

        return self::isValid($uuid);

    }

    public static function uuid_compare($uuid1, $uuid2)

    {

        if (!\is_string($uuid1 = self::toString($uuid1))) {

            trigger_error(sprintf('uuid_compare() expects parameter 1 to be string, %s given', \gettype($uuid1)), \E_USER_WARNING);

            return null;

        }

        if (!\is_string($uuid2 = self::toString($uuid2))) {

            trigger_error(sprintf('uuid_compare() expects parameter 2 to be string, %s given', \gettype($uuid2)), \E_USER_WARNING);

            return null;

        }

        if (!self::isValid($uuid1)) {

            if (80000 > \PHP_VERSION_ID) {

                return false;

            }

            throw new \ValueError('uuid_compare(): Argument #1 ($uuid1) UUID expected');

        }

        if (!self::isValid($uuid2)) {

            if (80000 > \PHP_VERSION_ID) {

                return false;

            }

            throw new \ValueError('uuid_compare(): Argument #2 ($uuid2) UUID expected');

        }

        return strcasecmp($uuid1, $uuid2);

    }

    public static function uuid_is_null($uuid)

    {

        if (!\is_string($uuid = self::toString($uuid))) {

            trigger_error(sprintf('uuid_is_null() expects parameter 1 to be string, %s given', \gettype($uuid)), \E_USER_WARNING);

            return null;

        }

        if (80000 <= \PHP_VERSION_ID && !self::isValid($uuid)) {

            throw new \ValueError('uuid_is_null(): Argument #1 ($uuid) UUID expected');

        }

        return '00000000-0000-0000-0000-000000000000' === $uuid;

    }

    public static function uuid_type($uuid)

    {

        if (!\is_string($uuid = self::toString($uuid))) {

            trigger_error(sprintf('uuid_type() expects parameter 1 to be string, %s given', \gettype($uuid)), \E_USER_WARNING);

            return null;

        }

        if ('00000000-0000-0000-0000-000000000000' === $uuid) {

            return self::UUID_TYPE_NULL;

        }

        if (null === $parsed = self::parse($uuid)) {

            if (80000 > \PHP_VERSION_ID) {

                return false;

            }

            throw new \ValueError('uuid_type(): Argument #1 ($uuid) UUID expected');

        }

        return $parsed['version'];

    }

    public static function uuid_variant($uuid)

    {

        if (!\is_string($uuid = self::toString($uuid))) {

            trigger_error(sprintf('uuid_variant() expects parameter 1 to be string, %s given', \gettype($uuid)), \E_USER_WARNING);

            return null;

        }

        if ('00000000-0000-0000-0000-000000000000' === $uuid) {

            return self::UUID_TYPE_NULL;

        }

        if (null === $parsed = self::parse($uuid)) {

            if (80000 > \PHP_VERSION_ID) {

                return false;

            }

            throw new \ValueError('uuid_variant(): Argument #1 ($uuid) UUID expected');

        }

        if (($parsed['clock_seq'] & 0x8000) === 0) {

            return self::UUID_VARIANT_NCS;

        }

        if (($parsed['clock_seq'] & 0x4000) === 0) {

            return self::UUID_VARIANT_DCE;

        }

        if (($parsed['clock_seq'] & 0x2000) === 0) {

            return self::UUID_VARIANT_MICROSOFT;

        }

        return self::UUID_VARIANT_OTHER;

    }

    public static function uuid_time($uuid)

    {

        if (!\is_string($uuid = self::toString($uuid))) {

            trigger_error(sprintf('uuid_time() expects parameter 1 to be string, %s given', \gettype($uuid)), \E_USER_WARNING);

            return null;

        }

        $parsed = self::parse($uuid);

        if (self::UUID_TYPE_TIME !== ($parsed['version'] ?? null)) {

            if (80000 > \PHP_VERSION_ID) {

                return false;

            }

            throw new \ValueError('uuid_time(): Argument #1 ($uuid) UUID DCE TIME expected');

        }

        if (\PHP_INT_SIZE >= 8) {

            return intdiv(hexdec($parsed['time']) - self::TIME_OFFSET_INT, 10000000);

        }

        $time = str_pad(hex2bin($parsed['time']), 8, "\0", \STR_PAD_LEFT);

        $time = self::binaryAdd($time, self::TIME_OFFSET_COM);

        $time[0] = $time[0] & "\x7F";

        return (int) substr(self::toDecimal($time), 0, -7);

    }

    public static function uuid_mac($uuid)

    {

        if (!\is_string($uuid = self::toString($uuid))) {

            trigger_error(sprintf('uuid_mac() expects parameter 1 to be string, %s given', \gettype($uuid)), \E_USER_WARNING);

            return null;

        }

        $parsed = self::parse($uuid);

        if (self::UUID_TYPE_TIME !== ($parsed['version'] ?? null)) {

            if (80000 > \PHP_VERSION_ID) {

                return false;

            }

            throw new \ValueError('uuid_mac(): Argument #1 ($uuid) UUID DCE TIME expected');

        }

        return strtr($parsed['node'], 'ABCDEF', 'abcdef');

    }

    public static function uuid_parse($uuid)

    {

        if (!\is_string($uuid = self::toString($uuid))) {

            trigger_error(sprintf('uuid_parse() expects parameter 1 to be string, %s given', \gettype($uuid)), \E_USER_WARNING);

            return null;

        }

        if (!self::isValid($uuid)) {

            if (80000 > \PHP_VERSION_ID) {

                return false;

            }

            throw new \ValueError('uuid_parse(): Argument #1 ($uuid) UUID expected');

        }

        return hex2bin(str_replace('-', '', $uuid));

    }

    public static function uuid_unparse($bytes)

    {

        if (!\is_string($bytes = self::toString($bytes))) {

            trigger_error(sprintf('uuid_unparse() expects parameter 1 to be string, %s given', \gettype($bytes)), \E_USER_WARNING);

            return null;

        }

        if (16 !== \strlen($bytes)) {

            if (80000 > \PHP_VERSION_ID) {

                return false;

            }

            throw new \ValueError('uuid_unparse(): Argument #1 ($uuid) UUID expected');

        }

        $uuid = bin2hex($bytes);

        $uuid = substr_replace($uuid, '-', 8, 0);

        $uuid = substr_replace($uuid, '-', 13, 0);

        $uuid = substr_replace($uuid, '-', 18, 0);

        return substr_replace($uuid, '-', 23, 0);

    }

    private static function uuid_generate_random()

    {

        $uuid = bin2hex(random_bytes(16));

        return sprintf('%08s-%04s-4%03s-%04x-%012s',

            // 32 bits for "time_low"

            substr($uuid, 0, 8),

            // 16 bits for "time_mid"

            substr($uuid, 8, 4),

            // 16 bits for "time_hi_and_version",

            // four most significant bits holds version number 4

            substr($uuid, 13, 3),

            // 16 bits:

            // * 8 bits for "clk_seq_hi_res",

            // * 8 bits for "clk_seq_low",

            // two most significant bits holds zero and one for variant DCE1.1

            hexdec(substr($uuid, 16, 4)) & 0x3FFF | 0x8000,

            // 48 bits for "node"

            substr($uuid, 20, 12)

        );

    }

    /**

     * @see http://tools.ietf.org/html/rfc4122#section-4.2.2

     */

    private static function uuid_generate_time()

    {

        $time = microtime(false);

        $time = substr($time, 11).substr($time, 2, 7);

        if (\PHP_INT_SIZE >= 8) {

            $time = str_pad(dechex($time + self::TIME_OFFSET_INT), 16, '0', \STR_PAD_LEFT);

        } else {

            $time = str_pad(self::toBinary($time), 8, "\0", \STR_PAD_LEFT);

            $time = self::binaryAdd($time, self::TIME_OFFSET_BIN);

            $time = bin2hex($time);

        }

        // https://tools.ietf.org/html/rfc4122#section-4.1.5

        // We are using a random data for the sake of simplicity: since we are

        // not able to get a super precise timeOfDay as a unique sequence

        $clockSeq = random_int(0, 0x3FFF);

        static $node;

        if (null === $node) {

            if (\function_exists('apcu_fetch')) {

                $node = apcu_fetch('__symfony_uuid_node');

                if (false === $node) {

                    $node = sprintf('%06x%06x',

                        random_int(0, 0xFFFFFF) | 0x010000,

                        random_int(0, 0xFFFFFF)

                    );

                    apcu_store('__symfony_uuid_node', $node);

                }

            } else {

                $node = sprintf('%06x%06x',

                    random_int(0, 0xFFFFFF) | 0x010000,

                    random_int(0, 0xFFFFFF)

                );

            }

        }

        return sprintf('%08s-%04s-1%03s-%04x-%012s',

            // 32 bits for "time_low"

            substr($time, -8),

            // 16 bits for "time_mid"

            substr($time, -12, 4),

            // 16 bits for "time_hi_and_version",

            // four most significant bits holds version number 1

            substr($time, -15, 3),

            // 16 bits:

            // * 8 bits for "clk_seq_hi_res",

            // * 8 bits for "clk_seq_low",

            // two most significant bits holds zero and one for variant DCE1.1

            $clockSeq | 0x8000,

            // 48 bits for "node"

            $node

        );

    }

    private static function isValid($uuid)

    {

        return (bool) preg_match('{^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$}Di', $uuid);

    }

    private static function parse($uuid)

    {

        if (!preg_match('{^(?<time_low>[0-9a-f]{8})-(?<time_mid>[0-9a-f]{4})-(?<version>[0-9a-f])(?<time_hi>[0-9a-f]{3})-(?<clock_seq>[0-9a-f]{4})-(?<node>[0-9a-f]{12})$}Di', $uuid, $matches)) {

            return null;

        }

        return [

            'time' => '0'.$matches['time_hi'].$matches['time_mid'].$matches['time_low'],

            'version' => hexdec($matches['version']),

            'clock_seq' => hexdec($matches['clock_seq']),

            'node' => $matches['node'],

        ];

    }

    private static function toString($v)

    {

        if (\is_string($v) || null === $v || (\is_object($v) ? method_exists($v, '__toString') : \is_scalar($v))) {

            return (string) $v;

        }

        return $v;

    }

    private static function toBinary($digits)

    {

        $bytes = '';

        $count = \strlen($digits);

        while ($count) {

            $quotient = [];

            $remainder = 0;

            for ($i = 0; $i !== $count; ++$i) {

                $carry = $digits[$i] + $remainder * 10;

                $digit = $carry >> 8;

                $remainder = $carry & 0xFF;

                if ($digit || $quotient) {

                    $quotient[] = $digit;

                }

            }

            $bytes = \chr($remainder).$bytes;

            $count = \count($digits = $quotient);

        }

        return $bytes;

    }

    private static function toDecimal($bytes)

    {

        $digits = '';

        $bytes = array_values(unpack('C*', $bytes));

        while ($count = \count($bytes)) {

            $quotient = [];

            $remainder = 0;

            for ($i = 0; $i !== $count; ++$i) {

                $carry = $bytes[$i] + ($remainder << 8);

                $digit = (int) ($carry / 10);

                $remainder = $carry % 10;

                if ($digit || $quotient) {

                    $quotient[] = $digit;

                }

            }

            $digits = $remainder.$digits;

            $bytes = $quotient;

        }

        return $digits;

    }

    private static function binaryAdd($a, $b)

    {

        $sum = 0;

        for ($i = 7; 0 <= $i; --$i) {

            $sum += \ord($a[$i]) + \ord($b[$i]);

            $a[$i] = \chr($sum & 0xFF);

            $sum >>= 8;

        }

        return $a;

    }

}