PathUtility.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\Utility;
 
use ‪TYPO3\CMS\Core\Core\Environment;
use ‪TYPO3\CMS\Core\Resource\Exception\InvalidFileException;
 
class ‪PathUtility
{
    public static function ‪getRelativePathTo($targetPath)
    {
        return ‪self::getRelativePath(self::dirname(‪Environment::getCurrentScript()), $targetPath);
    }
 
    public static function ‪getAbsoluteWebPath($targetPath, bool $prefixWithSitePath = true)
    {
        if (static::hasProtocolAndScheme($targetPath)) {
            return $targetPath;
        }
 
        $prefixWithSitePath = $prefixWithSitePath && !‪Environment::isCli();
        if (self::isAbsolutePath($targetPath)) {
            if (str_starts_with($targetPath, ‪Environment::getPublicPath())) {
                // It is an absolute file system path with file/folder inside document root,
                // therefore we can strip the full file system path to the document root to obtain the URI
                $targetPath = ‪self::stripPathSitePrefix($targetPath);
            } elseif (‪Environment::isComposerMode() && str_contains($targetPath, 'Resources/Public') && str_starts_with($targetPath, ‪Environment::getComposerRootPath())) {
                // TYPO3 is in managed by Composer and it is an absolute file system path inside composer root path,
                // and a public resource is referenced, therefore we can calculate the path to the published assets
                // This is true for all Composer packages that are installed in vendor folder by Composer, but still recognized by TYPO3
                $relativePath = substr($targetPath, strlen(‪Environment::getComposerRootPath()));
                [$relativePrefix, $relativeAssetPath] = explode('Resources/Public', $relativePath);
                $targetPath = '_assets/' . md5($relativePrefix) . $relativeAssetPath;
            } else {
                // At this point it can be ANY path, even an invalid or non existent and it is totally unclear,
                // whether this is a mistake or accidentally working as intended.
                // The only conclusion here is, that this API has to be deprecated altogether an be replaced with API
                // that clearly distinguishes between creating a URL from a static resource and ensuring an URL is absolute and not relative to current script.
                $prefixWithSitePath = false;
            }
        } else {
            // Make an absolute path out of it
            $targetPath = GeneralUtility::resolveBackPath(self::dirname(‪Environment::getCurrentScript()) . '/' . $targetPath);
            $targetPath = ‪self::stripPathSitePrefix($targetPath);
        }
 
        if ($prefixWithSitePath) {
            $targetPath = GeneralUtility::getIndpEnv('TYPO3_SITE_PATH') . $targetPath;
        }
 
        return $targetPath;
    }
 
    public static function ‪getPublicResourceWebPath(string $resourcePath, bool $prefixWithSitePath = true): string
    {
        if (!self::isExtensionPath($resourcePath)) {
            throw new ‪InvalidFileException('Resource paths must start with "EXT:"', 1630089406);
        }
        $absoluteFilePath = GeneralUtility::getFileAbsFileName($resourcePath);
        if (!str_contains($resourcePath, 'Resources/Public')) {
            if (!str_starts_with($absoluteFilePath, ‪Environment::getPublicPath())) {
                // This will be thrown in Composer mode, when extension are installed in vendor folder
                throw new ‪InvalidFileException(sprintf('"%s" is expected to be in public directory, but is not', $resourcePath), 1635268969);
            }
            trigger_error(sprintf('Public resource "%s" is not in extension\'s Resources/Public folder. This is deprecated and will not be supported any more in future TYPO3 versions.', $resourcePath), E_USER_DEPRECATED);
        }
 
        return ‪self::getAbsoluteWebPath($absoluteFilePath, $prefixWithSitePath);
    }
 
    public static function ‪isExtensionPath(string $path): bool
    {
        return str_starts_with($path, 'EXT:');
    }
 
    public static function ‪getRelativePath($sourcePath, $targetPath)
    {
        $relativePath = null;
        $sourcePath = rtrim(GeneralUtility::fixWindowsFilePath($sourcePath), '/');
        $targetPath = rtrim(GeneralUtility::fixWindowsFilePath($targetPath), '/');
        if ($sourcePath !== $targetPath) {
            $commonPrefix = ‪self::getCommonPrefix([$sourcePath, $targetPath]);
            if ($commonPrefix !== null && GeneralUtility::isAllowedAbsPath($commonPrefix)) {
                $commonPrefixLength = strlen($commonPrefix);
                $resolvedSourcePath = '';
                $resolvedTargetPath = '';
                $sourcePathSteps = 0;
                if (strlen($sourcePath) > $commonPrefixLength) {
                    $resolvedSourcePath = (string)substr($sourcePath, $commonPrefixLength);
                }
                if (strlen($targetPath) > $commonPrefixLength) {
                    $resolvedTargetPath = (string)substr($targetPath, $commonPrefixLength);
                }
                if ($resolvedSourcePath !== '') {
                    $sourcePathSteps = count(explode('/', $resolvedSourcePath));
                }
                $relativePath = ‪self::sanitizeTrailingSeparator(str_repeat('../', $sourcePathSteps) . $resolvedTargetPath);
            }
        }
        return $relativePath;
    }
 
    public static function ‪getCommonPrefix(array $paths)
    {
        $paths = array_map([GeneralUtility::class, 'fixWindowsFilePath'], $paths);
        $commonPath = null;
        if (count($paths) === 1) {
            $commonPath = array_shift($paths);
        } elseif (count($paths) > 1) {
            $parts = explode('/', (string)array_shift($paths));
            $comparePath = '';
            $break = false;
            foreach ($parts as $part) {
                $comparePath .= $part . '/';
                foreach ($paths as $path) {
                    if (strpos($path . '/', $comparePath) !== 0) {
                        $break = true;
                        break;
                    }
                }
                if ($break) {
                    break;
                }
                $commonPath = $comparePath;
            }
        }
        if ($commonPath !== null) {
            $commonPath = ‪self::sanitizeTrailingSeparator($commonPath, '/');
        }
        return $commonPath;
    }
 
    public static function ‪sanitizeTrailingSeparator($path, $separator = '/')
    {
        return rtrim($path, $separator) . $separator;
    }
 
    public static function ‪basename($path)
    {
        $targetLocale = ‪$GLOBALS['TYPO3_CONF_VARS']['SYS']['systemLocale'] ?? '';
        if (empty($targetLocale)) {
            return ‪basename($path);
        }
        $currentLocale = (string)setlocale(LC_CTYPE, '0');
        setlocale(LC_CTYPE, $targetLocale);
        $basename = ‪basename($path);
        setlocale(LC_CTYPE, $currentLocale);
        return $basename;
    }
 
    public static function ‪dirname($path)
    {
        $targetLocale = ‪$GLOBALS['TYPO3_CONF_VARS']['SYS']['systemLocale'] ?? '';
        if (empty($targetLocale)) {
            return ‪dirname($path);
        }
        $currentLocale = (string)setlocale(LC_CTYPE, '0');
        setlocale(LC_CTYPE, $targetLocale);
        $dirname = ‪dirname($path);
        setlocale(LC_CTYPE, $currentLocale);
        return $dirname;
    }
 
    public static function ‪pathinfo($path, $options = null)
    {
        $targetLocale = ‪$GLOBALS['TYPO3_CONF_VARS']['SYS']['systemLocale'] ?? '';
        if (empty($targetLocale)) {
            return $options === null ? ‪pathinfo($path) : ‪pathinfo($path, $options);
        }
        $currentLocale = (string)setlocale(LC_CTYPE, '0');
        setlocale(LC_CTYPE, $targetLocale);
        $pathinfo = $options == null ? ‪pathinfo($path) : ‪pathinfo($path, $options);
        setlocale(LC_CTYPE, $currentLocale);
        return $pathinfo;
    }
 
    public static function ‪isAbsolutePath($path)
    {
        // On Windows also a path starting with a drive letter is absolute: X:/
        if (‪Environment::isWindows() && (substr($path, 1, 2) === ':/' || substr($path, 1, 2) === ':\\')) {
            return true;
        }
        // Path starting with a / is always absolute, on every system, VFS is needed for tests
        return substr($path, 0, 1) === '/' || substr($path, 0, 6) === 'vfs://';
    }
 
    public static function ‪getAbsolutePathOfRelativeReferencedFileOrPath($baseFilenameOrPath, $includeFileName)
    {
        $fileName = static::basename($includeFileName);
        $basePath = substr($baseFilenameOrPath, -1) === '/' ? $baseFilenameOrPath : static::dirname($baseFilenameOrPath);
        $newDir = static::getCanonicalPath($basePath . '/' . static::dirname($includeFileName));
        // Avoid double slash on empty path
        $result = (($newDir !== '/') ? $newDir : '') . '/' . $fileName;
        return $result;
    }
 
    public static function ‪dirnameDuringBootstrap($path): string
    {
        return preg_replace('#(.*)(/|\\\\)([^\\\\/]+)$#', '$1', $path);
    }
 
    public static function ‪basenameDuringBootstrap($path): string
    {
        return preg_replace('#.*[/\\\\]([^\\\\/]+)$#', '$1', $path);
    }
 
    /*********************
     *
     * Cleaning methods
     *
     *********************/
    public static function ‪getCanonicalPath($path)
    {
        // Replace backslashes with slashes to work with Windows paths if given
        $path = trim(str_replace('\\', '/', $path));
 
        // @todo do we really need this? Probably only in testing context for vfs?
        $protocol = '';
        if (str_contains($path, '://')) {
            [$protocol, $path] = explode('://', $path);
            $protocol .= '://';
        }
 
        $absolutePathPrefix = '';
        if (static::isAbsolutePath($path)) {
            if (‪Environment::isWindows() && substr($path, 1, 2) === ':/') {
                $absolutePathPrefix = substr($path, 0, 3);
                $path = substr($path, 3);
            } else {
                $path = ltrim($path, '/');
                $absolutePathPrefix = '/';
            }
        }
 
        $theDirParts = explode('/', $path);
        $theDirPartsCount = count($theDirParts);
        for ($partCount = 0; $partCount < $theDirPartsCount; $partCount++) {
            // double-slashes in path: remove element
            if ($theDirParts[$partCount] === '') {
                array_splice($theDirParts, $partCount, 1);
                $partCount--;
                $theDirPartsCount--;
            }
            // "." in path: remove element
            if (($theDirParts[$partCount] ?? '') === '.') {
                array_splice($theDirParts, $partCount, 1);
                $partCount--;
                $theDirPartsCount--;
            }
            // ".." in path:
            if (($theDirParts[$partCount] ?? '') === '..') {
                if ($partCount >= 1) {
                    // Remove this and previous element
                    array_splice($theDirParts, $partCount - 1, 2);
                    $partCount -= 2;
                    $theDirPartsCount -= 2;
                } elseif ($absolutePathPrefix) {
                    // can't go higher than root dir
                    // simply remove this part and continue
                    array_splice($theDirParts, $partCount, 1);
                    $partCount--;
                    $theDirPartsCount--;
                }
            }
        }
 
        return $protocol . $absolutePathPrefix . implode('/', $theDirParts);
    }
 
    public static function ‪stripPathSitePrefix($path)
    {
        return substr($path, strlen(‪Environment::getPublicPath() . '/'));
    }
 
    public static function ‪hasProtocolAndScheme(string $path): bool
    {
        return strpos($path, '//') === 0 || strpos($path, '://') > 0;
    }
 
    public static function ‪isAllowedAdditionalPath(string $path): bool
    {
        // ensure the submitted path ends with a string, even for a file
        $path = ‪self::sanitizeTrailingSeparator($path);
        $allowedPaths = ‪$GLOBALS['TYPO3_CONF_VARS']['BE']['lockRootPath'] ?? [];
        if (is_string($allowedPaths)) {
            // The setting was a string before and is now an array
            // For compatibility reasons, we cast a string to an array here for now
            $allowedPaths = [$allowedPaths];
        }
        if (!is_array($allowedPaths)) {
            throw new \RuntimeException('$GLOBALS[\'TYPO3_CONF_VARS\'][\'BE\'][\'lockRootPath\'] is expected to be an array.', 1707408379);
        }
        foreach ($allowedPaths as $allowedPath) {
            $allowedPath = trim($allowedPath);
            if ($allowedPath !== '' && str_starts_with($path, self::sanitizeTrailingSeparator($allowedPath))) {
                return true;
            }
        }
        return false;
    }
}