Files.php

Go to the documentation of this file.

<?php
namespace TYPO3\Flow\Utility;

/*                                                                        *
 * This script belongs to the TYPO3 Flow framework.                       *
 *                                                                        *
 * It is free software; you can redistribute it and/or modify it under    *
 * the terms of the GNU Lesser General Public License, either version 3   *
 * of the License, or (at your option) any later version.                 *
 *                                                                        *
 * The TYPO3 project - inspiring people to share!                         *
 *                                                                        */

class Files {

    static public function getUnixStylePath($path) {
        if (strpos($path, ':') === FALSE) {
            return str_replace('//', '/', strtr($path, '\\', '/'));
        } else {
            return preg_replace('/^([a-z]{2,}):\//', '$1://', str_replace('//', '/', strtr($path, '\\', '/')));
        }
    }

    static public function getNormalizedPath($path) {
        return rtrim($path, '/') .'/';
    }

    static public function concatenatePaths(array $paths) {
        return rtrim(self::getUnixStylePath(implode('/', $paths)), '/');
    }

    static public function readDirectoryRecursively($path, $suffix = NULL, $returnRealPath = FALSE, $returnDotFiles = FALSE, &$filenames = array()) {
        if (!is_dir($path)) throw new \TYPO3\Flow\Utility\Exception('"' . $path . '" is no directory.', 1207253462);

        $directoryIterator = new \DirectoryIterator($path);
        $suffixLength = strlen($suffix);

        foreach ($directoryIterator as $fileInfo) {
            $filename = $fileInfo->getFilename();
            if ($filename === '.' || $filename === '..' || ($returnDotFiles === FALSE && $filename[0] === '.')) {
                continue;
            }
            if ($fileInfo->isFile() && ($suffix === NULL || substr($filename, -$suffixLength) === $suffix)) {
                $filenames[] = self::getUnixStylePath(($returnRealPath === TRUE ? realpath($fileInfo->getPathname()) : $fileInfo->getPathname()));
            }
            if ($fileInfo->isDir()) {
                self::readDirectoryRecursively($fileInfo->getPathname(), $suffix, $returnRealPath, $returnDotFiles, $filenames);
            }
        }
        return $filenames;
    }

    static public function emptyDirectoryRecursively($path) {
        if (!is_dir($path)) {
            throw new \TYPO3\Flow\Utility\Exception('"' . $path . '" is no directory.', 1169047616);
        }

        if (self::is_link($path)) {
            if (self::unlink($path) !== TRUE) {
                throw new \TYPO3\Flow\Utility\Exception('Could not unlink symbolic link "' . $path . '".', 1323697654);
            }
        } else {
            $directoryIterator = new \RecursiveDirectoryIterator($path);
            foreach ($directoryIterator as $fileInfo) {
                if (!$fileInfo->isDir()) {
                    if (self::unlink($fileInfo->getPathname()) !== TRUE) {
                        throw new \TYPO3\Flow\Utility\Exception('Could not unlink file "' . $fileInfo->getPathname() . '".', 1169047619);
                    }
                } elseif (!$directoryIterator->isDot()) {
                    self::removeDirectoryRecursively($fileInfo->getPathname());
                }
            }
        }
    }

    static public function removeDirectoryRecursively($path) {
        if (self::is_link($path)) {
            if (self::unlink($path) !== TRUE) {
                throw new \TYPO3\Flow\Utility\Exception('Could not unlink symbolic link "' . $path . '".', 1316000297);
            }
        } else {
            self::emptyDirectoryRecursively($path);
            try {
                if (rmdir($path) !== TRUE) {
                    throw new \TYPO3\Flow\Utility\Exception('Could not remove directory "' . $path . '".', 1316000298);
                }
            } catch (\Exception $exception) {
                throw new \TYPO3\Flow\Utility\Exception('Could not remove directory "' . $path . '".', 1323961907);
            }
        }
    }

    static public function createDirectoryRecursively($path) {
        if (substr($path, -2) === '/.') {
            $path = substr($path, 0, -1);
        }
        if (is_file($path)) {
            throw new \TYPO3\Flow\Utility\Exception('Could not create directory "' . $path . '", because a file with that name exists!', 1349340620);
        }
        if (!is_dir($path) && strlen($path) > 0) {
            $oldMask = umask(000);
            mkdir($path, 0777, TRUE);
            umask($oldMask);
            if (!is_dir($path)) {
                throw new \TYPO3\Flow\Utility\Exception('Could not create directory "' . $path . '"!', 1170251400);
            }
        }
    }

    static public function copyDirectoryRecursively($sourceDirectory, $targetDirectory, $keepExistingFiles = FALSE, $copyDotFiles = FALSE) {
        if (!is_dir($sourceDirectory)) {
            throw new \TYPO3\Flow\Utility\Exception('"' . $sourceDirectory . '" is no directory.', 1235428779);
        }

        self::createDirectoryRecursively($targetDirectory);
        if (!is_dir($targetDirectory)) {
            throw new \TYPO3\Flow\Utility\Exception('"' . $targetDirectory . '" is no directory.', 1235428780);
        }

        $sourceFilenames = self::readDirectoryRecursively($sourceDirectory, NULL, FALSE, $copyDotFiles);
        foreach ($sourceFilenames as $filename) {
            $relativeFilename = str_replace($sourceDirectory, '', $filename);
            self::createDirectoryRecursively($targetDirectory . dirname($relativeFilename));
            $targetPathAndFilename = self::concatenatePaths(array($targetDirectory, $relativeFilename));
            if ($keepExistingFiles === FALSE || !file_exists($targetPathAndFilename)) {
                copy($filename, $targetPathAndFilename);
            }
        }
    }

    static public function getFileContents($pathAndFilename, $flags = 0, $context = NULL, $offset = -1, $maximumLength = -1) {
        if ($flags === TRUE) $flags = FILE_USE_INCLUDE_PATH;
        try {
            if ($maximumLength > -1) {
                $content = file_get_contents($pathAndFilename, $flags, $context, $offset, $maximumLength);
            } else {
                $content = file_get_contents($pathAndFilename, $flags, $context, $offset);
            }
        } catch (\TYPO3\Flow\Error\Exception $ignoredException) {
            $content = FALSE;
        }
        return $content;
    }

    static public function getUploadErrorMessage($errorCode) {
        switch ($errorCode) {
            case \UPLOAD_ERR_INI_SIZE:
                return 'The uploaded file exceeds the upload_max_filesize directive in php.ini';
            case \UPLOAD_ERR_FORM_SIZE:
                return 'The uploaded file exceeds the MAX_FILE_SIZE directive that was specified in the HTML form';
            case \UPLOAD_ERR_PARTIAL:
                return 'The uploaded file was only partially uploaded';
            case \UPLOAD_ERR_NO_FILE:
                return 'No file was uploaded';
            case \UPLOAD_ERR_NO_TMP_DIR:
                return 'Missing a temporary folder';
            case \UPLOAD_ERR_CANT_WRITE:
                return 'Failed to write file to disk';
            case \UPLOAD_ERR_EXTENSION:
                return 'File upload stopped by extension';
            default:
                return 'Unknown upload error';
        }
    }

    static public function is_link($pathAndFilename) {
            // if not on Windows, call PHPs own is_link() function
        if (DIRECTORY_SEPARATOR === '/') {
            return \is_link($pathAndFilename);
        }
        if (!file_exists($pathAndFilename)) {
            return FALSE;
        }
        $normalizedPathAndFilename = strtolower(rtrim(self::getUnixStylePath($pathAndFilename), '/'));
        $normalizedTargetPathAndFilename = strtolower(self::getUnixStylePath(realpath($pathAndFilename)));
        if ($normalizedTargetPathAndFilename === '') {
            return FALSE;
        }
        return $normalizedPathAndFilename !== $normalizedTargetPathAndFilename;
    }

    static public function unlink($pathAndFilename) {
        try {
                // if not on Windows, call PHPs own unlink() function
            if (DIRECTORY_SEPARATOR === '/' || is_file($pathAndFilename)) {
                return @\unlink($pathAndFilename);
            }
            return rmdir($pathAndFilename);
        } catch (\Exception $exception) {
            return FALSE;
        }
    }
}
?>