X-Git-Url: https://git.mxchange.org/?p=core.git;a=blobdiff_plain;f=inc%2Fclasses%2Fmain%2Fclass_BaseFrameworkSystem.php;h=f4d7d6787493e73a85994085cf1010ece226cc56;hp=2e42a794b12018efe454f560730ca1a54d9e6d3a;hb=de4993bdd2170972f3c004bf7473bfd2032c2dda;hpb=9a2de3adcd917b49c9c5fa33095ccbc3a7032e9f diff --git a/inc/classes/main/class_BaseFrameworkSystem.php b/inc/classes/main/class_BaseFrameworkSystem.php index 2e42a794..f4d7d678 100644 --- a/inc/classes/main/class_BaseFrameworkSystem.php +++ b/inc/classes/main/class_BaseFrameworkSystem.php @@ -144,7 +144,7 @@ class BaseFrameworkSystem extends stdClass implements FrameworkInterface { private $helperInstance = NULL; /** - * An instance of a Sourceable class + * An instance of a Source class */ private $sourceInstance = NULL; @@ -213,6 +213,11 @@ class BaseFrameworkSystem extends stdClass implements FrameworkInterface { */ private $listenerInstance = NULL; + /** + * An instance of a communicator + */ + private $communicatorInstance = NULL; + /** * Thousands separator */ @@ -253,6 +258,34 @@ class BaseFrameworkSystem extends stdClass implements FrameworkInterface { */ private $controllerName = ''; + /** + * Array with bitmasks and such for pack/unpack methods to support both + * 32-bit and 64-bit systems + */ + private $packingData = array( + 32 => array( + 'step' => 3, + 'left' => 0xffff0000, + 'right' => 0x0000ffff, + 'factor' => 16, + 'format' => 'II', + ), + 64 => array( + 'step' => 7, + 'left' => 0xffffffff00000000, + 'right' => 0x00000000ffffffff, + 'factor' => 32, + 'format' => 'NN' + ) + ); + + /** + * Simple 64-bit check, thanks to "Salman A" from stackoverflow.com: + * + * The integer size is 4 bytes on 32-bit and 8 bytes on a 64-bit system. + */ + private $archArrayElement = FALSE; + /*********************** * Exception codes.... * ***********************/ @@ -313,9 +346,11 @@ class BaseFrameworkSystem extends stdClass implements FrameworkInterface { const EXCEPTION_FATAL_ERROR = 0x035; const EXCEPTION_FILE_NOT_FOUND = 0x036; const EXCEPTION_ASSERTION_FAILED = 0x037; - const EXCEPTION_FILE_CANNOT_BE_READ = 0x038; - const EXCEPTION_DATABASE_UPDATED_NOT_ALLOWED = 0x039; - const EXCEPTION_FILTER_CHAIN_INTERCEPTED = 0x03a; + const EXCEPTION_FILE_NOT_REACHABLE = 0x038; + const EXCEPTION_FILE_CANNOT_BE_READ = 0x039; + const EXCEPTION_FILE_CANNOT_BE_WRITTEN = 0x03a; + const EXCEPTION_DATABASE_UPDATED_NOT_ALLOWED = 0x03b; + const EXCEPTION_FILTER_CHAIN_INTERCEPTED = 0x03c; /** * Hexadecimal->Decimal translation array @@ -387,6 +422,9 @@ class BaseFrameworkSystem extends stdClass implements FrameworkInterface { // Then set it self::$startupTime = microtime(TRUE); } // END - if + + // Set array element + $this->archArrayElement = (PHP_INT_SIZE === 8 ? 64 : 32); } /** @@ -502,7 +540,7 @@ class BaseFrameworkSystem extends stdClass implements FrameworkInterface { } /** - * Magic function to catch setting of missing but set class fields/attributes + * Magic method to catch setting of missing but set class fields/attributes * * @param $name Name of the field/attribute * @param $value Value to store @@ -517,7 +555,7 @@ class BaseFrameworkSystem extends stdClass implements FrameworkInterface { } /** - * Magic function to catch getting of missing fields/attributes + * Magic method to catch getting of missing fields/attributes * * @param $name Name of the field/attribute * @return void @@ -529,7 +567,7 @@ class BaseFrameworkSystem extends stdClass implements FrameworkInterface { } /** - * Magic function to catch unsetting of missing fields/attributes + * Magic method to catch unsetting of missing fields/attributes * * @param $name Name of the field/attribute * @return void @@ -540,6 +578,36 @@ class BaseFrameworkSystem extends stdClass implements FrameworkInterface { )); } + /** + * Magic method to catch object serialization + * + * @return $unsupported Unsupported method + * @throws UnsupportedOperationException Objects of this framework cannot be serialized + */ + public final function __sleep () { + throw new UnsupportedOperationException(array($this, __FUNCTION__), self::EXCEPTION_UNSPPORTED_OPERATION); + } + + /** + * Magic method to catch object deserialization + * + * @return $unsupported Unsupported method + * @throws UnsupportedOperationException Objects of this framework cannot be serialized + */ + public final function __wakeup () { + throw new UnsupportedOperationException(array($this, __FUNCTION__), self::EXCEPTION_UNSPPORTED_OPERATION); + } + + /** + * Magic method to catch calls when an object instance is called + * + * @return $unsupported Unsupported method + * @throws UnsupportedOperationException Objects of this framework cannot be serialized + */ + public final function __invoke () { + throw new UnsupportedOperationException(array($this, __FUNCTION__), self::EXCEPTION_UNSPPORTED_OPERATION); + } + /** * Setter for the real class name * @@ -1142,19 +1210,19 @@ class BaseFrameworkSystem extends stdClass implements FrameworkInterface { } /** - * Setter for a Sourceable instance + * Setter for a Source instance * - * @param $sourceInstance An instance of a Sourceable class + * @param $sourceInstance An instance of a Source class * @return void */ - protected final function setSourceInstance (Sourceable $sourceInstance) { + protected final function setSourceInstance (Source $sourceInstance) { $this->sourceInstance = $sourceInstance; } /** - * Getter for a Sourceable instance + * Getter for a Source instance * - * @return $sourceInstance An instance of a Sourceable class + * @return $sourceInstance An instance of a Source class */ protected final function getSourceInstance () { return $this->sourceInstance; @@ -1443,6 +1511,25 @@ class BaseFrameworkSystem extends stdClass implements FrameworkInterface { return $this->listenerInstance; } + /** + * Getter for communicator instance + * + * @return $communicatorInstance An instance of a Communicator class + */ + public final function getCommunicatorInstance () { + return $this->communicatorInstance; + } + + /** + * Setter for communicator instance + * + * @param $communicatorInstance An instance of a Communicator class + * @return void + */ + protected final function setCommunicatorInstance (Communicator $communicatorInstance) { + $this->communicatorInstance = $communicatorInstance; + } + /** * Setter for command name * @@ -1948,7 +2035,7 @@ class BaseFrameworkSystem extends stdClass implements FrameworkInterface { */ protected final function getDatabaseEntry () { // Is there an instance? - if (is_null($this->getResultInstance())) { + if (!$this->getResultInstance() instanceof SearchableResult) { // Throw an exception here throw new NullPointerException($this, self::EXCEPTION_IS_NULL_POINTER); } // END - if @@ -3072,6 +3159,123 @@ class BaseFrameworkSystem extends stdClass implements FrameworkInterface { // ... and return it return $translated; } + + /** + * Encodes raw data (almost any type) by "serializing" it and then pack it + * into a "binary format". + * + * @param $rawData Raw data (almost any type) + * @return $encoded Encoded data + */ + protected function encodeData ($rawData) { + // Make sure no objects or resources pass through + assert(!is_object($rawData)); + assert(!is_resource($rawData)); + + // First "serialize" it (json_encode() is faster than serialize()) + $encoded = $this->packString(json_encode($rawData)); + + // And return it + return $encoded; + } + + /** + * Pack a string into a "binary format". Please execuse me that this is + * widely undocumented. :-( + * + * @param $str Unpacked string + * @return $packed Packed string + * @todo Improve documentation + */ + protected function packString ($str) { + // Debug message + //* NOISY-DEBUG */ self::createDebugInstance(__CLASS__)->debugOutput('str=' . $str . ' - CALLED!'); + + // First compress the string (gzcompress is okay) + $str = gzcompress($str); + + // Init variable + $packed = ''; + + // And start the "encoding" loop + for ($idx = 0; $idx < strlen($str); $idx += $this->packingData[$this->archArrayElement]['step']) { + $big = 0; + for ($i = 0; $i < $this->packingData[$this->archArrayElement]['step']; $i++) { + $factor = ($this->packingData[$this->archArrayElement]['step'] - 1 - $i); + + if (($idx + $i) <= strlen($str)) { + $ord = ord(substr($str, ($idx + $i), 1)); + + $add = $ord * pow(256, $factor); + + $big += $add; + + //print 'idx=' . $idx . ',i=' . $i . ',ord=' . $ord . ',factor=' . $factor . ',add=' . $add . ',big=' . $big . PHP_EOL; + } // END - if + } // END - for + + $l = ($big & $this->packingData[$this->archArrayElement]['left']) >>$this->packingData[$this->archArrayElement]['factor']; + $r = $big & $this->packingData[$this->archArrayElement]['right']; + + $chunk = str_pad(pack($this->packingData[$this->archArrayElement]['format'], $l, $r), 8, '0', STR_PAD_LEFT); + //* NOISY-DEBUG */ print 'big=' . $big . ',chunk('.strlen($chunk) . ')='.md5($chunk).PHP_EOL; + + $packed .= $chunk; + } // END - for + + // Return it + //* NOISY-DEBUG */ self::createDebugInstance(__CLASS__)->debugOutput('packed=' . $packed . ' - EXIT!'); + return $packed; + } + + /** + * Checks whether the given file/path is in open_basedir(). This does not + * gurantee that the file is actually readable and/or writeable. If you need + * such gurantee then please use isReadableFile() instead. + * + * @param $filePathName Name of the file/path to be checked + * @return $isReachable Whether it is within open_basedir() + */ + public static function isReachableFilePath ($filePathName) { + // Is not reachable by default + $isReachable = FALSE; + + // Get open_basedir parameter + $openBaseDir = ini_get('open_basedir'); + + // Is it set? + if (!empty($openBaseDir)) { + // Check all entries + foreach (explode(PATH_SEPARATOR, $openBaseDir) as $dir) { + // Check on existence + if (substr($filePathName, 0, strlen($dir)) == $dir) { + // Is reachable + $isReachable = TRUE; + } // END - if + } // END - foreach + } // END - if + + // Return status + return $isReachable; + } + + /** + * Checks whether the give file is within open_basedir() (done by + * isReachableFilePath()), is actually a file and is readable. + * + * @param $fileName Name of the file to be checked + * @return $isReadable Whether the file is readable (and therefor exists) + */ + public static function isReadableFile ($fileName) { + // Default is not readable + $isReadable = FALSE; + + // Is within parameters, so check if it is a file and readable + $isReadable = ((self::isReachableFilePath($fileName)) && (is_file($fileName)) && (is_readable($fileName))); + + // Return status + return $isReadable; + } } // [EOF]