ExtendedFileUtility.php

Go to the documentation of this file.

<?php
namespace TYPO3\CMS\Core\Utility\File;

/*
 * This file is part of the TYPO3 CMS project.
 *
 * It is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License, either version 2
 * of the License, or any later version.
 *
 * For the full copyright and license information, please read the
 * LICENSE.txt file that was distributed with this source code.
 *
 * The TYPO3 project - inspiring people to share!
 */

use TYPO3\CMS\Backend\Utility\BackendUtility;
use TYPO3\CMS\Core\Imaging\Icon;
use TYPO3\CMS\Core\Imaging\IconFactory;
use TYPO3\CMS\Core\Messaging\FlashMessage;
use TYPO3\CMS\Core\Messaging\FlashMessageService;
use TYPO3\CMS\Core\Resource\DuplicationBehavior;
use TYPO3\CMS\Core\Resource\Exception;
use TYPO3\CMS\Core\Resource\Exception\ResourceDoesNotExistException;
use TYPO3\CMS\Core\Resource\File;
use TYPO3\CMS\Core\Resource\Folder;
use TYPO3\CMS\Core\Resource\ResourceFactory;
use TYPO3\CMS\Core\Resource\ResourceStorage;
use TYPO3\CMS\Core\Utility\CommandUtility;
use TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\CMS\Core\Type\Exception\InvalidEnumerationValueException;

class ExtendedFileUtility extends BasicFileUtility
{
    public $unzipPath = '';

    public $dontCheckForUnique = 0;

    protected $existingFilesConflictMode;

    public $actionPerms = array(
        // File permissions
        'addFile' => false,
        'readFile' => false,
        'writeFile' => false,
        'copyFile' => false,
        'moveFile' => false,
        'renameFile' => false,
        'unzipFile' => false,
        'deleteFile' => false,
        // Folder permissions
        'addFolder' => false,
        'readFolder' => false,
        'writeFolder' => false,
        'copyFolder' => false,
        'moveFolder' => false,
        'renameFolder' => false,
        'deleteFolder' => false,
        'recursivedeleteFolder' => false
    );

    public $recyclerFN = '_recycler_';

    public $internalUploadMap = array();

    public $lastError = '';

    protected $errorMessages = array();

    protected $fileCmdMap;

    protected $fileFactory;

    public function getExistingFilesConflictMode()
    {
        return (string)$this->existingFilesConflictMode;
    }

    public function setExistingFilesConflictMode($existingFilesConflictMode)
    {
        try {
            $this->existingFilesConflictMode = DuplicationBehavior::cast($existingFilesConflictMode);
        } catch (InvalidEnumerationValueException $e) {
            throw new Exception(
                sprintf(
                    'Invalid argument, received: "%s", expected a value from enumeration \TYPO3\CMS\Core\Resource\DuplicationBehavior (%s)',
                    $existingFilesConflictMode,
                    implode(', ', DuplicationBehavior::getConstants())
                )
            );
        }
    }

    public function start($fileCmds)
    {
        $unzipPath = trim($GLOBALS['TYPO3_CONF_VARS']['BE']['unzip_path']);
        if (substr($unzipPath, -1) !== '/' && is_dir($unzipPath)) {
            // Make sure the path ends with a slash
            $unzipPath .= '/';
        }
        $this->unzipPath = $unzipPath;
        // Initialize Object Factory
        $this->fileFactory = ResourceFactory::getInstance();
        // Initializing file processing commands:
        $this->fileCmdMap = $fileCmds;
    }

    public function setActionPermissions(array $permissions = array())
    {
        if (empty($permissions)) {
            $permissions = $GLOBALS['BE_USER']->getFilePermissions();
        }
        $this->actionPerms = $permissions;
    }

    public function processData()
    {
        $result = array();
        if (!$this->isInit) {
            return false;
        }
        if (is_array($this->fileCmdMap)) {
            // Check if there were uploads expected, but no one made
            if ($this->fileCmdMap['upload']) {
                $uploads = $this->fileCmdMap['upload'];
                foreach ($uploads as $upload) {
                    if (empty($_FILES[('upload_' . $upload['data'])]['name'])
                        || (is_array($_FILES[('upload_' . $upload['data'])]['name'])
                            && empty($_FILES[('upload_' . $upload['data'])]['name'][0])
                        )
                    ) {
                        unset($this->fileCmdMap['upload'][$upload['data']]);
                    }
                }
                if (empty($this->fileCmdMap['upload'])) {
                    $this->writelog(1, 1, 108, 'No file was uploaded!', '');
                }
            }

            // Check if there were new folder names expected, but non given
            if ($this->fileCmdMap['newfolder']) {
                foreach ($this->fileCmdMap['newfolder'] as $key => $cmdArr) {
                    if (empty($cmdArr['data'])) {
                        unset($this->fileCmdMap['newfolder'][$key]);
                    }
                }
                if (empty($this->fileCmdMap['newfolder'])) {
                    $this->writeLog(6, 1, 108, 'No name for new folder given!', '');
                }
            }

            // Traverse each set of actions
            foreach ($this->fileCmdMap as $action => $actionData) {
                // Traverse all action data. More than one file might be affected at the same time.
                if (is_array($actionData)) {
                    $result[$action] = array();
                    foreach ($actionData as $cmdArr) {
                        // Clear file stats
                        clearstatcache();
                        // Branch out based on command:
                        switch ($action) {
                            case 'delete':
                                $result[$action][] = $this->func_delete($cmdArr);
                                break;
                            case 'copy':
                                $result[$action][] = $this->func_copy($cmdArr);
                                break;
                            case 'move':
                                $result[$action][] = $this->func_move($cmdArr);
                                break;
                            case 'rename':
                                $result[$action][] = $this->func_rename($cmdArr);
                                break;
                            case 'newfolder':
                                $result[$action][] = $this->func_newfolder($cmdArr);
                                break;
                            case 'newfile':
                                $result[$action][] = $this->func_newfile($cmdArr);
                                break;
                            case 'editfile':
                                $result[$action][] = $this->func_edit($cmdArr);
                                break;
                            case 'upload':
                                $result[$action][] = $this->func_upload($cmdArr);
                                break;
                            case 'replace':
                                $result[$action][] = $this->replaceFile($cmdArr);
                                break;
                            case 'unzip':
                                $result[$action][] = $this->func_unzip($cmdArr);
                                break;
                        }
                        // Hook for post-processing the action
                        if (is_array($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_extfilefunc.php']['processData'])) {
                            foreach ($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_extfilefunc.php']['processData'] as $classRef) {
                                $hookObject = GeneralUtility::getUserObj($classRef);
                                if (!$hookObject instanceof ExtendedFileUtilityProcessDataHookInterface) {
                                    throw new \UnexpectedValueException('$hookObject must implement interface TYPO3\\CMS\\Core\\Utility\\File\\ExtendedFileUtilityProcessDataHookInterface', 1279719168);
                                }
                                $hookObject->processData_postProcessAction($action, $cmdArr, $result[$action], $this);
                            }
                        }
                    }
                }
            }
        }
        return $result;
    }

    public function pushErrorMessagesToFlashMessageQueue()
    {
        foreach ($this->getErrorMessages() as $msg) {
            $flashMessage = GeneralUtility::makeInstance(
                FlashMessage::class,
                $msg,
                '',
                FlashMessage::ERROR,
                true
            );
            $this->addFlashMessage($flashMessage);
        }
    }

    public function getErrorMessages()
    {
        return $this->errorMessages;
    }

    public function writeLog($action, $error, $details_nr, $details, $data)
    {
        // Type value for tce_file.php
        $type = 2;
        if (is_object($this->getBackendUser())) {
            $this->getBackendUser()->writelog($type, $action, $error, $details_nr, $details, $data);
        }
        if ($error > 0) {
            $this->lastError = vsprintf($details, $data);
            $this->errorMessages[] = $this->lastError;
        }
    }

    /*************************************
     *
     * File operation functions
     *
     **************************************/
    public function func_delete(array $cmds)
    {
        $result = false;
        if (!$this->isInit) {
            return $result;
        }
        // Example indentifier for $cmds['data'] => "4:mypath/tomyfolder/myfile.jpg"
        // for backwards compatibility: the combined file identifier was the path+filename
        try {
            $fileObject = $this->getFileObject($cmds['data']);
        } catch (ResourceDoesNotExistException $e) {
            $flashMessage = GeneralUtility::makeInstance(
                FlashMessage::class,
                sprintf($GLOBALS['LANG']->sL('LLL:EXT:lang/locallang_core.xlf:message.description.fileNotFound'), $cmds['data']),
                $GLOBALS['LANG']->sL('LLL:EXT:lang/locallang_core.xlf:message.header.fileNotFound'),
                FlashMessage::ERROR,
                true
            );
            $this->addFlashMessage($flashMessage);

            return false;
        }
        // @todo implement the recycler feature which has been removed from the original implementation
        // checks to delete the file
        if ($fileObject instanceof File) {
            // check if the file still has references
            // Exclude sys_file_metadata records as these are no use references
            $databaseConnection = $this->getDatabaseConnection();
            $table = 'sys_refindex';
            $refIndexRecords = $databaseConnection->exec_SELECTgetRows(
                '*',
                $table,
                'deleted=0 AND ref_table=' . $databaseConnection->fullQuoteStr('sys_file', $table)
                    . ' AND ref_uid=' . (int)$fileObject->getUid()
                    . ' AND tablename != ' . $databaseConnection->fullQuoteStr('sys_file_metadata', $table)
            );
            $deleteFile = true;
            if (!empty($refIndexRecords)) {
                $shortcutContent = array();
                $brokenReferences = array();

                foreach ($refIndexRecords as $fileReferenceRow) {
                    if ($fileReferenceRow['tablename'] === 'sys_file_reference') {
                        $row = $this->transformFileReferenceToRecordReference($fileReferenceRow);
                        $shortcutRecord = BackendUtility::getRecord($row['tablename'], $row['recuid']);

                        if ($shortcutRecord) {
                            $shortcutContent[] = '[record:' . $row['tablename'] . ':' .  $row['recuid'] . ']';
                        } else {
                            $brokenReferences[] = $fileReferenceRow['ref_uid'];
                        }
                    }
                }
                if (!empty($brokenReferences)) {
                    // render a message that the file has broken references
                    $flashMessage = GeneralUtility::makeInstance(
                        FlashMessage::class,
                        sprintf($GLOBALS['LANG']->sL('LLL:EXT:lang/locallang_core.xlf:message.description.fileHasBrokenReferences'), count($brokenReferences)),
                        $GLOBALS['LANG']->sL('LLL:EXT:lang/locallang_core.xlf:message.header.fileHasBrokenReferences'),
                        FlashMessage::INFO,
                        true
                    );
                    $this->addFlashMessage($flashMessage);
                }
                if (!empty($shortcutContent)) {
                    // render a message that the file could not be deleted
                    $flashMessage = GeneralUtility::makeInstance(
                        FlashMessage::class,
                        sprintf($GLOBALS['LANG']->sL('LLL:EXT:lang/locallang_core.xlf:message.description.fileNotDeletedHasReferences'), $fileObject->getName()) . ' ' . implode(', ', $shortcutContent),
                        $GLOBALS['LANG']->sL('LLL:EXT:lang/locallang_core.xlf:message.header.fileNotDeletedHasReferences'),
                        FlashMessage::WARNING,
                        true
                    );
                    $this->addFlashMessage($flashMessage);
                    $deleteFile = false;
                }
            }

            if ($deleteFile) {
                try {
                    $result = $fileObject->delete();

                    // show the user that the file was deleted
                    $flashMessage = GeneralUtility::makeInstance(
                        FlashMessage::class,
                        sprintf($GLOBALS['LANG']->sL('LLL:EXT:lang/locallang_core.xlf:message.description.fileDeleted'), $fileObject->getName()),
                        $GLOBALS['LANG']->sL('LLL:EXT:lang/locallang_core.xlf:message.header.fileDeleted'),
                        FlashMessage::OK,
                        true
                    );
                    $this->addFlashMessage($flashMessage);
                    // Log success
                    $this->writelog(4, 0, 1, 'File "%s" deleted', array($fileObject->getIdentifier()));
                } catch (\TYPO3\CMS\Core\Resource\Exception\InsufficientFileAccessPermissionsException $e) {
                    $this->writelog(4, 1, 112, 'You are not allowed to access the file', array($fileObject->getIdentifier()));
                } catch (\TYPO3\CMS\Core\Resource\Exception\NotInMountPointException $e) {
                    $this->writelog(4, 1, 111, 'Target was not within your mountpoints! T="%s"', array($fileObject->getIdentifier()));
                } catch (\RuntimeException $e) {
                    $this->writelog(4, 1, 110, 'Could not delete file "%s". Write-permission problem?', array($fileObject->getIdentifier()));
                }
            }
        } else {
            if (!$this->folderHasFilesInUse($fileObject)) {
                try {
                    $result = $fileObject->delete(true);
                    if ($result) {
                        // notify the user that the folder was deleted
                        $flashMessage = GeneralUtility::makeInstance(
                            FlashMessage::class,
                            sprintf($GLOBALS['LANG']->sL('LLL:EXT:lang/locallang_core.xlf:message.description.folderDeleted'), $fileObject->getName()),
                            $GLOBALS['LANG']->sL('LLL:EXT:lang/locallang_core.xlf:message.header.folderDeleted'),
                            FlashMessage::OK,
                            true
                        );
                        $this->addFlashMessage($flashMessage);
                        // Log success
                        $this->writelog(4, 0, 3, 'Directory "%s" deleted', array($fileObject->getIdentifier()));
                    }
                } catch (\TYPO3\CMS\Core\Resource\Exception\InsufficientUserPermissionsException $e) {
                    $this->writelog(4, 1, 120, 'Could not delete directory! Is directory "%s" empty? (You are not allowed to delete directories recursively).', array($fileObject->getIdentifier()));
                } catch (\TYPO3\CMS\Core\Resource\Exception\InsufficientFolderAccessPermissionsException $e) {
                    $this->writelog(4, 1, 123, 'You are not allowed to access the directory', array($fileObject->getIdentifier()));
                } catch (\TYPO3\CMS\Core\Resource\Exception\NotInMountPointException $e) {
                    $this->writelog(4, 1, 121, 'Target was not within your mountpoints! T="%s"', array($fileObject->getIdentifier()));
                } catch (\TYPO3\CMS\Core\Resource\Exception\FileOperationErrorException $e) {
                    $this->writelog(4, 1, 120, 'Could not delete directory "%s"! Write-permission problem?', array($fileObject->getIdentifier()));
                }
            }
        }

        return $result;
    }

    public function folderHasFilesInUse(Folder $folder)
    {
        $files = $folder->getFiles(0, 0, Folder::FILTER_MODE_USE_OWN_AND_STORAGE_FILTERS, true);
        if (empty($files)) {
            return false;
        }

        $fileUids = array();
        foreach ($files as $file) {
            $fileUids[] = $file->getUid();
        }
        $numberOfReferences = $this->getDatabaseConnection()->exec_SELECTcountRows(
            '*',
            'sys_refindex',
            'deleted=0 AND ref_table="sys_file" AND ref_uid IN (' . implode(',', $fileUids) . ') AND tablename<>"sys_file_metadata"'
        );

        $hasReferences = $numberOfReferences > 0;
        if ($hasReferences) {
            $flashMessage = GeneralUtility::makeInstance(
                FlashMessage::class,
                $GLOBALS['LANG']->sL('LLL:EXT:lang/locallang_core.xlf:message.description.folderNotDeletedHasFilesWithReferences'),
                $GLOBALS['LANG']->sL('LLL:EXT:lang/locallang_core.xlf:message.header.folderNotDeletedHasFilesWithReferences'),
                FlashMessage::WARNING,
                true
            );
            $this->addFlashMessage($flashMessage);
        }

        return $hasReferences;
    }

    protected function transformFileReferenceToRecordReference(array $referenceRecord)
    {
        $fileReference = $this->getDatabaseConnection()->exec_SELECTgetSingleRow(
            '*',
            'sys_file_reference',
            'uid=' . (int)$referenceRecord['recuid']
        );
        return array(
            'recuid' => $fileReference['uid_foreign'],
            'tablename' => $fileReference['tablenames'],
            'field' => $fileReference['fieldname'],
            'flexpointer' => '',
            'softref_key' => '',
            'sorting' => $fileReference['sorting_foreign']
        );
    }

    protected function getFileObject($identifier)
    {
        $object = $this->fileFactory->retrieveFileOrFolderObject($identifier);
        if (!is_object($object)) {
            throw new \TYPO3\CMS\Core\Resource\Exception\InvalidFileException('The item ' . $identifier . ' was not a file or directory!!', 1320122453);
        }
        if ($object->getStorage()->getUid() === 0) {
            throw new \TYPO3\CMS\Core\Resource\Exception\InsufficientFileAccessPermissionsException('You are not allowed to access files outside your storages', 1375889830);
        }
        return $object;
    }

    protected function func_copy($cmds)
    {
        if (!$this->isInit) {
            return false;
        }
        $sourceFileObject = $this->getFileObject($cmds['data']);
        $targetFolderObject = $this->getFileObject($cmds['target']);
        // Basic check
        if (!$targetFolderObject instanceof Folder) {
            $this->writelog(2, 2, 100, 'Destination "%s" was not a directory', array($cmds['target']));
            return false;
        }
        // If this is TRUE, we append _XX to the file name if
        $appendSuffixOnConflict = (string)$cmds['altName'];
        $resultObject = null;
        $conflictMode = $appendSuffixOnConflict !== '' ? DuplicationBehavior::RENAME : DuplicationBehavior::CANCEL;
        // Copying the file
        if ($sourceFileObject instanceof File) {
            try {
                $resultObject = $sourceFileObject->copyTo($targetFolderObject, null, $conflictMode);
            } catch (\TYPO3\CMS\Core\Resource\Exception\InsufficientUserPermissionsException $e) {
                $this->writelog(2, 1, 114, 'You are not allowed to copy files', '');
            } catch (\TYPO3\CMS\Core\Resource\Exception\InsufficientFileAccessPermissionsException $e) {
                $this->writelog(2, 1, 110, 'Could not access all necessary resources. Source file or destination maybe was not within your mountpoints? T="%s", D="%s"', array($sourceFileObject->getIdentifier(), $targetFolderObject->getIdentifier()));
            } catch (\TYPO3\CMS\Core\Resource\Exception\IllegalFileExtensionException $e) {
                $this->writelog(2, 1, 111, 'Extension of file name "%s" is not allowed in "%s"!', array($sourceFileObject->getIdentifier(), $targetFolderObject->getIdentifier()));
            } catch (\TYPO3\CMS\Core\Resource\Exception\ExistingTargetFileNameException $e) {
                $this->writelog(2, 1, 112, 'File "%s" already exists in folder "%s"!', array($sourceFileObject->getIdentifier(), $targetFolderObject->getIdentifier()));
            } catch (\BadMethodCallException $e) {
                $this->writelog(3, 1, 128, 'The function to copy a file between storages is not yet implemented', array());
            } catch (\RuntimeException $e) {
                $this->writelog(2, 2, 109, 'File "%s" WAS NOT copied to "%s"! Write-permission problem?', array($sourceFileObject->getIdentifier(), $targetFolderObject->getIdentifier()));
            }
            if ($resultObject) {
                $this->writelog(2, 0, 1, 'File "%s" copied to "%s"', array($sourceFileObject->getIdentifier(), $resultObject->getIdentifier()));
            }
        } else {
            // Else means this is a Folder
            $sourceFolderObject = $sourceFileObject;
            try {
                $resultObject = $sourceFolderObject->copyTo($targetFolderObject, null, $conflictMode);
            } catch (\TYPO3\CMS\Core\Resource\Exception\InsufficientUserPermissionsException $e) {
                $this->writelog(2, 1, 125, 'You are not allowed to copy directories', '');
            } catch (\TYPO3\CMS\Core\Resource\Exception\InsufficientFileAccessPermissionsException $e) {
                $this->writelog(2, 1, 110, 'Could not access all necessary resources. Source file or destination maybe was not within your mountpoints? T="%s", D="%s"', array($sourceFolderObject->getIdentifier(), $targetFolderObject->getIdentifier()));
            } catch (\TYPO3\CMS\Core\Resource\Exception\InsufficientFolderAccessPermissionsException $e) {
                $this->writelog(2, 1, 121, 'You don\'t have full access to the destination directory "%s"!', array($targetFolderObject->getIdentifier()));
            } catch (\TYPO3\CMS\Core\Resource\Exception\InvalidTargetFolderException $e) {
                $this->writelog(2, 1, 122, 'Cannot copy folder "%s" into target folder "%s", because the target folder is already within the folder to be copied!', array($sourceFolderObject->getName(), $targetFolderObject->getName()));
            } catch (\TYPO3\CMS\Core\Resource\Exception\ExistingTargetFolderException $e) {
                $this->writelog(2, 1, 123, 'Target "%s" already exists!', array($targetFolderObject->getIdentifier()));
            } catch (\BadMethodCallException $e) {
                $this->writelog(3, 1, 129, 'The function to copy a folder between storages is not yet implemented', array());
            } catch (\RuntimeException $e) {
                $this->writelog(2, 2, 119, 'Directory "%s" WAS NOT copied to "%s"! Write-permission problem?', array($sourceFolderObject->getIdentifier(), $targetFolderObject->getIdentifier()));
            }
            if ($resultObject) {
                $this->writelog(2, 0, 2, 'Directory "%s" copied to "%s"', array($sourceFolderObject->getIdentifier(), $targetFolderObject->getIdentifier()));
            }
        }
        return $resultObject;
    }

    protected function func_move($cmds)
    {
        if (!$this->isInit) {
            return false;
        }
        $sourceFileObject = $this->getFileObject($cmds['data']);
        $targetFolderObject = $this->getFileObject($cmds['target']);
        // Basic check
        if (!$targetFolderObject instanceof Folder) {
            $this->writelog(3, 2, 100, 'Destination "%s" was not a directory', array($cmds['target']));
            return false;
        }
        $alternativeName = (string)$cmds['altName'];
        $resultObject = null;
        // Moving the file
        if ($sourceFileObject instanceof File) {
            try {
                if ($alternativeName !== '') {
                    // Don't allow overwriting existing files, but find a new name
                    $resultObject = $sourceFileObject->moveTo($targetFolderObject, $alternativeName, DuplicationBehavior::RENAME);
                } else {
                    // Don't allow overwriting existing files
                    $resultObject = $sourceFileObject->moveTo($targetFolderObject, null, DuplicationBehavior::CANCEL);
                }
                $this->writelog(3, 0, 1, 'File "%s" moved to "%s"', array($sourceFileObject->getIdentifier(), $resultObject->getIdentifier()));
            } catch (\TYPO3\CMS\Core\Resource\Exception\InsufficientUserPermissionsException $e) {
                $this->writelog(3, 1, 114, 'You are not allowed to move files', '');
            } catch (\TYPO3\CMS\Core\Resource\Exception\InsufficientFileAccessPermissionsException $e) {
                $this->writelog(3, 1, 110, 'Could not access all necessary resources. Source file or destination maybe was not within your mountpoints? T="%s", D="%s"', array($sourceFileObject->getIdentifier(), $targetFolderObject->getIdentifier()));
            } catch (\TYPO3\CMS\Core\Resource\Exception\IllegalFileExtensionException $e) {
                $this->writelog(3, 1, 111, 'Extension of file name "%s" is not allowed in "%s"!', array($sourceFileObject->getIdentifier(), $targetFolderObject->getIdentifier()));
            } catch (\TYPO3\CMS\Core\Resource\Exception\ExistingTargetFileNameException $e) {
                $this->writelog(3, 1, 112, 'File "%s" already exists in folder "%s"!', array($sourceFileObject->getIdentifier(), $targetFolderObject->getIdentifier()));
            } catch (\BadMethodCallException $e) {
                $this->writelog(3, 1, 126, 'The function to move a file between storages is not yet implemented', array());
            } catch (\RuntimeException $e) {
                $this->writelog(3, 2, 109, 'File "%s" WAS NOT copied to "%s"! Write-permission problem?', array($sourceFileObject->getIdentifier(), $targetFolderObject->getIdentifier()));
            }
        } else {
            // Else means this is a Folder
            $sourceFolderObject = $sourceFileObject;
            try {
                if ($alternativeName !== '') {
                    // Don't allow overwriting existing files, but find a new name
                    $resultObject = $sourceFolderObject->moveTo($targetFolderObject, $alternativeName, DuplicationBehavior::RENAME);
                } else {
                    // Don't allow overwriting existing files
                    $resultObject = $sourceFolderObject->moveTo($targetFolderObject, null, DuplicationBehavior::RENAME);
                }
                $this->writelog(3, 0, 2, 'Directory "%s" moved to "%s"', array($sourceFolderObject->getIdentifier(), $targetFolderObject->getIdentifier()));
            } catch (\TYPO3\CMS\Core\Resource\Exception\InsufficientUserPermissionsException $e) {
                $this->writelog(3, 1, 125, 'You are not allowed to move directories', '');
            } catch (\TYPO3\CMS\Core\Resource\Exception\InsufficientFileAccessPermissionsException $e) {
                $this->writelog(3, 1, 110, 'Could not access all necessary resources. Source file or destination maybe was not within your mountpoints? T="%s", D="%s"', array($sourceFolderObject->getIdentifier(), $targetFolderObject->getIdentifier()));
            } catch (\TYPO3\CMS\Core\Resource\Exception\InsufficientFolderAccessPermissionsException $e) {
                $this->writelog(3, 1, 121, 'You don\'t have full access to the destination directory "%s"!', array($targetFolderObject->getIdentifier()));
            } catch (\TYPO3\CMS\Core\Resource\Exception\InvalidTargetFolderException $e) {
                $this->writelog(3, 1, 122, 'Cannot move folder "%s" into target folder "%s", because the target folder is already within the folder to be moved!', array($sourceFolderObject->getName(), $targetFolderObject->getName()));
            } catch (\TYPO3\CMS\Core\Resource\Exception\ExistingTargetFolderException $e) {
                $this->writelog(3, 1, 123, 'Target "%s" already exists!', array($targetFolderObject->getIdentifier()));
            } catch (\BadMethodCallException $e) {
                $this->writelog(3, 1, 127, 'The function to move a folder between storages is not yet implemented', array());
            } catch (\RuntimeException $e) {
                $this->writelog(3, 2, 119, 'Directory "%s" WAS NOT moved to "%s"! Write-permission problem?', array($sourceFolderObject->getIdentifier(), $targetFolderObject->getIdentifier()));
            }
        }
        return $resultObject;
    }

    public function func_rename($cmds)
    {
        if (!$this->isInit) {
            return false;
        }
        $sourceFileObject = $this->getFileObject($cmds['data']);
        $sourceFile = $sourceFileObject->getName();
        $targetFile = $cmds['target'];
        $resultObject = null;
        if ($sourceFileObject instanceof File) {
            try {
                // Try to rename the File
                $resultObject = $sourceFileObject->rename($targetFile);
                $this->writelog(5, 0, 1, 'File renamed from "%s" to "%s"', array($sourceFile, $targetFile));
            } catch (\TYPO3\CMS\Core\Resource\Exception\InsufficientUserPermissionsException $e) {
                $this->writelog(5, 1, 102, 'You are not allowed to rename files!', '');
            } catch (\TYPO3\CMS\Core\Resource\Exception\IllegalFileExtensionException $e) {
                $this->writelog(5, 1, 101, 'Extension of file name "%s" or "%s" was not allowed!', array($sourceFileObject->getName(), $targetFile));
            } catch (\TYPO3\CMS\Core\Resource\Exception\ExistingTargetFileNameException $e) {
                $this->writelog(5, 1, 120, 'Destination "%s" existed already!', array($targetFile));
            } catch (\TYPO3\CMS\Core\Resource\Exception\NotInMountPointException $e) {
                $this->writelog(5, 1, 121, 'Destination path "%s" was not within your mountpoints!', array($targetFile));
            } catch (\RuntimeException $e) {
                $this->writelog(5, 1, 100, 'File "%s" was not renamed! Write-permission problem in "%s"?', array($sourceFileObject->getName(), $targetFile));
            }
        } else {
            // Else means this is a Folder
            try {
                // Try to rename the Folder
                $resultObject = $sourceFileObject->rename($targetFile);
                $this->writelog(5, 0, 2, 'Directory renamed from "%s" to "%s"', array($sourceFile, $targetFile));
            } catch (\TYPO3\CMS\Core\Resource\Exception\InsufficientUserPermissionsException $e) {
                $this->writelog(5, 1, 111, 'You are not allowed to rename directories!', '');
            } catch (\TYPO3\CMS\Core\Resource\Exception\ExistingTargetFileNameException $e) {
                $this->writelog(5, 1, 120, 'Destination "%s" existed already!', array($targetFile));
            } catch (\TYPO3\CMS\Core\Resource\Exception\NotInMountPointException $e) {
                $this->writelog(5, 1, 121, 'Destination path "%s" was not within your mountpoints!', array($targetFile));
            } catch (\RuntimeException $e) {
                $this->writelog(5, 1, 110, 'Directory "%s" was not renamed! Write-permission problem in "%s"?', array($sourceFileObject->getName(), $targetFile));
            }
        }
        return $resultObject;
    }

    public function func_newfolder($cmds)
    {
        if (!$this->isInit) {
            return false;
        }
        $targetFolderObject = $this->getFileObject($cmds['target']);
        if (!$targetFolderObject instanceof Folder) {
            $this->writelog(6, 2, 104, 'Destination "%s" was not a directory', array($cmds['target']));
            return false;
        }
        $resultObject = null;
        try {
            $folderName = $cmds['data'];
            $resultObject = $targetFolderObject->createFolder($folderName);
            $this->writelog(6, 0, 1, 'Directory "%s" created in "%s"', array($folderName, $targetFolderObject->getIdentifier() . '/'));
        } catch (\TYPO3\CMS\Core\Resource\Exception\InvalidFileNameException $e) {
            $this->writelog(6, 1, 104, 'Invalid folder name "%s"!', [$folderName]);
        } catch (\TYPO3\CMS\Core\Resource\Exception\InsufficientFolderWritePermissionsException $e) {
            $this->writelog(6, 1, 103, 'You are not allowed to create directories!', '');
        } catch (\TYPO3\CMS\Core\Resource\Exception\NotInMountPointException $e) {
            $this->writelog(6, 1, 102, 'Destination path "%s" was not within your mountpoints!', array($targetFolderObject->getIdentifier() . '/'));
        } catch (\TYPO3\CMS\Core\Resource\Exception\ExistingTargetFolderException $e) {
            $this->writelog(6, 1, 101, 'File or directory "%s" existed already!', array($folderName));
        } catch (\RuntimeException $e) {
            $this->writelog(6, 1, 100, 'Directory "%s" not created. Write-permission problem in "%s"?', array($folderName, $targetFolderObject->getIdentifier() . '/'));
        }
        return $resultObject;
    }

    public function func_newfile($cmds)
    {
        if (!$this->isInit) {
            return false;
        }
        $targetFolderObject = $this->getFileObject($cmds['target']);
        if (!$targetFolderObject instanceof Folder) {
            $this->writelog(8, 2, 104, 'Destination "%s" was not a directory', array($cmds['target']));
            return false;
        }
        $resultObject = null;
        try {
            $fileName = $cmds['data'];
            $resultObject = $targetFolderObject->createFile($fileName);
            $this->writelog(8, 0, 1, 'File created: "%s"', array($fileName));
        } catch (\TYPO3\CMS\Core\Resource\Exception\IllegalFileExtensionException $e) {
            $this->writeLog(8, 1, 106, 'Extension of file "%s" was not allowed!', array($fileName));
        } catch (\TYPO3\CMS\Core\Resource\Exception\InsufficientFolderWritePermissionsException $e) {
            $this->writelog(8, 1, 103, 'You are not allowed to create files!', '');
        } catch (\TYPO3\CMS\Core\Resource\Exception\NotInMountPointException $e) {
            $this->writelog(8, 1, 102, 'Destination path "%s" was not within your mountpoints!', array($targetFolderObject->getIdentifier()));
        } catch (\TYPO3\CMS\Core\Resource\Exception\ExistingTargetFileNameException $e) {
            $this->writelog(8, 1, 101, 'File existed already in "%s"!', array($targetFolderObject->getIdentifier()));
        } catch (\TYPO3\CMS\Core\Resource\Exception\InvalidFileNameException $e) {
            $this->writelog(8, 1, 106, 'File name "%s" was not allowed!', $fileName);
        } catch (\RuntimeException $e) {
            $this->writelog(8, 1, 100, 'File "%s" was not created! Write-permission problem in "%s"?', array($fileName, $targetFolderObject->getIdentifier()));
        }
        return $resultObject;
    }

    public function func_edit($cmds)
    {
        if (!$this->isInit) {
            return false;
        }
        // Example indentifier for $cmds['target'] => "4:mypath/tomyfolder/myfile.jpg"
        // for backwards compatibility: the combined file identifier was the path+filename
        $fileIdentifier = $cmds['target'];
        $fileObject = $this->getFileObject($fileIdentifier);
        // Example indentifier for $cmds['target'] => "2:targetpath/targetfolder/"
        $content = $cmds['data'];
        if (!$fileObject instanceof File) {
            $this->writelog(9, 2, 123, 'Target "%s" was not a file!', array($fileIdentifier));
            return false;
        }
        $extList = $GLOBALS['TYPO3_CONF_VARS']['SYS']['textfile_ext'];
        if (!GeneralUtility::inList($extList, $fileObject->getExtension())) {
            $this->writelog(9, 1, 102, 'File extension "%s" is not a textfile format! (%s)', array($fileObject->getExtension(), $extList));
            return false;
        }
        try {
            $fileObject->setContents($content);
            clearstatcache();
            $this->writelog(9, 0, 1, 'File saved to "%s", bytes: %s, MD5: %s ', array($fileObject->getIdentifier(), $fileObject->getSize(), md5($content)));
            return true;
        } catch (\TYPO3\CMS\Core\Resource\Exception\InsufficientUserPermissionsException $e) {
            $this->writelog(9, 1, 104, 'You are not allowed to edit files!', '');
            return false;
        } catch (\TYPO3\CMS\Core\Resource\Exception\InsufficientFileWritePermissionsException $e) {
            $this->writelog(9, 1, 100, 'File "%s" was not saved! Write-permission problem?', array($fileObject->getIdentifier()));
            return false;
        } catch (\TYPO3\CMS\Core\Resource\Exception\IllegalFileExtensionException $e) {
            $this->writelog(9, 1, 100, 'File "%s" was not saved! File extension rejected!', array($fileObject->getIdentifier()));
            return false;
        }
    }

    public function func_upload($cmds)
    {
        if (!$this->isInit) {
            return false;
        }
        $uploadPosition = $cmds['data'];
        $uploadedFileData = $_FILES['upload_' . $uploadPosition];
        if (empty($uploadedFileData['name']) || is_array($uploadedFileData['name']) && empty($uploadedFileData['name'][0])) {
            $this->writelog(1, 2, 108, 'No file was uploaded!', '');
            return false;
        }
        // Example indentifier for $cmds['target'] => "2:targetpath/targetfolder/"
        $targetFolderObject = $this->getFileObject($cmds['target']);
        // Uploading with non HTML-5-style, thus, make an array out of it, so we can loop over it
        if (!is_array($uploadedFileData['name'])) {
            $uploadedFileData = array(
                'name' => array($uploadedFileData['name']),
                'type' => array($uploadedFileData['type']),
                'tmp_name' => array($uploadedFileData['tmp_name']),
                'size' => array($uploadedFileData['size'])
            );
        }
        $resultObjects = array();
        $numberOfUploadedFilesForPosition = count($uploadedFileData['name']);
        // Loop through all uploaded files
        for ($i = 0; $i < $numberOfUploadedFilesForPosition; $i++) {
            $fileInfo = array(
                'name' => $uploadedFileData['name'][$i],
                'type' => $uploadedFileData['type'][$i],
                'tmp_name' => $uploadedFileData['tmp_name'][$i],
                'size' => $uploadedFileData['size'][$i]
            );
            try {
                if ((int)$this->dontCheckForUnique === 1) {
                    GeneralUtility::deprecationLog('dontCheckForUnique = 1 is deprecated. Use setExistingFilesConflictMode(DuplicationBehavior::REPLACE);. Support for dontCheckForUnique will be removed in TYPO3 CMS 8.');
                    $this->existingFilesConflictMode = DuplicationBehavior::cast(DuplicationBehavior::REPLACE);
                }

                $fileObject = $targetFolderObject->addUploadedFile($fileInfo, (string)$this->existingFilesConflictMode);
                $fileObject = ResourceFactory::getInstance()->getFileObjectByStorageAndIdentifier($targetFolderObject->getStorage()->getUid(), $fileObject->getIdentifier());
                if ($this->existingFilesConflictMode->equals(DuplicationBehavior::REPLACE)) {
                    $this->getIndexer($fileObject->getStorage())->updateIndexEntry($fileObject);
                }
                $resultObjects[] = $fileObject;
                $this->internalUploadMap[$uploadPosition] = $fileObject->getCombinedIdentifier();
                $this->writelog(1, 0, 1, 'Uploading file "%s" to "%s"', array($fileInfo['name'], $targetFolderObject->getIdentifier()));
            } catch (\TYPO3\CMS\Core\Resource\Exception\InsufficientFileWritePermissionsException $e) {
                $this->writelog(1, 1, 107, 'You are not allowed to override "%s"!', array($fileInfo['name']));
            } catch (\TYPO3\CMS\Core\Resource\Exception\UploadException $e) {
                $this->writelog(1, 2, 106, 'The upload has failed, no uploaded file found!', '');
            } catch (\TYPO3\CMS\Core\Resource\Exception\InsufficientUserPermissionsException $e) {
                $this->writelog(1, 1, 105, 'You are not allowed to upload files!', '');
            } catch (\TYPO3\CMS\Core\Resource\Exception\UploadSizeException $e) {
                $this->writelog(1, 1, 104, 'The uploaded file "%s" exceeds the size-limit', array($fileInfo['name']));
            } catch (\TYPO3\CMS\Core\Resource\Exception\InsufficientFolderWritePermissionsException $e) {
                $this->writelog(1, 1, 103, 'Destination path "%s" was not within your mountpoints!', array($targetFolderObject->getIdentifier()));
            } catch (\TYPO3\CMS\Core\Resource\Exception\IllegalFileExtensionException $e) {
                $this->writelog(1, 1, 102, 'Extension of file name "%s" is not allowed in "%s"!', array($fileInfo['name'], $targetFolderObject->getIdentifier()));
            } catch (\TYPO3\CMS\Core\Resource\Exception\ExistingTargetFileNameException $e) {
                $this->writelog(1, 1, 101, 'No unique filename available in "%s"!', array($targetFolderObject->getIdentifier()));
            } catch (\RuntimeException $e) {
                $this->writelog(1, 1, 100, 'Uploaded file could not be moved! Write-permission problem in "%s"?', array($targetFolderObject->getIdentifier()));
            }
        }

        return $resultObjects;
    }

    public function func_unzip($cmds)
    {
        if (!$this->isInit || $this->dont_use_exec_commands) {
            return false;
        }
        $theFile = $cmds['data'];
        if (!@is_file($theFile)) {
            $this->writelog(7, 2, 105, 'The file "%s" did not exist!', array($theFile));
            return false;
        }
        $fI = GeneralUtility::split_fileref($theFile);
        if (!isset($cmds['target'])) {
            $cmds['target'] = $fI['path'];
        }
        // Clean up destination directory
        // !!! Method has been put in the local driver, can be saftely removed
        $theDest = $this->is_directory($cmds['target']);
        if (!$theDest) {
            $this->writelog(7, 2, 104, 'Destination "%s" was not a directory', array($cmds['target']));
            return false;
        }
        if (!$this->actionPerms['unzipFile']) {
            $this->writelog(7, 1, 103, 'You are not allowed to unzip files', '');
            return false;
        }
        if ($fI['fileext'] != 'zip') {
            $this->writelog(7, 1, 102, 'File extension is not "zip"', '');
            return false;
        }
        if (!$this->checkIfFullAccess($theDest)) {
            $this->writelog(7, 1, 101, 'You don\'t have full access to the destination directory "%s"!', array($theDest));
            return false;
        }
        // !!! Method has been put in the sotrage driver, can be saftely removed
        if ($this->checkPathAgainstMounts($theFile) && $this->checkPathAgainstMounts($theDest . '/')) {
            // No way to do this under windows.
            $cmd = $this->unzipPath . 'unzip -qq ' . escapeshellarg($theFile) . ' -d ' . escapeshellarg($theDest);
            CommandUtility::exec($cmd);
            $this->writelog(7, 0, 1, 'Unzipping file "%s" in "%s"', array($theFile, $theDest));
            return true;
        } else {
            $this->writelog(7, 1, 100, 'File "%s" or destination "%s" was not within your mountpoints!', array($theFile, $theDest));
            return false;
        }
    }

    protected function replaceFile(array $cmdArr)
    {
        if (!$this->isInit) {
            return false;
        }

        $uploadPosition = $cmdArr['data'];
        $fileInfo = $_FILES['replace_' . $uploadPosition];
        if (empty($fileInfo['name'])) {
            $this->writelog(1, 2, 108, 'No file was uploaded for replacing!', '');
            return false;
        }

        $keepFileName = ($cmdArr['keepFilename'] == 1) ? true : false;
        $resultObjects = array();

        try {
            $fileObjectToReplace = $this->getFileObject($cmdArr['uid']);
            $folder = $fileObjectToReplace->getParentFolder();
            $resourceStorage = $fileObjectToReplace->getStorage();

            $fileObject = $resourceStorage->addUploadedFile($fileInfo, $folder, $fileObjectToReplace->getName(), DuplicationBehavior::REPLACE);

            // Check if there is a file that is going to be uploaded that has a different name as the replacing one
            // but exists in that folder as well.
            // rename to another name, but check if the name is already given
            if ($keepFileName === false) {
                // if a file with the same name already exists, we need to change it to _01 etc.
                // if the file does not exist, we can do a simple rename
                $resourceStorage->moveFile($fileObject, $folder, $fileInfo['name'], DuplicationBehavior::RENAME);
            }

            $resultObjects[] = $fileObject;
            $this->internalUploadMap[$uploadPosition] = $fileObject->getCombinedIdentifier();

            $this->writelog(1, 0, 1, 'Replacing file "%s" to "%s"', array($fileInfo['name'], $fileObjectToReplace->getIdentifier()));
        } catch (\TYPO3\CMS\Core\Resource\Exception\InsufficientFileWritePermissionsException $e) {
            $this->writelog(1, 1, 107, 'You are not allowed to override "%s"!', array($fileInfo['name']));
        } catch (\TYPO3\CMS\Core\Resource\Exception\UploadException $e) {
            $this->writelog(1, 2, 106, 'The upload has failed, no uploaded file found!', '');
        } catch (\TYPO3\CMS\Core\Resource\Exception\InsufficientUserPermissionsException $e) {
            $this->writelog(1, 1, 105, 'You are not allowed to upload files!', '');
        } catch (\TYPO3\CMS\Core\Resource\Exception\UploadSizeException $e) {
            $this->writelog(1, 1, 104, 'The uploaded file "%s" exceeds the size-limit', array($fileInfo['name']));
        } catch (\TYPO3\CMS\Core\Resource\Exception\InsufficientFolderWritePermissionsException $e) {
            $this->writelog(1, 1, 103, 'Destination path "%s" was not within your mountpoints!', array($fileObjectToReplace->getIdentifier()));
        } catch (\TYPO3\CMS\Core\Resource\Exception\IllegalFileExtensionException $e) {
            $this->writelog(1, 1, 102, 'Extension of file name "%s" is not allowed in "%s"!', array($fileInfo['name'], $fileObjectToReplace->getIdentifier()));
        } catch (\TYPO3\CMS\Core\Resource\Exception\ExistingTargetFileNameException $e) {
            $this->writelog(1, 1, 101, 'No unique filename available in "%s"!', array($fileObjectToReplace->getIdentifier()));
        } catch (\RuntimeException $e) {
            throw $e;
        }
        return $resultObjects;
    }

    protected function addFlashMessage(FlashMessage $flashMessage)
    {
        $flashMessageService = GeneralUtility::makeInstance(FlashMessageService::class);

        $defaultFlashMessageQueue = $flashMessageService->getMessageQueueByIdentifier();
        $defaultFlashMessageQueue->enqueue($flashMessage);
    }

    protected function getIndexer(ResourceStorage $storage)
    {
        return GeneralUtility::makeInstance(\TYPO3\CMS\Core\Resource\Index\Indexer::class, $storage);
    }

    protected function getDatabaseConnection()
    {
        return $GLOBALS['TYPO3_DB'];
    }

    protected function getBackendUser()
    {
        return $GLOBALS['BE_USER'];
    }
}