ExtendedFileUtility.php

Go to the documentation of this file.

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

use TYPO3\CMS\Backend\Utility\BackendUtility;
use TYPO3\CMS\Backend\Utility\IconUtility;
use TYPO3\CMS\Core\Messaging\FlashMessage;
use TYPO3\CMS\Core\Messaging\FlashMessageService;
use TYPO3\CMS\Core\Resource\Exception\ResourceDoesNotExistException;
use TYPO3\CMS\Core\Resource\File;
use TYPO3\CMS\Core\Utility\GeneralUtility;

class ExtendedFileUtility extends \TYPO3\CMS\Core\Utility\File\BasicFileUtility {

    // External static variables:
    // Notice; some of these are overridden in the start() method with values from $GLOBALS['TYPO3_CONF_VARS']['BE']
    // Path to unzip-program (with trailing '/')
    public $unzipPath = '';

    // If set, the uploaded files will overwrite existing files.
    public $dontCheckForUnique = 0;

    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
    );

    // This is regarded to be the recycler folder
    public $recyclerFN = '_recycler_';

    public $useRecycler = 1;

    // Internal, dynamic
    // Will contain map between upload ID and the final filename
    public $internalUploadMap = array();

    public $lastError = '';

    protected $errorMessages = array();

    protected $fileCmdMap;

    protected $fileFactory;


    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 = \TYPO3\CMS\Core\Resource\ResourceFactory::getInstance();
        // Initializing file processing commands:
        $this->fileCmdMap = $fileCmds;
    }

    public function init_actionPerms() {
        GeneralUtility::logDeprecatedFunction();
        $this->setActionPermissions();
    }

    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 (count($this->fileCmdMap['upload']) == 0) {
                    $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 (count($this->fileCmdMap['newfolder']) === 0) {
                    $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 '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 \TYPO3\CMS\Core\Utility\File\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 printLogErrorMessages($redirect = '') {
        GeneralUtility::logDeprecatedFunction();
        $this->pushErrorMessagesToFlashMessageQueue();
    }

    public function pushErrorMessagesToFlashMessageQueue() {
        foreach ($this->getErrorMessages() as $msg) {
            $flashMessage = GeneralUtility::makeInstance(
                'TYPO3\\CMS\\Core\\Messaging\\FlashMessage',
                htmlspecialchars($msg),
                '',
                \TYPO3\CMS\Core\Messaging\FlashMessage::ERROR,
                TRUE
            );
            $this->addFlashMessage($flashMessage);
        }
    }

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

    public function findRecycler($theFile) {
        GeneralUtility::logDeprecatedFunction();
        if (GeneralUtility::validPathStr($theFile)) {
            $theFile = \TYPO3\CMS\Core\Utility\PathUtility::getCanonicalPath($theFile);
            $fI = GeneralUtility::split_fileref($theFile);
            $c = 0;
            // !!! Method has been put in the storage, can be saftely removed
            $rDir = $fI['path'] . $this->recyclerFN;
            while ($this->checkPathAgainstMounts($fI['path']) && $c < 20) {
                if (@is_dir($rDir) && $this->recyclerFN != $fI['file']) {
                    return $rDir;
                }
                $theFile = $fI['path'];
                $theFile = \TYPO3\CMS\Core\Utility\PathUtility::getCanonicalPath($theFile);
                $fI = GeneralUtility::split_fileref($theFile);
                $c++;
            }
        }
    }

    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(
                'TYPO3\\CMS\\Core\\Messaging\\FlashMessage',
                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 (count($refIndexRecords) > 0) {
                $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) {
                            $icon = IconUtility::getSpriteIconForRecord($row['tablename'], $shortcutRecord);
                            $onClick = 'Clickmenu.show("' . $row['tablename'] . '", "' . $row['recuid'] . '", "1", "+info,history,edit", "|", "");return false;';
                            $shortcutContent[] = '<a href="#" oncontextmenu="this.click();return false;" onclick="' . htmlspecialchars($onClick) . '">' . $icon . '</a>' . htmlspecialchars((BackendUtility::getRecordTitle($row['tablename'], $shortcutRecord) . '  [' . BackendUtility::getRecordPath($shortcutRecord['pid'], '', 80) . ']'));
                        } else {
                            $brokenReferences[] = $fileReferenceRow['ref_uid'];
                        }
                    }
                }
                if (!empty($brokenReferences)) {
                    // render a message that the file has broken references
                    $flashMessage = GeneralUtility::makeInstance(
                        '\\TYPO3\\CMS\\Core\\Messaging\\FlashMessage',
                        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(
                        '\\TYPO3\\CMS\\Core\\Messaging\\FlashMessage',
                        sprintf($GLOBALS['LANG']->sL('LLL:EXT:lang/locallang_core.xlf:message.description.fileNotDeletedHasReferences'), $fileObject->getName()) . '<br />' . implode('<br />', $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(
                        '\\TYPO3\\CMS\\Core\\Messaging\\FlashMessage',
                        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'),
                        \TYPO3\CMS\Core\Messaging\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(
                            'TYPO3\\CMS\\Core\\Messaging\\FlashMessage',
                            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(\TYPO3\CMS\Core\Resource\Folder $folder) {
        $files = $folder->getFiles(0, 0, \TYPO3\CMS\Core\Resource\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(
                'TYPO3\\CMS\\Core\\Messaging\\FlashMessage',
                $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 \TYPO3\CMS\Core\Resource\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;
        // Copying the file
        if ($sourceFileObject instanceof File) {
            try {
                $conflictMode = $appendSuffixOnConflict !== '' ? 'renameNewFile' : 'cancel';
                $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 {
                $conflictMode = $appendSuffixOnConflict !== '' ? 'renameNewFile' : 'cancel';
                $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 \TYPO3\CMS\Core\Resource\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, 'renameNewFile');
                } else {
                    // Don't allow overwriting existing files
                    $resultObject = $sourceFileObject->moveTo($targetFolderObject, NULL, '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, 'renameNewFile');
                } else {
                    // Don't allow overwriting existing files
                    $resultObject = $sourceFolderObject->moveTo($targetFolderObject, NULL, 'renameNewFile');
                }
                $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']);
        $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($sourceFileObject->getName(), $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($sourceFileObject->getName(), $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 \TYPO3\CMS\Core\Resource\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\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 \TYPO3\CMS\Core\Resource\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 {
                // @todo can be improved towards conflict mode naming
                if ($this->dontCheckForUnique) {
                    $conflictMode = 'replace';
                } else {
                    $conflictMode = 'cancel';
                }
                $fileObject = $targetFolderObject->addUploadedFile($fileInfo, $conflictMode);
                $fileObject = \TYPO3\CMS\Core\Resource\ResourceFactory::getInstance()->getFileObjectByStorageAndIdentifier($targetFolderObject->getStorage()->getUid(), $fileObject->getIdentifier());
                if ($conflictMode === '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\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);
            \TYPO3\CMS\Core\Utility\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 addFlashMessage(\TYPO3\CMS\Core\Messaging\FlashMessage $flashMessage) {
        $flashMessageService = GeneralUtility::makeInstance(
            'TYPO3\\CMS\\Core\\Messaging\\FlashMessageService'
        );
        $defaultFlashMessageQueue = $flashMessageService->getMessageQueueByIdentifier();
        $defaultFlashMessageQueue->enqueue($flashMessage);
    }

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

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

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

}