9.5/_simple_file_backend_8php_source.html

<?php

namespace ‪TYPO3\CMS\Core\Cache\Backend;


/*

 * This file is part of the TYPO3 CMS project.

 *

 * It is free software; you can redistribute it and/or modify it under

 * the terms of the GNU General Public License, either version 2

 * of the License, or any later version.

 *

 * For the full copyright and license information, please read the

 * LICENSE.txt file that was distributed with this source code.

 *

 * The TYPO3 project - inspiring people to share!

 */


use ‪TYPO3\CMS\Core\Cache\Exception;

use ‪TYPO3\CMS\Core\Cache\Exception\InvalidDataException;

use ‪TYPO3\CMS\Core\Cache\Frontend\FrontendInterface;

use ‪TYPO3\CMS\Core\Cache\Frontend\PhpFrontend;

use ‪TYPO3\CMS\Core\Core\Environment;

use ‪TYPO3\CMS\Core\Service\OpcodeCacheService;

use ‪TYPO3\CMS\Core\Utility\GeneralUtility;

use ‪TYPO3\CMS\Core\Utility\PathUtility;

use ‪TYPO3\CMS\Core\Utility\StringUtility;


class ‪SimpleFileBackend extends ‪AbstractBackend implements ‪PhpCapableBackendInterface

{

    const ‪SEPARATOR = '^';

    const ‪EXPIRYTIME_FORMAT = 'YmdHis';

    const ‪EXPIRYTIME_LENGTH = 14;

    const ‪DATASIZE_DIGITS = 10;

    protected ‪$cacheDirectory = '';


    protected ‪$temporaryCacheDirectory = '';


    protected ‪$cacheEntryFileExtension = '';


    protected ‪$cacheEntryIdentifiers = [];


    protected ‪$frozen = false;


    public function ‪setCache(‪FrontendInterface ‪$cache)

    {

        parent::setCache(‪$cache);

        if (empty($this->temporaryCacheDirectory)) {

            // If no cache directory was given with cacheDirectory

            // configuration option, set it to a path below var/ folder

            ‪$temporaryCacheDirectory = ‪Environment::getVarPath() . '/';

        } else {

            ‪$temporaryCacheDirectory = ‪$this->temporaryCacheDirectory;

        }

        $codeOrData = ‪$cache instanceof ‪PhpFrontend ? 'code' : 'data';

        $finalCacheDirectory = ‪$temporaryCacheDirectory . 'cache/' . $codeOrData . '/' . $this->cacheIdentifier . '/';

        if (!is_dir($finalCacheDirectory)) {

            $this->‪createFinalCacheDirectory($finalCacheDirectory);

        }

        unset($this->temporaryCacheDirectory);

        $this->cacheDirectory = $finalCacheDirectory;

        $this->cacheEntryFileExtension = ‪$cache instanceof ‪PhpFrontend ? '.php' : '';

        if (strlen($this->cacheDirectory) + 23 > PHP_MAXPATHLEN) {

            throw new ‪Exception('The length of the temporary cache file path "' . $this->cacheDirectory . '" exceeds the ' . 'maximum path length of ' . (PHP_MAXPATHLEN - 23) . '. Please consider ' . 'setting the temporaryDirectoryBase option to a shorter path.', 1248710426);

        }

    }


    public function ‪setCacheDirectory(‪$cacheDirectory)

    {

        // Skip handling if directory is a stream ressource

        // This is used by unit tests with vfs:// directories

        if (strpos(‪$cacheDirectory, '://')) {

            $this->temporaryCacheDirectory = ‪$cacheDirectory;

            return;

        }

        $documentRoot = ‪Environment::getProjectPath() . '/';

        if ($open_basedir = ini_get('open_basedir')) {

            if (‪Environment::isWindows()) {

                $delimiter = ';';

                ‪$cacheDirectory = str_replace('\\', '/', ‪$cacheDirectory);

                if (!preg_match('/[A-Z]:/', substr(‪$cacheDirectory, 0, 2))) {

                    ‪$cacheDirectory = ‪Environment::getProjectPath() . ‪$cacheDirectory;

                }

            } else {

                $delimiter = ':';

                if (‪$cacheDirectory[0] !== '/') {

                    // relative path to cache directory.

                    ‪$cacheDirectory = ‪Environment::getProjectPath() . ‪$cacheDirectory;

                }

            }

            $basedirs = explode($delimiter, $open_basedir);

            $cacheDirectoryInBaseDir = false;

            foreach ($basedirs as $basedir) {

                if (‪Environment::isWindows()) {

                    $basedir = str_replace('\\', '/', $basedir);

                }

                if ($basedir[strlen($basedir) - 1] !== '/') {

                    $basedir .= '/';

                }

                if (GeneralUtility::isFirstPartOfStr(‪$cacheDirectory, $basedir)) {

                    $documentRoot = $basedir;

                    ‪$cacheDirectory = str_replace($basedir, '', ‪$cacheDirectory);

                    $cacheDirectoryInBaseDir = true;

                    break;

                }

            }

            if (!$cacheDirectoryInBaseDir) {

                throw new Exception(

                    'Open_basedir restriction in effect. The directory "' . ‪$cacheDirectory . '" is not in an allowed path.',

                    1476045417

                );

            }

        } else {

            if (‪$cacheDirectory[0] === '/') {

                // Absolute path to cache directory.

                $documentRoot = '';

            }

            if (‪Environment::isWindows()) {

                if (!empty($documentRoot) && strpos(‪$cacheDirectory, $documentRoot) === 0) {

                    $documentRoot = '';

                }

            }

        }

        // After this point all paths have '/' as directory separator

        if (‪$cacheDirectory[strlen(‪$cacheDirectory) - 1] !== '/') {

            ‪$cacheDirectory .= '/';

        }

        $this->temporaryCacheDirectory = $documentRoot . ‪$cacheDirectory;

    }


    protected function ‪createFinalCacheDirectory($finalCacheDirectory)

    {

        try {

            GeneralUtility::mkdir_deep($finalCacheDirectory);

        } catch (\RuntimeException $e) {

            throw new Exception('The directory "' . $finalCacheDirectory . '" can not be created.', 1303669848, $e);

        }

        if (!is_writable($finalCacheDirectory)) {

            throw new Exception('The directory "' . $finalCacheDirectory . '" is not writable.', 1203965200);

        }

    }


    public function ‪getCacheDirectory()

    {

        return ‪$this->cacheDirectory;

    }


    public function set($entryIdentifier, $data, array $tags = [], $lifetime = null)

    {

        if (!is_string($data)) {

            throw new InvalidDataException('The specified data is of type "' . gettype($data) . '" but a string is expected.', 1334756734);

        }

        if ($entryIdentifier !== ‪PathUtility::basename($entryIdentifier)) {

            throw new \InvalidArgumentException('The specified entry identifier must not contain a path segment.', 1334756735);

        }

        if ($entryIdentifier === '') {

            throw new \InvalidArgumentException('The specified entry identifier must not be empty.', 1334756736);

        }

        $temporaryCacheEntryPathAndFilename = $this->cacheDirectory . ‪StringUtility::getUniqueId() . '.temp';

        $result = file_put_contents($temporaryCacheEntryPathAndFilename, $data);

        GeneralUtility::fixPermissions($temporaryCacheEntryPathAndFilename);

        if ($result === false) {

            throw new Exception('The temporary cache file "' . $temporaryCacheEntryPathAndFilename . '" could not be written.', 1334756737);

        }

        $cacheEntryPathAndFilename = $this->cacheDirectory . $entryIdentifier . ‪$this->cacheEntryFileExtension;

        rename($temporaryCacheEntryPathAndFilename, $cacheEntryPathAndFilename);

        if ($this->cacheEntryFileExtension === '.php') {

            GeneralUtility::makeInstance(OpcodeCacheService::class)->clearAllActive($cacheEntryPathAndFilename);

        }

    }


    public function get($entryIdentifier)

    {

        if ($entryIdentifier !== ‪PathUtility::basename($entryIdentifier)) {

            throw new \InvalidArgumentException('The specified entry identifier must not contain a path segment.', 1334756877);

        }

        $pathAndFilename = $this->cacheDirectory . $entryIdentifier . ‪$this->cacheEntryFileExtension;

        if (!file_exists($pathAndFilename)) {

            return false;

        }

        return file_get_contents($pathAndFilename);

    }


    public function ‪has($entryIdentifier)

    {

        if ($entryIdentifier !== ‪PathUtility::basename($entryIdentifier)) {

            throw new \InvalidArgumentException('The specified entry identifier must not contain a path segment.', 1334756878);

        }

        return file_exists($this->cacheDirectory . $entryIdentifier . $this->cacheEntryFileExtension);

    }


    public function remove($entryIdentifier)

    {

        if ($entryIdentifier !== ‪PathUtility::basename($entryIdentifier)) {

            throw new \InvalidArgumentException('The specified entry identifier must not contain a path segment.', 1334756960);

        }

        if ($entryIdentifier === '') {

            throw new \InvalidArgumentException('The specified entry identifier must not be empty.', 1334756961);

        }

        try {

            unlink($this->cacheDirectory . $entryIdentifier . $this->cacheEntryFileExtension);

        } catch (\Exception $e) {

            return false;

        }

        return true;

    }


    public function ‪flush()

    {

        GeneralUtility::flushDirectory($this->cacheDirectory, true);

    }


    protected function ‪isCacheFileExpired($cacheEntryPathAndFilename)

    {

        return file_exists($cacheEntryPathAndFilename) === false;

    }


    public function ‪collectGarbage()

    {

    }


    protected function ‪findCacheFilesByIdentifier($entryIdentifier)

    {

        $pathAndFilename = $this->cacheDirectory . $entryIdentifier . ‪$this->cacheEntryFileExtension;

        return file_exists($pathAndFilename) ? [$pathAndFilename] : false;

    }


    public function ‪requireOnce($entryIdentifier)

    {

        $pathAndFilename = $this->cacheDirectory . $entryIdentifier . ‪$this->cacheEntryFileExtension;

        if ($entryIdentifier !== ‪PathUtility::basename($entryIdentifier)) {

            throw new \InvalidArgumentException('The specified entry identifier must not contain a path segment.', 1282073037);

        }

        return file_exists($pathAndFilename) ? require_once $pathAndFilename : false;

    }


    public function require(string $entryIdentifier)

    {

        $pathAndFilename = $this->cacheDirectory . $entryIdentifier . ‪$this->cacheEntryFileExtension;

        if ($entryIdentifier !== ‪PathUtility::basename($entryIdentifier)) {

            throw new \InvalidArgumentException('The specified entry identifier must not contain a path segment.', 1532528267);

        }

        return file_exists($pathAndFilename) ? require $pathAndFilename : false;

    }

}