AnonymousFox

//home/yknvptog/president-studio.com/libraries/src/Cache/Cache.php

<?php

/**
 * Joomla! Content Management System
 *
 * @copyright  (C) 2005 Open Source Matters, Inc. <https://www.joomla.org>
 * @license    GNU General Public License version 2 or later; see LICENSE.txt
 */

namespace Joomla\CMS\Cache;

use Joomla\Application\Web\WebClient;
use Joomla\CMS\Cache\Exception\CacheExceptionInterface;
use Joomla\CMS\Factory;
use Joomla\CMS\Filesystem\Path;
use Joomla\CMS\Session\Session;

// phpcs:disable PSR1.Files.SideEffects
\defined('_JEXEC') or die;
// phpcs:enable PSR1.Files.SideEffects

/**
 * Joomla! Cache base object
 *
 * @since  1.7.0
 */
class Cache
{
    /**
     * Storage handler
     *
     * @var    CacheStorage[]
     * @since  1.7.0
     */
    public static $_handler = [];

/**
     * Cache options
     *
     * @var    array
     * @since  1.7.0
     */
    public $_options;

/**
     * Constructor
     *
     * @param   array  $options  Cache options
     *
     * @since   1.7.0
     */
    public function __construct($options)
    {
        $app = Factory::getApplication();

$this->_options = [
            'cachebase'    => $app->get('cache_path', JPATH_CACHE),
            'lifetime'     => (int) $app->get('cachetime'),
            'language'     => $app->get('language', 'en-GB'),
            'storage'      => $app->get('cache_handler', ''),
            'defaultgroup' => 'default',
            'locking'      => true,
            'locktime'     => 15,
            'checkTime'    => true,
            'caching'      => ($app->get('caching') >= 1),
        ];

// Overwrite default options with given options
        foreach ($options as $option => $value) {
            if (isset($options[$option]) && $options[$option] !== '') {
                $this->_options[$option] = $options[$option];
            }
        }

if (empty($this->_options['storage'])) {
            $this->setCaching(false);
        }
    }

/**
     * Returns a reference to a cache adapter object, always creating it
     *
     * @param   string  $type     The cache object type to instantiate
     * @param   array   $options  The array of options
     *
     * @return  CacheController
     *
     * @since       1.7.0
     *
     * @deprecated  4.2 will be removed in 6.0
     *              Use the cache controller factory instead
     *              Example: Factory::getContainer()->get(CacheControllerFactoryInterface::class)->createCacheController($type, $options);
     */
    public static function getInstance($type = 'output', $options = [])
    {
        @trigger_error(
            sprintf(
                '%s() is deprecated. The cache controller should be fetched from the factory.',
                __METHOD__
            ),
            E_USER_DEPRECATED
        );

return Factory::getContainer()->get(CacheControllerFactoryInterface::class)->createCacheController($type, $options);
    }

/**
     * Get the storage handlers
     *
     * @return  array
     *
     * @since   1.7.0
     */
    public static function getStores()
    {
        $handlers = [];

// Get an iterator and loop through the driver classes.
        $iterator = new \DirectoryIterator(__DIR__ . '/Storage');

/** @type  $file  \DirectoryIterator */
        foreach ($iterator as $file) {
            $fileName = $file->getFilename();

// Only load for php files.
            if (!$file->isFile() || $file->getExtension() !== 'php' || $fileName === 'CacheStorageHelper.php') {
                continue;
            }

// Derive the class name from the type.
            $class = str_ireplace('.php', '', __NAMESPACE__ . '\\Storage\\' . ucfirst(trim($fileName)));

// If the class doesn't exist we have nothing left to do but look at the next type. We did our best.
            if (!class_exists($class)) {
                continue;
            }

// Sweet!  Our class exists, so now we just need to know if it passes its test method.
            if ($class::isSupported()) {
                // Connector names should not have file extensions.
                $handler    = str_ireplace('Storage.php', '', $fileName);
                $handler    = str_ireplace('.php', '', $handler);
                $handlers[] = strtolower($handler);
            }
        }

return $handlers;
    }

/**
     * Set caching enabled state
     *
     * @param   boolean  $enabled  True to enable caching
     *
     * @return  void
     *
     * @since   1.7.0
     */
    public function setCaching($enabled)
    {
        $this->_options['caching'] = $enabled;
    }

/**
     * Get caching state
     *
     * @return  boolean
     *
     * @since   1.7.0
     */
    public function getCaching()
    {
        return $this->_options['caching'];
    }

/**
     * Set cache lifetime
     *
     * @param   integer  $lt  Cache lifetime in minutes
     *
     * @return  void
     *
     * @since   1.7.0
     */
    public function setLifeTime($lt)
    {
        $this->_options['lifetime'] = $lt;
    }

/**
     * Check if the cache contains data stored by ID and group
     *
     * @param   string  $id     The cache data ID
     * @param   string  $group  The cache data group
     *
     * @return  boolean
     *
     * @since   3.7.0
     */
    public function contains($id, $group = null)
    {
        if (!$this->getCaching()) {
            return false;
        }

// Get the default group
        $group = $group ?: $this->_options['defaultgroup'];

return $this->_getStorage()->contains($id, $group);
    }

/**
     * Get cached data by ID and group
     *
     * @param   string  $id     The cache data ID
     * @param   string  $group  The cache data group
     *
     * @return  mixed  Boolean false on failure or a cached data object
     *
     * @since   1.7.0
     */
    public function get($id, $group = null)
    {
        if (!$this->getCaching()) {
            return false;
        }

// Get the default group
        $group = $group ?: $this->_options['defaultgroup'];

return $this->_getStorage()->get($id, $group, $this->_options['checkTime']);
    }

/**
     * Get a list of all cached data
     *
     * @return  mixed  Boolean false on failure or an object with a list of cache groups and data
     *
     * @since   1.7.0
     */
    public function getAll()
    {
        if (!$this->getCaching()) {
            return false;
        }

return $this->_getStorage()->getAll();
    }

/**
     * Store the cached data by ID and group
     *
     * @param   mixed   $data   The data to store
     * @param   string  $id     The cache data ID
     * @param   string  $group  The cache data group
     *
     * @return  boolean
     *
     * @since   1.7.0
     */
    public function store($data, $id, $group = null)
    {
        if (!$this->getCaching()) {
            return false;
        }

// Get the default group
        $group = $group ?: $this->_options['defaultgroup'];

// Get the storage and store the cached data
        return $this->_getStorage()->store($id, $group, $data);
    }

/**
     * Remove a cached data entry by ID and group
     *
     * @param   string  $id     The cache data ID
     * @param   string  $group  The cache data group
     *
     * @return  boolean
     *
     * @since   1.7.0
     */
    public function remove($id, $group = null)
    {
        // Get the default group
        $group = $group ?: $this->_options['defaultgroup'];

try {
            return $this->_getStorage()->remove($id, $group);
        } catch (CacheExceptionInterface $e) {
            if (!$this->getCaching()) {
                return false;
            }

throw $e;
        }
    }

/**
     * Clean cache for a group given a mode.
     *
     * group mode    : cleans all cache in the group
     * notgroup mode : cleans all cache not in the group
     *
     * @param   string  $group  The cache data group
     * @param   string  $mode   The mode for cleaning cache [group|notgroup]
     *
     * @return  boolean  True on success, false otherwise
     *
     * @since   1.7.0
     */
    public function clean($group = null, $mode = 'group')
    {
        // Get the default group
        $group = $group ?: $this->_options['defaultgroup'];

try {
            return $this->_getStorage()->clean($group, $mode);
        } catch (CacheExceptionInterface $e) {
            if (!$this->getCaching()) {
                return false;
            }

throw $e;
        }
    }

/**
     * Garbage collect expired cache data
     *
     * @return  boolean
     *
     * @since   1.7.0
     */
    public function gc()
    {
        try {
            return $this->_getStorage()->gc();
        } catch (CacheExceptionInterface $e) {
            if (!$this->getCaching()) {
                return false;
            }

throw $e;
        }
    }

/**
     * Set lock flag on cached item
     *
     * @param   string  $id        The cache data ID
     * @param   string  $group     The cache data group
     * @param   string  $locktime  The default locktime for locking the cache.
     *
     * @return  \stdClass  Object with properties of lock and locklooped
     *
     * @since   1.7.0
     */
    public function lock($id, $group = null, $locktime = null)
    {
        $returning             = new \stdClass();
        $returning->locklooped = false;

if (!$this->getCaching()) {
            $returning->locked = false;

return $returning;
        }

// Get the default group
        $group = $group ?: $this->_options['defaultgroup'];

// Get the default locktime
        $locktime = $locktime ?: $this->_options['locktime'];

/*
         * Allow storage handlers to perform locking on their own
         * NOTE drivers with lock need also unlock or unlocking will fail because of false $id
         */
        $handler = $this->_getStorage();

if ($this->_options['locking'] == true) {
            $locked = $handler->lock($id, $group, $locktime);

if ($locked !== false) {
                return $locked;
            }
        }

// Fallback
        $curentlifetime = $this->_options['lifetime'];

// Set lifetime to locktime for storing in children
        $this->_options['lifetime'] = $locktime;

$looptime = $locktime * 10;
        $id2      = $id . '_lock';

if ($this->_options['locking'] == true) {
            $data_lock = $handler->get($id2, $group, $this->_options['checkTime']);
        } else {
            $data_lock         = false;
            $returning->locked = false;
        }

if ($data_lock !== false) {
            $lock_counter = 0;

// Loop until you find that the lock has been released. That implies that data get from other thread has finished
            while ($data_lock !== false) {
                if ($lock_counter > $looptime) {
                    $returning->locked     = false;
                    $returning->locklooped = true;
                    break;
                }

usleep(100);
                $data_lock = $handler->get($id2, $group, $this->_options['checkTime']);
                $lock_counter++;
            }
        }

if ($this->_options['locking'] == true) {
            $returning->locked = $handler->store($id2, $group, 1);
        }

// Revert lifetime to previous one
        $this->_options['lifetime'] = $curentlifetime;

return $returning;
    }

/**
     * Unset lock flag on cached item
     *
     * @param   string  $id     The cache data ID
     * @param   string  $group  The cache data group
     *
     * @return  boolean
     *
     * @since   1.7.0
     */
    public function unlock($id, $group = null)
    {
        if (!$this->getCaching()) {
            return false;
        }

// Get the default group
        $group = $group ?: $this->_options['defaultgroup'];

// Allow handlers to perform unlocking on their own
        $handler = $this->_getStorage();

$unlocked = $handler->unlock($id, $group);

if ($unlocked !== false) {
            return $unlocked;
        }

// Fallback
        return $handler->remove($id . '_lock', $group);
    }

/**
     * Get the cache storage handler
     *
     * @return  CacheStorage
     *
     * @since   1.7.0
     */
    public function &_getStorage()
    {
        $hash = md5(serialize($this->_options));

if (isset(self::$_handler[$hash])) {
            return self::$_handler[$hash];
        }

self::$_handler[$hash] = CacheStorage::getInstance($this->_options['storage'], $this->_options);

return self::$_handler[$hash];
    }

/**
     * Perform workarounds on retrieved cached data
     *
     * @param   array   $data     Cached data
     * @param   array   $options  Array of options
     *
     * @return  string  Body of cached data
     *
     * @since   1.7.0
     */
    public static function getWorkarounds($data, $options = [])
    {
        $app      = Factory::getApplication();
        $document = Factory::getDocument();
        $body     = null;

// Get the document head out of the cache.
        if (
            isset($options['mergehead']) && $options['mergehead'] == 1 && isset($data['head']) && !empty($data['head'])
            && method_exists($document, 'mergeHeadData')
        ) {
            $document->mergeHeadData($data['head']);
        } elseif (isset($data['head']) && method_exists($document, 'setHeadData')) {
            $document->setHeadData($data['head']);
        }

// Get the document MIME encoding out of the cache
        if (isset($data['mime_encoding'])) {
            $document->setMimeEncoding($data['mime_encoding'], true);
        }

// If the pathway buffer is set in the cache data, get it.
        if (isset($data['pathway']) && \is_array($data['pathway'])) {
            // Push the pathway data into the pathway object.
            $app->getPathway()->setPathway($data['pathway']);
        }

// @todo check if the following is needed, seems like it should be in page cache
        // If a module buffer is set in the cache data, get it.
        if (isset($data['module']) && \is_array($data['module'])) {
            // Iterate through the module positions and push them into the document buffer.
            foreach ($data['module'] as $name => $contents) {
                $document->setBuffer($contents, 'module', $name);
            }
        }

// Set cached headers.
        if (isset($data['headers']) && $data['headers']) {
            foreach ($data['headers'] as $header) {
                $app->setHeader($header['name'], $header['value']);
            }
        }

// The following code searches for a token in the cached page and replaces it with the proper token.
        if (isset($data['body'])) {
            $token       = Session::getFormToken();
            $search      = '#<input type="hidden" name="[0-9a-f]{32}" value="1">#';
            $replacement = '<input type="hidden" name="' . $token . '" value="1">';

$data['body'] = preg_replace($search, $replacement, $data['body']);
            $body         = $data['body'];
        }

// Get the document body out of the cache.
        return $body;
    }

/**
     * Create workarounds for data to be cached
     *
     * @param   string  $data     Cached data
     * @param   array   $options  Array of options
     *
     * @return  array  Data to be cached
     *
     * @since   1.7.0
     */
    public static function setWorkarounds($data, $options = [])
    {
        $loptions = [
            'nopathway'  => 0,
            'nohead'     => 0,
            'nomodules'  => 0,
            'modulemode' => 0,
        ];

if (isset($options['nopathway'])) {
            $loptions['nopathway'] = $options['nopathway'];
        }

if (isset($options['nohead'])) {
            $loptions['nohead'] = $options['nohead'];
        }

if (isset($options['nomodules'])) {
            $loptions['nomodules'] = $options['nomodules'];
        }

if (isset($options['modulemode'])) {
            $loptions['modulemode'] = $options['modulemode'];
        }

$app      = Factory::getApplication();
        $document = Factory::getDocument();

if ($loptions['nomodules'] != 1) {
            // Get the modules buffer before component execution.
            $buffer1 = $document->getBuffer();

if (!\is_array($buffer1)) {
                $buffer1 = [];
            }

// Make sure the module buffer is an array.
            if (!isset($buffer1['module']) || !\is_array($buffer1['module'])) {
                $buffer1['module'] = [];
            }
        }

// View body data
        $cached = ['body' => $data];

// Document head data
        if ($loptions['nohead'] != 1 && method_exists($document, 'getHeadData')) {
            if ($loptions['modulemode'] == 1) {
                $headNow = $document->getHeadData();
                $unset   = ['title', 'description', 'link', 'links', 'metaTags'];

foreach ($unset as $key) {
                    unset($headNow[$key]);
                }

// Sanitize empty data
                foreach (\array_keys($headNow) as $key) {
                    if (!isset($headNow[$key]) || $headNow[$key] === []) {
                        unset($headNow[$key]);
                    }
                }

$cached['head'] = $headNow;
            } else {
                $cached['head'] = $document->getHeadData();

// Document MIME encoding
                $cached['mime_encoding'] = $document->getMimeEncoding();
            }
        }

// Pathway data
        if ($app->isClient('site') && $loptions['nopathway'] != 1) {
            $cached['pathway'] = $data['pathway'] ?? $app->getPathway()->getPathway();
        }

if ($loptions['nomodules'] != 1) {
            // @todo Check if the following is needed, seems like it should be in page cache
            // Get the module buffer after component execution.
            $buffer2 = $document->getBuffer();

if (!\is_array($buffer2)) {
                $buffer2 = [];
            }

// Make sure the module buffer is an array.
            if (!isset($buffer2['module']) || !\is_array($buffer2['module'])) {
                $buffer2['module'] = [];
            }

// Compare the second module buffer against the first buffer.
            $cached['module'] = array_diff_assoc($buffer2['module'], $buffer1['module']);
        }

// Headers data
        if (isset($options['headers']) && $options['headers']) {
            $cached['headers'] = $app->getHeaders();
        }

return $cached;
    }

/**
     * Create a safe ID for cached data from URL parameters
     *
     * @return  string  MD5 encoded cache ID
     *
     * @since   1.7.0
     */
    public static function makeId()
    {
        $app = Factory::getApplication();

$registeredurlparams = new \stdClass();

// Get url parameters set by plugins
        if (!empty($app->registeredurlparams)) {
            $registeredurlparams = $app->registeredurlparams;
        }

// Platform defaults
        $defaulturlparams = [
            'format' => 'CMD',
            'option' => 'CMD',
            'view'   => 'CMD',
            'layout' => 'CMD',
            'tpl'    => 'CMD',
            'id'     => 'STRING',
        ];

// Use platform defaults if parameter doesn't already exist.
        foreach ($defaulturlparams as $param => $type) {
            if (!property_exists($registeredurlparams, $param)) {
                $registeredurlparams->$param = $type;
            }
        }

$safeuriaddon = new \stdClass();

foreach ($registeredurlparams as $key => $value) {
            $safeuriaddon->$key = $app->getInput()->get($key, null, $value);
        }

return md5(serialize($safeuriaddon));
    }

/**
     * Set a prefix cache key if device calls for separate caching
     *
     * @return  string
     *
     * @since   3.5
     */
    public static function getPlatformPrefix()
    {
        // No prefix when Global Config is set to no platform specific prefix
        if (!Factory::getApplication()->get('cache_platformprefix', false)) {
            return '';
        }

$webclient = new WebClient();

if ($webclient->mobile) {
            return 'M-';
        }

return '';
    }

/**
     * Add a directory where Cache should search for handlers. You may either pass a string or an array of directories.
     *
     * @param   array|string  $path  A path to search.
     *
     * @return  array   An array with directory elements
     *
     * @since   1.7.0
     */
    public static function addIncludePath($path = '')
    {
        static $paths;

if (!isset($paths)) {
            $paths = [];
        }

if (!empty($path) && !\in_array($path, $paths)) {
            array_unshift($paths, Path::clean($path));
        }

return $paths;
    }
}