FileStreamWrapper.php

Go to the documentation of this file.

<?php
namespace TYPO3\CMS\Core\Tests;

/*
 * 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!
 */

class FileStreamWrapper
{
    protected $dirHandle = null;

    protected $fileHandle = null;

    protected static $registered = false;

    protected static $overlayPaths = [];

    protected static $rootPath = '';

    public static function init($rootPath)
    {
        self::$rootPath = rtrim(str_replace('\\', '/', $rootPath), '/') . '/';
        self::register();
    }

    public static function destroy()
    {
        self::$overlayPaths = [];
        self::$rootPath = '';
        if (self::$registered) {
            self::restore();
        }
    }

    public static function registerOverlayPath($overlay, $replace, $createFolder = true)
    {
        $overlay = trim(str_replace('\\', '/', $overlay), '/') . '/';
        $replace = rtrim(str_replace('\\', '/', $replace), '/') . '/';
        self::$overlayPaths[$overlay] = $replace;
        if ($createFolder) {
            mkdir($replace);
        }
    }

    protected static function overlayPath($path)
    {
        $path = str_replace('\\', '/', $path);
        $hasOverlay = false;
        if (strpos($path, self::$rootPath) !== 0) {
            // Path is not below root path, ignore it
            return $path;
        }

        $newPath = ltrim(substr($path, strlen(self::$rootPath)), '/');
        foreach (self::$overlayPaths as $overlay => $replace) {
            if (strpos($newPath, $overlay) === 0) {
                $newPath = $replace . substr($newPath, strlen($overlay));
                $hasOverlay = true;
                break;
            }
        }
        return $hasOverlay ? $newPath : $path;
    }

    protected static function register()
    {
        if (self::$registered) {
            return;
        }

        if (@stream_wrapper_unregister('file') === false) {
            throw new \BadFunctionCallException('Cannot unregister file:// stream wrapper.', 1396340331);
        }
        if (@stream_wrapper_register('file', __CLASS__) === false) {
            throw new \BadFunctionCallException('A handler has already been registered for the file:// scheme.', 1396340332);
        }

        self::$registered = true;
    }

    protected static function restore()
    {
        if (!self::$registered) {
            return;
        }
        if (@stream_wrapper_restore('file') === false) {
            throw new \BadFunctionCallException('Cannot restore the default file:// stream handler.', 1396340333);
        }
        self::$registered = false;
    }

    /*
     * The following list of functions is implemented as of
     * @see http://www.php.net/manual/en/streamwrapper.dir-closedir.php
     */

    public function dir_closedir()
    {
        if ($this->dirHandle === null) {
            return false;
        } else {
            self::restore();
            closedir($this->dirHandle);
            self::register();
            $this->dirHandle = null;
            return true;
        }
    }

    public function dir_opendir($path, $options = 0)
    {
        if ($this->dirHandle !== null) {
            return false;
        }
        self::restore();
        $path = self::overlayPath($path);
        $this->dirHandle = opendir($path);
        self::register();
        return $this->dirHandle !== false;
    }

    public function dir_readdir()
    {
        if ($this->dirHandle === null) {
            return false;
        }
        self::restore();
        $success = readdir($this->dirHandle);
        self::register();
        return $success;
    }

    public function dir_rewinddir()
    {
        if ($this->dirHandle === null) {
            return false;
        }
        self::restore();
        rewinddir($this->dirHandle);
        self::register();
        return true;
    }

    public function mkdir($path, $mode, $options = 0)
    {
        self::restore();
        $path = self::overlayPath($path);
        $success = mkdir($path, $mode, (bool)($options & STREAM_MKDIR_RECURSIVE));
        self::register();
        return $success;
    }

    public function rename($pathFrom, $pathTo)
    {
        self::restore();
        $pathFrom = self::overlayPath($pathFrom);
        $pathTo = self::overlayPath($pathTo);
        $success = rename($pathFrom, $pathTo);
        self::register();
        return $success;
    }

    public function rmdir($path)
    {
        self::restore();
        $path = self::overlayPath($path);
        $success = rmdir($path);
        self::register();
        return $success;
    }

    public function stream_cast($castAs)
    {
        if ($this->fileHandle !== null && $castAs & STREAM_CAST_AS_STREAM) {
            return $this->fileHandle;
        } else {
            return false;
        }
    }

    public function stream_close()
    {
        self::restore();
        if ($this->fileHandle !== null) {
            fclose($this->fileHandle);
            $this->fileHandle = null;
        }
        self::register();
    }

    public function stream_eof()
    {
        if ($this->fileHandle === null) {
            return false;
        }
        self::restore();
        $success = feof($this->fileHandle);
        self::register();
        return $success;
    }

    public function stream_flush()
    {
        if ($this->fileHandle === null) {
            return false;
        }
        self::restore();
        $success = fflush($this->fileHandle);
        self::register();
        return $success;
    }

    public function stream_lock($operation)
    {
        if ($this->fileHandle === null) {
            return false;
        }
        self::restore();
        $success = flock($this->fileHandle, $operation);
        self::register();
        return $success;
    }

    public function stream_metadata($path, $options, $value)
    {
        self::restore();
        $path = self::overlayPath($path);
        switch ($options) {
            case STREAM_META_TOUCH:
                $success = touch($path, $value[0], $value[1]);
                break;
            case STREAM_META_OWNER_NAME:
                // Fall through
            case STREAM_META_OWNER:
                $success = chown($path, $value);
                break;
            case STREAM_META_GROUP_NAME:
                // Fall through
            case STREAM_META_GROUP:
                $success = chgrp($path, $value);
                break;
            case STREAM_META_ACCESS:
                $success = chmod($path, $value);
                break;
            default:
                $success = false;
        }
        self::register();
        return $success;
    }

    public function stream_open($path, $mode, $options, &$opened_path)
    {
        if ($this->fileHandle !== null) {
            return false;
        }
        self::restore();
        $path = self::overlayPath($path);
        $this->fileHandle = fopen($path, $mode, (bool)($options & STREAM_USE_PATH));
        self::register();
        return $this->fileHandle !== false;
    }

    public function stream_read($length)
    {
        if ($this->fileHandle === null) {
            return false;
        }
        self::restore();
        $content = fread($this->fileHandle, $length);
        self::register();
        return $content;
    }

    public function stream_seek($offset, $whence = SEEK_SET)
    {
        if ($this->fileHandle === null) {
            return false;
        }
        self::restore();
        $success = fseek($this->fileHandle, $offset, $whence);
        self::register();
        return $success;
    }

    public function stream_set_option($option, $arg1, $arg2)
    {
        return false;
    }

    public function stream_stat()
    {
        if ($this->fileHandle === null) {
            return false;
        }
        self::restore();
        $stats = fstat($this->fileHandle);
        self::register();
        return $stats;
    }

    public function stream_tell()
    {
        if ($this->fileHandle === null) {
            return false;
        }
        self::restore();
        $position = ftell($this->fileHandle);
        self::register();
        return $position;
    }

    public function stream_truncate($size)
    {
        if ($this->fileHandle === null) {
            return false;
        }
        self::restore();
        $success = ftruncate($this->fileHandle, $size);
        self::register();
        return $success;
    }

    public function stream_write($data)
    {
        if ($this->fileHandle === null) {
            return false;
        }
        self::restore();
        $length = fwrite($this->fileHandle, $data);
        self::register();
        return $length;
    }

    public function unlink($path)
    {
        self::restore();
        $path = self::overlayPath($path);
        $success = unlink($path);
        self::register();
        return $success;
    }

    public function url_stat($path, $flags)
    {
        self::restore();
        $path = self::overlayPath($path);
        if ($flags & STREAM_URL_STAT_LINK) {
            $information = @lstat($path);
        } else {
            $information = @stat($path);
        }
        self::register();
        return $information;
    }
}