LocalDriver.php

Go to the documentation of this file.

<?php
namespace TYPO3\CMS\Core\Resource\Driver;

use TYPO3\CMS\Core\Resource\FolderInterface;
use TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\CMS\Core\Utility\PathUtility;

class LocalDriver extends AbstractHierarchicalFilesystemDriver {

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

    protected $absoluteBasePath;

    protected $supportedHashAlgorithms = array('sha1', 'md5');

    protected $baseUri = NULL;

    protected $charsetConversion;

    protected $mappingFolderNameToRole = array(
        '_recycler_' => FolderInterface::ROLE_RECYCLER,
        '_temp_' => FolderInterface::ROLE_TEMPORARY,
        'user_upload' => FolderInterface::ROLE_USERUPLOAD,
    );

    public function __construct(array $configuration = array()) {
        parent::__construct($configuration);
        // The capabilities default of this driver. See CAPABILITY_* constants for possible values
        $this->capabilities =
            \TYPO3\CMS\Core\Resource\ResourceStorage::CAPABILITY_BROWSABLE
            | \TYPO3\CMS\Core\Resource\ResourceStorage::CAPABILITY_PUBLIC
            | \TYPO3\CMS\Core\Resource\ResourceStorage::CAPABILITY_WRITABLE;
    }

    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 &= ~\TYPO3\CMS\Core\Resource\ResourceStorage::CAPABILITY_PUBLIC;
        }
    }

    public function initialize() {
    }

    protected function determineBaseUrl() {
        // only calculate baseURI if the storage does not enforce jumpUrl Script
        if ($this->hasCapability(\TYPO3\CMS\Core\Resource\ResourceStorage::CAPABILITY_PUBLIC)) {
            if (GeneralUtility::isFirstPartOfStr($this->absoluteBasePath, PATH_site)) {
                // use site-relative URLs
                $temporaryBaseUri = rtrim(\TYPO3\CMS\Core\Utility\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 \TYPO3\CMS\Core\Resource\Exception\InvalidConfigurationException(
                'Configuration must contain base path.',
                1346510477
            );
        }

        if ($configuration['pathType'] === 'relative') {
            $relativeBasePath = $configuration['basePath'];
            $absoluteBasePath = PATH_site . $relativeBasePath;
        } else {
            $absoluteBasePath = $configuration['basePath'];
        }
        $absoluteBasePath = $this->canonicalizeAndCheckFilePath($absoluteBasePath);
        $absoluteBasePath = rtrim($absoluteBasePath, '/') . '/';
        if (!is_dir($absoluteBasePath)) {
            throw new \TYPO3\CMS\Core\Resource\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 = $parentFolderIdentifier . $newFolderName . '/';
            GeneralUtility::mkdir($this->getAbsolutePath($newIdentifier));
        } else {
            $parts = GeneralUtility::trimExplode('/', $newFolderName);
            $parts = array_map(array($this, 'sanitizeFileName'), $parts);
            $newFolderName = implode('/', $parts);
            $newIdentifier = $parentFolderIdentifier . $newFolderName . '/';
            GeneralUtility::mkdir_deep($this->getAbsolutePath($parentFolderIdentifier) . '/', $newFolderName);
        }
        return $newIdentifier;
    }

    public function getFileInfoByIdentifier($fileIdentifier, array $propertiesToExtract = array()) {
        $dirPath = PathUtility::dirname($fileIdentifier);
        $dirPath = $this->canonicalizeAndCheckFolderIdentifier($dirPath);

        $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);
        }
        return $this->extractFileInformation($absoluteFilePath, $dirPath, $propertiesToExtract);
    }

    public function getFolderInfoByIdentifier($folderIdentifier) {
        $folderIdentifier = $this->canonicalizeAndCheckFolderIdentifier($folderIdentifier);

        if (!$this->folderExists($folderIdentifier)) {
            throw new \TYPO3\CMS\Core\Resource\Exception\FolderDoesNotExistException(
                'File ' . $folderIdentifier . ' does not exist.',
                1314516810
            );
        }
        return array(
            'identifier' => $folderIdentifier,
            'name' => PathUtility::basename($folderIdentifier),
            'storage' => $this->storageUid
        );
    }

    public function sanitizeFileName($fileName, $charset = '') {
        // 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 {
            // Define character set
            if (!$charset) {
                if (TYPO3_MODE === 'FE') {
                    $charset = $GLOBALS['TSFE']->renderCharset;
                } else {
                    // default for Backend
                    $charset = 'utf-8';
                }
            }
            // If a charset was found, convert fileName
            if ($charset) {
                $fileName = $this->getCharsetConversion()->specCharsToASCII($charset, $fileName);
            }
            // Replace unwanted characters by 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 \TYPO3\CMS\Core\Resource\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) {
        $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
            );
        }

        // Fetch the files and folders and sort them by name; we have to do
        // this here because the directory iterator does return them in
        // an arbitrary order
        $items = $this->retrieveFileAndFoldersInPath($realPath, $recursive, $includeFiles, $includeDirs);
        uksort(
            $items,
            array('\\TYPO3\\CMS\\Core\\Utility\\ResourceUtility', 'recursiveFileListSortingHelper')
        );

        $iterator = new \ArrayIterator($items);
        if ($iterator->count() === 0) {
            return array();
        }

        // $c is the counter for how many items we still have to fetch (-1 is unlimited)
        $c = $numberOfItems > 0 ? $numberOfItems : - 1;
        $items = array();
        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();

            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;
            }
        }
        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, array(), $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;
                } elseif ($result === FALSE) {
                    throw new \RuntimeException('Could not apply file/folder name filter ' . $filter[0] . '::' . $filter[1]);
                }
            }
        }
        return TRUE;
    }

    public function getFilesInFolder($folderIdentifier, $start = 0, $numberOfItems = 0, $recursive = FALSE, array $filenameFilterCallbacks = array()) {
        return $this->getDirectoryItemList($folderIdentifier, $start, $numberOfItems, $filenameFilterCallbacks, TRUE, FALSE, $recursive);
    }

    public function getFoldersInFolder($folderIdentifier, $start = 0, $numberOfItems = 0, $recursive = FALSE, array $folderNameFilterCallbacks = array()) {
        return $this->getDirectoryItemList($folderIdentifier, $start, $numberOfItems, $folderNameFilterCallbacks, FALSE, TRUE, $recursive);
    }

    protected function retrieveFileAndFoldersInPath($path, $recursive = FALSE, $includeFiles = TRUE, $includeDirs = TRUE) {
        $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
            );
        } else {
            $iterator = new \RecursiveDirectoryIterator($path, $iteratorMode);
        }

        $directoryEntries = array();
        while ($iterator->valid()) {
            $entry = $iterator->current();
            // skip non-files/non-folders, and empty entries
            if ((!$entry->isFile() && !$entry->isDir()) || $entry->getFilename() == '' ||
                ($entry->isFile() && !$includeFiles) || ($entry->isDir() && !$includeDirs)) {
                $iterator->next();
                continue;
            }
            $entryIdentifier = '/' . substr($entry->getPathname(), $pathLength);
            $entryName = PathUtility::basename($entryIdentifier);
            if ($entry->isDir()) {
                $entryIdentifier .= '/';
            }
            $entryArray = array(
                'identifier' => $entryIdentifier,
                'name' => $entryName,
                'type' => $entry->isDir() ? 'dir' : 'file'
            );
            $directoryEntries[$entryIdentifier] = $entryArray;
            $iterator->next();
        }
        return $directoryEntries;
    }

    protected function extractFileInformation($filePath, $containerPath, array $propertiesToExtract = array()) {
        if (count($propertiesToExtract) === 0) {
            $propertiesToExtract = array(
                'size', 'atime', 'atime', 'mtime', 'ctime', 'mimetype', 'name',
                'identifier', 'identifier_hash', 'storage', 'folder_hash'
            );
        }
        $fileInformation = array();
        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));

        switch ($property) {
            case 'size':
                return filesize($fileIdentifier);
            case 'atime':
                return fileatime($fileIdentifier);
            case 'mtime':
                return filemtime($fileIdentifier);
            case 'ctime':
                return filectime($fileIdentifier);
            case 'name':
                return PathUtility::basename($fileIdentifier);
            case 'mimetype':
                return $this->getMimeTypeOfFile($fileIdentifier);
            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));
        }
        return NULL;
    }

    protected function getAbsoluteBasePath() {
        return $this->absoluteBasePath;
    }

    protected function getAbsolutePath($fileIdentifier) {
        $relativeFilePath = ltrim($this->canonicalizeAndCheckFileIdentifier($fileIdentifier), '/');
        $path = $this->absoluteBasePath . $relativeFilePath;
        return $path;
    }

    protected function getMimeTypeOfFile($absoluteFilePath) {
        if (function_exists('finfo_file')) {
            $fileInfo = new \finfo();
            return $fileInfo->file($absoluteFilePath, FILEINFO_MIME_TYPE);
        } elseif (function_exists('mime_content_type')) {
            return mime_content_type($absoluteFilePath);
        }
        return FALSE;
    }

    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 PATH_site
        // 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.');
        }
        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);
        $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 failed.', 1320577649);
        }
        return $temporaryPath;
    }

    protected function createIdentifierMap(array $filesAndFolders, $sourceFolderIdentifier, $targetFolderIdentifier) {
        $identifierMap = array();
        $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 \TYPO3\CMS\Core\Resource\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
        );
        // 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()) {
                $result = copy($sourceFolderPath . '/' . $itemSubPath, $targetFolderPath . '/' . $itemSubPath);
                if ($result === FALSE) {
                    // rollback
                    GeneralUtility::rmdir($targetFolderIdentifier, TRUE);
                    throw new \TYPO3\CMS\Core\Resource\Exception\FileOperationErrorException(
                        'Copying file "' . $sourceFolderPath . $itemSubPath . '" to "' . $targetFolderPath . $itemSubPath . '" 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 \TYPO3\CMS\Core\Resource\Exception\ExistingTargetFileNameException('The target file 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);
        $result = GeneralUtility::rmdir($folderPath, $deleteRecursively);
        if ($result === FALSE) {
            throw new \TYPO3\CMS\Core\Resource\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);
        } else {
            return $this->copyFileToTemporaryPath($fileIdentifier);
        }
    }


    public function getPermissions($identifier) {
        $path = $this->getAbsolutePath($identifier);
        $permissionBits = fileperms($path);
        if ($permissionBits === FALSE) {
            throw new \TYPO3\CMS\Core\Resource\Exception\ResourcePermissionsUnavailableException(
                'Error while fetching permissions for ' . $path,
                1319455097
            );
        }
        return array(
            '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) {
        if (!$this->isValidFilename($fileName)) {
            throw new \TYPO3\CMS\Core\Resource\Exception\InvalidFileNameException(
                'Invalid characters in fileName "' . $fileName . '"',
                1320572272
            );
        }
        $parentFolderIdentifier = $this->canonicalizeAndCheckFolderIdentifier($parentFolderIdentifier);
        $fileIdentifier =  $this->canonicalizeAndCheckFileIdentifier(
            $parentFolderIdentifier . $this->sanitizeFileName(ltrim($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;
    }

    protected function getCharsetConversion() {
        if (!isset($this->charsetConversion)) {
            if (TYPO3_MODE === 'FE') {
                $this->charsetConversion = $GLOBALS['TSFE']->csConvObj;
            } elseif (is_object($GLOBALS['LANG'])) {
                // BE assumed:
                $this->charsetConversion = $GLOBALS['LANG']->csConvObj;
            } else {
                // The object may not exist yet, so we need to create it now. Happens in the Install Tool for example.
                $this->charsetConversion = GeneralUtility::makeInstance('TYPO3\\CMS\\Core\\Charset\\CharsetConverter');
            }
        }
        return $this->charsetConversion;
    }

    public function getRole($folderIdentifier) {
        $name = PathUtility::basename($folderIdentifier);
        $role = $this->mappingFolderNameToRole[$name];
        if (empty($role)) {
            $role = FolderInterface::ROLE_DEFAULT;
        }
        return $role;
    }

    public function dumpFileContents($identifier) {
        readfile($this->getAbsolutePath($this->canonicalizeAndCheckFileIdentifier($identifier)), 0);
    }


}