nextcloud / server

apps/files_external/lib/Lib/Storage/SMB.php

Indentation +655 added lines, -655 removed lines

@@ -67,659 +67,659 @@
 use OCP\ILogger;
 
 class SMB extends Common implements INotifyStorage {
-	/**
-	 * @var \Icewind\SMB\IServer
-	 */
-	protected $server;
-
-	/**
-	 * @var \Icewind\SMB\IShare
-	 */
-	protected $share;
-
-	/**
-	 * @var string
-	 */
-	protected $root;
-
-	/**
-	 * @var \Icewind\SMB\IFileInfo[]
-	 */
-	protected $statCache;
-
-	/** @var ILogger */
-	protected $logger;
-
-	/** @var bool */
-	protected $showHidden;
-
-	/** @var bool */
-	protected $checkAcl;
-
-	public function __construct($params) {
-		if (!isset($params['host'])) {
-			throw new \Exception('Invalid configuration, no host provided');
-		}
-
-		if (isset($params['auth'])) {
-			$auth = $params['auth'];
-		} elseif (isset($params['user']) && isset($params['password']) && isset($params['share'])) {
-			[$workgroup, $user] = $this->splitUser($params['user']);
-			$auth = new BasicAuth($user, $workgroup, $params['password']);
-		} else {
-			throw new \Exception('Invalid configuration, no credentials provided');
-		}
-
-		if (isset($params['logger'])) {
-			$this->logger = $params['logger'];
-		} else {
-			$this->logger = \OC::$server->getLogger();
-		}
-
-		$options = new Options();
-		if (isset($params['timeout'])) {
-			$timeout = (int)$params['timeout'];
-			if ($timeout > 0) {
-				$options->setTimeout($timeout);
-			}
-		}
-		$serverFactory = new ServerFactory($options);
-		$this->server = $serverFactory->createServer($params['host'], $auth);
-		$this->share = $this->server->getShare(trim($params['share'], '/'));
-
-		$this->root = $params['root'] ?? '/';
-		$this->root = '/' . ltrim($this->root, '/');
-		$this->root = rtrim($this->root, '/') . '/';
-
-		$this->showHidden = isset($params['show_hidden']) && $params['show_hidden'];
-		$this->checkAcl = isset($params['check_acl']) && $params['check_acl'];
-
-		$this->statCache = new CappedMemoryCache();
-		parent::__construct($params);
-	}
-
-	private function splitUser($user) {
-		if (strpos($user, '/')) {
-			return explode('/', $user, 2);
-		} elseif (strpos($user, '\\')) {
-			return explode('\\', $user);
-		} else {
-			return [null, $user];
-		}
-	}
-
-	/**
-	 * @return string
-	 */
-	public function getId() {
-		// FIXME: double slash to keep compatible with the old storage ids,
-		// failure to do so will lead to creation of a new storage id and
-		// loss of shares from the storage
-		return 'smb::' . $this->server->getAuth()->getUsername() . '@' . $this->server->getHost() . '//' . $this->share->getName() . '/' . $this->root;
-	}
-
-	/**
-	 * @param string $path
-	 * @return string
-	 */
-	protected function buildPath($path) {
-		return Filesystem::normalizePath($this->root . '/' . $path, true, false, true);
-	}
-
-	protected function relativePath($fullPath) {
-		if ($fullPath === $this->root) {
-			return '';
-		} elseif (substr($fullPath, 0, strlen($this->root)) === $this->root) {
-			return substr($fullPath, strlen($this->root));
-		} else {
-			return null;
-		}
-	}
-
-	/**
-	 * @param string $path
-	 * @return \Icewind\SMB\IFileInfo
-	 * @throws StorageAuthException
-	 */
-	protected function getFileInfo($path) {
-		try {
-			$path = $this->buildPath($path);
-			if (!isset($this->statCache[$path])) {
-				$this->statCache[$path] = $this->share->stat($path);
-			}
-			return $this->statCache[$path];
-		} catch (ConnectException $e) {
-			$this->throwUnavailable($e);
-		} catch (ForbiddenException $e) {
-			// with php-smbclient, this exceptions is thrown when the provided password is invalid.
-			// Possible is also ForbiddenException with a different error code, so we check it.
-			if ($e->getCode() === 1) {
-				$this->throwUnavailable($e);
-			}
-			throw $e;
-		}
-	}
-
-	/**
-	 * @param \Exception $e
-	 * @throws StorageAuthException
-	 */
-	protected function throwUnavailable(\Exception $e) {
-		$this->logger->logException($e, ['message' => 'Error while getting file info']);
-		throw new StorageAuthException($e->getMessage(), $e);
-	}
-
-	/**
-	 * get the acl from fileinfo that is relevant for the configured user
-	 *
-	 * @param IFileInfo $file
-	 * @return ACL|null
-	 */
-	private function getACL(IFileInfo $file): ?ACL {
-		$acls = $file->getAcls();
-		foreach ($acls as $user => $acl) {
-			[, $user] = explode('\\', $user); // strip domain
-			if ($user === $this->server->getAuth()->getUsername()) {
-				return $acl;
-			}
-		}
-
-		return null;
-	}
-
-	/**
-	 * @param string $path
-	 * @return \Icewind\SMB\IFileInfo[]
-	 * @throws StorageNotAvailableException
-	 */
-	protected function getFolderContents($path): iterable {
-		try {
-			$path = ltrim($this->buildPath($path), '/');
-			$files = $this->share->dir($path);
-			foreach ($files as $file) {
-				$this->statCache[$path . '/' . $file->getName()] = $file;
-			}
-
-			foreach ($files as $file) {
-				try {
-					// the isHidden check is done before checking the config boolean to ensure that the metadata is always fetch
-					// so we trigger the below exceptions where applicable
-					$hide = $file->isHidden() && !$this->showHidden;
-
-					if ($this->checkAcl && $acl = $this->getACL($file)) {
-						// if there is no explicit deny, we assume it's allowed
-						// this doesn't take inheritance fully into account but if read permissions is denied for a parent we wouldn't be in this folder
-						// additionally, it's better to have false negatives here then false positives
-						if ($acl->denies(ACL::MASK_READ) || $acl->denies(ACL::MASK_EXECUTE)) {
-							$this->logger->debug('Hiding non readable entry ' . $file->getName());
-							return false;
-						}
-					}
-
-					if ($hide) {
-						$this->logger->debug('hiding hidden file ' . $file->getName());
-					}
-					if (!$hide) {
-						yield $file;
-					}
-				} catch (ForbiddenException $e) {
-					$this->logger->logException($e, ['level' => ILogger::DEBUG, 'message' => 'Hiding forbidden entry ' . $file->getName()]);
-				} catch (NotFoundException $e) {
-					$this->logger->logException($e, ['level' => ILogger::DEBUG, 'message' => 'Hiding not found entry ' . $file->getName()]);
-				}
-			}
-		} catch (ConnectException $e) {
-			$this->logger->logException($e, ['message' => 'Error while getting folder content']);
-			throw new StorageNotAvailableException($e->getMessage(), $e->getCode(), $e);
-		}
-	}
-
-	/**
-	 * @param \Icewind\SMB\IFileInfo $info
-	 * @return array
-	 */
-	protected function formatInfo($info) {
-		$result = [
-			'size' => $info->getSize(),
-			'mtime' => $info->getMTime(),
-		];
-		if ($info->isDirectory()) {
-			$result['type'] = 'dir';
-		} else {
-			$result['type'] = 'file';
-		}
-		return $result;
-	}
-
-	/**
-	 * Rename the files. If the source or the target is the root, the rename won't happen.
-	 *
-	 * @param string $source the old name of the path
-	 * @param string $target the new name of the path
-	 * @return bool true if the rename is successful, false otherwise
-	 */
-	public function rename($source, $target, $retry = true) {
-		if ($this->isRootDir($source) || $this->isRootDir($target)) {
-			return false;
-		}
-
-		$absoluteSource = $this->buildPath($source);
-		$absoluteTarget = $this->buildPath($target);
-		try {
-			$result = $this->share->rename($absoluteSource, $absoluteTarget);
-		} catch (AlreadyExistsException $e) {
-			if ($retry) {
-				$this->remove($target);
-				$result = $this->share->rename($absoluteSource, $absoluteTarget, false);
-			} else {
-				$this->logger->logException($e, ['level' => ILogger::WARN]);
-				return false;
-			}
-		} catch (InvalidArgumentException $e) {
-			if ($retry) {
-				$this->remove($target);
-				$result = $this->share->rename($absoluteSource, $absoluteTarget, false);
-			} else {
-				$this->logger->logException($e, ['level' => ILogger::WARN]);
-				return false;
-			}
-		} catch (\Exception $e) {
-			$this->logger->logException($e, ['level' => ILogger::WARN]);
-			return false;
-		}
-		unset($this->statCache[$absoluteSource], $this->statCache[$absoluteTarget]);
-		return $result;
-	}
-
-	public function stat($path, $retry = true) {
-		try {
-			$result = $this->formatInfo($this->getFileInfo($path));
-		} catch (ForbiddenException $e) {
-			return false;
-		} catch (NotFoundException $e) {
-			return false;
-		} catch (TimedOutException $e) {
-			if ($retry) {
-				return $this->stat($path, false);
-			} else {
-				throw $e;
-			}
-		}
-		if ($this->remoteIsShare() && $this->isRootDir($path)) {
-			$result['mtime'] = $this->shareMTime();
-		}
-		return $result;
-	}
-
-	/**
-	 * get the best guess for the modification time of the share
-	 *
-	 * @return int
-	 */
-	private function shareMTime() {
-		$highestMTime = 0;
-		$files = $this->share->dir($this->root);
-		foreach ($files as $fileInfo) {
-			try {
-				if ($fileInfo->getMTime() > $highestMTime) {
-					$highestMTime = $fileInfo->getMTime();
-				}
-			} catch (NotFoundException $e) {
-				// Ignore this, can happen on unavailable DFS shares
-			} catch (ForbiddenException $e) {
-				// Ignore this too - it's a symlink
-			}
-		}
-		return $highestMTime;
-	}
-
-	/**
-	 * Check if the path is our root dir (not the smb one)
-	 *
-	 * @param string $path the path
-	 * @return bool
-	 */
-	private function isRootDir($path) {
-		return $path === '' || $path === '/' || $path === '.';
-	}
-
-	/**
-	 * Check if our root points to a smb share
-	 *
-	 * @return bool true if our root points to a share false otherwise
-	 */
-	private function remoteIsShare() {
-		return $this->share->getName() && (!$this->root || $this->root === '/');
-	}
-
-	/**
-	 * @param string $path
-	 * @return bool
-	 */
-	public function unlink($path) {
-		if ($this->isRootDir($path)) {
-			return false;
-		}
-
-		try {
-			if ($this->is_dir($path)) {
-				return $this->rmdir($path);
-			} else {
-				$path = $this->buildPath($path);
-				unset($this->statCache[$path]);
-				$this->share->del($path);
-				return true;
-			}
-		} catch (NotFoundException $e) {
-			return false;
-		} catch (ForbiddenException $e) {
-			return false;
-		} catch (ConnectException $e) {
-			$this->logger->logException($e, ['message' => 'Error while deleting file']);
-			throw new StorageNotAvailableException($e->getMessage(), $e->getCode(), $e);
-		}
-	}
-
-	/**
-	 * check if a file or folder has been updated since $time
-	 *
-	 * @param string $path
-	 * @param int $time
-	 * @return bool
-	 */
-	public function hasUpdated($path, $time) {
-		if (!$path and $this->root === '/') {
-			// mtime doesn't work for shares, but giving the nature of the backend,
-			// doing a full update is still just fast enough
-			return true;
-		} else {
-			$actualTime = $this->filemtime($path);
-			return $actualTime > $time;
-		}
-	}
-
-	/**
-	 * @param string $path
-	 * @param string $mode
-	 * @return resource|bool
-	 */
-	public function fopen($path, $mode) {
-		$fullPath = $this->buildPath($path);
-		try {
-			switch ($mode) {
-				case 'r':
-				case 'rb':
-					if (!$this->file_exists($path)) {
-						return false;
-					}
-					return $this->share->read($fullPath);
-				case 'w':
-				case 'wb':
-					$source = $this->share->write($fullPath);
-					return CallBackWrapper::wrap($source, null, null, function () use ($fullPath) {
-						unset($this->statCache[$fullPath]);
-					});
-				case 'a':
-				case 'ab':
-				case 'r+':
-				case 'w+':
-				case 'wb+':
-				case 'a+':
-				case 'x':
-				case 'x+':
-				case 'c':
-				case 'c+':
-					//emulate these
-					if (strrpos($path, '.') !== false) {
-						$ext = substr($path, strrpos($path, '.'));
-					} else {
-						$ext = '';
-					}
-					if ($this->file_exists($path)) {
-						if (!$this->isUpdatable($path)) {
-							return false;
-						}
-						$tmpFile = $this->getCachedFile($path);
-					} else {
-						if (!$this->isCreatable(dirname($path))) {
-							return false;
-						}
-						$tmpFile = \OC::$server->getTempManager()->getTemporaryFile($ext);
-					}
-					$source = fopen($tmpFile, $mode);
-					$share = $this->share;
-					return CallbackWrapper::wrap($source, null, null, function () use ($tmpFile, $fullPath, $share) {
-						unset($this->statCache[$fullPath]);
-						$share->put($tmpFile, $fullPath);
-						unlink($tmpFile);
-					});
-			}
-			return false;
-		} catch (NotFoundException $e) {
-			return false;
-		} catch (ForbiddenException $e) {
-			return false;
-		} catch (OutOfSpaceException $e) {
-			throw new EntityTooLargeException("not enough available space to create file", 0, $e);
-		} catch (ConnectException $e) {
-			$this->logger->logException($e, ['message' => 'Error while opening file']);
-			throw new StorageNotAvailableException($e->getMessage(), $e->getCode(), $e);
-		}
-	}
-
-	public function rmdir($path) {
-		if ($this->isRootDir($path)) {
-			return false;
-		}
-
-		try {
-			$this->statCache = [];
-			$content = $this->share->dir($this->buildPath($path));
-			foreach ($content as $file) {
-				if ($file->isDirectory()) {
-					$this->rmdir($path . '/' . $file->getName());
-				} else {
-					$this->share->del($file->getPath());
-				}
-			}
-			$this->share->rmdir($this->buildPath($path));
-			return true;
-		} catch (NotFoundException $e) {
-			return false;
-		} catch (ForbiddenException $e) {
-			return false;
-		} catch (ConnectException $e) {
-			$this->logger->logException($e, ['message' => 'Error while removing folder']);
-			throw new StorageNotAvailableException($e->getMessage(), $e->getCode(), $e);
-		}
-	}
-
-	public function touch($path, $mtime = null) {
-		try {
-			if (!$this->file_exists($path)) {
-				$fh = $this->share->write($this->buildPath($path));
-				fclose($fh);
-				return true;
-			}
-			return false;
-		} catch (OutOfSpaceException $e) {
-			throw new EntityTooLargeException("not enough available space to create file", 0, $e);
-		} catch (ConnectException $e) {
-			$this->logger->logException($e, ['message' => 'Error while creating file']);
-			throw new StorageNotAvailableException($e->getMessage(), $e->getCode(), $e);
-		}
-	}
-
-	public function getMetaData($path) {
-		$fileInfo = $this->getFileInfo($path);
-		if (!$fileInfo) {
-			return null;
-		}
-
-		return $this->getMetaDataFromFileInfo($fileInfo);
-	}
-
-	private function getMetaDataFromFileInfo(IFileInfo $fileInfo) {
-		$permissions = Constants::PERMISSION_READ + Constants::PERMISSION_SHARE;
-
-		if (!$fileInfo->isReadOnly()) {
-			$permissions += Constants::PERMISSION_DELETE;
-			$permissions += Constants::PERMISSION_UPDATE;
-			if ($fileInfo->isDirectory()) {
-				$permissions += Constants::PERMISSION_CREATE;
-			}
-		}
-
-		$data = [];
-		if ($fileInfo->isDirectory()) {
-			$data['mimetype'] = 'httpd/unix-directory';
-		} else {
-			$data['mimetype'] = \OC::$server->getMimeTypeDetector()->detectPath($fileInfo->getPath());
-		}
-		$data['mtime'] = $fileInfo->getMTime();
-		if ($fileInfo->isDirectory()) {
-			$data['size'] = -1; //unknown
-		} else {
-			$data['size'] = $fileInfo->getSize();
-		}
-		$data['etag'] = $this->getETag($fileInfo->getPath());
-		$data['storage_mtime'] = $data['mtime'];
-		$data['permissions'] = $permissions;
-		$data['name'] = $fileInfo->getName();
-
-		return $data;
-	}
-
-	public function opendir($path) {
-		try {
-			$files = $this->getFolderContents($path);
-		} catch (NotFoundException $e) {
-			return false;
-		} catch (ForbiddenException $e) {
-			return false;
-		}
-		$names = array_map(function ($info) {
-			/** @var \Icewind\SMB\IFileInfo $info */
-			return $info->getName();
-		}, iterator_to_array($files));
-		return IteratorDirectory::wrap($names);
-	}
-
-	public function getDirectoryContent($directory): \Traversable {
-		$files = $this->getFolderContents($directory);
-		foreach ($files as $file) {
-			yield $this->getMetaDataFromFileInfo($file);
-		}
-	}
-
-	public function filetype($path) {
-		try {
-			return $this->getFileInfo($path)->isDirectory() ? 'dir' : 'file';
-		} catch (NotFoundException $e) {
-			return false;
-		} catch (ForbiddenException $e) {
-			return false;
-		}
-	}
-
-	public function mkdir($path) {
-		$path = $this->buildPath($path);
-		try {
-			$this->share->mkdir($path);
-			return true;
-		} catch (ConnectException $e) {
-			$this->logger->logException($e, ['message' => 'Error while creating folder']);
-			throw new StorageNotAvailableException($e->getMessage(), $e->getCode(), $e);
-		} catch (Exception $e) {
-			return false;
-		}
-	}
-
-	public function file_exists($path) {
-		try {
-			$this->getFileInfo($path);
-			return true;
-		} catch (NotFoundException $e) {
-			return false;
-		} catch (ForbiddenException $e) {
-			return false;
-		} catch (ConnectException $e) {
-			throw new StorageNotAvailableException($e->getMessage(), $e->getCode(), $e);
-		}
-	}
-
-	public function isReadable($path) {
-		try {
-			$info = $this->getFileInfo($path);
-			return $this->showHidden || !$info->isHidden();
-		} catch (NotFoundException $e) {
-			return false;
-		} catch (ForbiddenException $e) {
-			return false;
-		}
-	}
-
-	public function isUpdatable($path) {
-		try {
-			$info = $this->getFileInfo($path);
-			// following windows behaviour for read-only folders: they can be written into
-			// (https://support.microsoft.com/en-us/kb/326549 - "cause" section)
-			return ($this->showHidden || !$info->isHidden()) && (!$info->isReadOnly() || $this->is_dir($path));
-		} catch (NotFoundException $e) {
-			return false;
-		} catch (ForbiddenException $e) {
-			return false;
-		}
-	}
-
-	public function isDeletable($path) {
-		try {
-			$info = $this->getFileInfo($path);
-			return ($this->showHidden || !$info->isHidden()) && !$info->isReadOnly();
-		} catch (NotFoundException $e) {
-			return false;
-		} catch (ForbiddenException $e) {
-			return false;
-		}
-	}
-
-	/**
-	 * check if smbclient is installed
-	 */
-	public static function checkDependencies() {
-		return (
-			(bool)\OC_Helper::findBinaryPath('smbclient')
-			|| NativeServer::available(new System())
-		) ? true : ['smbclient'];
-	}
-
-	/**
-	 * Test a storage for availability
-	 *
-	 * @return bool
-	 */
-	public function test() {
-		try {
-			return parent::test();
-		} catch (Exception $e) {
-			$this->logger->logException($e);
-			return false;
-		}
-	}
-
-	public function listen($path, callable $callback) {
-		$this->notify($path)->listen(function (IChange $change) use ($callback) {
-			if ($change instanceof IRenameChange) {
-				return $callback($change->getType(), $change->getPath(), $change->getTargetPath());
-			} else {
-				return $callback($change->getType(), $change->getPath());
-			}
-		});
-	}
-
-	public function notify($path) {
-		$path = '/' . ltrim($path, '/');
-		$shareNotifyHandler = $this->share->notify($this->buildPath($path));
-		return new SMBNotifyHandler($shareNotifyHandler, $this->root);
-	}
+    /**
+     * @var \Icewind\SMB\IServer
+     */
+    protected $server;
+
+    /**
+     * @var \Icewind\SMB\IShare
+     */
+    protected $share;
+
+    /**
+     * @var string
+     */
+    protected $root;
+
+    /**
+     * @var \Icewind\SMB\IFileInfo[]
+     */
+    protected $statCache;
+
+    /** @var ILogger */
+    protected $logger;
+
+    /** @var bool */
+    protected $showHidden;
+
+    /** @var bool */
+    protected $checkAcl;
+
+    public function __construct($params) {
+        if (!isset($params['host'])) {
+            throw new \Exception('Invalid configuration, no host provided');
+        }
+
+        if (isset($params['auth'])) {
+            $auth = $params['auth'];
+        } elseif (isset($params['user']) && isset($params['password']) && isset($params['share'])) {
+            [$workgroup, $user] = $this->splitUser($params['user']);
+            $auth = new BasicAuth($user, $workgroup, $params['password']);
+        } else {
+            throw new \Exception('Invalid configuration, no credentials provided');
+        }
+
+        if (isset($params['logger'])) {
+            $this->logger = $params['logger'];
+        } else {
+            $this->logger = \OC::$server->getLogger();
+        }
+
+        $options = new Options();
+        if (isset($params['timeout'])) {
+            $timeout = (int)$params['timeout'];
+            if ($timeout > 0) {
+                $options->setTimeout($timeout);
+            }
+        }
+        $serverFactory = new ServerFactory($options);
+        $this->server = $serverFactory->createServer($params['host'], $auth);
+        $this->share = $this->server->getShare(trim($params['share'], '/'));
+
+        $this->root = $params['root'] ?? '/';
+        $this->root = '/' . ltrim($this->root, '/');
+        $this->root = rtrim($this->root, '/') . '/';
+
+        $this->showHidden = isset($params['show_hidden']) && $params['show_hidden'];
+        $this->checkAcl = isset($params['check_acl']) && $params['check_acl'];
+
+        $this->statCache = new CappedMemoryCache();
+        parent::__construct($params);
+    }
+
+    private function splitUser($user) {
+        if (strpos($user, '/')) {
+            return explode('/', $user, 2);
+        } elseif (strpos($user, '\\')) {
+            return explode('\\', $user);
+        } else {
+            return [null, $user];
+        }
+    }
+
+    /**
+     * @return string
+     */
+    public function getId() {
+        // FIXME: double slash to keep compatible with the old storage ids,
+        // failure to do so will lead to creation of a new storage id and
+        // loss of shares from the storage
+        return 'smb::' . $this->server->getAuth()->getUsername() . '@' . $this->server->getHost() . '//' . $this->share->getName() . '/' . $this->root;
+    }
+
+    /**
+     * @param string $path
+     * @return string
+     */
+    protected function buildPath($path) {
+        return Filesystem::normalizePath($this->root . '/' . $path, true, false, true);
+    }
+
+    protected function relativePath($fullPath) {
+        if ($fullPath === $this->root) {
+            return '';
+        } elseif (substr($fullPath, 0, strlen($this->root)) === $this->root) {
+            return substr($fullPath, strlen($this->root));
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * @param string $path
+     * @return \Icewind\SMB\IFileInfo
+     * @throws StorageAuthException
+     */
+    protected function getFileInfo($path) {
+        try {
+            $path = $this->buildPath($path);
+            if (!isset($this->statCache[$path])) {
+                $this->statCache[$path] = $this->share->stat($path);
+            }
+            return $this->statCache[$path];
+        } catch (ConnectException $e) {
+            $this->throwUnavailable($e);
+        } catch (ForbiddenException $e) {
+            // with php-smbclient, this exceptions is thrown when the provided password is invalid.
+            // Possible is also ForbiddenException with a different error code, so we check it.
+            if ($e->getCode() === 1) {
+                $this->throwUnavailable($e);
+            }
+            throw $e;
+        }
+    }
+
+    /**
+     * @param \Exception $e
+     * @throws StorageAuthException
+     */
+    protected function throwUnavailable(\Exception $e) {
+        $this->logger->logException($e, ['message' => 'Error while getting file info']);
+        throw new StorageAuthException($e->getMessage(), $e);
+    }
+
+    /**
+     * get the acl from fileinfo that is relevant for the configured user
+     *
+     * @param IFileInfo $file
+     * @return ACL|null
+     */
+    private function getACL(IFileInfo $file): ?ACL {
+        $acls = $file->getAcls();
+        foreach ($acls as $user => $acl) {
+            [, $user] = explode('\\', $user); // strip domain
+            if ($user === $this->server->getAuth()->getUsername()) {
+                return $acl;
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * @param string $path
+     * @return \Icewind\SMB\IFileInfo[]
+     * @throws StorageNotAvailableException
+     */
+    protected function getFolderContents($path): iterable {
+        try {
+            $path = ltrim($this->buildPath($path), '/');
+            $files = $this->share->dir($path);
+            foreach ($files as $file) {
+                $this->statCache[$path . '/' . $file->getName()] = $file;
+            }
+
+            foreach ($files as $file) {
+                try {
+                    // the isHidden check is done before checking the config boolean to ensure that the metadata is always fetch
+                    // so we trigger the below exceptions where applicable
+                    $hide = $file->isHidden() && !$this->showHidden;
+
+                    if ($this->checkAcl && $acl = $this->getACL($file)) {
+                        // if there is no explicit deny, we assume it's allowed
+                        // this doesn't take inheritance fully into account but if read permissions is denied for a parent we wouldn't be in this folder
+                        // additionally, it's better to have false negatives here then false positives
+                        if ($acl->denies(ACL::MASK_READ) || $acl->denies(ACL::MASK_EXECUTE)) {
+                            $this->logger->debug('Hiding non readable entry ' . $file->getName());
+                            return false;
+                        }
+                    }
+
+                    if ($hide) {
+                        $this->logger->debug('hiding hidden file ' . $file->getName());
+                    }
+                    if (!$hide) {
+                        yield $file;
+                    }
+                } catch (ForbiddenException $e) {
+                    $this->logger->logException($e, ['level' => ILogger::DEBUG, 'message' => 'Hiding forbidden entry ' . $file->getName()]);
+                } catch (NotFoundException $e) {
+                    $this->logger->logException($e, ['level' => ILogger::DEBUG, 'message' => 'Hiding not found entry ' . $file->getName()]);
+                }
+            }
+        } catch (ConnectException $e) {
+            $this->logger->logException($e, ['message' => 'Error while getting folder content']);
+            throw new StorageNotAvailableException($e->getMessage(), $e->getCode(), $e);
+        }
+    }
+
+    /**
+     * @param \Icewind\SMB\IFileInfo $info
+     * @return array
+     */
+    protected function formatInfo($info) {
+        $result = [
+            'size' => $info->getSize(),
+            'mtime' => $info->getMTime(),
+        ];
+        if ($info->isDirectory()) {
+            $result['type'] = 'dir';
+        } else {
+            $result['type'] = 'file';
+        }
+        return $result;
+    }
+
+    /**
+     * Rename the files. If the source or the target is the root, the rename won't happen.
+     *
+     * @param string $source the old name of the path
+     * @param string $target the new name of the path
+     * @return bool true if the rename is successful, false otherwise
+     */
+    public function rename($source, $target, $retry = true) {
+        if ($this->isRootDir($source) || $this->isRootDir($target)) {
+            return false;
+        }
+
+        $absoluteSource = $this->buildPath($source);
+        $absoluteTarget = $this->buildPath($target);
+        try {
+            $result = $this->share->rename($absoluteSource, $absoluteTarget);
+        } catch (AlreadyExistsException $e) {
+            if ($retry) {
+                $this->remove($target);
+                $result = $this->share->rename($absoluteSource, $absoluteTarget, false);
+            } else {
+                $this->logger->logException($e, ['level' => ILogger::WARN]);
+                return false;
+            }
+        } catch (InvalidArgumentException $e) {
+            if ($retry) {
+                $this->remove($target);
+                $result = $this->share->rename($absoluteSource, $absoluteTarget, false);
+            } else {
+                $this->logger->logException($e, ['level' => ILogger::WARN]);
+                return false;
+            }
+        } catch (\Exception $e) {
+            $this->logger->logException($e, ['level' => ILogger::WARN]);
+            return false;
+        }
+        unset($this->statCache[$absoluteSource], $this->statCache[$absoluteTarget]);
+        return $result;
+    }
+
+    public function stat($path, $retry = true) {
+        try {
+            $result = $this->formatInfo($this->getFileInfo($path));
+        } catch (ForbiddenException $e) {
+            return false;
+        } catch (NotFoundException $e) {
+            return false;
+        } catch (TimedOutException $e) {
+            if ($retry) {
+                return $this->stat($path, false);
+            } else {
+                throw $e;
+            }
+        }
+        if ($this->remoteIsShare() && $this->isRootDir($path)) {
+            $result['mtime'] = $this->shareMTime();
+        }
+        return $result;
+    }
+
+    /**
+     * get the best guess for the modification time of the share
+     *
+     * @return int
+     */
+    private function shareMTime() {
+        $highestMTime = 0;
+        $files = $this->share->dir($this->root);
+        foreach ($files as $fileInfo) {
+            try {
+                if ($fileInfo->getMTime() > $highestMTime) {
+                    $highestMTime = $fileInfo->getMTime();
+                }
+            } catch (NotFoundException $e) {
+                // Ignore this, can happen on unavailable DFS shares
+            } catch (ForbiddenException $e) {
+                // Ignore this too - it's a symlink
+            }
+        }
+        return $highestMTime;
+    }
+
+    /**
+     * Check if the path is our root dir (not the smb one)
+     *
+     * @param string $path the path
+     * @return bool
+     */
+    private function isRootDir($path) {
+        return $path === '' || $path === '/' || $path === '.';
+    }
+
+    /**
+     * Check if our root points to a smb share
+     *
+     * @return bool true if our root points to a share false otherwise
+     */
+    private function remoteIsShare() {
+        return $this->share->getName() && (!$this->root || $this->root === '/');
+    }
+
+    /**
+     * @param string $path
+     * @return bool
+     */
+    public function unlink($path) {
+        if ($this->isRootDir($path)) {
+            return false;
+        }
+
+        try {
+            if ($this->is_dir($path)) {
+                return $this->rmdir($path);
+            } else {
+                $path = $this->buildPath($path);
+                unset($this->statCache[$path]);
+                $this->share->del($path);
+                return true;
+            }
+        } catch (NotFoundException $e) {
+            return false;
+        } catch (ForbiddenException $e) {
+            return false;
+        } catch (ConnectException $e) {
+            $this->logger->logException($e, ['message' => 'Error while deleting file']);
+            throw new StorageNotAvailableException($e->getMessage(), $e->getCode(), $e);
+        }
+    }
+
+    /**
+     * check if a file or folder has been updated since $time
+     *
+     * @param string $path
+     * @param int $time
+     * @return bool
+     */
+    public function hasUpdated($path, $time) {
+        if (!$path and $this->root === '/') {
+            // mtime doesn't work for shares, but giving the nature of the backend,
+            // doing a full update is still just fast enough
+            return true;
+        } else {
+            $actualTime = $this->filemtime($path);
+            return $actualTime > $time;
+        }
+    }
+
+    /**
+     * @param string $path
+     * @param string $mode
+     * @return resource|bool
+     */
+    public function fopen($path, $mode) {
+        $fullPath = $this->buildPath($path);
+        try {
+            switch ($mode) {
+                case 'r':
+                case 'rb':
+                    if (!$this->file_exists($path)) {
+                        return false;
+                    }
+                    return $this->share->read($fullPath);
+                case 'w':
+                case 'wb':
+                    $source = $this->share->write($fullPath);
+                    return CallBackWrapper::wrap($source, null, null, function () use ($fullPath) {
+                        unset($this->statCache[$fullPath]);
+                    });
+                case 'a':
+                case 'ab':
+                case 'r+':
+                case 'w+':
+                case 'wb+':
+                case 'a+':
+                case 'x':
+                case 'x+':
+                case 'c':
+                case 'c+':
+                    //emulate these
+                    if (strrpos($path, '.') !== false) {
+                        $ext = substr($path, strrpos($path, '.'));
+                    } else {
+                        $ext = '';
+                    }
+                    if ($this->file_exists($path)) {
+                        if (!$this->isUpdatable($path)) {
+                            return false;
+                        }
+                        $tmpFile = $this->getCachedFile($path);
+                    } else {
+                        if (!$this->isCreatable(dirname($path))) {
+                            return false;
+                        }
+                        $tmpFile = \OC::$server->getTempManager()->getTemporaryFile($ext);
+                    }
+                    $source = fopen($tmpFile, $mode);
+                    $share = $this->share;
+                    return CallbackWrapper::wrap($source, null, null, function () use ($tmpFile, $fullPath, $share) {
+                        unset($this->statCache[$fullPath]);
+                        $share->put($tmpFile, $fullPath);
+                        unlink($tmpFile);
+                    });
+            }
+            return false;
+        } catch (NotFoundException $e) {
+            return false;
+        } catch (ForbiddenException $e) {
+            return false;
+        } catch (OutOfSpaceException $e) {
+            throw new EntityTooLargeException("not enough available space to create file", 0, $e);
+        } catch (ConnectException $e) {
+            $this->logger->logException($e, ['message' => 'Error while opening file']);
+            throw new StorageNotAvailableException($e->getMessage(), $e->getCode(), $e);
+        }
+    }
+
+    public function rmdir($path) {
+        if ($this->isRootDir($path)) {
+            return false;
+        }
+
+        try {
+            $this->statCache = [];
+            $content = $this->share->dir($this->buildPath($path));
+            foreach ($content as $file) {
+                if ($file->isDirectory()) {
+                    $this->rmdir($path . '/' . $file->getName());
+                } else {
+                    $this->share->del($file->getPath());
+                }
+            }
+            $this->share->rmdir($this->buildPath($path));
+            return true;
+        } catch (NotFoundException $e) {
+            return false;
+        } catch (ForbiddenException $e) {
+            return false;
+        } catch (ConnectException $e) {
+            $this->logger->logException($e, ['message' => 'Error while removing folder']);
+            throw new StorageNotAvailableException($e->getMessage(), $e->getCode(), $e);
+        }
+    }
+
+    public function touch($path, $mtime = null) {
+        try {
+            if (!$this->file_exists($path)) {
+                $fh = $this->share->write($this->buildPath($path));
+                fclose($fh);
+                return true;
+            }
+            return false;
+        } catch (OutOfSpaceException $e) {
+            throw new EntityTooLargeException("not enough available space to create file", 0, $e);
+        } catch (ConnectException $e) {
+            $this->logger->logException($e, ['message' => 'Error while creating file']);
+            throw new StorageNotAvailableException($e->getMessage(), $e->getCode(), $e);
+        }
+    }
+
+    public function getMetaData($path) {
+        $fileInfo = $this->getFileInfo($path);
+        if (!$fileInfo) {
+            return null;
+        }
+
+        return $this->getMetaDataFromFileInfo($fileInfo);
+    }
+
+    private function getMetaDataFromFileInfo(IFileInfo $fileInfo) {
+        $permissions = Constants::PERMISSION_READ + Constants::PERMISSION_SHARE;
+
+        if (!$fileInfo->isReadOnly()) {
+            $permissions += Constants::PERMISSION_DELETE;
+            $permissions += Constants::PERMISSION_UPDATE;
+            if ($fileInfo->isDirectory()) {
+                $permissions += Constants::PERMISSION_CREATE;
+            }
+        }
+
+        $data = [];
+        if ($fileInfo->isDirectory()) {
+            $data['mimetype'] = 'httpd/unix-directory';
+        } else {
+            $data['mimetype'] = \OC::$server->getMimeTypeDetector()->detectPath($fileInfo->getPath());
+        }
+        $data['mtime'] = $fileInfo->getMTime();
+        if ($fileInfo->isDirectory()) {
+            $data['size'] = -1; //unknown
+        } else {
+            $data['size'] = $fileInfo->getSize();
+        }
+        $data['etag'] = $this->getETag($fileInfo->getPath());
+        $data['storage_mtime'] = $data['mtime'];
+        $data['permissions'] = $permissions;
+        $data['name'] = $fileInfo->getName();
+
+        return $data;
+    }
+
+    public function opendir($path) {
+        try {
+            $files = $this->getFolderContents($path);
+        } catch (NotFoundException $e) {
+            return false;
+        } catch (ForbiddenException $e) {
+            return false;
+        }
+        $names = array_map(function ($info) {
+            /** @var \Icewind\SMB\IFileInfo $info */
+            return $info->getName();
+        }, iterator_to_array($files));
+        return IteratorDirectory::wrap($names);
+    }
+
+    public function getDirectoryContent($directory): \Traversable {
+        $files = $this->getFolderContents($directory);
+        foreach ($files as $file) {
+            yield $this->getMetaDataFromFileInfo($file);
+        }
+    }
+
+    public function filetype($path) {
+        try {
+            return $this->getFileInfo($path)->isDirectory() ? 'dir' : 'file';
+        } catch (NotFoundException $e) {
+            return false;
+        } catch (ForbiddenException $e) {
+            return false;
+        }
+    }
+
+    public function mkdir($path) {
+        $path = $this->buildPath($path);
+        try {
+            $this->share->mkdir($path);
+            return true;
+        } catch (ConnectException $e) {
+            $this->logger->logException($e, ['message' => 'Error while creating folder']);
+            throw new StorageNotAvailableException($e->getMessage(), $e->getCode(), $e);
+        } catch (Exception $e) {
+            return false;
+        }
+    }
+
+    public function file_exists($path) {
+        try {
+            $this->getFileInfo($path);
+            return true;
+        } catch (NotFoundException $e) {
+            return false;
+        } catch (ForbiddenException $e) {
+            return false;
+        } catch (ConnectException $e) {
+            throw new StorageNotAvailableException($e->getMessage(), $e->getCode(), $e);
+        }
+    }
+
+    public function isReadable($path) {
+        try {
+            $info = $this->getFileInfo($path);
+            return $this->showHidden || !$info->isHidden();
+        } catch (NotFoundException $e) {
+            return false;
+        } catch (ForbiddenException $e) {
+            return false;
+        }
+    }
+
+    public function isUpdatable($path) {
+        try {
+            $info = $this->getFileInfo($path);
+            // following windows behaviour for read-only folders: they can be written into
+            // (https://support.microsoft.com/en-us/kb/326549 - "cause" section)
+            return ($this->showHidden || !$info->isHidden()) && (!$info->isReadOnly() || $this->is_dir($path));
+        } catch (NotFoundException $e) {
+            return false;
+        } catch (ForbiddenException $e) {
+            return false;
+        }
+    }
+
+    public function isDeletable($path) {
+        try {
+            $info = $this->getFileInfo($path);
+            return ($this->showHidden || !$info->isHidden()) && !$info->isReadOnly();
+        } catch (NotFoundException $e) {
+            return false;
+        } catch (ForbiddenException $e) {
+            return false;
+        }
+    }
+
+    /**
+     * check if smbclient is installed
+     */
+    public static function checkDependencies() {
+        return (
+            (bool)\OC_Helper::findBinaryPath('smbclient')
+            || NativeServer::available(new System())
+        ) ? true : ['smbclient'];
+    }
+
+    /**
+     * Test a storage for availability
+     *
+     * @return bool
+     */
+    public function test() {
+        try {
+            return parent::test();
+        } catch (Exception $e) {
+            $this->logger->logException($e);
+            return false;
+        }
+    }
+
+    public function listen($path, callable $callback) {
+        $this->notify($path)->listen(function (IChange $change) use ($callback) {
+            if ($change instanceof IRenameChange) {
+                return $callback($change->getType(), $change->getPath(), $change->getTargetPath());
+            } else {
+                return $callback($change->getType(), $change->getPath());
+            }
+        });
+    }
+
+    public function notify($path) {
+        $path = '/' . ltrim($path, '/');
+        $shareNotifyHandler = $this->share->notify($this->buildPath($path));
+        return new SMBNotifyHandler($shareNotifyHandler, $this->root);
+    }
 }

apps/dav/lib/Connector/Sabre/File.php

Indentation +618 added lines, -618 removed lines

@@ -73,622 +73,622 @@
 use Sabre\DAV\IFile;
 
 class File extends Node implements IFile {
-	protected $request;
-
-	/**
-	 * Sets up the node, expects a full path name
-	 *
-	 * @param \OC\Files\View $view
-	 * @param \OCP\Files\FileInfo $info
-	 * @param \OCP\Share\IManager $shareManager
-	 * @param \OC\AppFramework\Http\Request $request
-	 */
-	public function __construct(View $view, FileInfo $info, IManager $shareManager = null, Request $request = null) {
-		parent::__construct($view, $info, $shareManager);
-
-		if (isset($request)) {
-			$this->request = $request;
-		} else {
-			$this->request = \OC::$server->getRequest();
-		}
-	}
-
-	/**
-	 * Updates the data
-	 *
-	 * The data argument is a readable stream resource.
-	 *
-	 * After a successful put operation, you may choose to return an ETag. The
-	 * etag must always be surrounded by double-quotes. These quotes must
-	 * appear in the actual string you're returning.
-	 *
-	 * Clients may use the ETag from a PUT request to later on make sure that
-	 * when they update the file, the contents haven't changed in the mean
-	 * time.
-	 *
-	 * If you don't plan to store the file byte-by-byte, and you return a
-	 * different object on a subsequent GET you are strongly recommended to not
-	 * return an ETag, and just return null.
-	 *
-	 * @param resource $data
-	 *
-	 * @throws Forbidden
-	 * @throws UnsupportedMediaType
-	 * @throws BadRequest
-	 * @throws Exception
-	 * @throws EntityTooLarge
-	 * @throws ServiceUnavailable
-	 * @throws FileLocked
-	 * @return string|null
-	 */
-	public function put($data) {
-		try {
-			$exists = $this->fileView->file_exists($this->path);
-			if ($this->info && $exists && !$this->info->isUpdateable()) {
-				throw new Forbidden();
-			}
-		} catch (StorageNotAvailableException $e) {
-			throw new ServiceUnavailable("File is not updatable: " . $e->getMessage());
-		}
-
-		// verify path of the target
-		$this->verifyPath();
-
-		// chunked handling
-		if (isset($_SERVER['HTTP_OC_CHUNKED'])) {
-			try {
-				return $this->createFileChunked($data);
-			} catch (\Exception $e) {
-				$this->convertToSabreException($e);
-			}
-		}
-
-		/** @var Storage $partStorage */
-		list($partStorage) = $this->fileView->resolvePath($this->path);
-		$needsPartFile = $partStorage->needsPartFile() && (strlen($this->path) > 1);
-
-		$view = \OC\Files\Filesystem::getView();
-
-		if ($needsPartFile) {
-			// mark file as partial while uploading (ignored by the scanner)
-			$partFilePath = $this->getPartFileBasePath($this->path) . '.ocTransferId' . rand() . '.part';
-
-			if (!$view->isCreatable($partFilePath) && $view->isUpdatable($this->path)) {
-				$needsPartFile = false;
-			}
-		}
-		if (!$needsPartFile) {
-			// upload file directly as the final path
-			$partFilePath = $this->path;
-
-			if ($view && !$this->emitPreHooks($exists)) {
-				throw new Exception('Could not write to final file, canceled by hook');
-			}
-		}
-
-		// the part file and target file might be on a different storage in case of a single file storage (e.g. single file share)
-		/** @var \OC\Files\Storage\Storage $partStorage */
-		list($partStorage, $internalPartPath) = $this->fileView->resolvePath($partFilePath);
-		/** @var \OC\Files\Storage\Storage $storage */
-		list($storage, $internalPath) = $this->fileView->resolvePath($this->path);
-		try {
-			if (!$needsPartFile) {
-				$this->changeLock(ILockingProvider::LOCK_EXCLUSIVE);
-			}
-
-			if (!is_resource($data)) {
-				$tmpData = fopen('php://temp', 'r+');
-				if ($data !== null) {
-					fwrite($tmpData, $data);
-					rewind($tmpData);
-				}
-				$data = $tmpData;
-			}
-
-			$data = HashWrapper::wrap($data, 'md5', function ($hash) {
-				$this->header('X-Hash-MD5: ' . $hash);
-			});
-			$data = HashWrapper::wrap($data, 'sha1', function ($hash) {
-				$this->header('X-Hash-SHA1: ' . $hash);
-			});
-			$data = HashWrapper::wrap($data, 'sha256', function ($hash) {
-				$this->header('X-Hash-SHA256: ' . $hash);
-			});
-
-			if ($partStorage->instanceOfStorage(Storage\IWriteStreamStorage::class)) {
-				$isEOF = false;
-				$wrappedData = CallbackWrapper::wrap($data, null, null, null, null, function ($stream) use (&$isEOF) {
-					$isEOF = feof($stream);
-				});
-
-				$result = true;
-				$count = -1;
-				try {
-					$count = $partStorage->writeStream($internalPartPath, $wrappedData);
-				} catch (GenericFileException $e) {
-					$result = false;
-				}
-
-
-				if ($result === false) {
-					$result = $isEOF;
-					if (is_resource($wrappedData)) {
-						$result = feof($wrappedData);
-					}
-				}
-			} else {
-				$target = $partStorage->fopen($internalPartPath, 'wb');
-				if ($target === false) {
-					\OC::$server->getLogger()->error('\OC\Files\Filesystem::fopen() failed', ['app' => 'webdav']);
-					// because we have no clue about the cause we can only throw back a 500/Internal Server Error
-					throw new Exception('Could not write file contents');
-				}
-				list($count, $result) = \OC_Helper::streamCopy($data, $target);
-				fclose($target);
-			}
-
-			if ($result === false) {
-				$expected = -1;
-				if (isset($_SERVER['CONTENT_LENGTH'])) {
-					$expected = $_SERVER['CONTENT_LENGTH'];
-				}
-				if ($expected !== "0") {
-					throw new Exception('Error while copying file to target location (copied bytes: ' . $count . ', expected filesize: ' . $expected . ' )');
-				}
-			}
-
-			// if content length is sent by client:
-			// double check if the file was fully received
-			// compare expected and actual size
-			if (isset($_SERVER['CONTENT_LENGTH']) && $_SERVER['REQUEST_METHOD'] === 'PUT') {
-				$expected = (int)$_SERVER['CONTENT_LENGTH'];
-				if ($count !== $expected) {
-					throw new BadRequest('Expected filesize of ' . $expected . ' bytes but read (from Nextcloud client) and wrote (to Nextcloud storage) ' . $count . ' bytes. Could either be a network problem on the sending side or a problem writing to the storage on the server side.');
-				}
-			}
-		} catch (\Exception $e) {
-			$context = [];
-
-			if ($e instanceof LockedException) {
-				$context['level'] = ILogger::DEBUG;
-			}
-
-			\OC::$server->getLogger()->logException($e, $context);
-			if ($needsPartFile) {
-				$partStorage->unlink($internalPartPath);
-			}
-			$this->convertToSabreException($e);
-		}
-
-		try {
-			if ($needsPartFile) {
-				if ($view && !$this->emitPreHooks($exists)) {
-					$partStorage->unlink($internalPartPath);
-					throw new Exception('Could not rename part file to final file, canceled by hook');
-				}
-				try {
-					$this->changeLock(ILockingProvider::LOCK_EXCLUSIVE);
-				} catch (LockedException $e) {
-					// during very large uploads, the shared lock we got at the start might have been expired
-					// meaning that the above lock can fail not just only because somebody else got a shared lock
-					// or because there is no existing shared lock to make exclusive
-					//
-					// Thus we try to get a new exclusive lock, if the original lock failed because of a different shared
-					// lock this will still fail, if our original shared lock expired the new lock will be successful and
-					// the entire operation will be safe
-
-					try {
-						$this->acquireLock(ILockingProvider::LOCK_EXCLUSIVE);
-					} catch (LockedException $ex) {
-						if ($needsPartFile) {
-							$partStorage->unlink($internalPartPath);
-						}
-						throw new FileLocked($e->getMessage(), $e->getCode(), $e);
-					}
-				}
-
-				// rename to correct path
-				try {
-					$renameOkay = $storage->moveFromStorage($partStorage, $internalPartPath, $internalPath);
-					$fileExists = $storage->file_exists($internalPath);
-					if ($renameOkay === false || $fileExists === false) {
-						\OC::$server->getLogger()->error('renaming part file to final file failed $renameOkay: ' . ($renameOkay ? 'true' : 'false') . ', $fileExists: ' . ($fileExists ? 'true' : 'false') . ')', ['app' => 'webdav']);
-						throw new Exception('Could not rename part file to final file');
-					}
-				} catch (ForbiddenException $ex) {
-					if (!$ex->getRetry()) {
-						$partStorage->unlink($internalPartPath);
-					}
-					throw new DAVForbiddenException($ex->getMessage(), $ex->getRetry());
-				} catch (\Exception $e) {
-					$partStorage->unlink($internalPartPath);
-					$this->convertToSabreException($e);
-				}
-			}
-
-			// since we skipped the view we need to scan and emit the hooks ourselves
-			$storage->getUpdater()->update($internalPath);
-
-			try {
-				$this->changeLock(ILockingProvider::LOCK_SHARED);
-			} catch (LockedException $e) {
-				throw new FileLocked($e->getMessage(), $e->getCode(), $e);
-			}
-
-			// allow sync clients to send the mtime along in a header
-			if (isset($this->request->server['HTTP_X_OC_MTIME'])) {
-				$mtime = $this->sanitizeMtime($this->request->server['HTTP_X_OC_MTIME']);
-				if ($this->fileView->touch($this->path, $mtime)) {
-					$this->header('X-OC-MTime: accepted');
-				}
-			}
-
-			$fileInfoUpdate = [
-				'upload_time' => time()
-			];
-
-			// allow sync clients to send the creation time along in a header
-			if (isset($this->request->server['HTTP_X_OC_CTIME'])) {
-				$ctime = $this->sanitizeMtime($this->request->server['HTTP_X_OC_CTIME']);
-				$fileInfoUpdate['creation_time'] = $ctime;
-				$this->header('X-OC-CTime: accepted');
-			}
-
-			$this->fileView->putFileInfo($this->path, $fileInfoUpdate);
-
-			if ($view) {
-				$this->emitPostHooks($exists);
-			}
-
-			$this->refreshInfo();
-
-			if (isset($this->request->server['HTTP_OC_CHECKSUM'])) {
-				$checksum = trim($this->request->server['HTTP_OC_CHECKSUM']);
-				$this->fileView->putFileInfo($this->path, ['checksum' => $checksum]);
-				$this->refreshInfo();
-			} elseif ($this->getChecksum() !== null && $this->getChecksum() !== '') {
-				$this->fileView->putFileInfo($this->path, ['checksum' => '']);
-				$this->refreshInfo();
-			}
-		} catch (StorageNotAvailableException $e) {
-			throw new ServiceUnavailable("Failed to check file size: " . $e->getMessage(), 0, $e);
-		}
-
-		return '"' . $this->info->getEtag() . '"';
-	}
-
-	private function getPartFileBasePath($path) {
-		$partFileInStorage = \OC::$server->getConfig()->getSystemValue('part_file_in_storage', true);
-		if ($partFileInStorage) {
-			return $path;
-		} else {
-			return md5($path); // will place it in the root of the view with a unique name
-		}
-	}
-
-	/**
-	 * @param string $path
-	 */
-	private function emitPreHooks($exists, $path = null) {
-		if (is_null($path)) {
-			$path = $this->path;
-		}
-		$hookPath = Filesystem::getView()->getRelativePath($this->fileView->getAbsolutePath($path));
-		$run = true;
-
-		if (!$exists) {
-			\OC_Hook::emit(\OC\Files\Filesystem::CLASSNAME, \OC\Files\Filesystem::signal_create, [
-				\OC\Files\Filesystem::signal_param_path => $hookPath,
-				\OC\Files\Filesystem::signal_param_run => &$run,
-			]);
-		} else {
-			\OC_Hook::emit(\OC\Files\Filesystem::CLASSNAME, \OC\Files\Filesystem::signal_update, [
-				\OC\Files\Filesystem::signal_param_path => $hookPath,
-				\OC\Files\Filesystem::signal_param_run => &$run,
-			]);
-		}
-		\OC_Hook::emit(\OC\Files\Filesystem::CLASSNAME, \OC\Files\Filesystem::signal_write, [
-			\OC\Files\Filesystem::signal_param_path => $hookPath,
-			\OC\Files\Filesystem::signal_param_run => &$run,
-		]);
-		return $run;
-	}
-
-	/**
-	 * @param string $path
-	 */
-	private function emitPostHooks($exists, $path = null) {
-		if (is_null($path)) {
-			$path = $this->path;
-		}
-		$hookPath = Filesystem::getView()->getRelativePath($this->fileView->getAbsolutePath($path));
-		if (!$exists) {
-			\OC_Hook::emit(\OC\Files\Filesystem::CLASSNAME, \OC\Files\Filesystem::signal_post_create, [
-				\OC\Files\Filesystem::signal_param_path => $hookPath
-			]);
-		} else {
-			\OC_Hook::emit(\OC\Files\Filesystem::CLASSNAME, \OC\Files\Filesystem::signal_post_update, [
-				\OC\Files\Filesystem::signal_param_path => $hookPath
-			]);
-		}
-		\OC_Hook::emit(\OC\Files\Filesystem::CLASSNAME, \OC\Files\Filesystem::signal_post_write, [
-			\OC\Files\Filesystem::signal_param_path => $hookPath
-		]);
-	}
-
-	/**
-	 * Returns the data
-	 *
-	 * @return resource
-	 * @throws Forbidden
-	 * @throws ServiceUnavailable
-	 */
-	public function get() {
-		//throw exception if encryption is disabled but files are still encrypted
-		try {
-			if (!$this->info->isReadable()) {
-				// do a if the file did not exist
-				throw new NotFound();
-			}
-			try {
-				$res = $this->fileView->fopen(ltrim($this->path, '/'), 'rb');
-			} catch (\Exception $e) {
-				$this->convertToSabreException($e);
-			}
-			if ($res === false) {
-				throw new ServiceUnavailable("Could not open file");
-			}
-			return $res;
-		} catch (GenericEncryptionException $e) {
-			// returning 503 will allow retry of the operation at a later point in time
-			throw new ServiceUnavailable("Encryption not ready: " . $e->getMessage());
-		} catch (StorageNotAvailableException $e) {
-			throw new ServiceUnavailable("Failed to open file: " . $e->getMessage());
-		} catch (ForbiddenException $ex) {
-			throw new DAVForbiddenException($ex->getMessage(), $ex->getRetry());
-		} catch (LockedException $e) {
-			throw new FileLocked($e->getMessage(), $e->getCode(), $e);
-		}
-	}
-
-	/**
-	 * Delete the current file
-	 *
-	 * @throws Forbidden
-	 * @throws ServiceUnavailable
-	 */
-	public function delete() {
-		if (!$this->info->isDeletable()) {
-			throw new Forbidden();
-		}
-
-		try {
-			if (!$this->fileView->unlink($this->path)) {
-				// assume it wasn't possible to delete due to permissions
-				throw new Forbidden();
-			}
-		} catch (StorageNotAvailableException $e) {
-			throw new ServiceUnavailable("Failed to unlink: " . $e->getMessage());
-		} catch (ForbiddenException $ex) {
-			throw new DAVForbiddenException($ex->getMessage(), $ex->getRetry());
-		} catch (LockedException $e) {
-			throw new FileLocked($e->getMessage(), $e->getCode(), $e);
-		}
-	}
-
-	/**
-	 * Returns the mime-type for a file
-	 *
-	 * If null is returned, we'll assume application/octet-stream
-	 *
-	 * @return string
-	 */
-	public function getContentType() {
-		$mimeType = $this->info->getMimetype();
-
-		// PROPFIND needs to return the correct mime type, for consistency with the web UI
-		if (isset($_SERVER['REQUEST_METHOD']) && $_SERVER['REQUEST_METHOD'] === 'PROPFIND') {
-			return $mimeType;
-		}
-		return \OC::$server->getMimeTypeDetector()->getSecureMimeType($mimeType);
-	}
-
-	/**
-	 * @return array|bool
-	 */
-	public function getDirectDownload() {
-		if (\OCP\App::isEnabled('encryption')) {
-			return [];
-		}
-		/** @var \OCP\Files\Storage $storage */
-		list($storage, $internalPath) = $this->fileView->resolvePath($this->path);
-		if (is_null($storage)) {
-			return [];
-		}
-
-		return $storage->getDirectDownload($internalPath);
-	}
-
-	/**
-	 * @param resource $data
-	 * @return null|string
-	 * @throws Exception
-	 * @throws BadRequest
-	 * @throws NotImplemented
-	 * @throws ServiceUnavailable
-	 */
-	private function createFileChunked($data) {
-		list($path, $name) = \Sabre\Uri\split($this->path);
-
-		$info = \OC_FileChunking::decodeName($name);
-		if (empty($info)) {
-			throw new NotImplemented('Invalid chunk name');
-		}
-
-		$chunk_handler = new \OC_FileChunking($info);
-		$bytesWritten = $chunk_handler->store($info['index'], $data);
-
-		//detect aborted upload
-		if (isset($_SERVER['REQUEST_METHOD']) && $_SERVER['REQUEST_METHOD'] === 'PUT') {
-			if (isset($_SERVER['CONTENT_LENGTH'])) {
-				$expected = (int)$_SERVER['CONTENT_LENGTH'];
-				if ($bytesWritten !== $expected) {
-					$chunk_handler->remove($info['index']);
-					throw new BadRequest('Expected filesize of ' . $expected . ' bytes but read (from Nextcloud client) and wrote (to Nextcloud storage) ' . $bytesWritten . ' bytes. Could either be a network problem on the sending side or a problem writing to the storage on the server side.');
-				}
-			}
-		}
-
-		if ($chunk_handler->isComplete()) {
-			/** @var Storage $storage */
-			list($storage,) = $this->fileView->resolvePath($path);
-			$needsPartFile = $storage->needsPartFile();
-			$partFile = null;
-
-			$targetPath = $path . '/' . $info['name'];
-			/** @var \OC\Files\Storage\Storage $targetStorage */
-			list($targetStorage, $targetInternalPath) = $this->fileView->resolvePath($targetPath);
-
-			$exists = $this->fileView->file_exists($targetPath);
-
-			try {
-				$this->fileView->lockFile($targetPath, ILockingProvider::LOCK_SHARED);
-
-				$this->emitPreHooks($exists, $targetPath);
-				$this->fileView->changeLock($targetPath, ILockingProvider::LOCK_EXCLUSIVE);
-				/** @var \OC\Files\Storage\Storage $targetStorage */
-				list($targetStorage, $targetInternalPath) = $this->fileView->resolvePath($targetPath);
-
-				if ($needsPartFile) {
-					// we first assembly the target file as a part file
-					$partFile = $this->getPartFileBasePath($path . '/' . $info['name']) . '.ocTransferId' . $info['transferid'] . '.part';
-					/** @var \OC\Files\Storage\Storage $targetStorage */
-					list($partStorage, $partInternalPath) = $this->fileView->resolvePath($partFile);
-
-
-					$chunk_handler->file_assemble($partStorage, $partInternalPath);
-
-					// here is the final atomic rename
-					$renameOkay = $targetStorage->moveFromStorage($partStorage, $partInternalPath, $targetInternalPath);
-					$fileExists = $targetStorage->file_exists($targetInternalPath);
-					if ($renameOkay === false || $fileExists === false) {
-						\OC::$server->getLogger()->error('\OC\Files\Filesystem::rename() failed', ['app' => 'webdav']);
-						// only delete if an error occurred and the target file was already created
-						if ($fileExists) {
-							// set to null to avoid double-deletion when handling exception
-							// stray part file
-							$partFile = null;
-							$targetStorage->unlink($targetInternalPath);
-						}
-						$this->fileView->changeLock($targetPath, ILockingProvider::LOCK_SHARED);
-						throw new Exception('Could not rename part file assembled from chunks');
-					}
-				} else {
-					// assemble directly into the final file
-					$chunk_handler->file_assemble($targetStorage, $targetInternalPath);
-				}
-
-				// allow sync clients to send the mtime along in a header
-				if (isset($this->request->server['HTTP_X_OC_MTIME'])) {
-					$mtime = $this->sanitizeMtime($this->request->server['HTTP_X_OC_MTIME']);
-					if ($targetStorage->touch($targetInternalPath, $mtime)) {
-						$this->header('X-OC-MTime: accepted');
-					}
-				}
-
-				// since we skipped the view we need to scan and emit the hooks ourselves
-				$targetStorage->getUpdater()->update($targetInternalPath);
-
-				$this->fileView->changeLock($targetPath, ILockingProvider::LOCK_SHARED);
-
-				$this->emitPostHooks($exists, $targetPath);
-
-				// FIXME: should call refreshInfo but can't because $this->path is not the of the final file
-				$info = $this->fileView->getFileInfo($targetPath);
-
-				if (isset($this->request->server['HTTP_OC_CHECKSUM'])) {
-					$checksum = trim($this->request->server['HTTP_OC_CHECKSUM']);
-					$this->fileView->putFileInfo($targetPath, ['checksum' => $checksum]);
-				} elseif ($info->getChecksum() !== null && $info->getChecksum() !== '') {
-					$this->fileView->putFileInfo($this->path, ['checksum' => '']);
-				}
-
-				$this->fileView->unlockFile($targetPath, ILockingProvider::LOCK_SHARED);
-
-				return $info->getEtag();
-			} catch (\Exception $e) {
-				if ($partFile !== null) {
-					$targetStorage->unlink($targetInternalPath);
-				}
-				$this->convertToSabreException($e);
-			}
-		}
-
-		return null;
-	}
-
-	/**
-	 * Convert the given exception to a SabreException instance
-	 *
-	 * @param \Exception $e
-	 *
-	 * @throws \Sabre\DAV\Exception
-	 */
-	private function convertToSabreException(\Exception $e) {
-		if ($e instanceof \Sabre\DAV\Exception) {
-			throw $e;
-		}
-		if ($e instanceof NotPermittedException) {
-			// a more general case - due to whatever reason the content could not be written
-			throw new Forbidden($e->getMessage(), 0, $e);
-		}
-		if ($e instanceof ForbiddenException) {
-			// the path for the file was forbidden
-			throw new DAVForbiddenException($e->getMessage(), $e->getRetry(), $e);
-		}
-		if ($e instanceof EntityTooLargeException) {
-			// the file is too big to be stored
-			throw new EntityTooLarge($e->getMessage(), 0, $e);
-		}
-		if ($e instanceof InvalidContentException) {
-			// the file content is not permitted
-			throw new UnsupportedMediaType($e->getMessage(), 0, $e);
-		}
-		if ($e instanceof InvalidPathException) {
-			// the path for the file was not valid
-			// TODO: find proper http status code for this case
-			throw new Forbidden($e->getMessage(), 0, $e);
-		}
-		if ($e instanceof LockedException || $e instanceof LockNotAcquiredException) {
-			// the file is currently being written to by another process
-			throw new FileLocked($e->getMessage(), $e->getCode(), $e);
-		}
-		if ($e instanceof GenericEncryptionException) {
-			// returning 503 will allow retry of the operation at a later point in time
-			throw new ServiceUnavailable('Encryption not ready: ' . $e->getMessage(), 0, $e);
-		}
-		if ($e instanceof StorageNotAvailableException) {
-			throw new ServiceUnavailable('Failed to write file contents: ' . $e->getMessage(), 0, $e);
-		}
-		if ($e instanceof NotFoundException) {
-			throw new NotFound('File not found: ' . $e->getMessage(), 0, $e);
-		}
-
-		throw new \Sabre\DAV\Exception($e->getMessage(), 0, $e);
-	}
-
-	/**
-	 * Get the checksum for this file
-	 *
-	 * @return string
-	 */
-	public function getChecksum() {
-		return $this->info->getChecksum();
-	}
-
-	protected function header($string) {
-		if (!\OC::$CLI) {
-			\header($string);
-		}
-	}
+    protected $request;
+
+    /**
+     * Sets up the node, expects a full path name
+     *
+     * @param \OC\Files\View $view
+     * @param \OCP\Files\FileInfo $info
+     * @param \OCP\Share\IManager $shareManager
+     * @param \OC\AppFramework\Http\Request $request
+     */
+    public function __construct(View $view, FileInfo $info, IManager $shareManager = null, Request $request = null) {
+        parent::__construct($view, $info, $shareManager);
+
+        if (isset($request)) {
+            $this->request = $request;
+        } else {
+            $this->request = \OC::$server->getRequest();
+        }
+    }
+
+    /**
+     * Updates the data
+     *
+     * The data argument is a readable stream resource.
+     *
+     * After a successful put operation, you may choose to return an ETag. The
+     * etag must always be surrounded by double-quotes. These quotes must
+     * appear in the actual string you're returning.
+     *
+     * Clients may use the ETag from a PUT request to later on make sure that
+     * when they update the file, the contents haven't changed in the mean
+     * time.
+     *
+     * If you don't plan to store the file byte-by-byte, and you return a
+     * different object on a subsequent GET you are strongly recommended to not
+     * return an ETag, and just return null.
+     *
+     * @param resource $data
+     *
+     * @throws Forbidden
+     * @throws UnsupportedMediaType
+     * @throws BadRequest
+     * @throws Exception
+     * @throws EntityTooLarge
+     * @throws ServiceUnavailable
+     * @throws FileLocked
+     * @return string|null
+     */
+    public function put($data) {
+        try {
+            $exists = $this->fileView->file_exists($this->path);
+            if ($this->info && $exists && !$this->info->isUpdateable()) {
+                throw new Forbidden();
+            }
+        } catch (StorageNotAvailableException $e) {
+            throw new ServiceUnavailable("File is not updatable: " . $e->getMessage());
+        }
+
+        // verify path of the target
+        $this->verifyPath();
+
+        // chunked handling
+        if (isset($_SERVER['HTTP_OC_CHUNKED'])) {
+            try {
+                return $this->createFileChunked($data);
+            } catch (\Exception $e) {
+                $this->convertToSabreException($e);
+            }
+        }
+
+        /** @var Storage $partStorage */
+        list($partStorage) = $this->fileView->resolvePath($this->path);
+        $needsPartFile = $partStorage->needsPartFile() && (strlen($this->path) > 1);
+
+        $view = \OC\Files\Filesystem::getView();
+
+        if ($needsPartFile) {
+            // mark file as partial while uploading (ignored by the scanner)
+            $partFilePath = $this->getPartFileBasePath($this->path) . '.ocTransferId' . rand() . '.part';
+
+            if (!$view->isCreatable($partFilePath) && $view->isUpdatable($this->path)) {
+                $needsPartFile = false;
+            }
+        }
+        if (!$needsPartFile) {
+            // upload file directly as the final path
+            $partFilePath = $this->path;
+
+            if ($view && !$this->emitPreHooks($exists)) {
+                throw new Exception('Could not write to final file, canceled by hook');
+            }
+        }
+
+        // the part file and target file might be on a different storage in case of a single file storage (e.g. single file share)
+        /** @var \OC\Files\Storage\Storage $partStorage */
+        list($partStorage, $internalPartPath) = $this->fileView->resolvePath($partFilePath);
+        /** @var \OC\Files\Storage\Storage $storage */
+        list($storage, $internalPath) = $this->fileView->resolvePath($this->path);
+        try {
+            if (!$needsPartFile) {
+                $this->changeLock(ILockingProvider::LOCK_EXCLUSIVE);
+            }
+
+            if (!is_resource($data)) {
+                $tmpData = fopen('php://temp', 'r+');
+                if ($data !== null) {
+                    fwrite($tmpData, $data);
+                    rewind($tmpData);
+                }
+                $data = $tmpData;
+            }
+
+            $data = HashWrapper::wrap($data, 'md5', function ($hash) {
+                $this->header('X-Hash-MD5: ' . $hash);
+            });
+            $data = HashWrapper::wrap($data, 'sha1', function ($hash) {
+                $this->header('X-Hash-SHA1: ' . $hash);
+            });
+            $data = HashWrapper::wrap($data, 'sha256', function ($hash) {
+                $this->header('X-Hash-SHA256: ' . $hash);
+            });
+
+            if ($partStorage->instanceOfStorage(Storage\IWriteStreamStorage::class)) {
+                $isEOF = false;
+                $wrappedData = CallbackWrapper::wrap($data, null, null, null, null, function ($stream) use (&$isEOF) {
+                    $isEOF = feof($stream);
+                });
+
+                $result = true;
+                $count = -1;
+                try {
+                    $count = $partStorage->writeStream($internalPartPath, $wrappedData);
+                } catch (GenericFileException $e) {
+                    $result = false;
+                }
+
+
+                if ($result === false) {
+                    $result = $isEOF;
+                    if (is_resource($wrappedData)) {
+                        $result = feof($wrappedData);
+                    }
+                }
+            } else {
+                $target = $partStorage->fopen($internalPartPath, 'wb');
+                if ($target === false) {
+                    \OC::$server->getLogger()->error('\OC\Files\Filesystem::fopen() failed', ['app' => 'webdav']);
+                    // because we have no clue about the cause we can only throw back a 500/Internal Server Error
+                    throw new Exception('Could not write file contents');
+                }
+                list($count, $result) = \OC_Helper::streamCopy($data, $target);
+                fclose($target);
+            }
+
+            if ($result === false) {
+                $expected = -1;
+                if (isset($_SERVER['CONTENT_LENGTH'])) {
+                    $expected = $_SERVER['CONTENT_LENGTH'];
+                }
+                if ($expected !== "0") {
+                    throw new Exception('Error while copying file to target location (copied bytes: ' . $count . ', expected filesize: ' . $expected . ' )');
+                }
+            }
+
+            // if content length is sent by client:
+            // double check if the file was fully received
+            // compare expected and actual size
+            if (isset($_SERVER['CONTENT_LENGTH']) && $_SERVER['REQUEST_METHOD'] === 'PUT') {
+                $expected = (int)$_SERVER['CONTENT_LENGTH'];
+                if ($count !== $expected) {
+                    throw new BadRequest('Expected filesize of ' . $expected . ' bytes but read (from Nextcloud client) and wrote (to Nextcloud storage) ' . $count . ' bytes. Could either be a network problem on the sending side or a problem writing to the storage on the server side.');
+                }
+            }
+        } catch (\Exception $e) {
+            $context = [];
+
+            if ($e instanceof LockedException) {
+                $context['level'] = ILogger::DEBUG;
+            }
+
+            \OC::$server->getLogger()->logException($e, $context);
+            if ($needsPartFile) {
+                $partStorage->unlink($internalPartPath);
+            }
+            $this->convertToSabreException($e);
+        }
+
+        try {
+            if ($needsPartFile) {
+                if ($view && !$this->emitPreHooks($exists)) {
+                    $partStorage->unlink($internalPartPath);
+                    throw new Exception('Could not rename part file to final file, canceled by hook');
+                }
+                try {
+                    $this->changeLock(ILockingProvider::LOCK_EXCLUSIVE);
+                } catch (LockedException $e) {
+                    // during very large uploads, the shared lock we got at the start might have been expired
+                    // meaning that the above lock can fail not just only because somebody else got a shared lock
+                    // or because there is no existing shared lock to make exclusive
+                    //
+                    // Thus we try to get a new exclusive lock, if the original lock failed because of a different shared
+                    // lock this will still fail, if our original shared lock expired the new lock will be successful and
+                    // the entire operation will be safe
+
+                    try {
+                        $this->acquireLock(ILockingProvider::LOCK_EXCLUSIVE);
+                    } catch (LockedException $ex) {
+                        if ($needsPartFile) {
+                            $partStorage->unlink($internalPartPath);
+                        }
+                        throw new FileLocked($e->getMessage(), $e->getCode(), $e);
+                    }
+                }
+
+                // rename to correct path
+                try {
+                    $renameOkay = $storage->moveFromStorage($partStorage, $internalPartPath, $internalPath);
+                    $fileExists = $storage->file_exists($internalPath);
+                    if ($renameOkay === false || $fileExists === false) {
+                        \OC::$server->getLogger()->error('renaming part file to final file failed $renameOkay: ' . ($renameOkay ? 'true' : 'false') . ', $fileExists: ' . ($fileExists ? 'true' : 'false') . ')', ['app' => 'webdav']);
+                        throw new Exception('Could not rename part file to final file');
+                    }
+                } catch (ForbiddenException $ex) {
+                    if (!$ex->getRetry()) {
+                        $partStorage->unlink($internalPartPath);
+                    }
+                    throw new DAVForbiddenException($ex->getMessage(), $ex->getRetry());
+                } catch (\Exception $e) {
+                    $partStorage->unlink($internalPartPath);
+                    $this->convertToSabreException($e);
+                }
+            }
+
+            // since we skipped the view we need to scan and emit the hooks ourselves
+            $storage->getUpdater()->update($internalPath);
+
+            try {
+                $this->changeLock(ILockingProvider::LOCK_SHARED);
+            } catch (LockedException $e) {
+                throw new FileLocked($e->getMessage(), $e->getCode(), $e);
+            }
+
+            // allow sync clients to send the mtime along in a header
+            if (isset($this->request->server['HTTP_X_OC_MTIME'])) {
+                $mtime = $this->sanitizeMtime($this->request->server['HTTP_X_OC_MTIME']);
+                if ($this->fileView->touch($this->path, $mtime)) {
+                    $this->header('X-OC-MTime: accepted');
+                }
+            }
+
+            $fileInfoUpdate = [
+                'upload_time' => time()
+            ];
+
+            // allow sync clients to send the creation time along in a header
+            if (isset($this->request->server['HTTP_X_OC_CTIME'])) {
+                $ctime = $this->sanitizeMtime($this->request->server['HTTP_X_OC_CTIME']);
+                $fileInfoUpdate['creation_time'] = $ctime;
+                $this->header('X-OC-CTime: accepted');
+            }
+
+            $this->fileView->putFileInfo($this->path, $fileInfoUpdate);
+
+            if ($view) {
+                $this->emitPostHooks($exists);
+            }
+
+            $this->refreshInfo();
+
+            if (isset($this->request->server['HTTP_OC_CHECKSUM'])) {
+                $checksum = trim($this->request->server['HTTP_OC_CHECKSUM']);
+                $this->fileView->putFileInfo($this->path, ['checksum' => $checksum]);
+                $this->refreshInfo();
+            } elseif ($this->getChecksum() !== null && $this->getChecksum() !== '') {
+                $this->fileView->putFileInfo($this->path, ['checksum' => '']);
+                $this->refreshInfo();
+            }
+        } catch (StorageNotAvailableException $e) {
+            throw new ServiceUnavailable("Failed to check file size: " . $e->getMessage(), 0, $e);
+        }
+
+        return '"' . $this->info->getEtag() . '"';
+    }
+
+    private function getPartFileBasePath($path) {
+        $partFileInStorage = \OC::$server->getConfig()->getSystemValue('part_file_in_storage', true);
+        if ($partFileInStorage) {
+            return $path;
+        } else {
+            return md5($path); // will place it in the root of the view with a unique name
+        }
+    }
+
+    /**
+     * @param string $path
+     */
+    private function emitPreHooks($exists, $path = null) {
+        if (is_null($path)) {
+            $path = $this->path;
+        }
+        $hookPath = Filesystem::getView()->getRelativePath($this->fileView->getAbsolutePath($path));
+        $run = true;
+
+        if (!$exists) {
+            \OC_Hook::emit(\OC\Files\Filesystem::CLASSNAME, \OC\Files\Filesystem::signal_create, [
+                \OC\Files\Filesystem::signal_param_path => $hookPath,
+                \OC\Files\Filesystem::signal_param_run => &$run,
+            ]);
+        } else {
+            \OC_Hook::emit(\OC\Files\Filesystem::CLASSNAME, \OC\Files\Filesystem::signal_update, [
+                \OC\Files\Filesystem::signal_param_path => $hookPath,
+                \OC\Files\Filesystem::signal_param_run => &$run,
+            ]);
+        }
+        \OC_Hook::emit(\OC\Files\Filesystem::CLASSNAME, \OC\Files\Filesystem::signal_write, [
+            \OC\Files\Filesystem::signal_param_path => $hookPath,
+            \OC\Files\Filesystem::signal_param_run => &$run,
+        ]);
+        return $run;
+    }
+
+    /**
+     * @param string $path
+     */
+    private function emitPostHooks($exists, $path = null) {
+        if (is_null($path)) {
+            $path = $this->path;
+        }
+        $hookPath = Filesystem::getView()->getRelativePath($this->fileView->getAbsolutePath($path));
+        if (!$exists) {
+            \OC_Hook::emit(\OC\Files\Filesystem::CLASSNAME, \OC\Files\Filesystem::signal_post_create, [
+                \OC\Files\Filesystem::signal_param_path => $hookPath
+            ]);
+        } else {
+            \OC_Hook::emit(\OC\Files\Filesystem::CLASSNAME, \OC\Files\Filesystem::signal_post_update, [
+                \OC\Files\Filesystem::signal_param_path => $hookPath
+            ]);
+        }
+        \OC_Hook::emit(\OC\Files\Filesystem::CLASSNAME, \OC\Files\Filesystem::signal_post_write, [
+            \OC\Files\Filesystem::signal_param_path => $hookPath
+        ]);
+    }
+
+    /**
+     * Returns the data
+     *
+     * @return resource
+     * @throws Forbidden
+     * @throws ServiceUnavailable
+     */
+    public function get() {
+        //throw exception if encryption is disabled but files are still encrypted
+        try {
+            if (!$this->info->isReadable()) {
+                // do a if the file did not exist
+                throw new NotFound();
+            }
+            try {
+                $res = $this->fileView->fopen(ltrim($this->path, '/'), 'rb');
+            } catch (\Exception $e) {
+                $this->convertToSabreException($e);
+            }
+            if ($res === false) {
+                throw new ServiceUnavailable("Could not open file");
+            }
+            return $res;
+        } catch (GenericEncryptionException $e) {
+            // returning 503 will allow retry of the operation at a later point in time
+            throw new ServiceUnavailable("Encryption not ready: " . $e->getMessage());
+        } catch (StorageNotAvailableException $e) {
+            throw new ServiceUnavailable("Failed to open file: " . $e->getMessage());
+        } catch (ForbiddenException $ex) {
+            throw new DAVForbiddenException($ex->getMessage(), $ex->getRetry());
+        } catch (LockedException $e) {
+            throw new FileLocked($e->getMessage(), $e->getCode(), $e);
+        }
+    }
+
+    /**
+     * Delete the current file
+     *
+     * @throws Forbidden
+     * @throws ServiceUnavailable
+     */
+    public function delete() {
+        if (!$this->info->isDeletable()) {
+            throw new Forbidden();
+        }
+
+        try {
+            if (!$this->fileView->unlink($this->path)) {
+                // assume it wasn't possible to delete due to permissions
+                throw new Forbidden();
+            }
+        } catch (StorageNotAvailableException $e) {
+            throw new ServiceUnavailable("Failed to unlink: " . $e->getMessage());
+        } catch (ForbiddenException $ex) {
+            throw new DAVForbiddenException($ex->getMessage(), $ex->getRetry());
+        } catch (LockedException $e) {
+            throw new FileLocked($e->getMessage(), $e->getCode(), $e);
+        }
+    }
+
+    /**
+     * Returns the mime-type for a file
+     *
+     * If null is returned, we'll assume application/octet-stream
+     *
+     * @return string
+     */
+    public function getContentType() {
+        $mimeType = $this->info->getMimetype();
+
+        // PROPFIND needs to return the correct mime type, for consistency with the web UI
+        if (isset($_SERVER['REQUEST_METHOD']) && $_SERVER['REQUEST_METHOD'] === 'PROPFIND') {
+            return $mimeType;
+        }
+        return \OC::$server->getMimeTypeDetector()->getSecureMimeType($mimeType);
+    }
+
+    /**
+     * @return array|bool
+     */
+    public function getDirectDownload() {
+        if (\OCP\App::isEnabled('encryption')) {
+            return [];
+        }
+        /** @var \OCP\Files\Storage $storage */
+        list($storage, $internalPath) = $this->fileView->resolvePath($this->path);
+        if (is_null($storage)) {
+            return [];
+        }
+
+        return $storage->getDirectDownload($internalPath);
+    }
+
+    /**
+     * @param resource $data
+     * @return null|string
+     * @throws Exception
+     * @throws BadRequest
+     * @throws NotImplemented
+     * @throws ServiceUnavailable
+     */
+    private function createFileChunked($data) {
+        list($path, $name) = \Sabre\Uri\split($this->path);
+
+        $info = \OC_FileChunking::decodeName($name);
+        if (empty($info)) {
+            throw new NotImplemented('Invalid chunk name');
+        }
+
+        $chunk_handler = new \OC_FileChunking($info);
+        $bytesWritten = $chunk_handler->store($info['index'], $data);
+
+        //detect aborted upload
+        if (isset($_SERVER['REQUEST_METHOD']) && $_SERVER['REQUEST_METHOD'] === 'PUT') {
+            if (isset($_SERVER['CONTENT_LENGTH'])) {
+                $expected = (int)$_SERVER['CONTENT_LENGTH'];
+                if ($bytesWritten !== $expected) {
+                    $chunk_handler->remove($info['index']);
+                    throw new BadRequest('Expected filesize of ' . $expected . ' bytes but read (from Nextcloud client) and wrote (to Nextcloud storage) ' . $bytesWritten . ' bytes. Could either be a network problem on the sending side or a problem writing to the storage on the server side.');
+                }
+            }
+        }
+
+        if ($chunk_handler->isComplete()) {
+            /** @var Storage $storage */
+            list($storage,) = $this->fileView->resolvePath($path);
+            $needsPartFile = $storage->needsPartFile();
+            $partFile = null;
+
+            $targetPath = $path . '/' . $info['name'];
+            /** @var \OC\Files\Storage\Storage $targetStorage */
+            list($targetStorage, $targetInternalPath) = $this->fileView->resolvePath($targetPath);
+
+            $exists = $this->fileView->file_exists($targetPath);
+
+            try {
+                $this->fileView->lockFile($targetPath, ILockingProvider::LOCK_SHARED);
+
+                $this->emitPreHooks($exists, $targetPath);
+                $this->fileView->changeLock($targetPath, ILockingProvider::LOCK_EXCLUSIVE);
+                /** @var \OC\Files\Storage\Storage $targetStorage */
+                list($targetStorage, $targetInternalPath) = $this->fileView->resolvePath($targetPath);
+
+                if ($needsPartFile) {
+                    // we first assembly the target file as a part file
+                    $partFile = $this->getPartFileBasePath($path . '/' . $info['name']) . '.ocTransferId' . $info['transferid'] . '.part';
+                    /** @var \OC\Files\Storage\Storage $targetStorage */
+                    list($partStorage, $partInternalPath) = $this->fileView->resolvePath($partFile);
+
+
+                    $chunk_handler->file_assemble($partStorage, $partInternalPath);
+
+                    // here is the final atomic rename
+                    $renameOkay = $targetStorage->moveFromStorage($partStorage, $partInternalPath, $targetInternalPath);
+                    $fileExists = $targetStorage->file_exists($targetInternalPath);
+                    if ($renameOkay === false || $fileExists === false) {
+                        \OC::$server->getLogger()->error('\OC\Files\Filesystem::rename() failed', ['app' => 'webdav']);
+                        // only delete if an error occurred and the target file was already created
+                        if ($fileExists) {
+                            // set to null to avoid double-deletion when handling exception
+                            // stray part file
+                            $partFile = null;
+                            $targetStorage->unlink($targetInternalPath);
+                        }
+                        $this->fileView->changeLock($targetPath, ILockingProvider::LOCK_SHARED);
+                        throw new Exception('Could not rename part file assembled from chunks');
+                    }
+                } else {
+                    // assemble directly into the final file
+                    $chunk_handler->file_assemble($targetStorage, $targetInternalPath);
+                }
+
+                // allow sync clients to send the mtime along in a header
+                if (isset($this->request->server['HTTP_X_OC_MTIME'])) {
+                    $mtime = $this->sanitizeMtime($this->request->server['HTTP_X_OC_MTIME']);
+                    if ($targetStorage->touch($targetInternalPath, $mtime)) {
+                        $this->header('X-OC-MTime: accepted');
+                    }
+                }
+
+                // since we skipped the view we need to scan and emit the hooks ourselves
+                $targetStorage->getUpdater()->update($targetInternalPath);
+
+                $this->fileView->changeLock($targetPath, ILockingProvider::LOCK_SHARED);
+
+                $this->emitPostHooks($exists, $targetPath);
+
+                // FIXME: should call refreshInfo but can't because $this->path is not the of the final file
+                $info = $this->fileView->getFileInfo($targetPath);
+
+                if (isset($this->request->server['HTTP_OC_CHECKSUM'])) {
+                    $checksum = trim($this->request->server['HTTP_OC_CHECKSUM']);
+                    $this->fileView->putFileInfo($targetPath, ['checksum' => $checksum]);
+                } elseif ($info->getChecksum() !== null && $info->getChecksum() !== '') {
+                    $this->fileView->putFileInfo($this->path, ['checksum' => '']);
+                }
+
+                $this->fileView->unlockFile($targetPath, ILockingProvider::LOCK_SHARED);
+
+                return $info->getEtag();
+            } catch (\Exception $e) {
+                if ($partFile !== null) {
+                    $targetStorage->unlink($targetInternalPath);
+                }
+                $this->convertToSabreException($e);
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Convert the given exception to a SabreException instance
+     *
+     * @param \Exception $e
+     *
+     * @throws \Sabre\DAV\Exception
+     */
+    private function convertToSabreException(\Exception $e) {
+        if ($e instanceof \Sabre\DAV\Exception) {
+            throw $e;
+        }
+        if ($e instanceof NotPermittedException) {
+            // a more general case - due to whatever reason the content could not be written
+            throw new Forbidden($e->getMessage(), 0, $e);
+        }
+        if ($e instanceof ForbiddenException) {
+            // the path for the file was forbidden
+            throw new DAVForbiddenException($e->getMessage(), $e->getRetry(), $e);
+        }
+        if ($e instanceof EntityTooLargeException) {
+            // the file is too big to be stored
+            throw new EntityTooLarge($e->getMessage(), 0, $e);
+        }
+        if ($e instanceof InvalidContentException) {
+            // the file content is not permitted
+            throw new UnsupportedMediaType($e->getMessage(), 0, $e);
+        }
+        if ($e instanceof InvalidPathException) {
+            // the path for the file was not valid
+            // TODO: find proper http status code for this case
+            throw new Forbidden($e->getMessage(), 0, $e);
+        }
+        if ($e instanceof LockedException || $e instanceof LockNotAcquiredException) {
+            // the file is currently being written to by another process
+            throw new FileLocked($e->getMessage(), $e->getCode(), $e);
+        }
+        if ($e instanceof GenericEncryptionException) {
+            // returning 503 will allow retry of the operation at a later point in time
+            throw new ServiceUnavailable('Encryption not ready: ' . $e->getMessage(), 0, $e);
+        }
+        if ($e instanceof StorageNotAvailableException) {
+            throw new ServiceUnavailable('Failed to write file contents: ' . $e->getMessage(), 0, $e);
+        }
+        if ($e instanceof NotFoundException) {
+            throw new NotFound('File not found: ' . $e->getMessage(), 0, $e);
+        }
+
+        throw new \Sabre\DAV\Exception($e->getMessage(), 0, $e);
+    }
+
+    /**
+     * Get the checksum for this file
+     *
+     * @return string
+     */
+    public function getChecksum() {
+        return $this->info->getChecksum();
+    }
+
+    protected function header($string) {
+        if (!\OC::$CLI) {
+            \header($string);
+        }
+    }
 }

lib/private/Files/ObjectStore/StorageObjectStore.php

Indentation +58 added lines, -58 removed lines

@@ -32,70 +32,70 @@
  * Object store that wraps a storage backend, mostly for testing purposes
  */
 class StorageObjectStore implements IObjectStore {
-	/** @var IStorage */
-	private $storage;
+    /** @var IStorage */
+    private $storage;
 
-	/**
-	 * @param IStorage $storage
-	 */
-	public function __construct(IStorage $storage) {
-		$this->storage = $storage;
-	}
+    /**
+     * @param IStorage $storage
+     */
+    public function __construct(IStorage $storage) {
+        $this->storage = $storage;
+    }
 
-	/**
-	 * @return string the container or bucket name where objects are stored
-	 * @since 7.0.0
-	 */
-	public function getStorageId() {
-		$this->storage->getId();
-	}
+    /**
+     * @return string the container or bucket name where objects are stored
+     * @since 7.0.0
+     */
+    public function getStorageId() {
+        $this->storage->getId();
+    }
 
-	/**
-	 * @param string $urn the unified resource name used to identify the object
-	 * @return resource stream with the read data
-	 * @throws \Exception when something goes wrong, message will be logged
-	 * @since 7.0.0
-	 */
-	public function readObject($urn) {
-		$handle = $this->storage->fopen($urn, 'r');
-		if (is_resource($handle)) {
-			return $handle;
-		}
+    /**
+     * @param string $urn the unified resource name used to identify the object
+     * @return resource stream with the read data
+     * @throws \Exception when something goes wrong, message will be logged
+     * @since 7.0.0
+     */
+    public function readObject($urn) {
+        $handle = $this->storage->fopen($urn, 'r');
+        if (is_resource($handle)) {
+            return $handle;
+        }
 
-		throw new \Exception();
-	}
+        throw new \Exception();
+    }
 
-	/**
-	 * @param string $urn the unified resource name used to identify the object
-	 * @param resource $stream stream with the data to write
-	 * @throws \Exception when something goes wrong, message will be logged
-	 * @since 7.0.0
-	 */
-	public function writeObject($urn, $stream) {
-		$handle = $this->storage->fopen($urn, 'w');
-		if ($handle) {
-			stream_copy_to_stream($stream, $handle);
-			fclose($handle);
-		} else {
-			throw new \Exception();
-		}
-	}
+    /**
+     * @param string $urn the unified resource name used to identify the object
+     * @param resource $stream stream with the data to write
+     * @throws \Exception when something goes wrong, message will be logged
+     * @since 7.0.0
+     */
+    public function writeObject($urn, $stream) {
+        $handle = $this->storage->fopen($urn, 'w');
+        if ($handle) {
+            stream_copy_to_stream($stream, $handle);
+            fclose($handle);
+        } else {
+            throw new \Exception();
+        }
+    }
 
-	/**
-	 * @param string $urn the unified resource name used to identify the object
-	 * @return void
-	 * @throws \Exception when something goes wrong, message will be logged
-	 * @since 7.0.0
-	 */
-	public function deleteObject($urn) {
-		$this->storage->unlink($urn);
-	}
+    /**
+     * @param string $urn the unified resource name used to identify the object
+     * @return void
+     * @throws \Exception when something goes wrong, message will be logged
+     * @since 7.0.0
+     */
+    public function deleteObject($urn) {
+        $this->storage->unlink($urn);
+    }
 
-	public function objectExists($urn) {
-		return $this->storage->file_exists($urn);
-	}
+    public function objectExists($urn) {
+        return $this->storage->file_exists($urn);
+    }
 
-	public function copyObject($from, $to) {
-		$this->storage->copy($from, $to);
-	}
+    public function copyObject($from, $to) {
+        $this->storage->copy($from, $to);
+    }
 }

lib/private/Files/Storage/Common.php

Indentation +809 added lines, -809 removed lines

@@ -76,817 +76,817 @@
  * in classes which extend it, e.g. $this->stat() .
  */
 abstract class Common implements Storage, ILockingStorage, IWriteStreamStorage {
-	use LocalTempFileTrait;
-
-	protected $cache;
-	protected $scanner;
-	protected $watcher;
-	protected $propagator;
-	protected $storageCache;
-	protected $updater;
-
-	protected $mountOptions = [];
-	protected $owner = null;
-
-	private $shouldLogLocks = null;
-	private $logger;
-
-	public function __construct($parameters) {
-	}
-
-	/**
-	 * Remove a file or folder
-	 *
-	 * @param string $path
-	 * @return bool
-	 */
-	protected function remove($path) {
-		if ($this->is_dir($path)) {
-			return $this->rmdir($path);
-		} elseif ($this->is_file($path)) {
-			return $this->unlink($path);
-		} else {
-			return false;
-		}
-	}
-
-	public function is_dir($path) {
-		return $this->filetype($path) === 'dir';
-	}
-
-	public function is_file($path) {
-		return $this->filetype($path) === 'file';
-	}
-
-	public function filesize($path) {
-		if ($this->is_dir($path)) {
-			return 0; //by definition
-		} else {
-			$stat = $this->stat($path);
-			if (isset($stat['size'])) {
-				return $stat['size'];
-			} else {
-				return 0;
-			}
-		}
-	}
-
-	public function isReadable($path) {
-		// at least check whether it exists
-		// subclasses might want to implement this more thoroughly
-		return $this->file_exists($path);
-	}
-
-	public function isUpdatable($path) {
-		// at least check whether it exists
-		// subclasses might want to implement this more thoroughly
-		// a non-existing file/folder isn't updatable
-		return $this->file_exists($path);
-	}
-
-	public function isCreatable($path) {
-		if ($this->is_dir($path) && $this->isUpdatable($path)) {
-			return true;
-		}
-		return false;
-	}
-
-	public function isDeletable($path) {
-		if ($path === '' || $path === '/') {
-			return false;
-		}
-		$parent = dirname($path);
-		return $this->isUpdatable($parent) && $this->isUpdatable($path);
-	}
-
-	public function isSharable($path) {
-		return $this->isReadable($path);
-	}
-
-	public function getPermissions($path) {
-		$permissions = 0;
-		if ($this->isCreatable($path)) {
-			$permissions |= \OCP\Constants::PERMISSION_CREATE;
-		}
-		if ($this->isReadable($path)) {
-			$permissions |= \OCP\Constants::PERMISSION_READ;
-		}
-		if ($this->isUpdatable($path)) {
-			$permissions |= \OCP\Constants::PERMISSION_UPDATE;
-		}
-		if ($this->isDeletable($path)) {
-			$permissions |= \OCP\Constants::PERMISSION_DELETE;
-		}
-		if ($this->isSharable($path)) {
-			$permissions |= \OCP\Constants::PERMISSION_SHARE;
-		}
-		return $permissions;
-	}
-
-	public function filemtime($path) {
-		$stat = $this->stat($path);
-		if (isset($stat['mtime']) && $stat['mtime'] > 0) {
-			return $stat['mtime'];
-		} else {
-			return 0;
-		}
-	}
-
-	public function file_get_contents($path) {
-		$handle = $this->fopen($path, "r");
-		if (!$handle) {
-			return false;
-		}
-		$data = stream_get_contents($handle);
-		fclose($handle);
-		return $data;
-	}
-
-	public function file_put_contents($path, $data) {
-		$handle = $this->fopen($path, "w");
-		$this->removeCachedFile($path);
-		$count = fwrite($handle, $data);
-		fclose($handle);
-		return $count;
-	}
-
-	public function rename($path1, $path2) {
-		$this->remove($path2);
-
-		$this->removeCachedFile($path1);
-		return $this->copy($path1, $path2) and $this->remove($path1);
-	}
-
-	public function copy($path1, $path2) {
-		if ($this->is_dir($path1)) {
-			$this->remove($path2);
-			$dir = $this->opendir($path1);
-			$this->mkdir($path2);
-			while ($file = readdir($dir)) {
-				if (!Filesystem::isIgnoredDir($file)) {
-					if (!$this->copy($path1 . '/' . $file, $path2 . '/' . $file)) {
-						return false;
-					}
-				}
-			}
-			closedir($dir);
-			return true;
-		} else {
-			$source = $this->fopen($path1, 'r');
-			$target = $this->fopen($path2, 'w');
-			[, $result] = \OC_Helper::streamCopy($source, $target);
-			if (!$result) {
-				\OC::$server->getLogger()->warning("Failed to write data while copying $path1 to $path2");
-			}
-			$this->removeCachedFile($path2);
-			return $result;
-		}
-	}
-
-	public function getMimeType($path) {
-		if ($this->is_dir($path)) {
-			return 'httpd/unix-directory';
-		} elseif ($this->file_exists($path)) {
-			return \OC::$server->getMimeTypeDetector()->detectPath($path);
-		} else {
-			return false;
-		}
-	}
-
-	public function hash($type, $path, $raw = false) {
-		$fh = $this->fopen($path, 'rb');
-		$ctx = hash_init($type);
-		hash_update_stream($ctx, $fh);
-		fclose($fh);
-		return hash_final($ctx, $raw);
-	}
-
-	public function search($query) {
-		return $this->searchInDir($query);
-	}
-
-	public function getLocalFile($path) {
-		return $this->getCachedFile($path);
-	}
-
-	/**
-	 * @param string $path
-	 * @param string $target
-	 */
-	private function addLocalFolder($path, $target) {
-		$dh = $this->opendir($path);
-		if (is_resource($dh)) {
-			while (($file = readdir($dh)) !== false) {
-				if (!\OC\Files\Filesystem::isIgnoredDir($file)) {
-					if ($this->is_dir($path . '/' . $file)) {
-						mkdir($target . '/' . $file);
-						$this->addLocalFolder($path . '/' . $file, $target . '/' . $file);
-					} else {
-						$tmp = $this->toTmpFile($path . '/' . $file);
-						rename($tmp, $target . '/' . $file);
-					}
-				}
-			}
-		}
-	}
-
-	/**
-	 * @param string $query
-	 * @param string $dir
-	 * @return array
-	 */
-	protected function searchInDir($query, $dir = '') {
-		$files = [];
-		$dh = $this->opendir($dir);
-		if (is_resource($dh)) {
-			while (($item = readdir($dh)) !== false) {
-				if (\OC\Files\Filesystem::isIgnoredDir($item)) {
-					continue;
-				}
-				if (strstr(strtolower($item), strtolower($query)) !== false) {
-					$files[] = $dir . '/' . $item;
-				}
-				if ($this->is_dir($dir . '/' . $item)) {
-					$files = array_merge($files, $this->searchInDir($query, $dir . '/' . $item));
-				}
-			}
-		}
-		closedir($dh);
-		return $files;
-	}
-
-	/**
-	 * check if a file or folder has been updated since $time
-	 *
-	 * The method is only used to check if the cache needs to be updated. Storage backends that don't support checking
-	 * the mtime should always return false here. As a result storage implementations that always return false expect
-	 * exclusive access to the backend and will not pick up files that have been added in a way that circumvents
-	 * ownClouds filesystem.
-	 *
-	 * @param string $path
-	 * @param int $time
-	 * @return bool
-	 */
-	public function hasUpdated($path, $time) {
-		return $this->filemtime($path) > $time;
-	}
-
-	public function getCache($path = '', $storage = null) {
-		if (!$storage) {
-			$storage = $this;
-		}
-		if (!isset($storage->cache)) {
-			$storage->cache = new Cache($storage);
-		}
-		return $storage->cache;
-	}
-
-	public function getScanner($path = '', $storage = null) {
-		if (!$storage) {
-			$storage = $this;
-		}
-		if (!isset($storage->scanner)) {
-			$storage->scanner = new Scanner($storage);
-		}
-		return $storage->scanner;
-	}
-
-	public function getWatcher($path = '', $storage = null) {
-		if (!$storage) {
-			$storage = $this;
-		}
-		if (!isset($this->watcher)) {
-			$this->watcher = new Watcher($storage);
-			$globalPolicy = \OC::$server->getConfig()->getSystemValue('filesystem_check_changes', Watcher::CHECK_NEVER);
-			$this->watcher->setPolicy((int)$this->getMountOption('filesystem_check_changes', $globalPolicy));
-		}
-		return $this->watcher;
-	}
-
-	/**
-	 * get a propagator instance for the cache
-	 *
-	 * @param \OC\Files\Storage\Storage (optional) the storage to pass to the watcher
-	 * @return \OC\Files\Cache\Propagator
-	 */
-	public function getPropagator($storage = null) {
-		if (!$storage) {
-			$storage = $this;
-		}
-		if (!isset($storage->propagator)) {
-			$config = \OC::$server->getSystemConfig();
-			$storage->propagator = new Propagator($storage, \OC::$server->getDatabaseConnection(), ['appdata_' . $config->getValue('instanceid')]);
-		}
-		return $storage->propagator;
-	}
-
-	public function getUpdater($storage = null) {
-		if (!$storage) {
-			$storage = $this;
-		}
-		if (!isset($storage->updater)) {
-			$storage->updater = new Updater($storage);
-		}
-		return $storage->updater;
-	}
-
-	public function getStorageCache($storage = null) {
-		if (!$storage) {
-			$storage = $this;
-		}
-		if (!isset($this->storageCache)) {
-			$this->storageCache = new \OC\Files\Cache\Storage($storage);
-		}
-		return $this->storageCache;
-	}
-
-	/**
-	 * get the owner of a path
-	 *
-	 * @param string $path The path to get the owner
-	 * @return string|false uid or false
-	 */
-	public function getOwner($path) {
-		if ($this->owner === null) {
-			$this->owner = \OC_User::getUser();
-		}
-
-		return $this->owner;
-	}
-
-	/**
-	 * get the ETag for a file or folder
-	 *
-	 * @param string $path
-	 * @return string
-	 */
-	public function getETag($path) {
-		return uniqid();
-	}
-
-	/**
-	 * clean a path, i.e. remove all redundant '.' and '..'
-	 * making sure that it can't point to higher than '/'
-	 *
-	 * @param string $path The path to clean
-	 * @return string cleaned path
-	 */
-	public function cleanPath($path) {
-		if (strlen($path) == 0 or $path[0] != '/') {
-			$path = '/' . $path;
-		}
-
-		$output = [];
-		foreach (explode('/', $path) as $chunk) {
-			if ($chunk == '..') {
-				array_pop($output);
-			} elseif ($chunk == '.') {
-			} else {
-				$output[] = $chunk;
-			}
-		}
-		return implode('/', $output);
-	}
-
-	/**
-	 * Test a storage for availability
-	 *
-	 * @return bool
-	 */
-	public function test() {
-		try {
-			if ($this->stat('')) {
-				return true;
-			}
-			\OC::$server->getLogger()->info("External storage not available: stat() failed");
-			return false;
-		} catch (\Exception $e) {
-			\OC::$server->getLogger()->warning("External storage not available: " . $e->getMessage());
-			\OC::$server->getLogger()->logException($e, ['level' => ILogger::WARN]);
-			return false;
-		}
-	}
-
-	/**
-	 * get the free space in the storage
-	 *
-	 * @param string $path
-	 * @return int|false
-	 */
-	public function free_space($path) {
-		return \OCP\Files\FileInfo::SPACE_UNKNOWN;
-	}
-
-	/**
-	 * {@inheritdoc}
-	 */
-	public function isLocal() {
-		// the common implementation returns a temporary file by
-		// default, which is not local
-		return false;
-	}
-
-	/**
-	 * Check if the storage is an instance of $class or is a wrapper for a storage that is an instance of $class
-	 *
-	 * @param string $class
-	 * @return bool
-	 */
-	public function instanceOfStorage($class) {
-		if (ltrim($class, '\\') === 'OC\Files\Storage\Shared') {
-			// FIXME Temporary fix to keep existing checks working
-			$class = '\OCA\Files_Sharing\SharedStorage';
-		}
-		return is_a($this, $class);
-	}
-
-	/**
-	 * A custom storage implementation can return an url for direct download of a give file.
-	 *
-	 * For now the returned array can hold the parameter url - in future more attributes might follow.
-	 *
-	 * @param string $path
-	 * @return array|false
-	 */
-	public function getDirectDownload($path) {
-		return [];
-	}
-
-	/**
-	 * @inheritdoc
-	 * @throws InvalidPathException
-	 */
-	public function verifyPath($path, $fileName) {
-
-		// verify empty and dot files
-		$trimmed = trim($fileName);
-		if ($trimmed === '') {
-			throw new EmptyFileNameException();
-		}
-
-		if (\OC\Files\Filesystem::isIgnoredDir($trimmed)) {
-			throw new InvalidDirectoryException();
-		}
-
-		if (!\OC::$server->getDatabaseConnection()->supports4ByteText()) {
-			// verify database - e.g. mysql only 3-byte chars
-			if (preg_match('%(?:
+    use LocalTempFileTrait;
+
+    protected $cache;
+    protected $scanner;
+    protected $watcher;
+    protected $propagator;
+    protected $storageCache;
+    protected $updater;
+
+    protected $mountOptions = [];
+    protected $owner = null;
+
+    private $shouldLogLocks = null;
+    private $logger;
+
+    public function __construct($parameters) {
+    }
+
+    /**
+     * Remove a file or folder
+     *
+     * @param string $path
+     * @return bool
+     */
+    protected function remove($path) {
+        if ($this->is_dir($path)) {
+            return $this->rmdir($path);
+        } elseif ($this->is_file($path)) {
+            return $this->unlink($path);
+        } else {
+            return false;
+        }
+    }
+
+    public function is_dir($path) {
+        return $this->filetype($path) === 'dir';
+    }
+
+    public function is_file($path) {
+        return $this->filetype($path) === 'file';
+    }
+
+    public function filesize($path) {
+        if ($this->is_dir($path)) {
+            return 0; //by definition
+        } else {
+            $stat = $this->stat($path);
+            if (isset($stat['size'])) {
+                return $stat['size'];
+            } else {
+                return 0;
+            }
+        }
+    }
+
+    public function isReadable($path) {
+        // at least check whether it exists
+        // subclasses might want to implement this more thoroughly
+        return $this->file_exists($path);
+    }
+
+    public function isUpdatable($path) {
+        // at least check whether it exists
+        // subclasses might want to implement this more thoroughly
+        // a non-existing file/folder isn't updatable
+        return $this->file_exists($path);
+    }
+
+    public function isCreatable($path) {
+        if ($this->is_dir($path) && $this->isUpdatable($path)) {
+            return true;
+        }
+        return false;
+    }
+
+    public function isDeletable($path) {
+        if ($path === '' || $path === '/') {
+            return false;
+        }
+        $parent = dirname($path);
+        return $this->isUpdatable($parent) && $this->isUpdatable($path);
+    }
+
+    public function isSharable($path) {
+        return $this->isReadable($path);
+    }
+
+    public function getPermissions($path) {
+        $permissions = 0;
+        if ($this->isCreatable($path)) {
+            $permissions |= \OCP\Constants::PERMISSION_CREATE;
+        }
+        if ($this->isReadable($path)) {
+            $permissions |= \OCP\Constants::PERMISSION_READ;
+        }
+        if ($this->isUpdatable($path)) {
+            $permissions |= \OCP\Constants::PERMISSION_UPDATE;
+        }
+        if ($this->isDeletable($path)) {
+            $permissions |= \OCP\Constants::PERMISSION_DELETE;
+        }
+        if ($this->isSharable($path)) {
+            $permissions |= \OCP\Constants::PERMISSION_SHARE;
+        }
+        return $permissions;
+    }
+
+    public function filemtime($path) {
+        $stat = $this->stat($path);
+        if (isset($stat['mtime']) && $stat['mtime'] > 0) {
+            return $stat['mtime'];
+        } else {
+            return 0;
+        }
+    }
+
+    public function file_get_contents($path) {
+        $handle = $this->fopen($path, "r");
+        if (!$handle) {
+            return false;
+        }
+        $data = stream_get_contents($handle);
+        fclose($handle);
+        return $data;
+    }
+
+    public function file_put_contents($path, $data) {
+        $handle = $this->fopen($path, "w");
+        $this->removeCachedFile($path);
+        $count = fwrite($handle, $data);
+        fclose($handle);
+        return $count;
+    }
+
+    public function rename($path1, $path2) {
+        $this->remove($path2);
+
+        $this->removeCachedFile($path1);
+        return $this->copy($path1, $path2) and $this->remove($path1);
+    }
+
+    public function copy($path1, $path2) {
+        if ($this->is_dir($path1)) {
+            $this->remove($path2);
+            $dir = $this->opendir($path1);
+            $this->mkdir($path2);
+            while ($file = readdir($dir)) {
+                if (!Filesystem::isIgnoredDir($file)) {
+                    if (!$this->copy($path1 . '/' . $file, $path2 . '/' . $file)) {
+                        return false;
+                    }
+                }
+            }
+            closedir($dir);
+            return true;
+        } else {
+            $source = $this->fopen($path1, 'r');
+            $target = $this->fopen($path2, 'w');
+            [, $result] = \OC_Helper::streamCopy($source, $target);
+            if (!$result) {
+                \OC::$server->getLogger()->warning("Failed to write data while copying $path1 to $path2");
+            }
+            $this->removeCachedFile($path2);
+            return $result;
+        }
+    }
+
+    public function getMimeType($path) {
+        if ($this->is_dir($path)) {
+            return 'httpd/unix-directory';
+        } elseif ($this->file_exists($path)) {
+            return \OC::$server->getMimeTypeDetector()->detectPath($path);
+        } else {
+            return false;
+        }
+    }
+
+    public function hash($type, $path, $raw = false) {
+        $fh = $this->fopen($path, 'rb');
+        $ctx = hash_init($type);
+        hash_update_stream($ctx, $fh);
+        fclose($fh);
+        return hash_final($ctx, $raw);
+    }
+
+    public function search($query) {
+        return $this->searchInDir($query);
+    }
+
+    public function getLocalFile($path) {
+        return $this->getCachedFile($path);
+    }
+
+    /**
+     * @param string $path
+     * @param string $target
+     */
+    private function addLocalFolder($path, $target) {
+        $dh = $this->opendir($path);
+        if (is_resource($dh)) {
+            while (($file = readdir($dh)) !== false) {
+                if (!\OC\Files\Filesystem::isIgnoredDir($file)) {
+                    if ($this->is_dir($path . '/' . $file)) {
+                        mkdir($target . '/' . $file);
+                        $this->addLocalFolder($path . '/' . $file, $target . '/' . $file);
+                    } else {
+                        $tmp = $this->toTmpFile($path . '/' . $file);
+                        rename($tmp, $target . '/' . $file);
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * @param string $query
+     * @param string $dir
+     * @return array
+     */
+    protected function searchInDir($query, $dir = '') {
+        $files = [];
+        $dh = $this->opendir($dir);
+        if (is_resource($dh)) {
+            while (($item = readdir($dh)) !== false) {
+                if (\OC\Files\Filesystem::isIgnoredDir($item)) {
+                    continue;
+                }
+                if (strstr(strtolower($item), strtolower($query)) !== false) {
+                    $files[] = $dir . '/' . $item;
+                }
+                if ($this->is_dir($dir . '/' . $item)) {
+                    $files = array_merge($files, $this->searchInDir($query, $dir . '/' . $item));
+                }
+            }
+        }
+        closedir($dh);
+        return $files;
+    }
+
+    /**
+     * check if a file or folder has been updated since $time
+     *
+     * The method is only used to check if the cache needs to be updated. Storage backends that don't support checking
+     * the mtime should always return false here. As a result storage implementations that always return false expect
+     * exclusive access to the backend and will not pick up files that have been added in a way that circumvents
+     * ownClouds filesystem.
+     *
+     * @param string $path
+     * @param int $time
+     * @return bool
+     */
+    public function hasUpdated($path, $time) {
+        return $this->filemtime($path) > $time;
+    }
+
+    public function getCache($path = '', $storage = null) {
+        if (!$storage) {
+            $storage = $this;
+        }
+        if (!isset($storage->cache)) {
+            $storage->cache = new Cache($storage);
+        }
+        return $storage->cache;
+    }
+
+    public function getScanner($path = '', $storage = null) {
+        if (!$storage) {
+            $storage = $this;
+        }
+        if (!isset($storage->scanner)) {
+            $storage->scanner = new Scanner($storage);
+        }
+        return $storage->scanner;
+    }
+
+    public function getWatcher($path = '', $storage = null) {
+        if (!$storage) {
+            $storage = $this;
+        }
+        if (!isset($this->watcher)) {
+            $this->watcher = new Watcher($storage);
+            $globalPolicy = \OC::$server->getConfig()->getSystemValue('filesystem_check_changes', Watcher::CHECK_NEVER);
+            $this->watcher->setPolicy((int)$this->getMountOption('filesystem_check_changes', $globalPolicy));
+        }
+        return $this->watcher;
+    }
+
+    /**
+     * get a propagator instance for the cache
+     *
+     * @param \OC\Files\Storage\Storage (optional) the storage to pass to the watcher
+     * @return \OC\Files\Cache\Propagator
+     */
+    public function getPropagator($storage = null) {
+        if (!$storage) {
+            $storage = $this;
+        }
+        if (!isset($storage->propagator)) {
+            $config = \OC::$server->getSystemConfig();
+            $storage->propagator = new Propagator($storage, \OC::$server->getDatabaseConnection(), ['appdata_' . $config->getValue('instanceid')]);
+        }
+        return $storage->propagator;
+    }
+
+    public function getUpdater($storage = null) {
+        if (!$storage) {
+            $storage = $this;
+        }
+        if (!isset($storage->updater)) {
+            $storage->updater = new Updater($storage);
+        }
+        return $storage->updater;
+    }
+
+    public function getStorageCache($storage = null) {
+        if (!$storage) {
+            $storage = $this;
+        }
+        if (!isset($this->storageCache)) {
+            $this->storageCache = new \OC\Files\Cache\Storage($storage);
+        }
+        return $this->storageCache;
+    }
+
+    /**
+     * get the owner of a path
+     *
+     * @param string $path The path to get the owner
+     * @return string|false uid or false
+     */
+    public function getOwner($path) {
+        if ($this->owner === null) {
+            $this->owner = \OC_User::getUser();
+        }
+
+        return $this->owner;
+    }
+
+    /**
+     * get the ETag for a file or folder
+     *
+     * @param string $path
+     * @return string
+     */
+    public function getETag($path) {
+        return uniqid();
+    }
+
+    /**
+     * clean a path, i.e. remove all redundant '.' and '..'
+     * making sure that it can't point to higher than '/'
+     *
+     * @param string $path The path to clean
+     * @return string cleaned path
+     */
+    public function cleanPath($path) {
+        if (strlen($path) == 0 or $path[0] != '/') {
+            $path = '/' . $path;
+        }
+
+        $output = [];
+        foreach (explode('/', $path) as $chunk) {
+            if ($chunk == '..') {
+                array_pop($output);
+            } elseif ($chunk == '.') {
+            } else {
+                $output[] = $chunk;
+            }
+        }
+        return implode('/', $output);
+    }
+
+    /**
+     * Test a storage for availability
+     *
+     * @return bool
+     */
+    public function test() {
+        try {
+            if ($this->stat('')) {
+                return true;
+            }
+            \OC::$server->getLogger()->info("External storage not available: stat() failed");
+            return false;
+        } catch (\Exception $e) {
+            \OC::$server->getLogger()->warning("External storage not available: " . $e->getMessage());
+            \OC::$server->getLogger()->logException($e, ['level' => ILogger::WARN]);
+            return false;
+        }
+    }
+
+    /**
+     * get the free space in the storage
+     *
+     * @param string $path
+     * @return int|false
+     */
+    public function free_space($path) {
+        return \OCP\Files\FileInfo::SPACE_UNKNOWN;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function isLocal() {
+        // the common implementation returns a temporary file by
+        // default, which is not local
+        return false;
+    }
+
+    /**
+     * Check if the storage is an instance of $class or is a wrapper for a storage that is an instance of $class
+     *
+     * @param string $class
+     * @return bool
+     */
+    public function instanceOfStorage($class) {
+        if (ltrim($class, '\\') === 'OC\Files\Storage\Shared') {
+            // FIXME Temporary fix to keep existing checks working
+            $class = '\OCA\Files_Sharing\SharedStorage';
+        }
+        return is_a($this, $class);
+    }
+
+    /**
+     * A custom storage implementation can return an url for direct download of a give file.
+     *
+     * For now the returned array can hold the parameter url - in future more attributes might follow.
+     *
+     * @param string $path
+     * @return array|false
+     */
+    public function getDirectDownload($path) {
+        return [];
+    }
+
+    /**
+     * @inheritdoc
+     * @throws InvalidPathException
+     */
+    public function verifyPath($path, $fileName) {
+
+        // verify empty and dot files
+        $trimmed = trim($fileName);
+        if ($trimmed === '') {
+            throw new EmptyFileNameException();
+        }
+
+        if (\OC\Files\Filesystem::isIgnoredDir($trimmed)) {
+            throw new InvalidDirectoryException();
+        }
+
+        if (!\OC::$server->getDatabaseConnection()->supports4ByteText()) {
+            // verify database - e.g. mysql only 3-byte chars
+            if (preg_match('%(?:
       \xF0[\x90-\xBF][\x80-\xBF]{2}      # planes 1-3
     | [\xF1-\xF3][\x80-\xBF]{3}          # planes 4-15
     | \xF4[\x80-\x8F][\x80-\xBF]{2}      # plane 16
 )%xs', $fileName)) {
-				throw new InvalidCharacterInPathException();
-			}
-		}
-
-		// 255 characters is the limit on common file systems (ext/xfs)
-		// oc_filecache has a 250 char length limit for the filename
-		if (isset($fileName[250])) {
-			throw new FileNameTooLongException();
-		}
-
-		// NOTE: $path will remain unverified for now
-		$this->verifyPosixPath($fileName);
-	}
-
-	/**
-	 * @param string $fileName
-	 * @throws InvalidPathException
-	 */
-	protected function verifyPosixPath($fileName) {
-		$fileName = trim($fileName);
-		$this->scanForInvalidCharacters($fileName, "\\/");
-		$reservedNames = ['*'];
-		if (in_array($fileName, $reservedNames)) {
-			throw new ReservedWordException();
-		}
-	}
-
-	/**
-	 * @param string $fileName
-	 * @param string $invalidChars
-	 * @throws InvalidPathException
-	 */
-	private function scanForInvalidCharacters($fileName, $invalidChars) {
-		foreach (str_split($invalidChars) as $char) {
-			if (strpos($fileName, $char) !== false) {
-				throw new InvalidCharacterInPathException();
-			}
-		}
-
-		$sanitizedFileName = filter_var($fileName, FILTER_UNSAFE_RAW, FILTER_FLAG_STRIP_LOW);
-		if ($sanitizedFileName !== $fileName) {
-			throw new InvalidCharacterInPathException();
-		}
-	}
-
-	/**
-	 * @param array $options
-	 */
-	public function setMountOptions(array $options) {
-		$this->mountOptions = $options;
-	}
-
-	/**
-	 * @param string $name
-	 * @param mixed $default
-	 * @return mixed
-	 */
-	public function getMountOption($name, $default = null) {
-		return isset($this->mountOptions[$name]) ? $this->mountOptions[$name] : $default;
-	}
-
-	/**
-	 * @param IStorage $sourceStorage
-	 * @param string $sourceInternalPath
-	 * @param string $targetInternalPath
-	 * @param bool $preserveMtime
-	 * @return bool
-	 */
-	public function copyFromStorage(IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath, $preserveMtime = false) {
-		if ($sourceStorage === $this) {
-			return $this->copy($sourceInternalPath, $targetInternalPath);
-		}
-
-		if ($sourceStorage->is_dir($sourceInternalPath)) {
-			$dh = $sourceStorage->opendir($sourceInternalPath);
-			$result = $this->mkdir($targetInternalPath);
-			if (is_resource($dh)) {
-				while ($result and ($file = readdir($dh)) !== false) {
-					if (!Filesystem::isIgnoredDir($file)) {
-						$result &= $this->copyFromStorage($sourceStorage, $sourceInternalPath . '/' . $file, $targetInternalPath . '/' . $file);
-					}
-				}
-			}
-		} else {
-			$source = $sourceStorage->fopen($sourceInternalPath, 'r');
-			$result = false;
-			if ($source) {
-				try {
-					$this->writeStream($targetInternalPath, $source);
-					$result = true;
-				} catch (\Exception $e) {
-					\OC::$server->getLogger()->logException($e, ['level' => ILogger::WARN, 'message' => 'Failed to copy stream to storage']);
-				}
-			}
-
-			if ($result && $preserveMtime) {
-				$mtime = $sourceStorage->filemtime($sourceInternalPath);
-				$this->touch($targetInternalPath, is_int($mtime) ? $mtime : null);
-			}
-
-			if (!$result) {
-				// delete partially written target file
-				$this->unlink($targetInternalPath);
-				// delete cache entry that was created by fopen
-				$this->getCache()->remove($targetInternalPath);
-			}
-		}
-		return (bool)$result;
-	}
-
-	/**
-	 * Check if a storage is the same as the current one, including wrapped storages
-	 *
-	 * @param IStorage $storage
-	 * @return bool
-	 */
-	private function isSameStorage(IStorage $storage): bool {
-		while ($storage->instanceOfStorage(Wrapper::class)) {
-			/**
-			 * @var Wrapper $sourceStorage
-			 */
-			$storage = $storage->getWrapperStorage();
-		}
-
-		return $storage === $this;
-	}
-
-	/**
-	 * @param IStorage $sourceStorage
-	 * @param string $sourceInternalPath
-	 * @param string $targetInternalPath
-	 * @return bool
-	 */
-	public function moveFromStorage(IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath) {
-		if ($this->isSameStorage($sourceStorage)) {
-			// resolve any jailed paths
-			while ($sourceStorage->instanceOfStorage(Jail::class)) {
-				/**
-				 * @var Jail $sourceStorage
-				 */
-				$sourceInternalPath = $sourceStorage->getUnjailedPath($sourceInternalPath);
-				$sourceStorage = $sourceStorage->getUnjailedStorage();
-			}
-
-			return $this->rename($sourceInternalPath, $targetInternalPath);
-		}
-
-		if (!$sourceStorage->isDeletable($sourceInternalPath)) {
-			return false;
-		}
-
-		$result = $this->copyFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath, true);
-		if ($result) {
-			if ($sourceStorage->is_dir($sourceInternalPath)) {
-				$result &= $sourceStorage->rmdir($sourceInternalPath);
-			} else {
-				$result &= $sourceStorage->unlink($sourceInternalPath);
-			}
-		}
-		return $result;
-	}
-
-	/**
-	 * @inheritdoc
-	 */
-	public function getMetaData($path) {
-		$permissions = $this->getPermissions($path);
-		if (!$permissions & \OCP\Constants::PERMISSION_READ) {
-			//can't read, nothing we can do
-			return null;
-		}
-
-		$data = [];
-		$data['mimetype'] = $this->getMimeType($path);
-		$data['mtime'] = $this->filemtime($path);
-		if ($data['mtime'] === false) {
-			$data['mtime'] = time();
-		}
-		if ($data['mimetype'] == 'httpd/unix-directory') {
-			$data['size'] = -1; //unknown
-		} else {
-			$data['size'] = $this->filesize($path);
-		}
-		$data['etag'] = $this->getETag($path);
-		$data['storage_mtime'] = $data['mtime'];
-		$data['permissions'] = $permissions;
-		$data['name'] = basename($path);
-
-		return $data;
-	}
-
-	/**
-	 * @param string $path
-	 * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
-	 * @param \OCP\Lock\ILockingProvider $provider
-	 * @throws \OCP\Lock\LockedException
-	 */
-	public function acquireLock($path, $type, ILockingProvider $provider) {
-		$logger = $this->getLockLogger();
-		if ($logger) {
-			$typeString = ($type === ILockingProvider::LOCK_SHARED) ? 'shared' : 'exclusive';
-			$logger->info(
-				sprintf(
-					'acquire %s lock on "%s" on storage "%s"',
-					$typeString,
-					$path,
-					$this->getId()
-				),
-				[
-					'app' => 'locking',
-				]
-			);
-		}
-		try {
-			$provider->acquireLock('files/' . md5($this->getId() . '::' . trim($path, '/')), $type, $this->getId() . '::' . $path);
-		} catch (LockedException $e) {
-			if ($logger) {
-				$logger->logException($e, ['level' => ILogger::INFO]);
-			}
-			throw $e;
-		}
-	}
-
-	/**
-	 * @param string $path
-	 * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
-	 * @param \OCP\Lock\ILockingProvider $provider
-	 * @throws \OCP\Lock\LockedException
-	 */
-	public function releaseLock($path, $type, ILockingProvider $provider) {
-		$logger = $this->getLockLogger();
-		if ($logger) {
-			$typeString = ($type === ILockingProvider::LOCK_SHARED) ? 'shared' : 'exclusive';
-			$logger->info(
-				sprintf(
-					'release %s lock on "%s" on storage "%s"',
-					$typeString,
-					$path,
-					$this->getId()
-				),
-				[
-					'app' => 'locking',
-				]
-			);
-		}
-		try {
-			$provider->releaseLock('files/' . md5($this->getId() . '::' . trim($path, '/')), $type);
-		} catch (LockedException $e) {
-			if ($logger) {
-				$logger->logException($e, ['level' => ILogger::INFO]);
-			}
-			throw $e;
-		}
-	}
-
-	/**
-	 * @param string $path
-	 * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
-	 * @param \OCP\Lock\ILockingProvider $provider
-	 * @throws \OCP\Lock\LockedException
-	 */
-	public function changeLock($path, $type, ILockingProvider $provider) {
-		$logger = $this->getLockLogger();
-		if ($logger) {
-			$typeString = ($type === ILockingProvider::LOCK_SHARED) ? 'shared' : 'exclusive';
-			$logger->info(
-				sprintf(
-					'change lock on "%s" to %s on storage "%s"',
-					$path,
-					$typeString,
-					$this->getId()
-				),
-				[
-					'app' => 'locking',
-				]
-			);
-		}
-		try {
-			$provider->changeLock('files/' . md5($this->getId() . '::' . trim($path, '/')), $type);
-		} catch (LockedException $e) {
-			\OC::$server->getLogger()->logException($e, ['level' => ILogger::INFO]);
-			throw $e;
-		}
-	}
-
-	private function getLockLogger() {
-		if (is_null($this->shouldLogLocks)) {
-			$this->shouldLogLocks = \OC::$server->getConfig()->getSystemValue('filelocking.debug', false);
-			$this->logger = $this->shouldLogLocks ? \OC::$server->getLogger() : null;
-		}
-		return $this->logger;
-	}
-
-	/**
-	 * @return array [ available, last_checked ]
-	 */
-	public function getAvailability() {
-		return $this->getStorageCache()->getAvailability();
-	}
-
-	/**
-	 * @param bool $isAvailable
-	 */
-	public function setAvailability($isAvailable) {
-		$this->getStorageCache()->setAvailability($isAvailable);
-	}
-
-	/**
-	 * @return bool
-	 */
-	public function needsPartFile() {
-		return true;
-	}
-
-	/**
-	 * fallback implementation
-	 *
-	 * @param string $path
-	 * @param resource $stream
-	 * @param int $size
-	 * @return int
-	 */
-	public function writeStream(string $path, $stream, int $size = null): int {
-		$target = $this->fopen($path, 'w');
-		if (!$target) {
-			throw new GenericFileException("Failed to open $path for writing");
-		}
-		try {
-			[$count, $result] = \OC_Helper::streamCopy($stream, $target);
-			if (!$result) {
-				throw new GenericFileException("Failed to copy stream");
-			}
-		} finally {
-			fclose($target);
-			fclose($stream);
-		}
-		return $count;
-	}
-
-	public function getDirectoryContent($directory): \Traversable {
-		$dh = $this->opendir($directory);
-		if (is_resource($dh)) {
-			$basePath = rtrim($directory, '/');
-			while (($file = readdir($dh)) !== false) {
-				if (!Filesystem::isIgnoredDir($file) && !Filesystem::isFileBlacklisted($file)) {
-					$childPath = $basePath . '/' . trim($file, '/');
-					$metadata = $this->getMetaData($childPath);
-					if ($metadata !== null) {
-						yield $metadata;
-					}
-				}
-			}
-		}
-	}
+                throw new InvalidCharacterInPathException();
+            }
+        }
+
+        // 255 characters is the limit on common file systems (ext/xfs)
+        // oc_filecache has a 250 char length limit for the filename
+        if (isset($fileName[250])) {
+            throw new FileNameTooLongException();
+        }
+
+        // NOTE: $path will remain unverified for now
+        $this->verifyPosixPath($fileName);
+    }
+
+    /**
+     * @param string $fileName
+     * @throws InvalidPathException
+     */
+    protected function verifyPosixPath($fileName) {
+        $fileName = trim($fileName);
+        $this->scanForInvalidCharacters($fileName, "\\/");
+        $reservedNames = ['*'];
+        if (in_array($fileName, $reservedNames)) {
+            throw new ReservedWordException();
+        }
+    }
+
+    /**
+     * @param string $fileName
+     * @param string $invalidChars
+     * @throws InvalidPathException
+     */
+    private function scanForInvalidCharacters($fileName, $invalidChars) {
+        foreach (str_split($invalidChars) as $char) {
+            if (strpos($fileName, $char) !== false) {
+                throw new InvalidCharacterInPathException();
+            }
+        }
+
+        $sanitizedFileName = filter_var($fileName, FILTER_UNSAFE_RAW, FILTER_FLAG_STRIP_LOW);
+        if ($sanitizedFileName !== $fileName) {
+            throw new InvalidCharacterInPathException();
+        }
+    }
+
+    /**
+     * @param array $options
+     */
+    public function setMountOptions(array $options) {
+        $this->mountOptions = $options;
+    }
+
+    /**
+     * @param string $name
+     * @param mixed $default
+     * @return mixed
+     */
+    public function getMountOption($name, $default = null) {
+        return isset($this->mountOptions[$name]) ? $this->mountOptions[$name] : $default;
+    }
+
+    /**
+     * @param IStorage $sourceStorage
+     * @param string $sourceInternalPath
+     * @param string $targetInternalPath
+     * @param bool $preserveMtime
+     * @return bool
+     */
+    public function copyFromStorage(IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath, $preserveMtime = false) {
+        if ($sourceStorage === $this) {
+            return $this->copy($sourceInternalPath, $targetInternalPath);
+        }
+
+        if ($sourceStorage->is_dir($sourceInternalPath)) {
+            $dh = $sourceStorage->opendir($sourceInternalPath);
+            $result = $this->mkdir($targetInternalPath);
+            if (is_resource($dh)) {
+                while ($result and ($file = readdir($dh)) !== false) {
+                    if (!Filesystem::isIgnoredDir($file)) {
+                        $result &= $this->copyFromStorage($sourceStorage, $sourceInternalPath . '/' . $file, $targetInternalPath . '/' . $file);
+                    }
+                }
+            }
+        } else {
+            $source = $sourceStorage->fopen($sourceInternalPath, 'r');
+            $result = false;
+            if ($source) {
+                try {
+                    $this->writeStream($targetInternalPath, $source);
+                    $result = true;
+                } catch (\Exception $e) {
+                    \OC::$server->getLogger()->logException($e, ['level' => ILogger::WARN, 'message' => 'Failed to copy stream to storage']);
+                }
+            }
+
+            if ($result && $preserveMtime) {
+                $mtime = $sourceStorage->filemtime($sourceInternalPath);
+                $this->touch($targetInternalPath, is_int($mtime) ? $mtime : null);
+            }
+
+            if (!$result) {
+                // delete partially written target file
+                $this->unlink($targetInternalPath);
+                // delete cache entry that was created by fopen
+                $this->getCache()->remove($targetInternalPath);
+            }
+        }
+        return (bool)$result;
+    }
+
+    /**
+     * Check if a storage is the same as the current one, including wrapped storages
+     *
+     * @param IStorage $storage
+     * @return bool
+     */
+    private function isSameStorage(IStorage $storage): bool {
+        while ($storage->instanceOfStorage(Wrapper::class)) {
+            /**
+             * @var Wrapper $sourceStorage
+             */
+            $storage = $storage->getWrapperStorage();
+        }
+
+        return $storage === $this;
+    }
+
+    /**
+     * @param IStorage $sourceStorage
+     * @param string $sourceInternalPath
+     * @param string $targetInternalPath
+     * @return bool
+     */
+    public function moveFromStorage(IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath) {
+        if ($this->isSameStorage($sourceStorage)) {
+            // resolve any jailed paths
+            while ($sourceStorage->instanceOfStorage(Jail::class)) {
+                /**
+                 * @var Jail $sourceStorage
+                 */
+                $sourceInternalPath = $sourceStorage->getUnjailedPath($sourceInternalPath);
+                $sourceStorage = $sourceStorage->getUnjailedStorage();
+            }
+
+            return $this->rename($sourceInternalPath, $targetInternalPath);
+        }
+
+        if (!$sourceStorage->isDeletable($sourceInternalPath)) {
+            return false;
+        }
+
+        $result = $this->copyFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath, true);
+        if ($result) {
+            if ($sourceStorage->is_dir($sourceInternalPath)) {
+                $result &= $sourceStorage->rmdir($sourceInternalPath);
+            } else {
+                $result &= $sourceStorage->unlink($sourceInternalPath);
+            }
+        }
+        return $result;
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public function getMetaData($path) {
+        $permissions = $this->getPermissions($path);
+        if (!$permissions & \OCP\Constants::PERMISSION_READ) {
+            //can't read, nothing we can do
+            return null;
+        }
+
+        $data = [];
+        $data['mimetype'] = $this->getMimeType($path);
+        $data['mtime'] = $this->filemtime($path);
+        if ($data['mtime'] === false) {
+            $data['mtime'] = time();
+        }
+        if ($data['mimetype'] == 'httpd/unix-directory') {
+            $data['size'] = -1; //unknown
+        } else {
+            $data['size'] = $this->filesize($path);
+        }
+        $data['etag'] = $this->getETag($path);
+        $data['storage_mtime'] = $data['mtime'];
+        $data['permissions'] = $permissions;
+        $data['name'] = basename($path);
+
+        return $data;
+    }
+
+    /**
+     * @param string $path
+     * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
+     * @param \OCP\Lock\ILockingProvider $provider
+     * @throws \OCP\Lock\LockedException
+     */
+    public function acquireLock($path, $type, ILockingProvider $provider) {
+        $logger = $this->getLockLogger();
+        if ($logger) {
+            $typeString = ($type === ILockingProvider::LOCK_SHARED) ? 'shared' : 'exclusive';
+            $logger->info(
+                sprintf(
+                    'acquire %s lock on "%s" on storage "%s"',
+                    $typeString,
+                    $path,
+                    $this->getId()
+                ),
+                [
+                    'app' => 'locking',
+                ]
+            );
+        }
+        try {
+            $provider->acquireLock('files/' . md5($this->getId() . '::' . trim($path, '/')), $type, $this->getId() . '::' . $path);
+        } catch (LockedException $e) {
+            if ($logger) {
+                $logger->logException($e, ['level' => ILogger::INFO]);
+            }
+            throw $e;
+        }
+    }
+
+    /**
+     * @param string $path
+     * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
+     * @param \OCP\Lock\ILockingProvider $provider
+     * @throws \OCP\Lock\LockedException
+     */
+    public function releaseLock($path, $type, ILockingProvider $provider) {
+        $logger = $this->getLockLogger();
+        if ($logger) {
+            $typeString = ($type === ILockingProvider::LOCK_SHARED) ? 'shared' : 'exclusive';
+            $logger->info(
+                sprintf(
+                    'release %s lock on "%s" on storage "%s"',
+                    $typeString,
+                    $path,
+                    $this->getId()
+                ),
+                [
+                    'app' => 'locking',
+                ]
+            );
+        }
+        try {
+            $provider->releaseLock('files/' . md5($this->getId() . '::' . trim($path, '/')), $type);
+        } catch (LockedException $e) {
+            if ($logger) {
+                $logger->logException($e, ['level' => ILogger::INFO]);
+            }
+            throw $e;
+        }
+    }
+
+    /**
+     * @param string $path
+     * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
+     * @param \OCP\Lock\ILockingProvider $provider
+     * @throws \OCP\Lock\LockedException
+     */
+    public function changeLock($path, $type, ILockingProvider $provider) {
+        $logger = $this->getLockLogger();
+        if ($logger) {
+            $typeString = ($type === ILockingProvider::LOCK_SHARED) ? 'shared' : 'exclusive';
+            $logger->info(
+                sprintf(
+                    'change lock on "%s" to %s on storage "%s"',
+                    $path,
+                    $typeString,
+                    $this->getId()
+                ),
+                [
+                    'app' => 'locking',
+                ]
+            );
+        }
+        try {
+            $provider->changeLock('files/' . md5($this->getId() . '::' . trim($path, '/')), $type);
+        } catch (LockedException $e) {
+            \OC::$server->getLogger()->logException($e, ['level' => ILogger::INFO]);
+            throw $e;
+        }
+    }
+
+    private function getLockLogger() {
+        if (is_null($this->shouldLogLocks)) {
+            $this->shouldLogLocks = \OC::$server->getConfig()->getSystemValue('filelocking.debug', false);
+            $this->logger = $this->shouldLogLocks ? \OC::$server->getLogger() : null;
+        }
+        return $this->logger;
+    }
+
+    /**
+     * @return array [ available, last_checked ]
+     */
+    public function getAvailability() {
+        return $this->getStorageCache()->getAvailability();
+    }
+
+    /**
+     * @param bool $isAvailable
+     */
+    public function setAvailability($isAvailable) {
+        $this->getStorageCache()->setAvailability($isAvailable);
+    }
+
+    /**
+     * @return bool
+     */
+    public function needsPartFile() {
+        return true;
+    }
+
+    /**
+     * fallback implementation
+     *
+     * @param string $path
+     * @param resource $stream
+     * @param int $size
+     * @return int
+     */
+    public function writeStream(string $path, $stream, int $size = null): int {
+        $target = $this->fopen($path, 'w');
+        if (!$target) {
+            throw new GenericFileException("Failed to open $path for writing");
+        }
+        try {
+            [$count, $result] = \OC_Helper::streamCopy($stream, $target);
+            if (!$result) {
+                throw new GenericFileException("Failed to copy stream");
+            }
+        } finally {
+            fclose($target);
+            fclose($stream);
+        }
+        return $count;
+    }
+
+    public function getDirectoryContent($directory): \Traversable {
+        $dh = $this->opendir($directory);
+        if (is_resource($dh)) {
+            $basePath = rtrim($directory, '/');
+            while (($file = readdir($dh)) !== false) {
+                if (!Filesystem::isIgnoredDir($file) && !Filesystem::isFileBlacklisted($file)) {
+                    $childPath = $basePath . '/' . trim($file, '/');
+                    $metadata = $this->getMetaData($childPath);
+                    if ($metadata !== null) {
+                        yield $metadata;
+                    }
+                }
+            }
+        }
+    }
 }

lib/private/Files/Storage/Wrapper/Quota.php

Indentation +204 added lines, -204 removed lines

@@ -36,208 +36,208 @@
 
 class Quota extends Wrapper {
 
-	/**
-	 * @var int $quota
-	 */
-	protected $quota;
-
-	/**
-	 * @var string $sizeRoot
-	 */
-	protected $sizeRoot;
-
-	private $config;
-
-	/**
-	 * @param array $parameters
-	 */
-	public function __construct($parameters) {
-		parent::__construct($parameters);
-		$this->quota = $parameters['quota'];
-		$this->sizeRoot = isset($parameters['root']) ? $parameters['root'] : '';
-		$this->config = \OC::$server->getSystemConfig();
-	}
-
-	/**
-	 * @return int quota value
-	 */
-	public function getQuota() {
-		return $this->quota;
-	}
-
-	/**
-	 * @param string $path
-	 * @param \OC\Files\Storage\Storage $storage
-	 */
-	protected function getSize($path, $storage = null) {
-		if ($this->config->getValue('quota_include_external_storage', false)) {
-			$rootInfo = Filesystem::getFileInfo('', 'ext');
-			if ($rootInfo) {
-				return $rootInfo->getSize(true);
-			}
-			return \OCP\Files\FileInfo::SPACE_NOT_COMPUTED;
-		} else {
-			if (is_null($storage)) {
-				$cache = $this->getCache();
-			} else {
-				$cache = $storage->getCache();
-			}
-			$data = $cache->get($path);
-			if ($data instanceof ICacheEntry and isset($data['size'])) {
-				return $data['size'];
-			} else {
-				return \OCP\Files\FileInfo::SPACE_NOT_COMPUTED;
-			}
-		}
-	}
-
-	/**
-	 * Get free space as limited by the quota
-	 *
-	 * @param string $path
-	 * @return int|bool
-	 */
-	public function free_space($path) {
-		if ($this->quota < 0 || strpos($path, 'cache') === 0 || strpos($path, 'uploads') === 0) {
-			return $this->storage->free_space($path);
-		} else {
-			$used = $this->getSize($this->sizeRoot);
-			if ($used < 0) {
-				return \OCP\Files\FileInfo::SPACE_NOT_COMPUTED;
-			} else {
-				$free = $this->storage->free_space($path);
-				$quotaFree = max($this->quota - $used, 0);
-				// if free space is known
-				if ($free >= 0) {
-					$free = min($free, $quotaFree);
-				} else {
-					$free = $quotaFree;
-				}
-				return $free;
-			}
-		}
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.file_put_contents.php
-	 *
-	 * @param string $path
-	 * @param mixed $data
-	 * @return int|false
-	 */
-	public function file_put_contents($path, $data) {
-		$free = $this->free_space($path);
-		if ($free < 0 or strlen($data) < $free) {
-			return $this->storage->file_put_contents($path, $data);
-		} else {
-			return false;
-		}
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.copy.php
-	 *
-	 * @param string $source
-	 * @param string $target
-	 * @return bool
-	 */
-	public function copy($source, $target) {
-		$free = $this->free_space($target);
-		if ($free < 0 or $this->getSize($source) < $free) {
-			return $this->storage->copy($source, $target);
-		} else {
-			return false;
-		}
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.fopen.php
-	 *
-	 * @param string $path
-	 * @param string $mode
-	 * @return resource|bool
-	 */
-	public function fopen($path, $mode) {
-		$source = $this->storage->fopen($path, $mode);
-
-		// don't apply quota for part files
-		if (!$this->isPartFile($path)) {
-			$free = $this->free_space($path);
-			if ($source && is_int($free) && $free >= 0 && $mode !== 'r' && $mode !== 'rb') {
-				// only apply quota for files, not metadata, trash or others
-				if ($this->shouldApplyQuota($path)) {
-					return \OC\Files\Stream\Quota::wrap($source, $free);
-				}
-			}
-		}
-		return $source;
-	}
-
-	/**
-	 * Checks whether the given path is a part file
-	 *
-	 * @param string $path Path that may identify a .part file
-	 * @return string File path without .part extension
-	 * @note this is needed for reusing keys
-	 */
-	private function isPartFile($path) {
-		$extension = pathinfo($path, PATHINFO_EXTENSION);
-
-		return ($extension === 'part');
-	}
-
-	/**
-	 * Only apply quota for files, not metadata, trash or others
-	 */
-	private function shouldApplyQuota(string $path): bool {
-		return strpos(ltrim($path, '/'), 'files/') === 0;
-	}
-
-	/**
-	 * @param IStorage $sourceStorage
-	 * @param string $sourceInternalPath
-	 * @param string $targetInternalPath
-	 * @return bool
-	 */
-	public function copyFromStorage(IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath) {
-		$free = $this->free_space($targetInternalPath);
-		if ($free < 0 or $this->getSize($sourceInternalPath, $sourceStorage) < $free) {
-			return $this->storage->copyFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath);
-		} else {
-			return false;
-		}
-	}
-
-	/**
-	 * @param IStorage $sourceStorage
-	 * @param string $sourceInternalPath
-	 * @param string $targetInternalPath
-	 * @return bool
-	 */
-	public function moveFromStorage(IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath) {
-		$free = $this->free_space($targetInternalPath);
-		if ($free < 0 or $this->getSize($sourceInternalPath, $sourceStorage) < $free) {
-			return $this->storage->moveFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath);
-		} else {
-			return false;
-		}
-	}
-
-	public function mkdir($path) {
-		$free = $this->free_space($path);
-		if ($this->shouldApplyQuota($path) && $free === 0.0) {
-			return false;
-		}
-
-		return parent::mkdir($path);
-	}
-
-	public function touch($path, $mtime = null) {
-		$free = $this->free_space($path);
-		if ($free === 0.0) {
-			return false;
-		}
-
-		return parent::touch($path, $mtime);
-	}
+    /**
+     * @var int $quota
+     */
+    protected $quota;
+
+    /**
+     * @var string $sizeRoot
+     */
+    protected $sizeRoot;
+
+    private $config;
+
+    /**
+     * @param array $parameters
+     */
+    public function __construct($parameters) {
+        parent::__construct($parameters);
+        $this->quota = $parameters['quota'];
+        $this->sizeRoot = isset($parameters['root']) ? $parameters['root'] : '';
+        $this->config = \OC::$server->getSystemConfig();
+    }
+
+    /**
+     * @return int quota value
+     */
+    public function getQuota() {
+        return $this->quota;
+    }
+
+    /**
+     * @param string $path
+     * @param \OC\Files\Storage\Storage $storage
+     */
+    protected function getSize($path, $storage = null) {
+        if ($this->config->getValue('quota_include_external_storage', false)) {
+            $rootInfo = Filesystem::getFileInfo('', 'ext');
+            if ($rootInfo) {
+                return $rootInfo->getSize(true);
+            }
+            return \OCP\Files\FileInfo::SPACE_NOT_COMPUTED;
+        } else {
+            if (is_null($storage)) {
+                $cache = $this->getCache();
+            } else {
+                $cache = $storage->getCache();
+            }
+            $data = $cache->get($path);
+            if ($data instanceof ICacheEntry and isset($data['size'])) {
+                return $data['size'];
+            } else {
+                return \OCP\Files\FileInfo::SPACE_NOT_COMPUTED;
+            }
+        }
+    }
+
+    /**
+     * Get free space as limited by the quota
+     *
+     * @param string $path
+     * @return int|bool
+     */
+    public function free_space($path) {
+        if ($this->quota < 0 || strpos($path, 'cache') === 0 || strpos($path, 'uploads') === 0) {
+            return $this->storage->free_space($path);
+        } else {
+            $used = $this->getSize($this->sizeRoot);
+            if ($used < 0) {
+                return \OCP\Files\FileInfo::SPACE_NOT_COMPUTED;
+            } else {
+                $free = $this->storage->free_space($path);
+                $quotaFree = max($this->quota - $used, 0);
+                // if free space is known
+                if ($free >= 0) {
+                    $free = min($free, $quotaFree);
+                } else {
+                    $free = $quotaFree;
+                }
+                return $free;
+            }
+        }
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.file_put_contents.php
+     *
+     * @param string $path
+     * @param mixed $data
+     * @return int|false
+     */
+    public function file_put_contents($path, $data) {
+        $free = $this->free_space($path);
+        if ($free < 0 or strlen($data) < $free) {
+            return $this->storage->file_put_contents($path, $data);
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.copy.php
+     *
+     * @param string $source
+     * @param string $target
+     * @return bool
+     */
+    public function copy($source, $target) {
+        $free = $this->free_space($target);
+        if ($free < 0 or $this->getSize($source) < $free) {
+            return $this->storage->copy($source, $target);
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.fopen.php
+     *
+     * @param string $path
+     * @param string $mode
+     * @return resource|bool
+     */
+    public function fopen($path, $mode) {
+        $source = $this->storage->fopen($path, $mode);
+
+        // don't apply quota for part files
+        if (!$this->isPartFile($path)) {
+            $free = $this->free_space($path);
+            if ($source && is_int($free) && $free >= 0 && $mode !== 'r' && $mode !== 'rb') {
+                // only apply quota for files, not metadata, trash or others
+                if ($this->shouldApplyQuota($path)) {
+                    return \OC\Files\Stream\Quota::wrap($source, $free);
+                }
+            }
+        }
+        return $source;
+    }
+
+    /**
+     * Checks whether the given path is a part file
+     *
+     * @param string $path Path that may identify a .part file
+     * @return string File path without .part extension
+     * @note this is needed for reusing keys
+     */
+    private function isPartFile($path) {
+        $extension = pathinfo($path, PATHINFO_EXTENSION);
+
+        return ($extension === 'part');
+    }
+
+    /**
+     * Only apply quota for files, not metadata, trash or others
+     */
+    private function shouldApplyQuota(string $path): bool {
+        return strpos(ltrim($path, '/'), 'files/') === 0;
+    }
+
+    /**
+     * @param IStorage $sourceStorage
+     * @param string $sourceInternalPath
+     * @param string $targetInternalPath
+     * @return bool
+     */
+    public function copyFromStorage(IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath) {
+        $free = $this->free_space($targetInternalPath);
+        if ($free < 0 or $this->getSize($sourceInternalPath, $sourceStorage) < $free) {
+            return $this->storage->copyFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath);
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * @param IStorage $sourceStorage
+     * @param string $sourceInternalPath
+     * @param string $targetInternalPath
+     * @return bool
+     */
+    public function moveFromStorage(IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath) {
+        $free = $this->free_space($targetInternalPath);
+        if ($free < 0 or $this->getSize($sourceInternalPath, $sourceStorage) < $free) {
+            return $this->storage->moveFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath);
+        } else {
+            return false;
+        }
+    }
+
+    public function mkdir($path) {
+        $free = $this->free_space($path);
+        if ($this->shouldApplyQuota($path) && $free === 0.0) {
+            return false;
+        }
+
+        return parent::mkdir($path);
+    }
+
+    public function touch($path, $mtime = null) {
+        $free = $this->free_space($path);
+        if ($free === 0.0) {
+            return false;
+        }
+
+        return parent::touch($path, $mtime);
+    }
 }

lib/private/Files/Storage/Wrapper/Encoding.php

Indentation +502 added lines, -502 removed lines

@@ -37,506 +37,506 @@
  */
 class Encoding extends Wrapper {
 
-	/**
-	 * @var ICache
-	 */
-	private $namesCache;
-
-	/**
-	 * @param array $parameters
-	 */
-	public function __construct($parameters) {
-		$this->storage = $parameters['storage'];
-		$this->namesCache = new CappedMemoryCache();
-	}
-
-	/**
-	 * Returns whether the given string is only made of ASCII characters
-	 *
-	 * @param string $str string
-	 *
-	 * @return bool true if the string is all ASCII, false otherwise
-	 */
-	private function isAscii($str) {
-		return (bool) !preg_match('/[\\x80-\\xff]+/', $str);
-	}
-
-	/**
-	 * Checks whether the given path exists in NFC or NFD form after checking
-	 * each form for each path section and returns the correct form.
-	 * If no existing path found, returns the path as it was given.
-	 *
-	 * @param string $fullPath path to check
-	 *
-	 * @return string original or converted path
-	 */
-	private function findPathToUse($fullPath) {
-		$cachedPath = $this->namesCache[$fullPath];
-		if ($cachedPath !== null) {
-			return $cachedPath;
-		}
-
-		$sections = explode('/', $fullPath);
-		$path = '';
-		foreach ($sections as $section) {
-			$convertedPath = $this->findPathToUseLastSection($path, $section);
-			if ($convertedPath === null) {
-				// no point in continuing if the section was not found, use original path
-				return $fullPath;
-			}
-			$path = $convertedPath . '/';
-		}
-		$path = rtrim($path, '/');
-		return $path;
-	}
-
-	/**
-	 * Checks whether the last path section of the given path exists in NFC or NFD form
-	 * and returns the correct form. If no existing path found, returns null.
-	 *
-	 * @param string $basePath base path to check
-	 * @param string $lastSection last section of the path to check for NFD/NFC variations
-	 *
-	 * @return string|null original or converted path, or null if none of the forms was found
-	 */
-	private function findPathToUseLastSection($basePath, $lastSection) {
-		$fullPath = $basePath . $lastSection;
-		if ($lastSection === '' || $this->isAscii($lastSection) || $this->storage->file_exists($fullPath)) {
-			$this->namesCache[$fullPath] = $fullPath;
-			return $fullPath;
-		}
-
-		// swap encoding
-		if (\Normalizer::isNormalized($lastSection, \Normalizer::FORM_C)) {
-			$otherFormPath = \Normalizer::normalize($lastSection, \Normalizer::FORM_D);
-		} else {
-			$otherFormPath = \Normalizer::normalize($lastSection, \Normalizer::FORM_C);
-		}
-		$otherFullPath = $basePath . $otherFormPath;
-		if ($this->storage->file_exists($otherFullPath)) {
-			$this->namesCache[$fullPath] = $otherFullPath;
-			return $otherFullPath;
-		}
-
-		// return original path, file did not exist at all
-		$this->namesCache[$fullPath] = $fullPath;
-		return null;
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.mkdir.php
-	 *
-	 * @param string $path
-	 * @return bool
-	 */
-	public function mkdir($path) {
-		// note: no conversion here, method should not be called with non-NFC names!
-		$result = $this->storage->mkdir($path);
-		if ($result) {
-			$this->namesCache[$path] = $path;
-		}
-		return $result;
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.rmdir.php
-	 *
-	 * @param string $path
-	 * @return bool
-	 */
-	public function rmdir($path) {
-		$result = $this->storage->rmdir($this->findPathToUse($path));
-		if ($result) {
-			unset($this->namesCache[$path]);
-		}
-		return $result;
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.opendir.php
-	 *
-	 * @param string $path
-	 * @return resource|bool
-	 */
-	public function opendir($path) {
-		return $this->storage->opendir($this->findPathToUse($path));
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.is_dir.php
-	 *
-	 * @param string $path
-	 * @return bool
-	 */
-	public function is_dir($path) {
-		return $this->storage->is_dir($this->findPathToUse($path));
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.is_file.php
-	 *
-	 * @param string $path
-	 * @return bool
-	 */
-	public function is_file($path) {
-		return $this->storage->is_file($this->findPathToUse($path));
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.stat.php
-	 * only the following keys are required in the result: size and mtime
-	 *
-	 * @param string $path
-	 * @return array|bool
-	 */
-	public function stat($path) {
-		return $this->storage->stat($this->findPathToUse($path));
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.filetype.php
-	 *
-	 * @param string $path
-	 * @return string|bool
-	 */
-	public function filetype($path) {
-		return $this->storage->filetype($this->findPathToUse($path));
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.filesize.php
-	 * The result for filesize when called on a folder is required to be 0
-	 *
-	 * @param string $path
-	 * @return int|bool
-	 */
-	public function filesize($path) {
-		return $this->storage->filesize($this->findPathToUse($path));
-	}
-
-	/**
-	 * check if a file can be created in $path
-	 *
-	 * @param string $path
-	 * @return bool
-	 */
-	public function isCreatable($path) {
-		return $this->storage->isCreatable($this->findPathToUse($path));
-	}
-
-	/**
-	 * check if a file can be read
-	 *
-	 * @param string $path
-	 * @return bool
-	 */
-	public function isReadable($path) {
-		return $this->storage->isReadable($this->findPathToUse($path));
-	}
-
-	/**
-	 * check if a file can be written to
-	 *
-	 * @param string $path
-	 * @return bool
-	 */
-	public function isUpdatable($path) {
-		return $this->storage->isUpdatable($this->findPathToUse($path));
-	}
-
-	/**
-	 * check if a file can be deleted
-	 *
-	 * @param string $path
-	 * @return bool
-	 */
-	public function isDeletable($path) {
-		return $this->storage->isDeletable($this->findPathToUse($path));
-	}
-
-	/**
-	 * check if a file can be shared
-	 *
-	 * @param string $path
-	 * @return bool
-	 */
-	public function isSharable($path) {
-		return $this->storage->isSharable($this->findPathToUse($path));
-	}
-
-	/**
-	 * get the full permissions of a path.
-	 * Should return a combination of the PERMISSION_ constants defined in lib/public/constants.php
-	 *
-	 * @param string $path
-	 * @return int
-	 */
-	public function getPermissions($path) {
-		return $this->storage->getPermissions($this->findPathToUse($path));
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.file_exists.php
-	 *
-	 * @param string $path
-	 * @return bool
-	 */
-	public function file_exists($path) {
-		return $this->storage->file_exists($this->findPathToUse($path));
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.filemtime.php
-	 *
-	 * @param string $path
-	 * @return int|bool
-	 */
-	public function filemtime($path) {
-		return $this->storage->filemtime($this->findPathToUse($path));
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.file_get_contents.php
-	 *
-	 * @param string $path
-	 * @return string|bool
-	 */
-	public function file_get_contents($path) {
-		return $this->storage->file_get_contents($this->findPathToUse($path));
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.file_put_contents.php
-	 *
-	 * @param string $path
-	 * @param mixed $data
-	 * @return int|false
-	 */
-	public function file_put_contents($path, $data) {
-		return $this->storage->file_put_contents($this->findPathToUse($path), $data);
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.unlink.php
-	 *
-	 * @param string $path
-	 * @return bool
-	 */
-	public function unlink($path) {
-		$result = $this->storage->unlink($this->findPathToUse($path));
-		if ($result) {
-			unset($this->namesCache[$path]);
-		}
-		return $result;
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.rename.php
-	 *
-	 * @param string $path1
-	 * @param string $path2
-	 * @return bool
-	 */
-	public function rename($path1, $path2) {
-		// second name always NFC
-		return $this->storage->rename($this->findPathToUse($path1), $this->findPathToUse($path2));
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.copy.php
-	 *
-	 * @param string $path1
-	 * @param string $path2
-	 * @return bool
-	 */
-	public function copy($path1, $path2) {
-		return $this->storage->copy($this->findPathToUse($path1), $this->findPathToUse($path2));
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.fopen.php
-	 *
-	 * @param string $path
-	 * @param string $mode
-	 * @return resource|bool
-	 */
-	public function fopen($path, $mode) {
-		$result = $this->storage->fopen($this->findPathToUse($path), $mode);
-		if ($result && $mode !== 'r' && $mode !== 'rb') {
-			unset($this->namesCache[$path]);
-		}
-		return $result;
-	}
-
-	/**
-	 * get the mimetype for a file or folder
-	 * The mimetype for a folder is required to be "httpd/unix-directory"
-	 *
-	 * @param string $path
-	 * @return string|bool
-	 */
-	public function getMimeType($path) {
-		return $this->storage->getMimeType($this->findPathToUse($path));
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.hash.php
-	 *
-	 * @param string $type
-	 * @param string $path
-	 * @param bool $raw
-	 * @return string|bool
-	 */
-	public function hash($type, $path, $raw = false) {
-		return $this->storage->hash($type, $this->findPathToUse($path), $raw);
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.free_space.php
-	 *
-	 * @param string $path
-	 * @return int|bool
-	 */
-	public function free_space($path) {
-		return $this->storage->free_space($this->findPathToUse($path));
-	}
-
-	/**
-	 * search for occurrences of $query in file names
-	 *
-	 * @param string $query
-	 * @return array|bool
-	 */
-	public function search($query) {
-		return $this->storage->search($query);
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.touch.php
-	 * If the backend does not support the operation, false should be returned
-	 *
-	 * @param string $path
-	 * @param int $mtime
-	 * @return bool
-	 */
-	public function touch($path, $mtime = null) {
-		return $this->storage->touch($this->findPathToUse($path), $mtime);
-	}
-
-	/**
-	 * get the path to a local version of the file.
-	 * The local version of the file can be temporary and doesn't have to be persistent across requests
-	 *
-	 * @param string $path
-	 * @return string|bool
-	 */
-	public function getLocalFile($path) {
-		return $this->storage->getLocalFile($this->findPathToUse($path));
-	}
-
-	/**
-	 * check if a file or folder has been updated since $time
-	 *
-	 * @param string $path
-	 * @param int $time
-	 * @return bool
-	 *
-	 * hasUpdated for folders should return at least true if a file inside the folder is add, removed or renamed.
-	 * returning true for other changes in the folder is optional
-	 */
-	public function hasUpdated($path, $time) {
-		return $this->storage->hasUpdated($this->findPathToUse($path), $time);
-	}
-
-	/**
-	 * get a cache instance for the storage
-	 *
-	 * @param string $path
-	 * @param \OC\Files\Storage\Storage (optional) the storage to pass to the cache
-	 * @return \OC\Files\Cache\Cache
-	 */
-	public function getCache($path = '', $storage = null) {
-		if (!$storage) {
-			$storage = $this;
-		}
-		return $this->storage->getCache($this->findPathToUse($path), $storage);
-	}
-
-	/**
-	 * get a scanner instance for the storage
-	 *
-	 * @param string $path
-	 * @param \OC\Files\Storage\Storage (optional) the storage to pass to the scanner
-	 * @return \OC\Files\Cache\Scanner
-	 */
-	public function getScanner($path = '', $storage = null) {
-		if (!$storage) {
-			$storage = $this;
-		}
-		return $this->storage->getScanner($this->findPathToUse($path), $storage);
-	}
-
-	/**
-	 * get the ETag for a file or folder
-	 *
-	 * @param string $path
-	 * @return string|bool
-	 */
-	public function getETag($path) {
-		return $this->storage->getETag($this->findPathToUse($path));
-	}
-
-	/**
-	 * @param IStorage $sourceStorage
-	 * @param string $sourceInternalPath
-	 * @param string $targetInternalPath
-	 * @return bool
-	 */
-	public function copyFromStorage(IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath) {
-		if ($sourceStorage === $this) {
-			return $this->copy($sourceInternalPath, $this->findPathToUse($targetInternalPath));
-		}
-
-		$result = $this->storage->copyFromStorage($sourceStorage, $sourceInternalPath, $this->findPathToUse($targetInternalPath));
-		if ($result) {
-			unset($this->namesCache[$targetInternalPath]);
-		}
-		return $result;
-	}
-
-	/**
-	 * @param IStorage $sourceStorage
-	 * @param string $sourceInternalPath
-	 * @param string $targetInternalPath
-	 * @return bool
-	 */
-	public function moveFromStorage(IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath) {
-		if ($sourceStorage === $this) {
-			$result = $this->rename($sourceInternalPath, $this->findPathToUse($targetInternalPath));
-			if ($result) {
-				unset($this->namesCache[$sourceInternalPath]);
-				unset($this->namesCache[$targetInternalPath]);
-			}
-			return $result;
-		}
-
-		$result = $this->storage->moveFromStorage($sourceStorage, $sourceInternalPath, $this->findPathToUse($targetInternalPath));
-		if ($result) {
-			unset($this->namesCache[$sourceInternalPath]);
-			unset($this->namesCache[$targetInternalPath]);
-		}
-		return $result;
-	}
-
-	/**
-	 * @param string $path
-	 * @return array
-	 */
-	public function getMetaData($path) {
-		return $this->storage->getMetaData($this->findPathToUse($path));
-	}
-
-	public function getDirectoryContent($directory): \Traversable {
-		return $this->storage->getDirectoryContent($this->findPathToUse($directory));
-	}
+    /**
+     * @var ICache
+     */
+    private $namesCache;
+
+    /**
+     * @param array $parameters
+     */
+    public function __construct($parameters) {
+        $this->storage = $parameters['storage'];
+        $this->namesCache = new CappedMemoryCache();
+    }
+
+    /**
+     * Returns whether the given string is only made of ASCII characters
+     *
+     * @param string $str string
+     *
+     * @return bool true if the string is all ASCII, false otherwise
+     */
+    private function isAscii($str) {
+        return (bool) !preg_match('/[\\x80-\\xff]+/', $str);
+    }
+
+    /**
+     * Checks whether the given path exists in NFC or NFD form after checking
+     * each form for each path section and returns the correct form.
+     * If no existing path found, returns the path as it was given.
+     *
+     * @param string $fullPath path to check
+     *
+     * @return string original or converted path
+     */
+    private function findPathToUse($fullPath) {
+        $cachedPath = $this->namesCache[$fullPath];
+        if ($cachedPath !== null) {
+            return $cachedPath;
+        }
+
+        $sections = explode('/', $fullPath);
+        $path = '';
+        foreach ($sections as $section) {
+            $convertedPath = $this->findPathToUseLastSection($path, $section);
+            if ($convertedPath === null) {
+                // no point in continuing if the section was not found, use original path
+                return $fullPath;
+            }
+            $path = $convertedPath . '/';
+        }
+        $path = rtrim($path, '/');
+        return $path;
+    }
+
+    /**
+     * Checks whether the last path section of the given path exists in NFC or NFD form
+     * and returns the correct form. If no existing path found, returns null.
+     *
+     * @param string $basePath base path to check
+     * @param string $lastSection last section of the path to check for NFD/NFC variations
+     *
+     * @return string|null original or converted path, or null if none of the forms was found
+     */
+    private function findPathToUseLastSection($basePath, $lastSection) {
+        $fullPath = $basePath . $lastSection;
+        if ($lastSection === '' || $this->isAscii($lastSection) || $this->storage->file_exists($fullPath)) {
+            $this->namesCache[$fullPath] = $fullPath;
+            return $fullPath;
+        }
+
+        // swap encoding
+        if (\Normalizer::isNormalized($lastSection, \Normalizer::FORM_C)) {
+            $otherFormPath = \Normalizer::normalize($lastSection, \Normalizer::FORM_D);
+        } else {
+            $otherFormPath = \Normalizer::normalize($lastSection, \Normalizer::FORM_C);
+        }
+        $otherFullPath = $basePath . $otherFormPath;
+        if ($this->storage->file_exists($otherFullPath)) {
+            $this->namesCache[$fullPath] = $otherFullPath;
+            return $otherFullPath;
+        }
+
+        // return original path, file did not exist at all
+        $this->namesCache[$fullPath] = $fullPath;
+        return null;
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.mkdir.php
+     *
+     * @param string $path
+     * @return bool
+     */
+    public function mkdir($path) {
+        // note: no conversion here, method should not be called with non-NFC names!
+        $result = $this->storage->mkdir($path);
+        if ($result) {
+            $this->namesCache[$path] = $path;
+        }
+        return $result;
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.rmdir.php
+     *
+     * @param string $path
+     * @return bool
+     */
+    public function rmdir($path) {
+        $result = $this->storage->rmdir($this->findPathToUse($path));
+        if ($result) {
+            unset($this->namesCache[$path]);
+        }
+        return $result;
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.opendir.php
+     *
+     * @param string $path
+     * @return resource|bool
+     */
+    public function opendir($path) {
+        return $this->storage->opendir($this->findPathToUse($path));
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.is_dir.php
+     *
+     * @param string $path
+     * @return bool
+     */
+    public function is_dir($path) {
+        return $this->storage->is_dir($this->findPathToUse($path));
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.is_file.php
+     *
+     * @param string $path
+     * @return bool
+     */
+    public function is_file($path) {
+        return $this->storage->is_file($this->findPathToUse($path));
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.stat.php
+     * only the following keys are required in the result: size and mtime
+     *
+     * @param string $path
+     * @return array|bool
+     */
+    public function stat($path) {
+        return $this->storage->stat($this->findPathToUse($path));
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.filetype.php
+     *
+     * @param string $path
+     * @return string|bool
+     */
+    public function filetype($path) {
+        return $this->storage->filetype($this->findPathToUse($path));
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.filesize.php
+     * The result for filesize when called on a folder is required to be 0
+     *
+     * @param string $path
+     * @return int|bool
+     */
+    public function filesize($path) {
+        return $this->storage->filesize($this->findPathToUse($path));
+    }
+
+    /**
+     * check if a file can be created in $path
+     *
+     * @param string $path
+     * @return bool
+     */
+    public function isCreatable($path) {
+        return $this->storage->isCreatable($this->findPathToUse($path));
+    }
+
+    /**
+     * check if a file can be read
+     *
+     * @param string $path
+     * @return bool
+     */
+    public function isReadable($path) {
+        return $this->storage->isReadable($this->findPathToUse($path));
+    }
+
+    /**
+     * check if a file can be written to
+     *
+     * @param string $path
+     * @return bool
+     */
+    public function isUpdatable($path) {
+        return $this->storage->isUpdatable($this->findPathToUse($path));
+    }
+
+    /**
+     * check if a file can be deleted
+     *
+     * @param string $path
+     * @return bool
+     */
+    public function isDeletable($path) {
+        return $this->storage->isDeletable($this->findPathToUse($path));
+    }
+
+    /**
+     * check if a file can be shared
+     *
+     * @param string $path
+     * @return bool
+     */
+    public function isSharable($path) {
+        return $this->storage->isSharable($this->findPathToUse($path));
+    }
+
+    /**
+     * get the full permissions of a path.
+     * Should return a combination of the PERMISSION_ constants defined in lib/public/constants.php
+     *
+     * @param string $path
+     * @return int
+     */
+    public function getPermissions($path) {
+        return $this->storage->getPermissions($this->findPathToUse($path));
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.file_exists.php
+     *
+     * @param string $path
+     * @return bool
+     */
+    public function file_exists($path) {
+        return $this->storage->file_exists($this->findPathToUse($path));
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.filemtime.php
+     *
+     * @param string $path
+     * @return int|bool
+     */
+    public function filemtime($path) {
+        return $this->storage->filemtime($this->findPathToUse($path));
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.file_get_contents.php
+     *
+     * @param string $path
+     * @return string|bool
+     */
+    public function file_get_contents($path) {
+        return $this->storage->file_get_contents($this->findPathToUse($path));
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.file_put_contents.php
+     *
+     * @param string $path
+     * @param mixed $data
+     * @return int|false
+     */
+    public function file_put_contents($path, $data) {
+        return $this->storage->file_put_contents($this->findPathToUse($path), $data);
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.unlink.php
+     *
+     * @param string $path
+     * @return bool
+     */
+    public function unlink($path) {
+        $result = $this->storage->unlink($this->findPathToUse($path));
+        if ($result) {
+            unset($this->namesCache[$path]);
+        }
+        return $result;
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.rename.php
+     *
+     * @param string $path1
+     * @param string $path2
+     * @return bool
+     */
+    public function rename($path1, $path2) {
+        // second name always NFC
+        return $this->storage->rename($this->findPathToUse($path1), $this->findPathToUse($path2));
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.copy.php
+     *
+     * @param string $path1
+     * @param string $path2
+     * @return bool
+     */
+    public function copy($path1, $path2) {
+        return $this->storage->copy($this->findPathToUse($path1), $this->findPathToUse($path2));
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.fopen.php
+     *
+     * @param string $path
+     * @param string $mode
+     * @return resource|bool
+     */
+    public function fopen($path, $mode) {
+        $result = $this->storage->fopen($this->findPathToUse($path), $mode);
+        if ($result && $mode !== 'r' && $mode !== 'rb') {
+            unset($this->namesCache[$path]);
+        }
+        return $result;
+    }
+
+    /**
+     * get the mimetype for a file or folder
+     * The mimetype for a folder is required to be "httpd/unix-directory"
+     *
+     * @param string $path
+     * @return string|bool
+     */
+    public function getMimeType($path) {
+        return $this->storage->getMimeType($this->findPathToUse($path));
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.hash.php
+     *
+     * @param string $type
+     * @param string $path
+     * @param bool $raw
+     * @return string|bool
+     */
+    public function hash($type, $path, $raw = false) {
+        return $this->storage->hash($type, $this->findPathToUse($path), $raw);
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.free_space.php
+     *
+     * @param string $path
+     * @return int|bool
+     */
+    public function free_space($path) {
+        return $this->storage->free_space($this->findPathToUse($path));
+    }
+
+    /**
+     * search for occurrences of $query in file names
+     *
+     * @param string $query
+     * @return array|bool
+     */
+    public function search($query) {
+        return $this->storage->search($query);
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.touch.php
+     * If the backend does not support the operation, false should be returned
+     *
+     * @param string $path
+     * @param int $mtime
+     * @return bool
+     */
+    public function touch($path, $mtime = null) {
+        return $this->storage->touch($this->findPathToUse($path), $mtime);
+    }
+
+    /**
+     * get the path to a local version of the file.
+     * The local version of the file can be temporary and doesn't have to be persistent across requests
+     *
+     * @param string $path
+     * @return string|bool
+     */
+    public function getLocalFile($path) {
+        return $this->storage->getLocalFile($this->findPathToUse($path));
+    }
+
+    /**
+     * check if a file or folder has been updated since $time
+     *
+     * @param string $path
+     * @param int $time
+     * @return bool
+     *
+     * hasUpdated for folders should return at least true if a file inside the folder is add, removed or renamed.
+     * returning true for other changes in the folder is optional
+     */
+    public function hasUpdated($path, $time) {
+        return $this->storage->hasUpdated($this->findPathToUse($path), $time);
+    }
+
+    /**
+     * get a cache instance for the storage
+     *
+     * @param string $path
+     * @param \OC\Files\Storage\Storage (optional) the storage to pass to the cache
+     * @return \OC\Files\Cache\Cache
+     */
+    public function getCache($path = '', $storage = null) {
+        if (!$storage) {
+            $storage = $this;
+        }
+        return $this->storage->getCache($this->findPathToUse($path), $storage);
+    }
+
+    /**
+     * get a scanner instance for the storage
+     *
+     * @param string $path
+     * @param \OC\Files\Storage\Storage (optional) the storage to pass to the scanner
+     * @return \OC\Files\Cache\Scanner
+     */
+    public function getScanner($path = '', $storage = null) {
+        if (!$storage) {
+            $storage = $this;
+        }
+        return $this->storage->getScanner($this->findPathToUse($path), $storage);
+    }
+
+    /**
+     * get the ETag for a file or folder
+     *
+     * @param string $path
+     * @return string|bool
+     */
+    public function getETag($path) {
+        return $this->storage->getETag($this->findPathToUse($path));
+    }
+
+    /**
+     * @param IStorage $sourceStorage
+     * @param string $sourceInternalPath
+     * @param string $targetInternalPath
+     * @return bool
+     */
+    public function copyFromStorage(IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath) {
+        if ($sourceStorage === $this) {
+            return $this->copy($sourceInternalPath, $this->findPathToUse($targetInternalPath));
+        }
+
+        $result = $this->storage->copyFromStorage($sourceStorage, $sourceInternalPath, $this->findPathToUse($targetInternalPath));
+        if ($result) {
+            unset($this->namesCache[$targetInternalPath]);
+        }
+        return $result;
+    }
+
+    /**
+     * @param IStorage $sourceStorage
+     * @param string $sourceInternalPath
+     * @param string $targetInternalPath
+     * @return bool
+     */
+    public function moveFromStorage(IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath) {
+        if ($sourceStorage === $this) {
+            $result = $this->rename($sourceInternalPath, $this->findPathToUse($targetInternalPath));
+            if ($result) {
+                unset($this->namesCache[$sourceInternalPath]);
+                unset($this->namesCache[$targetInternalPath]);
+            }
+            return $result;
+        }
+
+        $result = $this->storage->moveFromStorage($sourceStorage, $sourceInternalPath, $this->findPathToUse($targetInternalPath));
+        if ($result) {
+            unset($this->namesCache[$sourceInternalPath]);
+            unset($this->namesCache[$targetInternalPath]);
+        }
+        return $result;
+    }
+
+    /**
+     * @param string $path
+     * @return array
+     */
+    public function getMetaData($path) {
+        return $this->storage->getMetaData($this->findPathToUse($path));
+    }
+
+    public function getDirectoryContent($directory): \Traversable {
+        return $this->storage->getDirectoryContent($this->findPathToUse($directory));
+    }
 }

lib/private/Files/Storage/Wrapper/Wrapper.php

Indentation +604 added lines, -604 removed lines

@@ -37,608 +37,608 @@
 use OCP\Lock\ILockingProvider;
 
 class Wrapper implements \OC\Files\Storage\Storage, ILockingStorage, IWriteStreamStorage {
-	/**
-	 * @var \OC\Files\Storage\Storage $storage
-	 */
-	protected $storage;
-
-	public $cache;
-	public $scanner;
-	public $watcher;
-	public $propagator;
-	public $updater;
-
-	/**
-	 * @param array $parameters
-	 */
-	public function __construct($parameters) {
-		$this->storage = $parameters['storage'];
-	}
-
-	/**
-	 * @return \OC\Files\Storage\Storage
-	 */
-	public function getWrapperStorage() {
-		return $this->storage;
-	}
-
-	/**
-	 * Get the identifier for the storage,
-	 * the returned id should be the same for every storage object that is created with the same parameters
-	 * and two storage objects with the same id should refer to two storages that display the same files.
-	 *
-	 * @return string
-	 */
-	public function getId() {
-		return $this->getWrapperStorage()->getId();
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.mkdir.php
-	 *
-	 * @param string $path
-	 * @return bool
-	 */
-	public function mkdir($path) {
-		return $this->getWrapperStorage()->mkdir($path);
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.rmdir.php
-	 *
-	 * @param string $path
-	 * @return bool
-	 */
-	public function rmdir($path) {
-		return $this->getWrapperStorage()->rmdir($path);
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.opendir.php
-	 *
-	 * @param string $path
-	 * @return resource|bool
-	 */
-	public function opendir($path) {
-		return $this->getWrapperStorage()->opendir($path);
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.is_dir.php
-	 *
-	 * @param string $path
-	 * @return bool
-	 */
-	public function is_dir($path) {
-		return $this->getWrapperStorage()->is_dir($path);
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.is_file.php
-	 *
-	 * @param string $path
-	 * @return bool
-	 */
-	public function is_file($path) {
-		return $this->getWrapperStorage()->is_file($path);
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.stat.php
-	 * only the following keys are required in the result: size and mtime
-	 *
-	 * @param string $path
-	 * @return array|bool
-	 */
-	public function stat($path) {
-		return $this->getWrapperStorage()->stat($path);
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.filetype.php
-	 *
-	 * @param string $path
-	 * @return string|bool
-	 */
-	public function filetype($path) {
-		return $this->getWrapperStorage()->filetype($path);
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.filesize.php
-	 * The result for filesize when called on a folder is required to be 0
-	 *
-	 * @param string $path
-	 * @return int|bool
-	 */
-	public function filesize($path) {
-		return $this->getWrapperStorage()->filesize($path);
-	}
-
-	/**
-	 * check if a file can be created in $path
-	 *
-	 * @param string $path
-	 * @return bool
-	 */
-	public function isCreatable($path) {
-		return $this->getWrapperStorage()->isCreatable($path);
-	}
-
-	/**
-	 * check if a file can be read
-	 *
-	 * @param string $path
-	 * @return bool
-	 */
-	public function isReadable($path) {
-		return $this->getWrapperStorage()->isReadable($path);
-	}
-
-	/**
-	 * check if a file can be written to
-	 *
-	 * @param string $path
-	 * @return bool
-	 */
-	public function isUpdatable($path) {
-		return $this->getWrapperStorage()->isUpdatable($path);
-	}
-
-	/**
-	 * check if a file can be deleted
-	 *
-	 * @param string $path
-	 * @return bool
-	 */
-	public function isDeletable($path) {
-		return $this->getWrapperStorage()->isDeletable($path);
-	}
-
-	/**
-	 * check if a file can be shared
-	 *
-	 * @param string $path
-	 * @return bool
-	 */
-	public function isSharable($path) {
-		return $this->getWrapperStorage()->isSharable($path);
-	}
-
-	/**
-	 * get the full permissions of a path.
-	 * Should return a combination of the PERMISSION_ constants defined in lib/public/constants.php
-	 *
-	 * @param string $path
-	 * @return int
-	 */
-	public function getPermissions($path) {
-		return $this->getWrapperStorage()->getPermissions($path);
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.file_exists.php
-	 *
-	 * @param string $path
-	 * @return bool
-	 */
-	public function file_exists($path) {
-		return $this->getWrapperStorage()->file_exists($path);
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.filemtime.php
-	 *
-	 * @param string $path
-	 * @return int|bool
-	 */
-	public function filemtime($path) {
-		return $this->getWrapperStorage()->filemtime($path);
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.file_get_contents.php
-	 *
-	 * @param string $path
-	 * @return string|bool
-	 */
-	public function file_get_contents($path) {
-		return $this->getWrapperStorage()->file_get_contents($path);
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.file_put_contents.php
-	 *
-	 * @param string $path
-	 * @param mixed $data
-	 * @return int|false
-	 */
-	public function file_put_contents($path, $data) {
-		return $this->getWrapperStorage()->file_put_contents($path, $data);
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.unlink.php
-	 *
-	 * @param string $path
-	 * @return bool
-	 */
-	public function unlink($path) {
-		return $this->getWrapperStorage()->unlink($path);
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.rename.php
-	 *
-	 * @param string $path1
-	 * @param string $path2
-	 * @return bool
-	 */
-	public function rename($path1, $path2) {
-		return $this->getWrapperStorage()->rename($path1, $path2);
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.copy.php
-	 *
-	 * @param string $path1
-	 * @param string $path2
-	 * @return bool
-	 */
-	public function copy($path1, $path2) {
-		return $this->getWrapperStorage()->copy($path1, $path2);
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.fopen.php
-	 *
-	 * @param string $path
-	 * @param string $mode
-	 * @return resource|bool
-	 */
-	public function fopen($path, $mode) {
-		return $this->getWrapperStorage()->fopen($path, $mode);
-	}
-
-	/**
-	 * get the mimetype for a file or folder
-	 * The mimetype for a folder is required to be "httpd/unix-directory"
-	 *
-	 * @param string $path
-	 * @return string|bool
-	 */
-	public function getMimeType($path) {
-		return $this->getWrapperStorage()->getMimeType($path);
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.hash.php
-	 *
-	 * @param string $type
-	 * @param string $path
-	 * @param bool $raw
-	 * @return string|bool
-	 */
-	public function hash($type, $path, $raw = false) {
-		return $this->getWrapperStorage()->hash($type, $path, $raw);
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.free_space.php
-	 *
-	 * @param string $path
-	 * @return int|bool
-	 */
-	public function free_space($path) {
-		return $this->getWrapperStorage()->free_space($path);
-	}
-
-	/**
-	 * search for occurrences of $query in file names
-	 *
-	 * @param string $query
-	 * @return array|bool
-	 */
-	public function search($query) {
-		return $this->getWrapperStorage()->search($query);
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.touch.php
-	 * If the backend does not support the operation, false should be returned
-	 *
-	 * @param string $path
-	 * @param int $mtime
-	 * @return bool
-	 */
-	public function touch($path, $mtime = null) {
-		return $this->getWrapperStorage()->touch($path, $mtime);
-	}
-
-	/**
-	 * get the path to a local version of the file.
-	 * The local version of the file can be temporary and doesn't have to be persistent across requests
-	 *
-	 * @param string $path
-	 * @return string|bool
-	 */
-	public function getLocalFile($path) {
-		return $this->getWrapperStorage()->getLocalFile($path);
-	}
-
-	/**
-	 * check if a file or folder has been updated since $time
-	 *
-	 * @param string $path
-	 * @param int $time
-	 * @return bool
-	 *
-	 * hasUpdated for folders should return at least true if a file inside the folder is add, removed or renamed.
-	 * returning true for other changes in the folder is optional
-	 */
-	public function hasUpdated($path, $time) {
-		return $this->getWrapperStorage()->hasUpdated($path, $time);
-	}
-
-	/**
-	 * get a cache instance for the storage
-	 *
-	 * @param string $path
-	 * @param \OC\Files\Storage\Storage (optional) the storage to pass to the cache
-	 * @return \OC\Files\Cache\Cache
-	 */
-	public function getCache($path = '', $storage = null) {
-		if (!$storage) {
-			$storage = $this;
-		}
-		return $this->getWrapperStorage()->getCache($path, $storage);
-	}
-
-	/**
-	 * get a scanner instance for the storage
-	 *
-	 * @param string $path
-	 * @param \OC\Files\Storage\Storage (optional) the storage to pass to the scanner
-	 * @return \OC\Files\Cache\Scanner
-	 */
-	public function getScanner($path = '', $storage = null) {
-		if (!$storage) {
-			$storage = $this;
-		}
-		return $this->getWrapperStorage()->getScanner($path, $storage);
-	}
-
-
-	/**
-	 * get the user id of the owner of a file or folder
-	 *
-	 * @param string $path
-	 * @return string
-	 */
-	public function getOwner($path) {
-		return $this->getWrapperStorage()->getOwner($path);
-	}
-
-	/**
-	 * get a watcher instance for the cache
-	 *
-	 * @param string $path
-	 * @param \OC\Files\Storage\Storage (optional) the storage to pass to the watcher
-	 * @return \OC\Files\Cache\Watcher
-	 */
-	public function getWatcher($path = '', $storage = null) {
-		if (!$storage) {
-			$storage = $this;
-		}
-		return $this->getWrapperStorage()->getWatcher($path, $storage);
-	}
-
-	public function getPropagator($storage = null) {
-		if (!$storage) {
-			$storage = $this;
-		}
-		return $this->getWrapperStorage()->getPropagator($storage);
-	}
-
-	public function getUpdater($storage = null) {
-		if (!$storage) {
-			$storage = $this;
-		}
-		return $this->getWrapperStorage()->getUpdater($storage);
-	}
-
-	/**
-	 * @return \OC\Files\Cache\Storage
-	 */
-	public function getStorageCache() {
-		return $this->getWrapperStorage()->getStorageCache();
-	}
-
-	/**
-	 * get the ETag for a file or folder
-	 *
-	 * @param string $path
-	 * @return string|bool
-	 */
-	public function getETag($path) {
-		return $this->getWrapperStorage()->getETag($path);
-	}
-
-	/**
-	 * Returns true
-	 *
-	 * @return true
-	 */
-	public function test() {
-		return $this->getWrapperStorage()->test();
-	}
-
-	/**
-	 * Returns the wrapped storage's value for isLocal()
-	 *
-	 * @return bool wrapped storage's isLocal() value
-	 */
-	public function isLocal() {
-		return $this->getWrapperStorage()->isLocal();
-	}
-
-	/**
-	 * Check if the storage is an instance of $class or is a wrapper for a storage that is an instance of $class
-	 *
-	 * @param string $class
-	 * @return bool
-	 */
-	public function instanceOfStorage($class) {
-		if (ltrim($class, '\\') === 'OC\Files\Storage\Shared') {
-			// FIXME Temporary fix to keep existing checks working
-			$class = '\OCA\Files_Sharing\SharedStorage';
-		}
-		return is_a($this, $class) or $this->getWrapperStorage()->instanceOfStorage($class);
-	}
-
-	/**
-	 * Pass any methods custom to specific storage implementations to the wrapped storage
-	 *
-	 * @param string $method
-	 * @param array $args
-	 * @return mixed
-	 */
-	public function __call($method, $args) {
-		return call_user_func_array([$this->getWrapperStorage(), $method], $args);
-	}
-
-	/**
-	 * A custom storage implementation can return an url for direct download of a give file.
-	 *
-	 * For now the returned array can hold the parameter url - in future more attributes might follow.
-	 *
-	 * @param string $path
-	 * @return array|bool
-	 */
-	public function getDirectDownload($path) {
-		return $this->getWrapperStorage()->getDirectDownload($path);
-	}
-
-	/**
-	 * Get availability of the storage
-	 *
-	 * @return array [ available, last_checked ]
-	 */
-	public function getAvailability() {
-		return $this->getWrapperStorage()->getAvailability();
-	}
-
-	/**
-	 * Set availability of the storage
-	 *
-	 * @param bool $isAvailable
-	 */
-	public function setAvailability($isAvailable) {
-		$this->getWrapperStorage()->setAvailability($isAvailable);
-	}
-
-	/**
-	 * @param string $path the path of the target folder
-	 * @param string $fileName the name of the file itself
-	 * @return void
-	 * @throws InvalidPathException
-	 */
-	public function verifyPath($path, $fileName) {
-		$this->getWrapperStorage()->verifyPath($path, $fileName);
-	}
-
-	/**
-	 * @param IStorage $sourceStorage
-	 * @param string $sourceInternalPath
-	 * @param string $targetInternalPath
-	 * @return bool
-	 */
-	public function copyFromStorage(IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath) {
-		if ($sourceStorage === $this) {
-			return $this->copy($sourceInternalPath, $targetInternalPath);
-		}
-
-		return $this->getWrapperStorage()->copyFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath);
-	}
-
-	/**
-	 * @param IStorage $sourceStorage
-	 * @param string $sourceInternalPath
-	 * @param string $targetInternalPath
-	 * @return bool
-	 */
-	public function moveFromStorage(IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath) {
-		if ($sourceStorage === $this) {
-			return $this->rename($sourceInternalPath, $targetInternalPath);
-		}
-
-		return $this->getWrapperStorage()->moveFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath);
-	}
-
-	/**
-	 * @param string $path
-	 * @return array
-	 */
-	public function getMetaData($path) {
-		return $this->getWrapperStorage()->getMetaData($path);
-	}
-
-	/**
-	 * @param string $path
-	 * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
-	 * @param \OCP\Lock\ILockingProvider $provider
-	 * @throws \OCP\Lock\LockedException
-	 */
-	public function acquireLock($path, $type, ILockingProvider $provider) {
-		if ($this->getWrapperStorage()->instanceOfStorage('\OCP\Files\Storage\ILockingStorage')) {
-			$this->getWrapperStorage()->acquireLock($path, $type, $provider);
-		}
-	}
-
-	/**
-	 * @param string $path
-	 * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
-	 * @param \OCP\Lock\ILockingProvider $provider
-	 */
-	public function releaseLock($path, $type, ILockingProvider $provider) {
-		if ($this->getWrapperStorage()->instanceOfStorage('\OCP\Files\Storage\ILockingStorage')) {
-			$this->getWrapperStorage()->releaseLock($path, $type, $provider);
-		}
-	}
-
-	/**
-	 * @param string $path
-	 * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
-	 * @param \OCP\Lock\ILockingProvider $provider
-	 */
-	public function changeLock($path, $type, ILockingProvider $provider) {
-		if ($this->getWrapperStorage()->instanceOfStorage('\OCP\Files\Storage\ILockingStorage')) {
-			$this->getWrapperStorage()->changeLock($path, $type, $provider);
-		}
-	}
-
-	/**
-	 * @return bool
-	 */
-	public function needsPartFile() {
-		return $this->getWrapperStorage()->needsPartFile();
-	}
-
-	public function writeStream(string $path, $stream, int $size = null): int {
-		$storage = $this->getWrapperStorage();
-		if ($storage->instanceOfStorage(IWriteStreamStorage::class)) {
-			/** @var IWriteStreamStorage $storage */
-			return $storage->writeStream($path, $stream, $size);
-		} else {
-			$target = $this->fopen($path, 'w');
-			list($count, $result) = \OC_Helper::streamCopy($stream, $target);
-			fclose($stream);
-			fclose($target);
-			return $count;
-		}
-	}
-
-	public function getDirectoryContent($directory): \Traversable {
-		return $this->getWrapperStorage()->getDirectoryContent($directory);
-	}
+    /**
+     * @var \OC\Files\Storage\Storage $storage
+     */
+    protected $storage;
+
+    public $cache;
+    public $scanner;
+    public $watcher;
+    public $propagator;
+    public $updater;
+
+    /**
+     * @param array $parameters
+     */
+    public function __construct($parameters) {
+        $this->storage = $parameters['storage'];
+    }
+
+    /**
+     * @return \OC\Files\Storage\Storage
+     */
+    public function getWrapperStorage() {
+        return $this->storage;
+    }
+
+    /**
+     * Get the identifier for the storage,
+     * the returned id should be the same for every storage object that is created with the same parameters
+     * and two storage objects with the same id should refer to two storages that display the same files.
+     *
+     * @return string
+     */
+    public function getId() {
+        return $this->getWrapperStorage()->getId();
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.mkdir.php
+     *
+     * @param string $path
+     * @return bool
+     */
+    public function mkdir($path) {
+        return $this->getWrapperStorage()->mkdir($path);
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.rmdir.php
+     *
+     * @param string $path
+     * @return bool
+     */
+    public function rmdir($path) {
+        return $this->getWrapperStorage()->rmdir($path);
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.opendir.php
+     *
+     * @param string $path
+     * @return resource|bool
+     */
+    public function opendir($path) {
+        return $this->getWrapperStorage()->opendir($path);
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.is_dir.php
+     *
+     * @param string $path
+     * @return bool
+     */
+    public function is_dir($path) {
+        return $this->getWrapperStorage()->is_dir($path);
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.is_file.php
+     *
+     * @param string $path
+     * @return bool
+     */
+    public function is_file($path) {
+        return $this->getWrapperStorage()->is_file($path);
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.stat.php
+     * only the following keys are required in the result: size and mtime
+     *
+     * @param string $path
+     * @return array|bool
+     */
+    public function stat($path) {
+        return $this->getWrapperStorage()->stat($path);
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.filetype.php
+     *
+     * @param string $path
+     * @return string|bool
+     */
+    public function filetype($path) {
+        return $this->getWrapperStorage()->filetype($path);
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.filesize.php
+     * The result for filesize when called on a folder is required to be 0
+     *
+     * @param string $path
+     * @return int|bool
+     */
+    public function filesize($path) {
+        return $this->getWrapperStorage()->filesize($path);
+    }
+
+    /**
+     * check if a file can be created in $path
+     *
+     * @param string $path
+     * @return bool
+     */
+    public function isCreatable($path) {
+        return $this->getWrapperStorage()->isCreatable($path);
+    }
+
+    /**
+     * check if a file can be read
+     *
+     * @param string $path
+     * @return bool
+     */
+    public function isReadable($path) {
+        return $this->getWrapperStorage()->isReadable($path);
+    }
+
+    /**
+     * check if a file can be written to
+     *
+     * @param string $path
+     * @return bool
+     */
+    public function isUpdatable($path) {
+        return $this->getWrapperStorage()->isUpdatable($path);
+    }
+
+    /**
+     * check if a file can be deleted
+     *
+     * @param string $path
+     * @return bool
+     */
+    public function isDeletable($path) {
+        return $this->getWrapperStorage()->isDeletable($path);
+    }
+
+    /**
+     * check if a file can be shared
+     *
+     * @param string $path
+     * @return bool
+     */
+    public function isSharable($path) {
+        return $this->getWrapperStorage()->isSharable($path);
+    }
+
+    /**
+     * get the full permissions of a path.
+     * Should return a combination of the PERMISSION_ constants defined in lib/public/constants.php
+     *
+     * @param string $path
+     * @return int
+     */
+    public function getPermissions($path) {
+        return $this->getWrapperStorage()->getPermissions($path);
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.file_exists.php
+     *
+     * @param string $path
+     * @return bool
+     */
+    public function file_exists($path) {
+        return $this->getWrapperStorage()->file_exists($path);
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.filemtime.php
+     *
+     * @param string $path
+     * @return int|bool
+     */
+    public function filemtime($path) {
+        return $this->getWrapperStorage()->filemtime($path);
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.file_get_contents.php
+     *
+     * @param string $path
+     * @return string|bool
+     */
+    public function file_get_contents($path) {
+        return $this->getWrapperStorage()->file_get_contents($path);
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.file_put_contents.php
+     *
+     * @param string $path
+     * @param mixed $data
+     * @return int|false
+     */
+    public function file_put_contents($path, $data) {
+        return $this->getWrapperStorage()->file_put_contents($path, $data);
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.unlink.php
+     *
+     * @param string $path
+     * @return bool
+     */
+    public function unlink($path) {
+        return $this->getWrapperStorage()->unlink($path);
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.rename.php
+     *
+     * @param string $path1
+     * @param string $path2
+     * @return bool
+     */
+    public function rename($path1, $path2) {
+        return $this->getWrapperStorage()->rename($path1, $path2);
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.copy.php
+     *
+     * @param string $path1
+     * @param string $path2
+     * @return bool
+     */
+    public function copy($path1, $path2) {
+        return $this->getWrapperStorage()->copy($path1, $path2);
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.fopen.php
+     *
+     * @param string $path
+     * @param string $mode
+     * @return resource|bool
+     */
+    public function fopen($path, $mode) {
+        return $this->getWrapperStorage()->fopen($path, $mode);
+    }
+
+    /**
+     * get the mimetype for a file or folder
+     * The mimetype for a folder is required to be "httpd/unix-directory"
+     *
+     * @param string $path
+     * @return string|bool
+     */
+    public function getMimeType($path) {
+        return $this->getWrapperStorage()->getMimeType($path);
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.hash.php
+     *
+     * @param string $type
+     * @param string $path
+     * @param bool $raw
+     * @return string|bool
+     */
+    public function hash($type, $path, $raw = false) {
+        return $this->getWrapperStorage()->hash($type, $path, $raw);
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.free_space.php
+     *
+     * @param string $path
+     * @return int|bool
+     */
+    public function free_space($path) {
+        return $this->getWrapperStorage()->free_space($path);
+    }
+
+    /**
+     * search for occurrences of $query in file names
+     *
+     * @param string $query
+     * @return array|bool
+     */
+    public function search($query) {
+        return $this->getWrapperStorage()->search($query);
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.touch.php
+     * If the backend does not support the operation, false should be returned
+     *
+     * @param string $path
+     * @param int $mtime
+     * @return bool
+     */
+    public function touch($path, $mtime = null) {
+        return $this->getWrapperStorage()->touch($path, $mtime);
+    }
+
+    /**
+     * get the path to a local version of the file.
+     * The local version of the file can be temporary and doesn't have to be persistent across requests
+     *
+     * @param string $path
+     * @return string|bool
+     */
+    public function getLocalFile($path) {
+        return $this->getWrapperStorage()->getLocalFile($path);
+    }
+
+    /**
+     * check if a file or folder has been updated since $time
+     *
+     * @param string $path
+     * @param int $time
+     * @return bool
+     *
+     * hasUpdated for folders should return at least true if a file inside the folder is add, removed or renamed.
+     * returning true for other changes in the folder is optional
+     */
+    public function hasUpdated($path, $time) {
+        return $this->getWrapperStorage()->hasUpdated($path, $time);
+    }
+
+    /**
+     * get a cache instance for the storage
+     *
+     * @param string $path
+     * @param \OC\Files\Storage\Storage (optional) the storage to pass to the cache
+     * @return \OC\Files\Cache\Cache
+     */
+    public function getCache($path = '', $storage = null) {
+        if (!$storage) {
+            $storage = $this;
+        }
+        return $this->getWrapperStorage()->getCache($path, $storage);
+    }
+
+    /**
+     * get a scanner instance for the storage
+     *
+     * @param string $path
+     * @param \OC\Files\Storage\Storage (optional) the storage to pass to the scanner
+     * @return \OC\Files\Cache\Scanner
+     */
+    public function getScanner($path = '', $storage = null) {
+        if (!$storage) {
+            $storage = $this;
+        }
+        return $this->getWrapperStorage()->getScanner($path, $storage);
+    }
+
+
+    /**
+     * get the user id of the owner of a file or folder
+     *
+     * @param string $path
+     * @return string
+     */
+    public function getOwner($path) {
+        return $this->getWrapperStorage()->getOwner($path);
+    }
+
+    /**
+     * get a watcher instance for the cache
+     *
+     * @param string $path
+     * @param \OC\Files\Storage\Storage (optional) the storage to pass to the watcher
+     * @return \OC\Files\Cache\Watcher
+     */
+    public function getWatcher($path = '', $storage = null) {
+        if (!$storage) {
+            $storage = $this;
+        }
+        return $this->getWrapperStorage()->getWatcher($path, $storage);
+    }
+
+    public function getPropagator($storage = null) {
+        if (!$storage) {
+            $storage = $this;
+        }
+        return $this->getWrapperStorage()->getPropagator($storage);
+    }
+
+    public function getUpdater($storage = null) {
+        if (!$storage) {
+            $storage = $this;
+        }
+        return $this->getWrapperStorage()->getUpdater($storage);
+    }
+
+    /**
+     * @return \OC\Files\Cache\Storage
+     */
+    public function getStorageCache() {
+        return $this->getWrapperStorage()->getStorageCache();
+    }
+
+    /**
+     * get the ETag for a file or folder
+     *
+     * @param string $path
+     * @return string|bool
+     */
+    public function getETag($path) {
+        return $this->getWrapperStorage()->getETag($path);
+    }
+
+    /**
+     * Returns true
+     *
+     * @return true
+     */
+    public function test() {
+        return $this->getWrapperStorage()->test();
+    }
+
+    /**
+     * Returns the wrapped storage's value for isLocal()
+     *
+     * @return bool wrapped storage's isLocal() value
+     */
+    public function isLocal() {
+        return $this->getWrapperStorage()->isLocal();
+    }
+
+    /**
+     * Check if the storage is an instance of $class or is a wrapper for a storage that is an instance of $class
+     *
+     * @param string $class
+     * @return bool
+     */
+    public function instanceOfStorage($class) {
+        if (ltrim($class, '\\') === 'OC\Files\Storage\Shared') {
+            // FIXME Temporary fix to keep existing checks working
+            $class = '\OCA\Files_Sharing\SharedStorage';
+        }
+        return is_a($this, $class) or $this->getWrapperStorage()->instanceOfStorage($class);
+    }
+
+    /**
+     * Pass any methods custom to specific storage implementations to the wrapped storage
+     *
+     * @param string $method
+     * @param array $args
+     * @return mixed
+     */
+    public function __call($method, $args) {
+        return call_user_func_array([$this->getWrapperStorage(), $method], $args);
+    }
+
+    /**
+     * A custom storage implementation can return an url for direct download of a give file.
+     *
+     * For now the returned array can hold the parameter url - in future more attributes might follow.
+     *
+     * @param string $path
+     * @return array|bool
+     */
+    public function getDirectDownload($path) {
+        return $this->getWrapperStorage()->getDirectDownload($path);
+    }
+
+    /**
+     * Get availability of the storage
+     *
+     * @return array [ available, last_checked ]
+     */
+    public function getAvailability() {
+        return $this->getWrapperStorage()->getAvailability();
+    }
+
+    /**
+     * Set availability of the storage
+     *
+     * @param bool $isAvailable
+     */
+    public function setAvailability($isAvailable) {
+        $this->getWrapperStorage()->setAvailability($isAvailable);
+    }
+
+    /**
+     * @param string $path the path of the target folder
+     * @param string $fileName the name of the file itself
+     * @return void
+     * @throws InvalidPathException
+     */
+    public function verifyPath($path, $fileName) {
+        $this->getWrapperStorage()->verifyPath($path, $fileName);
+    }
+
+    /**
+     * @param IStorage $sourceStorage
+     * @param string $sourceInternalPath
+     * @param string $targetInternalPath
+     * @return bool
+     */
+    public function copyFromStorage(IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath) {
+        if ($sourceStorage === $this) {
+            return $this->copy($sourceInternalPath, $targetInternalPath);
+        }
+
+        return $this->getWrapperStorage()->copyFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath);
+    }
+
+    /**
+     * @param IStorage $sourceStorage
+     * @param string $sourceInternalPath
+     * @param string $targetInternalPath
+     * @return bool
+     */
+    public function moveFromStorage(IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath) {
+        if ($sourceStorage === $this) {
+            return $this->rename($sourceInternalPath, $targetInternalPath);
+        }
+
+        return $this->getWrapperStorage()->moveFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath);
+    }
+
+    /**
+     * @param string $path
+     * @return array
+     */
+    public function getMetaData($path) {
+        return $this->getWrapperStorage()->getMetaData($path);
+    }
+
+    /**
+     * @param string $path
+     * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
+     * @param \OCP\Lock\ILockingProvider $provider
+     * @throws \OCP\Lock\LockedException
+     */
+    public function acquireLock($path, $type, ILockingProvider $provider) {
+        if ($this->getWrapperStorage()->instanceOfStorage('\OCP\Files\Storage\ILockingStorage')) {
+            $this->getWrapperStorage()->acquireLock($path, $type, $provider);
+        }
+    }
+
+    /**
+     * @param string $path
+     * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
+     * @param \OCP\Lock\ILockingProvider $provider
+     */
+    public function releaseLock($path, $type, ILockingProvider $provider) {
+        if ($this->getWrapperStorage()->instanceOfStorage('\OCP\Files\Storage\ILockingStorage')) {
+            $this->getWrapperStorage()->releaseLock($path, $type, $provider);
+        }
+    }
+
+    /**
+     * @param string $path
+     * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
+     * @param \OCP\Lock\ILockingProvider $provider
+     */
+    public function changeLock($path, $type, ILockingProvider $provider) {
+        if ($this->getWrapperStorage()->instanceOfStorage('\OCP\Files\Storage\ILockingStorage')) {
+            $this->getWrapperStorage()->changeLock($path, $type, $provider);
+        }
+    }
+
+    /**
+     * @return bool
+     */
+    public function needsPartFile() {
+        return $this->getWrapperStorage()->needsPartFile();
+    }
+
+    public function writeStream(string $path, $stream, int $size = null): int {
+        $storage = $this->getWrapperStorage();
+        if ($storage->instanceOfStorage(IWriteStreamStorage::class)) {
+            /** @var IWriteStreamStorage $storage */
+            return $storage->writeStream($path, $stream, $size);
+        } else {
+            $target = $this->fopen($path, 'w');
+            list($count, $result) = \OC_Helper::streamCopy($stream, $target);
+            fclose($stream);
+            fclose($target);
+            return $count;
+        }
+    }
+
+    public function getDirectoryContent($directory): \Traversable {
+        return $this->getWrapperStorage()->getDirectoryContent($directory);
+    }
 }

lib/private/Files/Storage/Wrapper/Jail.php

Indentation +500 added lines, -500 removed lines

@@ -39,504 +39,504 @@
  * This restricts access to a subfolder of the wrapped storage with the subfolder becoming the root folder new storage
  */
 class Jail extends Wrapper {
-	/**
-	 * @var string
-	 */
-	protected $rootPath;
-
-	/**
-	 * @param array $arguments ['storage' => $storage, 'mask' => $root]
-	 *
-	 * $storage: The storage that will be wrapper
-	 * $root: The folder in the wrapped storage that will become the root folder of the wrapped storage
-	 */
-	public function __construct($arguments) {
-		parent::__construct($arguments);
-		$this->rootPath = $arguments['root'];
-	}
-
-	public function getUnjailedPath($path) {
-		return trim(Filesystem::normalizePath($this->rootPath . '/' . $path), '/');
-	}
-
-	/**
-	 * This is separate from Wrapper::getWrapperStorage so we can get the jailed storage consistently even if the jail is inside another wrapper
-	 */
-	public function getUnjailedStorage() {
-		return $this->storage;
-	}
-
-
-	public function getJailedPath($path) {
-		$root = rtrim($this->rootPath, '/') . '/';
-
-		if ($path !== $this->rootPath && strpos($path, $root) !== 0) {
-			return null;
-		} else {
-			$path = substr($path, strlen($this->rootPath));
-			return trim($path, '/');
-		}
-	}
-
-	public function getId() {
-		return parent::getId();
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.mkdir.php
-	 *
-	 * @param string $path
-	 * @return bool
-	 */
-	public function mkdir($path) {
-		return $this->getWrapperStorage()->mkdir($this->getUnjailedPath($path));
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.rmdir.php
-	 *
-	 * @param string $path
-	 * @return bool
-	 */
-	public function rmdir($path) {
-		return $this->getWrapperStorage()->rmdir($this->getUnjailedPath($path));
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.opendir.php
-	 *
-	 * @param string $path
-	 * @return resource|bool
-	 */
-	public function opendir($path) {
-		return $this->getWrapperStorage()->opendir($this->getUnjailedPath($path));
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.is_dir.php
-	 *
-	 * @param string $path
-	 * @return bool
-	 */
-	public function is_dir($path) {
-		return $this->getWrapperStorage()->is_dir($this->getUnjailedPath($path));
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.is_file.php
-	 *
-	 * @param string $path
-	 * @return bool
-	 */
-	public function is_file($path) {
-		return $this->getWrapperStorage()->is_file($this->getUnjailedPath($path));
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.stat.php
-	 * only the following keys are required in the result: size and mtime
-	 *
-	 * @param string $path
-	 * @return array|bool
-	 */
-	public function stat($path) {
-		return $this->getWrapperStorage()->stat($this->getUnjailedPath($path));
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.filetype.php
-	 *
-	 * @param string $path
-	 * @return bool
-	 */
-	public function filetype($path) {
-		return $this->getWrapperStorage()->filetype($this->getUnjailedPath($path));
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.filesize.php
-	 * The result for filesize when called on a folder is required to be 0
-	 *
-	 * @param string $path
-	 * @return int|bool
-	 */
-	public function filesize($path) {
-		return $this->getWrapperStorage()->filesize($this->getUnjailedPath($path));
-	}
-
-	/**
-	 * check if a file can be created in $path
-	 *
-	 * @param string $path
-	 * @return bool
-	 */
-	public function isCreatable($path) {
-		return $this->getWrapperStorage()->isCreatable($this->getUnjailedPath($path));
-	}
-
-	/**
-	 * check if a file can be read
-	 *
-	 * @param string $path
-	 * @return bool
-	 */
-	public function isReadable($path) {
-		return $this->getWrapperStorage()->isReadable($this->getUnjailedPath($path));
-	}
-
-	/**
-	 * check if a file can be written to
-	 *
-	 * @param string $path
-	 * @return bool
-	 */
-	public function isUpdatable($path) {
-		return $this->getWrapperStorage()->isUpdatable($this->getUnjailedPath($path));
-	}
-
-	/**
-	 * check if a file can be deleted
-	 *
-	 * @param string $path
-	 * @return bool
-	 */
-	public function isDeletable($path) {
-		return $this->getWrapperStorage()->isDeletable($this->getUnjailedPath($path));
-	}
-
-	/**
-	 * check if a file can be shared
-	 *
-	 * @param string $path
-	 * @return bool
-	 */
-	public function isSharable($path) {
-		return $this->getWrapperStorage()->isSharable($this->getUnjailedPath($path));
-	}
-
-	/**
-	 * get the full permissions of a path.
-	 * Should return a combination of the PERMISSION_ constants defined in lib/public/constants.php
-	 *
-	 * @param string $path
-	 * @return int
-	 */
-	public function getPermissions($path) {
-		return $this->getWrapperStorage()->getPermissions($this->getUnjailedPath($path));
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.file_exists.php
-	 *
-	 * @param string $path
-	 * @return bool
-	 */
-	public function file_exists($path) {
-		return $this->getWrapperStorage()->file_exists($this->getUnjailedPath($path));
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.filemtime.php
-	 *
-	 * @param string $path
-	 * @return int|bool
-	 */
-	public function filemtime($path) {
-		return $this->getWrapperStorage()->filemtime($this->getUnjailedPath($path));
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.file_get_contents.php
-	 *
-	 * @param string $path
-	 * @return string|bool
-	 */
-	public function file_get_contents($path) {
-		return $this->getWrapperStorage()->file_get_contents($this->getUnjailedPath($path));
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.file_put_contents.php
-	 *
-	 * @param string $path
-	 * @param mixed $data
-	 * @return int|false
-	 */
-	public function file_put_contents($path, $data) {
-		return $this->getWrapperStorage()->file_put_contents($this->getUnjailedPath($path), $data);
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.unlink.php
-	 *
-	 * @param string $path
-	 * @return bool
-	 */
-	public function unlink($path) {
-		return $this->getWrapperStorage()->unlink($this->getUnjailedPath($path));
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.rename.php
-	 *
-	 * @param string $path1
-	 * @param string $path2
-	 * @return bool
-	 */
-	public function rename($path1, $path2) {
-		return $this->getWrapperStorage()->rename($this->getUnjailedPath($path1), $this->getUnjailedPath($path2));
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.copy.php
-	 *
-	 * @param string $path1
-	 * @param string $path2
-	 * @return bool
-	 */
-	public function copy($path1, $path2) {
-		return $this->getWrapperStorage()->copy($this->getUnjailedPath($path1), $this->getUnjailedPath($path2));
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.fopen.php
-	 *
-	 * @param string $path
-	 * @param string $mode
-	 * @return resource|bool
-	 */
-	public function fopen($path, $mode) {
-		return $this->getWrapperStorage()->fopen($this->getUnjailedPath($path), $mode);
-	}
-
-	/**
-	 * get the mimetype for a file or folder
-	 * The mimetype for a folder is required to be "httpd/unix-directory"
-	 *
-	 * @param string $path
-	 * @return string|bool
-	 */
-	public function getMimeType($path) {
-		return $this->getWrapperStorage()->getMimeType($this->getUnjailedPath($path));
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.hash.php
-	 *
-	 * @param string $type
-	 * @param string $path
-	 * @param bool $raw
-	 * @return string|bool
-	 */
-	public function hash($type, $path, $raw = false) {
-		return $this->getWrapperStorage()->hash($type, $this->getUnjailedPath($path), $raw);
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.free_space.php
-	 *
-	 * @param string $path
-	 * @return int|bool
-	 */
-	public function free_space($path) {
-		return $this->getWrapperStorage()->free_space($this->getUnjailedPath($path));
-	}
-
-	/**
-	 * search for occurrences of $query in file names
-	 *
-	 * @param string $query
-	 * @return array|bool
-	 */
-	public function search($query) {
-		return $this->getWrapperStorage()->search($query);
-	}
-
-	/**
-	 * see https://www.php.net/manual/en/function.touch.php
-	 * If the backend does not support the operation, false should be returned
-	 *
-	 * @param string $path
-	 * @param int $mtime
-	 * @return bool
-	 */
-	public function touch($path, $mtime = null) {
-		return $this->getWrapperStorage()->touch($this->getUnjailedPath($path), $mtime);
-	}
-
-	/**
-	 * get the path to a local version of the file.
-	 * The local version of the file can be temporary and doesn't have to be persistent across requests
-	 *
-	 * @param string $path
-	 * @return string|bool
-	 */
-	public function getLocalFile($path) {
-		return $this->getWrapperStorage()->getLocalFile($this->getUnjailedPath($path));
-	}
-
-	/**
-	 * check if a file or folder has been updated since $time
-	 *
-	 * @param string $path
-	 * @param int $time
-	 * @return bool
-	 *
-	 * hasUpdated for folders should return at least true if a file inside the folder is add, removed or renamed.
-	 * returning true for other changes in the folder is optional
-	 */
-	public function hasUpdated($path, $time) {
-		return $this->getWrapperStorage()->hasUpdated($this->getUnjailedPath($path), $time);
-	}
-
-	/**
-	 * get a cache instance for the storage
-	 *
-	 * @param string $path
-	 * @param \OC\Files\Storage\Storage (optional) the storage to pass to the cache
-	 * @return \OC\Files\Cache\Cache
-	 */
-	public function getCache($path = '', $storage = null) {
-		if (!$storage) {
-			$storage = $this->getWrapperStorage();
-		}
-		$sourceCache = $this->getWrapperStorage()->getCache($this->getUnjailedPath($path), $storage);
-		return new CacheJail($sourceCache, $this->rootPath);
-	}
-
-	/**
-	 * get the user id of the owner of a file or folder
-	 *
-	 * @param string $path
-	 * @return string
-	 */
-	public function getOwner($path) {
-		return $this->getWrapperStorage()->getOwner($this->getUnjailedPath($path));
-	}
-
-	/**
-	 * get a watcher instance for the cache
-	 *
-	 * @param string $path
-	 * @param \OC\Files\Storage\Storage (optional) the storage to pass to the watcher
-	 * @return \OC\Files\Cache\Watcher
-	 */
-	public function getWatcher($path = '', $storage = null) {
-		if (!$storage) {
-			$storage = $this;
-		}
-		return $this->getWrapperStorage()->getWatcher($this->getUnjailedPath($path), $storage);
-	}
-
-	/**
-	 * get the ETag for a file or folder
-	 *
-	 * @param string $path
-	 * @return string|bool
-	 */
-	public function getETag($path) {
-		return $this->getWrapperStorage()->getETag($this->getUnjailedPath($path));
-	}
-
-	/**
-	 * @param string $path
-	 * @return array
-	 */
-	public function getMetaData($path) {
-		return $this->getWrapperStorage()->getMetaData($this->getUnjailedPath($path));
-	}
-
-	/**
-	 * @param string $path
-	 * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
-	 * @param \OCP\Lock\ILockingProvider $provider
-	 * @throws \OCP\Lock\LockedException
-	 */
-	public function acquireLock($path, $type, ILockingProvider $provider) {
-		$this->getWrapperStorage()->acquireLock($this->getUnjailedPath($path), $type, $provider);
-	}
-
-	/**
-	 * @param string $path
-	 * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
-	 * @param \OCP\Lock\ILockingProvider $provider
-	 */
-	public function releaseLock($path, $type, ILockingProvider $provider) {
-		$this->getWrapperStorage()->releaseLock($this->getUnjailedPath($path), $type, $provider);
-	}
-
-	/**
-	 * @param string $path
-	 * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
-	 * @param \OCP\Lock\ILockingProvider $provider
-	 */
-	public function changeLock($path, $type, ILockingProvider $provider) {
-		$this->getWrapperStorage()->changeLock($this->getUnjailedPath($path), $type, $provider);
-	}
-
-	/**
-	 * Resolve the path for the source of the share
-	 *
-	 * @param string $path
-	 * @return array
-	 */
-	public function resolvePath($path) {
-		return [$this->getWrapperStorage(), $this->getUnjailedPath($path)];
-	}
-
-	/**
-	 * @param IStorage $sourceStorage
-	 * @param string $sourceInternalPath
-	 * @param string $targetInternalPath
-	 * @return bool
-	 */
-	public function copyFromStorage(IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath) {
-		if ($sourceStorage === $this) {
-			return $this->copy($sourceInternalPath, $targetInternalPath);
-		}
-		return $this->getWrapperStorage()->copyFromStorage($sourceStorage, $sourceInternalPath, $this->getUnjailedPath($targetInternalPath));
-	}
-
-	/**
-	 * @param IStorage $sourceStorage
-	 * @param string $sourceInternalPath
-	 * @param string $targetInternalPath
-	 * @return bool
-	 */
-	public function moveFromStorage(IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath) {
-		if ($sourceStorage === $this) {
-			return $this->rename($sourceInternalPath, $targetInternalPath);
-		}
-		return $this->getWrapperStorage()->moveFromStorage($sourceStorage, $sourceInternalPath, $this->getUnjailedPath($targetInternalPath));
-	}
-
-	public function getPropagator($storage = null) {
-		if (isset($this->propagator)) {
-			return $this->propagator;
-		}
-
-		if (!$storage) {
-			$storage = $this;
-		}
-		$this->propagator = new JailPropagator($storage, \OC::$server->getDatabaseConnection());
-		return $this->propagator;
-	}
-
-	public function writeStream(string $path, $stream, int $size = null): int {
-		$storage = $this->getWrapperStorage();
-		if ($storage->instanceOfStorage(IWriteStreamStorage::class)) {
-			/** @var IWriteStreamStorage $storage */
-			return $storage->writeStream($this->getUnjailedPath($path), $stream, $size);
-		} else {
-			$target = $this->fopen($path, 'w');
-			list($count, $result) = \OC_Helper::streamCopy($stream, $target);
-			fclose($stream);
-			fclose($target);
-			return $count;
-		}
-	}
-
-	public function getDirectoryContent($directory): \Traversable {
-		return $this->getWrapperStorage()->getDirectoryContent($this->getUnjailedPath($directory));
-	}
+    /**
+     * @var string
+     */
+    protected $rootPath;
+
+    /**
+     * @param array $arguments ['storage' => $storage, 'mask' => $root]
+     *
+     * $storage: The storage that will be wrapper
+     * $root: The folder in the wrapped storage that will become the root folder of the wrapped storage
+     */
+    public function __construct($arguments) {
+        parent::__construct($arguments);
+        $this->rootPath = $arguments['root'];
+    }
+
+    public function getUnjailedPath($path) {
+        return trim(Filesystem::normalizePath($this->rootPath . '/' . $path), '/');
+    }
+
+    /**
+     * This is separate from Wrapper::getWrapperStorage so we can get the jailed storage consistently even if the jail is inside another wrapper
+     */
+    public function getUnjailedStorage() {
+        return $this->storage;
+    }
+
+
+    public function getJailedPath($path) {
+        $root = rtrim($this->rootPath, '/') . '/';
+
+        if ($path !== $this->rootPath && strpos($path, $root) !== 0) {
+            return null;
+        } else {
+            $path = substr($path, strlen($this->rootPath));
+            return trim($path, '/');
+        }
+    }
+
+    public function getId() {
+        return parent::getId();
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.mkdir.php
+     *
+     * @param string $path
+     * @return bool
+     */
+    public function mkdir($path) {
+        return $this->getWrapperStorage()->mkdir($this->getUnjailedPath($path));
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.rmdir.php
+     *
+     * @param string $path
+     * @return bool
+     */
+    public function rmdir($path) {
+        return $this->getWrapperStorage()->rmdir($this->getUnjailedPath($path));
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.opendir.php
+     *
+     * @param string $path
+     * @return resource|bool
+     */
+    public function opendir($path) {
+        return $this->getWrapperStorage()->opendir($this->getUnjailedPath($path));
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.is_dir.php
+     *
+     * @param string $path
+     * @return bool
+     */
+    public function is_dir($path) {
+        return $this->getWrapperStorage()->is_dir($this->getUnjailedPath($path));
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.is_file.php
+     *
+     * @param string $path
+     * @return bool
+     */
+    public function is_file($path) {
+        return $this->getWrapperStorage()->is_file($this->getUnjailedPath($path));
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.stat.php
+     * only the following keys are required in the result: size and mtime
+     *
+     * @param string $path
+     * @return array|bool
+     */
+    public function stat($path) {
+        return $this->getWrapperStorage()->stat($this->getUnjailedPath($path));
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.filetype.php
+     *
+     * @param string $path
+     * @return bool
+     */
+    public function filetype($path) {
+        return $this->getWrapperStorage()->filetype($this->getUnjailedPath($path));
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.filesize.php
+     * The result for filesize when called on a folder is required to be 0
+     *
+     * @param string $path
+     * @return int|bool
+     */
+    public function filesize($path) {
+        return $this->getWrapperStorage()->filesize($this->getUnjailedPath($path));
+    }
+
+    /**
+     * check if a file can be created in $path
+     *
+     * @param string $path
+     * @return bool
+     */
+    public function isCreatable($path) {
+        return $this->getWrapperStorage()->isCreatable($this->getUnjailedPath($path));
+    }
+
+    /**
+     * check if a file can be read
+     *
+     * @param string $path
+     * @return bool
+     */
+    public function isReadable($path) {
+        return $this->getWrapperStorage()->isReadable($this->getUnjailedPath($path));
+    }
+
+    /**
+     * check if a file can be written to
+     *
+     * @param string $path
+     * @return bool
+     */
+    public function isUpdatable($path) {
+        return $this->getWrapperStorage()->isUpdatable($this->getUnjailedPath($path));
+    }
+
+    /**
+     * check if a file can be deleted
+     *
+     * @param string $path
+     * @return bool
+     */
+    public function isDeletable($path) {
+        return $this->getWrapperStorage()->isDeletable($this->getUnjailedPath($path));
+    }
+
+    /**
+     * check if a file can be shared
+     *
+     * @param string $path
+     * @return bool
+     */
+    public function isSharable($path) {
+        return $this->getWrapperStorage()->isSharable($this->getUnjailedPath($path));
+    }
+
+    /**
+     * get the full permissions of a path.
+     * Should return a combination of the PERMISSION_ constants defined in lib/public/constants.php
+     *
+     * @param string $path
+     * @return int
+     */
+    public function getPermissions($path) {
+        return $this->getWrapperStorage()->getPermissions($this->getUnjailedPath($path));
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.file_exists.php
+     *
+     * @param string $path
+     * @return bool
+     */
+    public function file_exists($path) {
+        return $this->getWrapperStorage()->file_exists($this->getUnjailedPath($path));
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.filemtime.php
+     *
+     * @param string $path
+     * @return int|bool
+     */
+    public function filemtime($path) {
+        return $this->getWrapperStorage()->filemtime($this->getUnjailedPath($path));
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.file_get_contents.php
+     *
+     * @param string $path
+     * @return string|bool
+     */
+    public function file_get_contents($path) {
+        return $this->getWrapperStorage()->file_get_contents($this->getUnjailedPath($path));
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.file_put_contents.php
+     *
+     * @param string $path
+     * @param mixed $data
+     * @return int|false
+     */
+    public function file_put_contents($path, $data) {
+        return $this->getWrapperStorage()->file_put_contents($this->getUnjailedPath($path), $data);
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.unlink.php
+     *
+     * @param string $path
+     * @return bool
+     */
+    public function unlink($path) {
+        return $this->getWrapperStorage()->unlink($this->getUnjailedPath($path));
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.rename.php
+     *
+     * @param string $path1
+     * @param string $path2
+     * @return bool
+     */
+    public function rename($path1, $path2) {
+        return $this->getWrapperStorage()->rename($this->getUnjailedPath($path1), $this->getUnjailedPath($path2));
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.copy.php
+     *
+     * @param string $path1
+     * @param string $path2
+     * @return bool
+     */
+    public function copy($path1, $path2) {
+        return $this->getWrapperStorage()->copy($this->getUnjailedPath($path1), $this->getUnjailedPath($path2));
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.fopen.php
+     *
+     * @param string $path
+     * @param string $mode
+     * @return resource|bool
+     */
+    public function fopen($path, $mode) {
+        return $this->getWrapperStorage()->fopen($this->getUnjailedPath($path), $mode);
+    }
+
+    /**
+     * get the mimetype for a file or folder
+     * The mimetype for a folder is required to be "httpd/unix-directory"
+     *
+     * @param string $path
+     * @return string|bool
+     */
+    public function getMimeType($path) {
+        return $this->getWrapperStorage()->getMimeType($this->getUnjailedPath($path));
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.hash.php
+     *
+     * @param string $type
+     * @param string $path
+     * @param bool $raw
+     * @return string|bool
+     */
+    public function hash($type, $path, $raw = false) {
+        return $this->getWrapperStorage()->hash($type, $this->getUnjailedPath($path), $raw);
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.free_space.php
+     *
+     * @param string $path
+     * @return int|bool
+     */
+    public function free_space($path) {
+        return $this->getWrapperStorage()->free_space($this->getUnjailedPath($path));
+    }
+
+    /**
+     * search for occurrences of $query in file names
+     *
+     * @param string $query
+     * @return array|bool
+     */
+    public function search($query) {
+        return $this->getWrapperStorage()->search($query);
+    }
+
+    /**
+     * see https://www.php.net/manual/en/function.touch.php
+     * If the backend does not support the operation, false should be returned
+     *
+     * @param string $path
+     * @param int $mtime
+     * @return bool
+     */
+    public function touch($path, $mtime = null) {
+        return $this->getWrapperStorage()->touch($this->getUnjailedPath($path), $mtime);
+    }
+
+    /**
+     * get the path to a local version of the file.
+     * The local version of the file can be temporary and doesn't have to be persistent across requests
+     *
+     * @param string $path
+     * @return string|bool
+     */
+    public function getLocalFile($path) {
+        return $this->getWrapperStorage()->getLocalFile($this->getUnjailedPath($path));
+    }
+
+    /**
+     * check if a file or folder has been updated since $time
+     *
+     * @param string $path
+     * @param int $time
+     * @return bool
+     *
+     * hasUpdated for folders should return at least true if a file inside the folder is add, removed or renamed.
+     * returning true for other changes in the folder is optional
+     */
+    public function hasUpdated($path, $time) {
+        return $this->getWrapperStorage()->hasUpdated($this->getUnjailedPath($path), $time);
+    }
+
+    /**
+     * get a cache instance for the storage
+     *
+     * @param string $path
+     * @param \OC\Files\Storage\Storage (optional) the storage to pass to the cache
+     * @return \OC\Files\Cache\Cache
+     */
+    public function getCache($path = '', $storage = null) {
+        if (!$storage) {
+            $storage = $this->getWrapperStorage();
+        }
+        $sourceCache = $this->getWrapperStorage()->getCache($this->getUnjailedPath($path), $storage);
+        return new CacheJail($sourceCache, $this->rootPath);
+    }
+
+    /**
+     * get the user id of the owner of a file or folder
+     *
+     * @param string $path
+     * @return string
+     */
+    public function getOwner($path) {
+        return $this->getWrapperStorage()->getOwner($this->getUnjailedPath($path));
+    }
+
+    /**
+     * get a watcher instance for the cache
+     *
+     * @param string $path
+     * @param \OC\Files\Storage\Storage (optional) the storage to pass to the watcher
+     * @return \OC\Files\Cache\Watcher
+     */
+    public function getWatcher($path = '', $storage = null) {
+        if (!$storage) {
+            $storage = $this;
+        }
+        return $this->getWrapperStorage()->getWatcher($this->getUnjailedPath($path), $storage);
+    }
+
+    /**
+     * get the ETag for a file or folder
+     *
+     * @param string $path
+     * @return string|bool
+     */
+    public function getETag($path) {
+        return $this->getWrapperStorage()->getETag($this->getUnjailedPath($path));
+    }
+
+    /**
+     * @param string $path
+     * @return array
+     */
+    public function getMetaData($path) {
+        return $this->getWrapperStorage()->getMetaData($this->getUnjailedPath($path));
+    }
+
+    /**
+     * @param string $path
+     * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
+     * @param \OCP\Lock\ILockingProvider $provider
+     * @throws \OCP\Lock\LockedException
+     */
+    public function acquireLock($path, $type, ILockingProvider $provider) {
+        $this->getWrapperStorage()->acquireLock($this->getUnjailedPath($path), $type, $provider);
+    }
+
+    /**
+     * @param string $path
+     * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
+     * @param \OCP\Lock\ILockingProvider $provider
+     */
+    public function releaseLock($path, $type, ILockingProvider $provider) {
+        $this->getWrapperStorage()->releaseLock($this->getUnjailedPath($path), $type, $provider);
+    }
+
+    /**
+     * @param string $path
+     * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
+     * @param \OCP\Lock\ILockingProvider $provider
+     */
+    public function changeLock($path, $type, ILockingProvider $provider) {
+        $this->getWrapperStorage()->changeLock($this->getUnjailedPath($path), $type, $provider);
+    }
+
+    /**
+     * Resolve the path for the source of the share
+     *
+     * @param string $path
+     * @return array
+     */
+    public function resolvePath($path) {
+        return [$this->getWrapperStorage(), $this->getUnjailedPath($path)];
+    }
+
+    /**
+     * @param IStorage $sourceStorage
+     * @param string $sourceInternalPath
+     * @param string $targetInternalPath
+     * @return bool
+     */
+    public function copyFromStorage(IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath) {
+        if ($sourceStorage === $this) {
+            return $this->copy($sourceInternalPath, $targetInternalPath);
+        }
+        return $this->getWrapperStorage()->copyFromStorage($sourceStorage, $sourceInternalPath, $this->getUnjailedPath($targetInternalPath));
+    }
+
+    /**
+     * @param IStorage $sourceStorage
+     * @param string $sourceInternalPath
+     * @param string $targetInternalPath
+     * @return bool
+     */
+    public function moveFromStorage(IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath) {
+        if ($sourceStorage === $this) {
+            return $this->rename($sourceInternalPath, $targetInternalPath);
+        }
+        return $this->getWrapperStorage()->moveFromStorage($sourceStorage, $sourceInternalPath, $this->getUnjailedPath($targetInternalPath));
+    }
+
+    public function getPropagator($storage = null) {
+        if (isset($this->propagator)) {
+            return $this->propagator;
+        }
+
+        if (!$storage) {
+            $storage = $this;
+        }
+        $this->propagator = new JailPropagator($storage, \OC::$server->getDatabaseConnection());
+        return $this->propagator;
+    }
+
+    public function writeStream(string $path, $stream, int $size = null): int {
+        $storage = $this->getWrapperStorage();
+        if ($storage->instanceOfStorage(IWriteStreamStorage::class)) {
+            /** @var IWriteStreamStorage $storage */
+            return $storage->writeStream($this->getUnjailedPath($path), $stream, $size);
+        } else {
+            $target = $this->fopen($path, 'w');
+            list($count, $result) = \OC_Helper::streamCopy($stream, $target);
+            fclose($stream);
+            fclose($target);
+            return $count;
+        }
+    }
+
+    public function getDirectoryContent($directory): \Traversable {
+        return $this->getWrapperStorage()->getDirectoryContent($this->getUnjailedPath($directory));
+    }
 }

lib/private/Files/Stream/Quota.php

Indentation +59 added lines, -59 removed lines

@@ -34,70 +34,70 @@
  * usage: resource \OC\Files\Stream\Quota::wrap($stream, $limit)
  */
 class Quota extends Wrapper {
-	/**
-	 * @var int $limit
-	 */
-	private $limit;
+    /**
+     * @var int $limit
+     */
+    private $limit;
 
-	/**
-	 * @param resource $stream
-	 * @param int $limit
-	 * @return bool|resource
-	 */
-	public static function wrap($stream, $limit) {
-		$context = stream_context_create([
-			'quota' => [
-				'source' => $stream,
-				'limit' => $limit
-			]
-		]);
-		return Wrapper::wrapSource($stream, $context, 'quota', self::class);
-	}
+    /**
+     * @param resource $stream
+     * @param int $limit
+     * @return bool|resource
+     */
+    public static function wrap($stream, $limit) {
+        $context = stream_context_create([
+            'quota' => [
+                'source' => $stream,
+                'limit' => $limit
+            ]
+        ]);
+        return Wrapper::wrapSource($stream, $context, 'quota', self::class);
+    }
 
-	public function stream_open($path, $mode, $options, &$opened_path) {
-		$context = $this->loadContext('quota');
-		$this->source = $context['source'];
-		$this->limit = $context['limit'];
+    public function stream_open($path, $mode, $options, &$opened_path) {
+        $context = $this->loadContext('quota');
+        $this->source = $context['source'];
+        $this->limit = $context['limit'];
 
-		return true;
-	}
+        return true;
+    }
 
-	public function dir_opendir($path, $options) {
-		return false;
-	}
+    public function dir_opendir($path, $options) {
+        return false;
+    }
 
-	public function stream_seek($offset, $whence = SEEK_SET) {
-		if ($whence === SEEK_END) {
-			// go to the end to find out last position's offset
-			$oldOffset = $this->stream_tell();
-			if (fseek($this->source, 0, $whence) !== 0) {
-				return false;
-			}
-			$whence = SEEK_SET;
-			$offset = $this->stream_tell() + $offset;
-			$this->limit += $oldOffset - $offset;
-		} elseif ($whence === SEEK_SET) {
-			$this->limit += $this->stream_tell() - $offset;
-		} else {
-			$this->limit -= $offset;
-		}
-		// this wrapper needs to return "true" for success.
-		// the fseek call itself returns 0 on succeess
-		return fseek($this->source, $offset, $whence) === 0;
-	}
+    public function stream_seek($offset, $whence = SEEK_SET) {
+        if ($whence === SEEK_END) {
+            // go to the end to find out last position's offset
+            $oldOffset = $this->stream_tell();
+            if (fseek($this->source, 0, $whence) !== 0) {
+                return false;
+            }
+            $whence = SEEK_SET;
+            $offset = $this->stream_tell() + $offset;
+            $this->limit += $oldOffset - $offset;
+        } elseif ($whence === SEEK_SET) {
+            $this->limit += $this->stream_tell() - $offset;
+        } else {
+            $this->limit -= $offset;
+        }
+        // this wrapper needs to return "true" for success.
+        // the fseek call itself returns 0 on succeess
+        return fseek($this->source, $offset, $whence) === 0;
+    }
 
-	public function stream_read($count) {
-		$this->limit -= $count;
-		return fread($this->source, $count);
-	}
+    public function stream_read($count) {
+        $this->limit -= $count;
+        return fread($this->source, $count);
+    }
 
-	public function stream_write($data) {
-		$size = strlen($data);
-		if ($size > $this->limit) {
-			$data = substr($data, 0, $this->limit);
-			$size = $this->limit;
-		}
-		$this->limit -= $size;
-		return fwrite($this->source, $data);
-	}
+    public function stream_write($data) {
+        $size = strlen($data);
+        if ($size > $this->limit) {
+            $data = substr($data, 0, $this->limit);
+            $size = $this->limit;
+        }
+        $this->limit -= $size;
+        return fwrite($this->source, $data);
+    }
 }