SimpleFileBackend.php

Go to the documentation of this file.

<?php
 
/*
 * 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!
 */
 
namespace ‪TYPO3\CMS\Core\Cache\Backend;
 
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
{
    public const ‪SEPARATOR = '^';
    public const ‪EXPIRYTIME_FORMAT = 'YmdHis';
    public const ‪EXPIRYTIME_LENGTH = 14;
    public 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 resource
        // This is used by unit tests with vfs:// directories
        if (‪PathUtility::hasProtocolAndScheme(‪$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 (str_starts_with(‪$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) && str_starts_with(‪$cacheDirectory, $documentRoot)) {
                    $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);
        }
        $file = $this->cacheDirectory . $entryIdentifier . ‪$this->cacheEntryFileExtension;
        if (file_exists($file)) {
            return unlink($file);
        }
        return false;
    }
 
    public function ‪flush()
    {
        $directory = ‪$this->cacheDirectory;
        if (is_link($directory)) {
            // Avoid attempting to rename the symlink see #87367
            $directory = (string)realpath($directory);
        }
 
        if (is_dir($directory)) {
            $temporaryDirectory = rtrim($directory, '/') . '.' . ‪StringUtility::getUniqueId('remove');
            if (rename($directory, $temporaryDirectory)) {
                ‪GeneralUtility::mkdir($directory);
                clearstatcache();
                ‪GeneralUtility::rmdir($temporaryDirectory, 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;
    }
}