Merge pull request #712 from wallabag/dev1.7.0

1.7, call me "Premium version"

1 files changed, 314 insertions, 0 deletions

diff --git a/inc/3rdparty/libraries/PHPePub/lib.uuid.php b/inc/3rdparty/libraries/PHPePub/lib.uuid.php
new file mode 100644
index 00000000..c6a8de52
--- /dev/null
+++ b/inc/3rdparty/libraries/PHPePub/lib.uuid.php
@@ -0,0 +1,314 @@
+<?php
+/*
+ DrUUID RFC4122 library for PHP5
+by J. King (http://jkingweb.ca/)
+Licensed under MIT license
+
+See http://jkingweb.ca/code/php/lib.uuid/
+for documentation
+
+Last revised 2010-02-15
+*/
+
+/*
+ Copyright (c) 2009 J. King
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+
+class UUID {
+        const MD5  = 3;
+        const SHA1 = 5;
+        const clearVer = 15;  // 00001111  Clears all bits of version byte with AND
+        const clearVar = 63;  // 00111111  Clears all relevant bits of variant byte with AND
+        const varRes   = 224; // 11100000  Variant reserved for future use
+        const varMS    = 192; // 11000000  Microsft GUID variant
+        const varRFC   = 128; // 10000000  The RFC 4122 variant (this variant)
+        const varNCS   = 0;   // 00000000  The NCS compatibility variant
+        const version1 = 16;  // 00010000
+        const version3 = 48;  // 00110000
+        const version4 = 64;  // 01000000
+        const version5 = 80;  // 01010000
+        const interval = 0x01b21dd213814000; // Time (in 100ns steps) between the start of the UTC and Unix epochs
+        const nsDNS  = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
+        const nsURL  = '6ba7b811-9dad-11d1-80b4-00c04fd430c8';
+        const nsOID  = '6ba7b812-9dad-11d1-80b4-00c04fd430c8';
+        const nsX500 = '6ba7b814-9dad-11d1-80b4-00c04fd430c8';
+        protected static $randomFunc = 'randomTwister';
+        protected static $randomSource = NULL;
+        //instance properties
+        protected $bytes;
+        protected $hex;
+        protected $string;
+        protected $urn;
+        protected $version;
+        protected $variant;
+        protected $node;
+        protected $time;
+
+        public static function mint($ver = 1, $node = NULL, $ns = NULL) {
+                /* Create a new UUID based on provided data. */
+                switch((int) $ver) {
+                        case 1:
+                                return new self(self::mintTime($node));
+                        case 2:
+                                // Version 2 is not supported
+                                throw new UUIDException("Version 2 is unsupported.");
+                        case 3:
+                                return new self(self::mintName(self::MD5, $node, $ns));
+                        case 4:
+                                return new self(self::mintRand());
+                        case 5:
+                                return new self(self::mintName(self::SHA1, $node, $ns));
+                        default:
+                                throw new UUIDException("Selected version is invalid or unsupported.");
+                }
+        }
+
+        public static function import($uuid) {
+                /* Import an existing UUID. */
+                return new self(self::makeBin($uuid, 16));
+        }
+
+        public static function compare($a, $b) {
+                /* Compares the binary representations of two UUIDs.
+                 The comparison will return true if they are bit-exact,
+                or if neither is valid. */
+                if (self::makeBin($a, 16)==self::makeBin($b, 16)) {
+                        return TRUE;
+                } else {
+                        return FALSE;
+                }
+        }
+
+        public function __toString() {
+                return $this->string;
+        }
+
+        public function __get($var) {
+                switch($var) {
+                        case "bytes":
+                                return $this->bytes;
+                        case "hex":
+                                return bin2hex($this->bytes);
+                        case "string":
+                                return $this->__toString();
+                        case "urn":
+                                return "urn:uuid:".$this->__toString();
+                        case "version":
+                                return ord($this->bytes[6]) >> 4;
+                        case "variant":
+                                $byte = ord($this->bytes[8]);
+                                if ($byte >= self::varRes) {
+                                        return 3;
+                                }
+                                if ($byte >= self::varMS) {
+                                        return 2;
+                                }
+                                if ($byte >= self::varRFC) {
+                                        return 1;
+                                }
+                                return 0;
+                        case "node":
+                                if (ord($this->bytes[6])>>4==1) {
+                                        return bin2hex(substr($this->bytes,10));
+                                } else {
+                                        return NULL;
+                                }
+                        case "time":
+                                if (ord($this->bytes[6])>>4==1) {
+                                        // Restore contiguous big-endian byte order
+                                        $time = bin2hex($this->bytes[6].$this->bytes[7].$this->bytes[4].$this->bytes[5].$this->bytes[0].$this->bytes[1].$this->bytes[2].$this->bytes[3]);
+                                        // Clear version flag
+                                        $time[0] = "0";
+                                        // Do some reverse arithmetic to get a Unix timestamp
+                                        $time = (hexdec($time) - self::interval) / 10000000;
+                                        return $time;
+                                } else {
+                                        return NULL;
+                                }
+                        default:
+                                return NULL;
+                }
+        }
+
+        protected function __construct($uuid) {
+                if (strlen($uuid) != 16) {
+                        throw new UUIDException("Input must be a 128-bit integer.");
+                }
+                $this->bytes  = $uuid;
+                // Optimize the most common use
+                $this->string =
+                bin2hex(substr($uuid,0,4))."-".
+                bin2hex(substr($uuid,4,2))."-".
+                bin2hex(substr($uuid,6,2))."-".
+                bin2hex(substr($uuid,8,2))."-".
+                bin2hex(substr($uuid,10,6));
+        }
+
+        protected static function mintTime($node = NULL) {
+                /* Generates a Version 1 UUID.
+                 These are derived from the time at which they were generated. */
+                // Get time since Gregorian calendar reform in 100ns intervals
+                // This is exceedingly difficult because of PHP's (and pack()'s)
+                //  integer size limits.
+                // Note that this will never be more accurate than to the microsecond.
+                $time = microtime(1) * 10000000 + self::interval;
+                // Convert to a string representation
+                $time = sprintf("%F", $time);
+                preg_match("/^\d+/", $time, $time); //strip decimal point
+                // And now to a 64-bit binary representation
+                $time = base_convert($time[0], 10, 16);
+                $time = pack("H*", str_pad($time, 16, "0", STR_PAD_LEFT));
+                // Reorder bytes to their proper locations in the UUID
+                $uuid  = $time[4].$time[5].$time[6].$time[7].$time[2].$time[3].$time[0].$time[1];
+                // Generate a random clock sequence
+                $uuid .= self::randomBytes(2);
+                // set variant
+                $uuid[8] = chr(ord($uuid[8]) & self::clearVar | self::varRFC);
+                // set version
+                $uuid[6] = chr(ord($uuid[6]) & self::clearVer | self::version1);
+                // Set the final 'node' parameter, a MAC address
+                if ($node) {
+                        $node = self::makeBin($node, 6);
+                }
+                if (!$node) {
+                        // If no node was provided or if the node was invalid,
+                        //  generate a random MAC address and set the multicast bit
+                        $node = self::randomBytes(6);
+                        $node[0] = pack("C", ord($node[0]) | 1);
+                }
+                $uuid .= $node;
+                return $uuid;
+        }
+
+        protected static function mintRand() {
+                /* Generate a Version 4 UUID.
+                 These are derived soly from random numbers. */
+                // generate random fields
+                $uuid = self::randomBytes(16);
+                // set variant
+                $uuid[8] = chr(ord($uuid[8]) & self::clearVar | self::varRFC);
+                // set version
+                $uuid[6] = chr(ord($uuid[6]) & self::clearVer | self::version4);
+                return $uuid;
+        }
+
+        protected static function mintName($ver, $node, $ns) {
+                /* Generates a Version 3 or Version 5 UUID.
+                 These are derived from a hash of a name and its namespace, in binary form. */
+                if (!$node) {
+                        throw new UUIDException("A name-string is required for Version 3 or 5 UUIDs.");
+                }
+                // if the namespace UUID isn't binary, make it so
+                $ns = self::makeBin($ns, 16);
+                if (!$ns) {
+                        throw new UUIDException("A binary namespace is required for Version 3 or 5 UUIDs.");
+                }
+                $uuid = null;
+                $version =  self::version3;
+                switch($ver) {
+                        case self::MD5:
+                                $version = self::version3;
+                                $uuid = md5($ns.$node,1);
+                                break;
+                        case self::SHA1:
+                                $version = self::version5;
+                                $uuid = substr(sha1($ns.$node,1),0, 16);
+                                break;
+                }
+                // set variant
+                $uuid[8] = chr(ord($uuid[8]) & self::clearVar | self::varRFC);
+                // set version
+                $uuid[6] = chr(ord($uuid[6]) & self::clearVer | $version);
+                return ($uuid);
+        }
+
+        protected static function makeBin($str, $len) {
+                /* Insure that an input string is either binary or hexadecimal.
+                 Returns binary representation, or false on failure. */
+                if ($str instanceof self) {
+                        return $str->bytes;
+                }
+                if (strlen($str)==$len) {
+                        return $str;
+                } else {
+                        $str = preg_replace("/^urn:uuid:/is", "", $str); // strip URN scheme and namespace
+                }
+                $str = preg_replace("/[^a-f0-9]/is", "", $str);  // strip non-hex characters
+                if (strlen($str) != ($len * 2)) {
+                        return FALSE;
+                } else {
+                        return pack("H*", $str);
+                }
+        }
+
+        public static function initRandom() {
+                /* Look for a system-provided source of randomness, which is usually crytographically secure.
+                 /dev/urandom is tried first simply out of bias for Linux systems. */
+                if (is_readable('/dev/urandom')) {
+                        self::$randomSource = fopen('/dev/urandom', 'rb');
+                        self::$randomFunc = 'randomFRead';
+                }
+                else if (class_exists('COM', 0)) {
+                        try {
+                                self::$randomSource = new COM('CAPICOM.Utilities.1');  // See http://msdn.microsoft.com/en-us/library/aa388182(VS.85).aspx
+                                self::$randomFunc = 'randomCOM';
+                        }
+                        catch(Exception $e) {
+                        }
+                }
+                return self::$randomFunc;
+        }
+
+        public static function randomBytes($bytes) {
+                return call_user_func(array('self', self::$randomFunc), $bytes);
+        }
+
+        protected static function randomTwister($bytes) {
+                /* Get the specified number of random bytes, using mt_rand().
+                 Randomness is returned as a string of bytes. */
+                $rand = "";
+                for ($a = 0; $a < $bytes; $a++) {
+                        $rand .= chr(mt_rand(0, 255));
+                }
+                return $rand;
+        }
+
+        protected static function randomFRead($bytes) {
+                /* Get the specified number of random bytes using a file handle
+                 previously opened with UUID::initRandom().
+                Randomness is returned as a string of bytes. */
+                return fread(self::$randomSource, $bytes);
+        }
+
+        protected static function randomCOM($bytes) {
+                /* Get the specified number of random bytes using Windows'
+                 randomness source via a COM object previously created by UUID::initRandom().
+                Randomness is returned as a string of bytes. */
+                return base64_decode(self::$randomSource->GetRandom($bytes,0)); // straight binary mysteriously doesn't work, hence the base64
+        }
+}
+
+class UUIDException extends Exception {
+}