9.5/_local_driver_8php_source.html

<?php

namespace ‪TYPO3\CMS\Core\Resource\Driver;


/*

 * 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 Psr\Http\Message\ResponseInterface;

use ‪TYPO3\CMS\Core\Charset\CharsetConverter;

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

use ‪TYPO3\CMS\Core\Http\Response;

use ‪TYPO3\CMS\Core\Http\SelfEmittableLazyOpenStream;

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

use ‪TYPO3\CMS\Core\Resource\FolderInterface;

use ‪TYPO3\CMS\Core\Resource\ResourceStorage;

use ‪TYPO3\CMS\Core\Type\File\FileInfo;

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

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


class ‪LocalDriver extends ‪AbstractHierarchicalFilesystemDriver implements ‪StreamableDriverInterface

{

    const ‪UNSAFE_FILENAME_CHARACTER_EXPRESSION = '\\x00-\\x2C\\/\\x3A-\\x3F\\x5B-\\x60\\x7B-\\xBF';


    protected ‪$absoluteBasePath;


    protected ‪$supportedHashAlgorithms = ['sha1', 'md5'];


    protected ‪$baseUri;


    protected ‪$mappingFolderNameToRole = [

        '_recycler_' => ‪FolderInterface::ROLE_RECYCLER,

        '_temp_' => ‪FolderInterface::ROLE_TEMPORARY,

        'user_upload' => ‪FolderInterface::ROLE_USERUPLOAD,

    ];


    public function ‪__construct(array ‪$configuration = [])

    {

        parent::__construct(‪$configuration);

        // The capabilities default of this driver. See CAPABILITY_* constants for possible values

        $this->capabilities =

            ‪ResourceStorage::CAPABILITY_BROWSABLE

            | ‪ResourceStorage::CAPABILITY_PUBLIC

            | ‪ResourceStorage::CAPABILITY_WRITABLE

            | ‪ResourceStorage::CAPABILITY_HIERARCHICAL_IDENTIFIERS;

    }


    public function ‪mergeConfigurationCapabilities(‪$capabilities)

    {

        $this->capabilities &= ‪$capabilities;


        return ‪$this->capabilities;

    }


    public function ‪processConfiguration()

    {

        $this->absoluteBasePath = $this->‪calculateBasePath($this->configuration);

        $this->‪determineBaseUrl();

        if ($this->baseUri === null) {

            // remove public flag

            $this->capabilities &= ~‪ResourceStorage::CAPABILITY_PUBLIC;

        }

    }


    public function ‪initialize()

    {

    }


    protected function ‪determineBaseUrl()

    {

        // only calculate baseURI if the storage does not enforce jumpUrl Script

        if ($this->‪hasCapability(‪ResourceStorage::CAPABILITY_PUBLIC)) {

            if (GeneralUtility::isFirstPartOfStr($this->absoluteBasePath, ‪Environment::getPublicPath())) {

                // use site-relative URLs

                $temporaryBaseUri = rtrim(‪PathUtility::stripPathSitePrefix($this->absoluteBasePath), '/');

                if ($temporaryBaseUri !== '') {

                    $uriParts = explode('/', $temporaryBaseUri);

                    $uriParts = array_map('rawurlencode', $uriParts);

                    $temporaryBaseUri = implode('/', $uriParts) . '/';

                }

                $this->baseUri = $temporaryBaseUri;

            } elseif (isset($this->configuration['baseUri']) && GeneralUtility::isValidUrl($this->configuration['baseUri'])) {

                $this->baseUri = rtrim($this->configuration['baseUri'], '/') . '/';

            }

        }

    }


    protected function ‪calculateBasePath(array ‪$configuration)

    {

        if (!array_key_exists('basePath', ‪$configuration) || empty(‪$configuration['basePath'])) {

            throw new Exception\InvalidConfigurationException(

                'Configuration must contain base path.',

                1346510477

            );

        }


        if (!empty(‪$configuration['pathType']) && ‪$configuration['pathType'] === 'relative') {

            $relativeBasePath = ‪$configuration['basePath'];

            ‪$absoluteBasePath = ‪Environment::getPublicPath() . '/' . $relativeBasePath;

        } else {

            ‪$absoluteBasePath = ‪$configuration['basePath'];

        }

        ‪$absoluteBasePath = $this->‪canonicalizeAndCheckFilePath(‪$absoluteBasePath);

        ‪$absoluteBasePath = rtrim(‪$absoluteBasePath, '/') . '/';

        if (!is_dir(‪$absoluteBasePath)) {

            throw new Exception\InvalidConfigurationException(

                'Base path "' . ‪$absoluteBasePath . '" does not exist or is no directory.',

                1299233097

            );

        }

        return ‪$absoluteBasePath;

    }


    public function ‪getPublicUrl($identifier)

    {

        $publicUrl = null;

        if ($this->baseUri !== null) {

            $uriParts = explode('/', ltrim($identifier, '/'));

            $uriParts = array_map('rawurlencode', $uriParts);

            $identifier = implode('/', $uriParts);

            $publicUrl = $this->baseUri . $identifier;

        }

        return $publicUrl;

    }


    public function ‪getRootLevelFolder()

    {

        return '/';

    }


    public function ‪getDefaultFolder()

    {

        $identifier = '/user_upload/';

        $createFolder = !$this->‪folderExists($identifier);

        if ($createFolder === true) {

            $identifier = $this->‪createFolder('user_upload');

        }

        return $identifier;

    }


    public function ‪createFolder($newFolderName, $parentFolderIdentifier = '', $recursive = false)

    {

        $parentFolderIdentifier = $this->‪canonicalizeAndCheckFolderIdentifier($parentFolderIdentifier);

        $newFolderName = trim($newFolderName, '/');

        if ($recursive === false) {

            $newFolderName = $this->‪sanitizeFileName($newFolderName);

            $newIdentifier = $this->‪canonicalizeAndCheckFolderIdentifier($parentFolderIdentifier . $newFolderName . '/');

            GeneralUtility::mkdir($this->‪getAbsolutePath($newIdentifier));

        } else {

            $parts = GeneralUtility::trimExplode('/', $newFolderName);

            $parts = array_map([$this, 'sanitizeFileName'], $parts);

            $newFolderName = implode('/', $parts);

            $newIdentifier = $this->‪canonicalizeAndCheckFolderIdentifier(

                $parentFolderIdentifier . $newFolderName . '/'

            );

            GeneralUtility::mkdir_deep($this->‪getAbsolutePath($newIdentifier));

        }

        return $newIdentifier;

    }


    public function ‪getFileInfoByIdentifier($fileIdentifier, array $propertiesToExtract = [])

    {

        $absoluteFilePath = $this->‪getAbsolutePath($fileIdentifier);

        // don't use $this->fileExists() because we need the absolute path to the file anyways, so we can directly

        // use PHP's filesystem method.

        if (!file_exists($absoluteFilePath) || !is_file($absoluteFilePath)) {

            throw new \InvalidArgumentException('File ' . $fileIdentifier . ' does not exist.', 1314516809);

        }


        $dirPath = ‪PathUtility::dirname($fileIdentifier);

        $dirPath = $this->‪canonicalizeAndCheckFolderIdentifier($dirPath);

        return $this->‪extractFileInformation($absoluteFilePath, $dirPath, $propertiesToExtract);

    }


    public function ‪getFolderInfoByIdentifier($folderIdentifier)

    {

        $folderIdentifier = $this->‪canonicalizeAndCheckFolderIdentifier($folderIdentifier);


        if (!$this->‪folderExists($folderIdentifier)) {

            throw new Exception\FolderDoesNotExistException(

                'Folder "' . $folderIdentifier . '" does not exist.',

                1314516810

            );

        }

        $absolutePath = $this->‪getAbsolutePath($folderIdentifier);

        return [

            'identifier' => $folderIdentifier,

            'name' => ‪PathUtility::basename($folderIdentifier),

            'mtime' => filemtime($absolutePath),

            'ctime' => filectime($absolutePath),

            'storage' => ‪$this->storageUid

        ];

    }


    public function ‪sanitizeFileName($fileName, $charset = 'utf-8')

    {

        // Handle UTF-8 characters

        if (‪$GLOBALS['TYPO3_CONF_VARS']['SYS']['UTF8filesystem']) {

            // Allow ".", "-", 0-9, a-z, A-Z and everything beyond U+C0 (latin capital letter a with grave)

            $cleanFileName = preg_replace('/[' . self::UNSAFE_FILENAME_CHARACTER_EXPRESSION . ']/u', '_', trim($fileName));

        } else {

            $fileName = GeneralUtility::makeInstance(CharsetConverter::class)->specCharsToASCII($charset, $fileName);

            // Replace unwanted characters with underscores

            $cleanFileName = preg_replace('/[' . self::UNSAFE_FILENAME_CHARACTER_EXPRESSION . '\\xC0-\\xFF]/', '_', trim($fileName));

        }

        // Strip trailing dots and return

        $cleanFileName = rtrim($cleanFileName, '.');

        if ($cleanFileName === '') {

            throw new Exception\InvalidFileNameException(

                'File name ' . $fileName . ' is invalid.',

                1320288991

            );

        }

        return $cleanFileName;

    }


    protected function ‪getDirectoryItemList($folderIdentifier, $start = 0, $numberOfItems = 0, array $filterMethods, $includeFiles = true, $includeDirs = true, $recursive = false, $sort = '', $sortRev = false)

    {

        $folderIdentifier = $this->‪canonicalizeAndCheckFolderIdentifier($folderIdentifier);

        $realPath = $this->‪getAbsolutePath($folderIdentifier);

        if (!is_dir($realPath)) {

            throw new \InvalidArgumentException(

                'Cannot list items in directory ' . $folderIdentifier . ' - does not exist or is no directory',

                1314349666

            );

        }


        $items = $this->‪retrieveFileAndFoldersInPath($realPath, $recursive, $includeFiles, $includeDirs, $sort, $sortRev);

        $iterator = new \ArrayIterator($items);

        if ($iterator->count() === 0) {

            return [];

        }


        // $c is the counter for how many items we still have to fetch (-1 is unlimited)

        $c = $numberOfItems > 0 ? $numberOfItems : - 1;

        $items = [];

        while ($iterator->valid() && ($numberOfItems === 0 || $c > 0)) {

            // $iteratorItem is the file or folder name

            $iteratorItem = $iterator->current();

            // go on to the next iterator item now as we might skip this one early

            $iterator->next();


            try {

                if (

                !$this->‪applyFilterMethodsToDirectoryItem(

                    $filterMethods,

                    $iteratorItem['name'],

                    $iteratorItem['identifier'],

                    $this->‪getParentFolderIdentifierOfIdentifier($iteratorItem['identifier'])

                )

                ) {

                    continue;

                }

                if ($start > 0) {

                    $start--;

                } else {

                    $items[$iteratorItem['identifier']] = $iteratorItem['identifier'];

                    // Decrement item counter to make sure we only return $numberOfItems

                    // we cannot do this earlier in the method (unlike moving the iterator forward) because we only add the

                    // item here

                    --$c;

                }

            } catch (Exception\InvalidPathException $e) {

            }

        }

        return $items;

    }


    protected function ‪applyFilterMethodsToDirectoryItem(array $filterMethods, $itemName, $itemIdentifier, $parentIdentifier)

    {

        foreach ($filterMethods as $filter) {

            if (is_callable($filter)) {

                $result = call_user_func($filter, $itemName, $itemIdentifier, $parentIdentifier, [], $this);

                // We have to use -1 as the „don't include“ return value, as call_user_func() will return FALSE

                // If calling the method succeeded and thus we can't use that as a return value.

                if ($result === -1) {

                    return false;

                }

                if ($result === false) {

                    throw new \RuntimeException(

                        'Could not apply file/folder name filter ' . $filter[0] . '::' . $filter[1],

                        1476046425

                    );

                }

            }

        }

        return true;

    }


    public function ‪getFileInFolder($fileName, $folderIdentifier)

    {

        return $this->‪canonicalizeAndCheckFileIdentifier($folderIdentifier . '/' . $fileName);

    }


    public function ‪getFilesInFolder($folderIdentifier, $start = 0, $numberOfItems = 0, $recursive = false, array $filenameFilterCallbacks = [], $sort = '', $sortRev = false)

    {

        return $this->‪getDirectoryItemList($folderIdentifier, $start, $numberOfItems, $filenameFilterCallbacks, true, false, $recursive, $sort, $sortRev);

    }


    public function ‪countFilesInFolder($folderIdentifier, $recursive = false, array $filenameFilterCallbacks = [])

    {

        return count($this->‪getFilesInFolder($folderIdentifier, 0, 0, $recursive, $filenameFilterCallbacks));

    }


    public function ‪getFoldersInFolder($folderIdentifier, $start = 0, $numberOfItems = 0, $recursive = false, array $folderNameFilterCallbacks = [], $sort = '', $sortRev = false)

    {

        return $this->‪getDirectoryItemList($folderIdentifier, $start, $numberOfItems, $folderNameFilterCallbacks, false, true, $recursive, $sort, $sortRev);

    }


    public function ‪countFoldersInFolder($folderIdentifier, $recursive = false, array $folderNameFilterCallbacks = [])

    {

        return count($this->‪getFoldersInFolder($folderIdentifier, 0, 0, $recursive, $folderNameFilterCallbacks));

    }


    protected function ‪retrieveFileAndFoldersInPath($path, $recursive = false, $includeFiles = true, $includeDirs = true, $sort = '', $sortRev = false)

    {

        $pathLength = strlen($this->‪getAbsoluteBasePath());

        $iteratorMode = \FilesystemIterator::UNIX_PATHS | \FilesystemIterator::SKIP_DOTS | \FilesystemIterator::CURRENT_AS_FILEINFO | \FilesystemIterator::FOLLOW_SYMLINKS;

        if ($recursive) {

            $iterator = new \RecursiveIteratorIterator(

                new \RecursiveDirectoryIterator($path, $iteratorMode),

                \RecursiveIteratorIterator::SELF_FIRST,

                \RecursiveIteratorIterator::CATCH_GET_CHILD

            );

        } else {

            $iterator = new \RecursiveDirectoryIterator($path, $iteratorMode);

        }


        $directoryEntries = [];

        while ($iterator->valid()) {

            $entry = $iterator->current();

            $isFile = $entry->isFile();

            $isDirectory = $isFile ? false : $entry->isDir();

            if (

                (!$isFile && !$isDirectory) // skip non-files/non-folders

                || ($isFile && !$includeFiles) // skip files if they are excluded

                || ($isDirectory && !$includeDirs) // skip directories if they are excluded

                || $entry->getFilename() === '' // skip empty entries

                || !$entry->isReadable() // skip unreadable entries

            ) {

                $iterator->next();

                continue;

            }

            $entryIdentifier = '/' . substr($entry->getPathname(), $pathLength);

            $entryName = ‪PathUtility::basename($entryIdentifier);

            if ($isDirectory) {

                $entryIdentifier .= '/';

            }

            $entryArray = [

                'identifier' => $entryIdentifier,

                'name' => $entryName,

                'type' => $isDirectory ? 'dir' : 'file'

            ];

            $directoryEntries[$entryIdentifier] = $entryArray;

            $iterator->next();

        }

        return $this->‪sortDirectoryEntries($directoryEntries, $sort, $sortRev);

    }


    protected function ‪sortDirectoryEntries($directoryEntries, $sort = '', $sortRev = false)

    {

        $entriesToSort = [];

        foreach ($directoryEntries as $entryArray) {

            ‪$dir      = pathinfo($entryArray['name'], PATHINFO_DIRNAME) . '/';

            $fullPath = $this->‪getAbsoluteBasePath() . $entryArray['identifier'];

            switch ($sort) {

                case 'size':

                    $sortingKey = '0';

                    if ($entryArray['type'] === 'file') {

                        $sortingKey = $this->‪getSpecificFileInformation($fullPath, ‪$dir, 'size');

                    }

                    // Add a character for a natural order sorting

                    $sortingKey .= 's';

                    break;

                case 'rw':

                    $perms = $this->‪getPermissions($entryArray['identifier']);

                    $sortingKey = ($perms['r'] ? 'R' : '')

                        . ($perms['w'] ? 'W' : '');

                    break;

                case 'fileext':

                    $sortingKey = pathinfo($entryArray['name'], PATHINFO_EXTENSION);

                    break;

                case 'tstamp':

                    $sortingKey = $this->‪getSpecificFileInformation($fullPath, ‪$dir, 'mtime');

                    // Add a character for a natural order sorting

                    $sortingKey .= 't';

                    break;

                case 'name':

                case 'file':

                default:

                    $sortingKey = $entryArray['name'];

            }

            $i = 0;

            while (isset($entriesToSort[$sortingKey . $i])) {

                $i++;

            }

            $entriesToSort[$sortingKey . $i] = $entryArray;

        }

        uksort($entriesToSort, 'strnatcasecmp');


        if ($sortRev) {

            $entriesToSort = array_reverse($entriesToSort);

        }


        return $entriesToSort;

    }


    protected function ‪extractFileInformation($filePath, $containerPath, array $propertiesToExtract = [])

    {

        if (empty($propertiesToExtract)) {

            $propertiesToExtract = [

                'size', 'atime', 'mtime', 'ctime', 'mimetype', 'name', 'extension',

                'identifier', 'identifier_hash', 'storage', 'folder_hash'

            ];

        }

        $fileInformation = [];

        foreach ($propertiesToExtract as $property) {

            $fileInformation[$property] = $this->‪getSpecificFileInformation($filePath, $containerPath, $property);

        }

        return $fileInformation;

    }


    public function ‪getSpecificFileInformation($fileIdentifier, $containerPath, $property)

    {

        $identifier = $this->‪canonicalizeAndCheckFileIdentifier($containerPath . ‪PathUtility::basename($fileIdentifier));


        $fileInfo = GeneralUtility::makeInstance(FileInfo::class, $fileIdentifier);

        switch ($property) {

            case 'size':

                return $fileInfo->getSize();

            case 'atime':

                return $fileInfo->getATime();

            case 'mtime':

                return $fileInfo->getMTime();

            case 'ctime':

                return $fileInfo->getCTime();

            case 'name':

                return ‪PathUtility::basename($fileIdentifier);

            case 'extension':

                return ‪PathUtility::pathinfo($fileIdentifier, PATHINFO_EXTENSION);

            case 'mimetype':

                return (string)$fileInfo->getMimeType();

            case 'identifier':

                return $identifier;

            case 'storage':

                return ‪$this->storageUid;

            case 'identifier_hash':

                return $this->‪hashIdentifier($identifier);

            case 'folder_hash':

                return $this->‪hashIdentifier($this->‪getParentFolderIdentifierOfIdentifier($identifier));

            default:

                throw new \InvalidArgumentException(sprintf('The information "%s" is not available.', $property), 1476047422);

        }

    }


    protected function ‪getAbsoluteBasePath()

    {

        return ‪$this->absoluteBasePath;

    }


    protected function ‪getAbsolutePath($fileIdentifier)

    {

        $relativeFilePath = ltrim($this->‪canonicalizeAndCheckFileIdentifier($fileIdentifier), '/');

        $path = $this->absoluteBasePath . $relativeFilePath;

        return $path;

    }


    public function ‪hash($fileIdentifier, $hashAlgorithm)

    {

        if (!in_array($hashAlgorithm, $this->supportedHashAlgorithms)) {

            throw new \InvalidArgumentException('Hash algorithm "' . $hashAlgorithm . '" is not supported.', 1304964032);

        }

        switch ($hashAlgorithm) {

            case 'sha1':

                $hash = sha1_file($this->‪getAbsolutePath($fileIdentifier));

                break;

            case 'md5':

                $hash = md5_file($this->‪getAbsolutePath($fileIdentifier));

                break;

            default:

                throw new \RuntimeException('Hash algorithm ' . $hashAlgorithm . ' is not implemented.', 1329644451);

        }

        return $hash;

    }


    public function ‪addFile($localFilePath, $targetFolderIdentifier, $newFileName = '', $removeOriginal = true)

    {

        $localFilePath = $this->‪canonicalizeAndCheckFilePath($localFilePath);

        // as for the "virtual storage" for backwards-compatibility, this check always fails, as the file probably lies under public web path

        // thus, it is not checked here

        // @todo is check in storage

        if (GeneralUtility::isFirstPartOfStr($localFilePath, $this->absoluteBasePath) && $this->storageUid > 0) {

            throw new \InvalidArgumentException('Cannot add a file that is already part of this storage.', 1314778269);

        }

        $newFileName = $this->‪sanitizeFileName($newFileName !== '' ? $newFileName : ‪PathUtility::basename($localFilePath));

        $newFileIdentifier = $this->‪canonicalizeAndCheckFolderIdentifier($targetFolderIdentifier) . $newFileName;

        $targetPath = $this->‪getAbsolutePath($newFileIdentifier);


        if ($removeOriginal) {

            if (is_uploaded_file($localFilePath)) {

                $result = move_uploaded_file($localFilePath, $targetPath);

            } else {

                $result = rename($localFilePath, $targetPath);

            }

        } else {

            $result = copy($localFilePath, $targetPath);

        }

        if ($result === false || !file_exists($targetPath)) {

            throw new \RuntimeException(

                'Adding file ' . $localFilePath . ' at ' . $newFileIdentifier . ' failed.',

                1476046453

            );

        }

        clearstatcache();

        // Change the permissions of the file

        GeneralUtility::fixPermissions($targetPath);

        return $newFileIdentifier;

    }


    public function ‪fileExists($fileIdentifier)

    {

        $absoluteFilePath = $this->‪getAbsolutePath($fileIdentifier);

        return is_file($absoluteFilePath);

    }


    public function ‪fileExistsInFolder($fileName, $folderIdentifier)

    {

        $identifier = $folderIdentifier . '/' . $fileName;

        $identifier = $this->‪canonicalizeAndCheckFileIdentifier($identifier);

        return $this->‪fileExists($identifier);

    }


    public function ‪folderExists($folderIdentifier)

    {

        $absoluteFilePath = $this->‪getAbsolutePath($folderIdentifier);

        return is_dir($absoluteFilePath);

    }


    public function ‪folderExistsInFolder($folderName, $folderIdentifier)

    {

        $identifier = $folderIdentifier . '/' . $folderName;

        $identifier = $this->‪canonicalizeAndCheckFolderIdentifier($identifier);

        return $this->‪folderExists($identifier);

    }


    public function ‪getFolderInFolder($folderName, $folderIdentifier)

    {

        $folderIdentifier = $this->‪canonicalizeAndCheckFolderIdentifier($folderIdentifier . '/' . $folderName);

        return $folderIdentifier;

    }


    public function ‪replaceFile($fileIdentifier, $localFilePath)

    {

        $filePath = $this->‪getAbsolutePath($fileIdentifier);

        if (is_uploaded_file($localFilePath)) {

            $result = move_uploaded_file($localFilePath, $filePath);

        } else {

            $result = rename($localFilePath, $filePath);

        }

        GeneralUtility::fixPermissions($filePath);

        if ($result === false) {

            throw new \RuntimeException('Replacing file ' . $fileIdentifier . ' with ' . $localFilePath . ' failed.', 1315314711);

        }

        return $result;

    }


    public function ‪copyFileWithinStorage($fileIdentifier, $targetFolderIdentifier, $fileName)

    {

        $sourcePath = $this->‪getAbsolutePath($fileIdentifier);

        $newIdentifier = $targetFolderIdentifier . '/' . $fileName;

        $newIdentifier = $this->‪canonicalizeAndCheckFileIdentifier($newIdentifier);


        $absoluteFilePath = $this->‪getAbsolutePath($newIdentifier);

        copy($sourcePath, $absoluteFilePath);

        GeneralUtility::fixPermissions($absoluteFilePath);

        return $newIdentifier;

    }


    public function ‪moveFileWithinStorage($fileIdentifier, $targetFolderIdentifier, $newFileName)

    {

        $sourcePath = $this->‪getAbsolutePath($fileIdentifier);

        $targetIdentifier = $targetFolderIdentifier . '/' . $newFileName;

        $targetIdentifier = $this->‪canonicalizeAndCheckFileIdentifier($targetIdentifier);

        $result = rename($sourcePath, $this->‪getAbsolutePath($targetIdentifier));

        if ($result === false) {

            throw new \RuntimeException('Moving file ' . $sourcePath . ' to ' . $targetIdentifier . ' failed.', 1315314712);

        }

        return $targetIdentifier;

    }


    protected function ‪copyFileToTemporaryPath($fileIdentifier)

    {

        $sourcePath = $this->‪getAbsolutePath($fileIdentifier);

        $temporaryPath = $this->‪getTemporaryPathForFile($fileIdentifier);

        $result = copy($sourcePath, $temporaryPath);

        touch($temporaryPath, filemtime($sourcePath));

        if ($result === false) {

            throw new \RuntimeException(

                'Copying file "' . $fileIdentifier . '" to temporary path "' . $temporaryPath . '" failed.',

                1320577649

            );

        }

        return $temporaryPath;

    }


    protected function ‪recycleFileOrFolder($filePath, $recycleDirectory)

    {

        $destinationFile = $recycleDirectory . '/' . ‪PathUtility::basename($filePath);

        if (file_exists($destinationFile)) {

            $timeStamp = \DateTimeImmutable::createFromFormat('U.u', microtime(true))->format('YmdHisu');

            $destinationFile = $recycleDirectory . '/' . $timeStamp . '_' . ‪PathUtility::basename($filePath);

        }

        $result = rename($filePath, $destinationFile);

        // Update the mtime for the file, so the recycler garbage collection task knows which files to delete

        // Using ctime() is not possible there since this is not supported on Windows

        if ($result) {

            touch($destinationFile);

        }

        return $result;

    }


    protected function ‪createIdentifierMap(array $filesAndFolders, $sourceFolderIdentifier, $targetFolderIdentifier)

    {

        $identifierMap = [];

        $identifierMap[$sourceFolderIdentifier] = $targetFolderIdentifier;

        foreach ($filesAndFolders as $oldItem) {

            if ($oldItem['type'] === 'dir') {

                $oldIdentifier = $oldItem['identifier'];

                $newIdentifier = $this->‪canonicalizeAndCheckFolderIdentifier(

                    str_replace($sourceFolderIdentifier, $targetFolderIdentifier, $oldItem['identifier'])

                );

            } else {

                $oldIdentifier = $oldItem['identifier'];

                $newIdentifier = $this->‪canonicalizeAndCheckFileIdentifier(

                    str_replace($sourceFolderIdentifier, $targetFolderIdentifier, $oldItem['identifier'])

                );

            }

            if (!file_exists($this->‪getAbsolutePath($newIdentifier))) {

                throw new Exception\FileOperationErrorException(

                    sprintf('File "%1$s" was not found (should have been copied/moved from "%2$s").', $newIdentifier, $oldIdentifier),

                    1330119453

                );

            }

            $identifierMap[$oldIdentifier] = $newIdentifier;

        }

        return $identifierMap;

    }


    public function ‪moveFolderWithinStorage($sourceFolderIdentifier, $targetFolderIdentifier, $newFolderName)

    {

        $sourcePath = $this->‪getAbsolutePath($sourceFolderIdentifier);

        $relativeTargetPath = $this->‪canonicalizeAndCheckFolderIdentifier($targetFolderIdentifier . '/' . $newFolderName);

        $targetPath = $this->‪getAbsolutePath($relativeTargetPath);

        // get all files and folders we are going to move, to have a map for updating later.

        $filesAndFolders = $this->‪retrieveFileAndFoldersInPath($sourcePath, true);

        $result = rename($sourcePath, $targetPath);

        if ($result === false) {

            throw new \RuntimeException('Moving folder ' . $sourcePath . ' to ' . $targetPath . ' failed.', 1320711817);

        }

        // Create a mapping from old to new identifiers

        $identifierMap = $this->‪createIdentifierMap($filesAndFolders, $sourceFolderIdentifier, $relativeTargetPath);

        return $identifierMap;

    }


    public function ‪copyFolderWithinStorage($sourceFolderIdentifier, $targetFolderIdentifier, $newFolderName)

    {

        // This target folder path already includes the topmost level, i.e. the folder this method knows as $folderToCopy.

        // We can thus rely on this folder being present and just create the subfolder we want to copy to.

        $newFolderIdentifier = $this->‪canonicalizeAndCheckFolderIdentifier($targetFolderIdentifier . '/' . $newFolderName);

        $sourceFolderPath = $this->‪getAbsolutePath($sourceFolderIdentifier);

        $targetFolderPath = $this->‪getAbsolutePath($newFolderIdentifier);


        mkdir($targetFolderPath);

        $iterator = new \RecursiveIteratorIterator(

            new \RecursiveDirectoryIterator($sourceFolderPath),

            \RecursiveIteratorIterator::SELF_FIRST,

            \RecursiveIteratorIterator::CATCH_GET_CHILD

        );

        // Rewind the iterator as this is important for some systems e.g. Windows

        $iterator->rewind();

        while ($iterator->valid()) {

            $current = $iterator->current();

            $fileName = $current->getFilename();

            $itemSubPath = GeneralUtility::fixWindowsFilePath($iterator->getSubPathname());

            if ($current->isDir() && !($fileName === '..' || $fileName === '.')) {

                GeneralUtility::mkdir($targetFolderPath . '/' . $itemSubPath);

            } elseif ($current->isFile()) {

                $copySourcePath = $sourceFolderPath . '/' . $itemSubPath;

                $copyTargetPath = $targetFolderPath . '/' . $itemSubPath;

                $result = copy($copySourcePath, $copyTargetPath);

                if ($result === false) {

                    // rollback

                    GeneralUtility::rmdir($targetFolderIdentifier, true);

                    throw new Exception\FileOperationErrorException(

                        'Copying resource "' . $copySourcePath . '" to "' . $copyTargetPath . '" failed.',

                        1330119452

                    );

                }

            }

            $iterator->next();

        }

        GeneralUtility::fixPermissions($targetFolderPath, true);

        return true;

    }


    public function ‪renameFile($fileIdentifier, $newName)

    {

        // Makes sure the Path given as parameter is valid

        $newName = $this->‪sanitizeFileName($newName);

        $newIdentifier = rtrim(GeneralUtility::fixWindowsFilePath(‪PathUtility::dirname($fileIdentifier)), '/') . '/' . $newName;

        $newIdentifier = $this->‪canonicalizeAndCheckFileIdentifier($newIdentifier);

        // The target should not exist already

        if ($this->‪fileExists($newIdentifier)) {

            throw new Exception\ExistingTargetFileNameException(

                'The target file "' . $newIdentifier . '" already exists.',

                1320291063

            );

        }

        $sourcePath = $this->‪getAbsolutePath($fileIdentifier);

        $targetPath = $this->‪getAbsolutePath($newIdentifier);

        $result = rename($sourcePath, $targetPath);

        if ($result === false) {

            throw new \RuntimeException('Renaming file ' . $sourcePath . ' to ' . $targetPath . ' failed.', 1320375115);

        }

        return $newIdentifier;

    }


    public function ‪renameFolder($folderIdentifier, $newName)

    {

        $folderIdentifier = $this->‪canonicalizeAndCheckFolderIdentifier($folderIdentifier);

        $newName = $this->‪sanitizeFileName($newName);


        $newIdentifier = ‪PathUtility::dirname($folderIdentifier) . '/' . $newName;

        $newIdentifier = $this->‪canonicalizeAndCheckFolderIdentifier($newIdentifier);


        $sourcePath = $this->‪getAbsolutePath($folderIdentifier);

        $targetPath = $this->‪getAbsolutePath($newIdentifier);

        // get all files and folders we are going to move, to have a map for updating later.

        $filesAndFolders = $this->‪retrieveFileAndFoldersInPath($sourcePath, true);

        $result = rename($sourcePath, $targetPath);

        if ($result === false) {

            throw new \RuntimeException(sprintf('Renaming folder "%1$s" to "%2$s" failed."', $sourcePath, $targetPath), 1320375116);

        }

        try {

            // Create a mapping from old to new identifiers

            $identifierMap = $this->‪createIdentifierMap($filesAndFolders, $folderIdentifier, $newIdentifier);

        } catch (\Exception $e) {

            rename($targetPath, $sourcePath);

            throw new \RuntimeException(

                sprintf(

                    'Creating filename mapping after renaming "%1$s" to "%2$s" failed. Reverted rename operation.\\n\\nOriginal error: %3$s"',

                    $sourcePath,

                    $targetPath,

                    $e->getMessage()

                ),

                1334160746

            );

        }

        return $identifierMap;

    }


    public function ‪deleteFile($fileIdentifier)

    {

        $filePath = $this->‪getAbsolutePath($fileIdentifier);

        $result = unlink($filePath);


        if ($result === false) {

            throw new \RuntimeException('Deletion of file ' . $fileIdentifier . ' failed.', 1320855304);

        }

        return $result;

    }


    public function ‪deleteFolder($folderIdentifier, $deleteRecursively = false)

    {

        $folderPath = $this->‪getAbsolutePath($folderIdentifier);

        $recycleDirectory = $this->‪getRecycleDirectory($folderPath);

        if (!empty($recycleDirectory) && $folderPath !== $recycleDirectory) {

            $result = $this->‪recycleFileOrFolder($folderPath, $recycleDirectory);

        } else {

            $result = GeneralUtility::rmdir($folderPath, $deleteRecursively);

        }

        if ($result === false) {

            throw new Exception\FileOperationErrorException(

                'Deleting folder "' . $folderIdentifier . '" failed.',

                1330119451

            );

        }

        return $result;

    }


    public function ‪isFolderEmpty($folderIdentifier)

    {

        $path = $this->‪getAbsolutePath($folderIdentifier);

        $dirHandle = opendir($path);

        while ($entry = readdir($dirHandle)) {

            if ($entry !== '.' && $entry !== '..') {

                closedir($dirHandle);

                return false;

            }

        }

        closedir($dirHandle);

        return true;

    }


    public function ‪getFileForLocalProcessing($fileIdentifier, $writable = true)

    {

        if ($writable === false) {

            return $this->‪getAbsolutePath($fileIdentifier);

        }

        return $this->‪copyFileToTemporaryPath($fileIdentifier);

    }


    public function ‪getPermissions($identifier)

    {

        $path = $this->‪getAbsolutePath($identifier);

        $permissionBits = fileperms($path);

        if ($permissionBits === false) {

            throw new Exception\ResourcePermissionsUnavailableException('Error while fetching permissions for ' . $path, 1319455097);

        }

        return [

            'r' => (bool)is_readable($path),

            'w' => (bool)is_writable($path)

        ];

    }


    public function ‪isWithin($folderIdentifier, $identifier)

    {

        $folderIdentifier = $this->‪canonicalizeAndCheckFileIdentifier($folderIdentifier);

        $entryIdentifier = $this->‪canonicalizeAndCheckFileIdentifier($identifier);

        if ($folderIdentifier === $entryIdentifier) {

            return true;

        }

        // File identifier canonicalization will not modify a single slash so

        // we must not append another slash in that case.

        if ($folderIdentifier !== '/') {

            $folderIdentifier .= '/';

        }

        return GeneralUtility::isFirstPartOfStr($entryIdentifier, $folderIdentifier);

    }


    public function ‪createFile($fileName, $parentFolderIdentifier)

    {

        $fileName = $this->‪sanitizeFileName(ltrim($fileName, '/'));

        $parentFolderIdentifier = $this->‪canonicalizeAndCheckFolderIdentifier($parentFolderIdentifier);

        $fileIdentifier = $this->‪canonicalizeAndCheckFileIdentifier(

            $parentFolderIdentifier . $fileName

        );

        $absoluteFilePath = $this->‪getAbsolutePath($fileIdentifier);

        $result = touch($absoluteFilePath);

        GeneralUtility::fixPermissions($absoluteFilePath);

        clearstatcache();

        if ($result !== true) {

            throw new \RuntimeException('Creating file ' . $fileIdentifier . ' failed.', 1320569854);

        }

        return $fileIdentifier;

    }


    public function ‪getFileContents($fileIdentifier)

    {

        $filePath = $this->‪getAbsolutePath($fileIdentifier);

        return file_get_contents($filePath);

    }


    public function ‪setFileContents($fileIdentifier, $contents)

    {

        $filePath = $this->‪getAbsolutePath($fileIdentifier);

        $result = file_put_contents($filePath, $contents);


        // Make sure later calls to filesize() etc. return correct values.

        clearstatcache(true, $filePath);


        if ($result === false) {

            throw new \RuntimeException('Setting contents of file "' . $fileIdentifier . '" failed.', 1325419305);

        }

        return $result;

    }


    public function ‪getRole($folderIdentifier)

    {

        $name = ‪PathUtility::basename($folderIdentifier);

        $role = $this->mappingFolderNameToRole[$name] ?? ‪FolderInterface::ROLE_DEFAULT;

        return $role;

    }


    public function ‪dumpFileContents($identifier)

    {

        readfile($this->‪getAbsolutePath($this->‪canonicalizeAndCheckFileIdentifier($identifier)), 0);

    }


    public function ‪streamFile(string $identifier, array $properties): ResponseInterface

    {

        $fileInfo = $this->‪getFileInfoByIdentifier($identifier, ['name', 'mimetype', 'mtime', 'size']);

        $downloadName = $properties['filename_overwrite'] ?? $fileInfo['name'] ?? '';

        $mimeType = $properties['mimetype_overwrite'] ?? $fileInfo['mimetype'] ?? '';

        $contentDisposition = ($properties['as_download'] ?? false) ? 'attachment' : 'inline';


        $filePath = $this->‪getAbsolutePath($this->‪canonicalizeAndCheckFileIdentifier($identifier));


        return new Response(

            new SelfEmittableLazyOpenStream($filePath),

            200,

            [

                'Content-Disposition' => $contentDisposition . '; filename="' . $downloadName . '"',

                'Content-Type' => $mimeType,

                'Content-Length' => (string)$fileInfo['size'],

                'Last-Modified' => gmdate('D, d M Y H:i:s', $fileInfo['mtime']) . ' GMT',

                // Cache-Control header is needed here to solve an issue with browser IE8 and lower

                // See for more information: http://support.microsoft.com/kb/323308

                'Cache-Control' => '',

            ]

        );

    }


    protected function ‪getRecycleDirectory($path)

    {

        $recyclerSubdirectory = array_search(‪FolderInterface::ROLE_RECYCLER, $this->mappingFolderNameToRole, true);

        if ($recyclerSubdirectory === false) {

            return '';

        }

        $rootDirectory = rtrim($this->‪getAbsolutePath($this->‪getRootLevelFolder()), '/');

        $searchDirectory = ‪PathUtility::dirname($path);

        // Check if file or folder to be deleted is inside a recycler directory

        if ($this->‪getRole($searchDirectory) === ‪FolderInterface::ROLE_RECYCLER) {

            $searchDirectory = ‪PathUtility::dirname($searchDirectory);

            // Check if file or folder to be deleted is inside the root recycler

            if ($searchDirectory == $rootDirectory) {

                return '';

            }

            $searchDirectory = ‪PathUtility::dirname($searchDirectory);

        }

        // Search for the closest recycler directory

        while ($searchDirectory) {

            $recycleDirectory = $searchDirectory . '/' . $recyclerSubdirectory;

            if (is_dir($recycleDirectory)) {

                return $recycleDirectory;

            }

            if ($searchDirectory === $rootDirectory) {

                return '';

            }

            $searchDirectory = ‪PathUtility::dirname($searchDirectory);

        }


        return '';

    }

}