nextcloud / server

lib/private/Files/View.php

Indentation +2080 added lines, -2080 removed lines

@@ -81,2084 +81,2084 @@
  * \OC\Files\Storage\Storage object
  */
 class View {
-	/** @var string */
-	private $fakeRoot = '';
-
-	/**
-	 * @var \OCP\Lock\ILockingProvider
-	 */
-	protected $lockingProvider;
-
-	private $lockingEnabled;
-
-	private $updaterEnabled = true;
-
-	/** @var \OC\User\Manager */
-	private $userManager;
-
-	/** @var \OCP\ILogger */
-	private $logger;
-
-	/**
-	 * @param string $root
-	 * @throws \Exception If $root contains an invalid path
-	 */
-	public function __construct($root = '') {
-		if (is_null($root)) {
-			throw new \InvalidArgumentException('Root can\'t be null');
-		}
-		if (!Filesystem::isValidPath($root)) {
-			throw new \Exception();
-		}
-
-		$this->fakeRoot = $root;
-		$this->lockingProvider = \OC::$server->getLockingProvider();
-		$this->lockingEnabled = !($this->lockingProvider instanceof \OC\Lock\NoopLockingProvider);
-		$this->userManager = \OC::$server->getUserManager();
-		$this->logger = \OC::$server->getLogger();
-	}
-
-	public function getAbsolutePath($path = '/') {
-		if ($path === null) {
-			return null;
-		}
-		$this->assertPathLength($path);
-		if ($path === '') {
-			$path = '/';
-		}
-		if ($path[0] !== '/') {
-			$path = '/' . $path;
-		}
-		return $this->fakeRoot . $path;
-	}
-
-	/**
-	 * change the root to a fake root
-	 *
-	 * @param string $fakeRoot
-	 * @return boolean|null
-	 */
-	public function chroot($fakeRoot) {
-		if (!$fakeRoot == '') {
-			if ($fakeRoot[0] !== '/') {
-				$fakeRoot = '/' . $fakeRoot;
-			}
-		}
-		$this->fakeRoot = $fakeRoot;
-	}
-
-	/**
-	 * get the fake root
-	 *
-	 * @return string
-	 */
-	public function getRoot() {
-		return $this->fakeRoot;
-	}
-
-	/**
-	 * get path relative to the root of the view
-	 *
-	 * @param string $path
-	 * @return string
-	 */
-	public function getRelativePath($path) {
-		$this->assertPathLength($path);
-		if ($this->fakeRoot == '') {
-			return $path;
-		}
-
-		if (rtrim($path, '/') === rtrim($this->fakeRoot, '/')) {
-			return '/';
-		}
-
-		// missing slashes can cause wrong matches!
-		$root = rtrim($this->fakeRoot, '/') . '/';
-
-		if (strpos($path, $root) !== 0) {
-			return null;
-		} else {
-			$path = substr($path, strlen($this->fakeRoot));
-			if (strlen($path) === 0) {
-				return '/';
-			} else {
-				return $path;
-			}
-		}
-	}
-
-	/**
-	 * get the mountpoint of the storage object for a path
-	 * ( note: because a storage is not always mounted inside the fakeroot, the
-	 * returned mountpoint is relative to the absolute root of the filesystem
-	 * and does not take the chroot into account )
-	 *
-	 * @param string $path
-	 * @return string
-	 */
-	public function getMountPoint($path) {
-		return Filesystem::getMountPoint($this->getAbsolutePath($path));
-	}
-
-	/**
-	 * get the mountpoint of the storage object for a path
-	 * ( note: because a storage is not always mounted inside the fakeroot, the
-	 * returned mountpoint is relative to the absolute root of the filesystem
-	 * and does not take the chroot into account )
-	 *
-	 * @param string $path
-	 * @return \OCP\Files\Mount\IMountPoint
-	 */
-	public function getMount($path) {
-		return Filesystem::getMountManager()->find($this->getAbsolutePath($path));
-	}
-
-	/**
-	 * resolve a path to a storage and internal path
-	 *
-	 * @param string $path
-	 * @return array an array consisting of the storage and the internal path
-	 */
-	public function resolvePath($path) {
-		$a = $this->getAbsolutePath($path);
-		$p = Filesystem::normalizePath($a);
-		return Filesystem::resolvePath($p);
-	}
-
-	/**
-	 * return the path to a local version of the file
-	 * we need this because we can't know if a file is stored local or not from
-	 * outside the filestorage and for some purposes a local file is needed
-	 *
-	 * @param string $path
-	 * @return string
-	 */
-	public function getLocalFile($path) {
-		$parent = substr($path, 0, strrpos($path, '/'));
-		$path = $this->getAbsolutePath($path);
-		list($storage, $internalPath) = Filesystem::resolvePath($path);
-		if (Filesystem::isValidPath($parent) and $storage) {
-			return $storage->getLocalFile($internalPath);
-		} else {
-			return null;
-		}
-	}
-
-	/**
-	 * @param string $path
-	 * @return string
-	 */
-	public function getLocalFolder($path) {
-		$parent = substr($path, 0, strrpos($path, '/'));
-		$path = $this->getAbsolutePath($path);
-		list($storage, $internalPath) = Filesystem::resolvePath($path);
-		if (Filesystem::isValidPath($parent) and $storage) {
-			return $storage->getLocalFolder($internalPath);
-		} else {
-			return null;
-		}
-	}
-
-	/**
-	 * the following functions operate with arguments and return values identical
-	 * to those of their PHP built-in equivalents. Mostly they are merely wrappers
-	 * for \OC\Files\Storage\Storage via basicOperation().
-	 */
-	public function mkdir($path) {
-		return $this->basicOperation('mkdir', $path, array('create', 'write'));
-	}
-
-	/**
-	 * remove mount point
-	 *
-	 * @param \OC\Files\Mount\MoveableMount $mount
-	 * @param string $path relative to data/
-	 * @return boolean
-	 */
-	protected function removeMount($mount, $path) {
-		if ($mount instanceof MoveableMount) {
-			// cut of /user/files to get the relative path to data/user/files
-			$pathParts = explode('/', $path, 4);
-			$relPath = '/' . $pathParts[3];
-			$this->lockFile($relPath, ILockingProvider::LOCK_SHARED, true);
-			\OC_Hook::emit(
-				Filesystem::CLASSNAME, "umount",
-				array(Filesystem::signal_param_path => $relPath)
-			);
-			$this->changeLock($relPath, ILockingProvider::LOCK_EXCLUSIVE, true);
-			$result = $mount->removeMount();
-			$this->changeLock($relPath, ILockingProvider::LOCK_SHARED, true);
-			if ($result) {
-				\OC_Hook::emit(
-					Filesystem::CLASSNAME, "post_umount",
-					array(Filesystem::signal_param_path => $relPath)
-				);
-			}
-			$this->unlockFile($relPath, ILockingProvider::LOCK_SHARED, true);
-			return $result;
-		} else {
-			// do not allow deleting the storage's root / the mount point
-			// because for some storages it might delete the whole contents
-			// but isn't supposed to work that way
-			return false;
-		}
-	}
-
-	public function disableCacheUpdate() {
-		$this->updaterEnabled = false;
-	}
-
-	public function enableCacheUpdate() {
-		$this->updaterEnabled = true;
-	}
-
-	protected function writeUpdate(Storage $storage, $internalPath, $time = null) {
-		if ($this->updaterEnabled) {
-			if (is_null($time)) {
-				$time = time();
-			}
-			$storage->getUpdater()->update($internalPath, $time);
-		}
-	}
-
-	protected function removeUpdate(Storage $storage, $internalPath) {
-		if ($this->updaterEnabled) {
-			$storage->getUpdater()->remove($internalPath);
-		}
-	}
-
-	protected function renameUpdate(Storage $sourceStorage, Storage $targetStorage, $sourceInternalPath, $targetInternalPath) {
-		if ($this->updaterEnabled) {
-			$targetStorage->getUpdater()->renameFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath);
-		}
-	}
-
-	/**
-	 * @param string $path
-	 * @return bool|mixed
-	 */
-	public function rmdir($path) {
-		$absolutePath = $this->getAbsolutePath($path);
-		$mount = Filesystem::getMountManager()->find($absolutePath);
-		if ($mount->getInternalPath($absolutePath) === '') {
-			return $this->removeMount($mount, $absolutePath);
-		}
-		if ($this->is_dir($path)) {
-			$result = $this->basicOperation('rmdir', $path, array('delete'));
-		} else {
-			$result = false;
-		}
-
-		if (!$result && !$this->file_exists($path)) { //clear ghost files from the cache on delete
-			$storage = $mount->getStorage();
-			$internalPath = $mount->getInternalPath($absolutePath);
-			$storage->getUpdater()->remove($internalPath);
-		}
-		return $result;
-	}
-
-	/**
-	 * @param string $path
-	 * @return resource
-	 */
-	public function opendir($path) {
-		return $this->basicOperation('opendir', $path, array('read'));
-	}
-
-	/**
-	 * @param string $path
-	 * @return bool|mixed
-	 */
-	public function is_dir($path) {
-		if ($path == '/') {
-			return true;
-		}
-		return $this->basicOperation('is_dir', $path);
-	}
-
-	/**
-	 * @param string $path
-	 * @return bool|mixed
-	 */
-	public function is_file($path) {
-		if ($path == '/') {
-			return false;
-		}
-		return $this->basicOperation('is_file', $path);
-	}
-
-	/**
-	 * @param string $path
-	 * @return mixed
-	 */
-	public function stat($path) {
-		return $this->basicOperation('stat', $path);
-	}
-
-	/**
-	 * @param string $path
-	 * @return mixed
-	 */
-	public function filetype($path) {
-		return $this->basicOperation('filetype', $path);
-	}
-
-	/**
-	 * @param string $path
-	 * @return mixed
-	 */
-	public function filesize($path) {
-		return $this->basicOperation('filesize', $path);
-	}
-
-	/**
-	 * @param string $path
-	 * @return bool|mixed
-	 * @throws \OCP\Files\InvalidPathException
-	 */
-	public function readfile($path) {
-		$this->assertPathLength($path);
-		@ob_end_clean();
-		$handle = $this->fopen($path, 'rb');
-		if ($handle) {
-			$chunkSize = 8192; // 8 kB chunks
-			while (!feof($handle)) {
-				echo fread($handle, $chunkSize);
-				flush();
-			}
-			fclose($handle);
-			return $this->filesize($path);
-		}
-		return false;
-	}
-
-	/**
-	 * @param string $path
-	 * @param int $from
-	 * @param int $to
-	 * @return bool|mixed
-	 * @throws \OCP\Files\InvalidPathException
-	 * @throws \OCP\Files\UnseekableException
-	 */
-	public function readfilePart($path, $from, $to) {
-		$this->assertPathLength($path);
-		@ob_end_clean();
-		$handle = $this->fopen($path, 'rb');
-		if ($handle) {
-			$chunkSize = 8192; // 8 kB chunks
-			$startReading = true;
-
-			if ($from !== 0 && $from !== '0' && fseek($handle, $from) !== 0) {
-				// forward file handle via chunked fread because fseek seem to have failed
-
-				$end = $from + 1;
-				while (!feof($handle) && ftell($handle) < $end) {
-					$len = $from - ftell($handle);
-					if ($len > $chunkSize) {
-						$len = $chunkSize;
-					}
-					$result = fread($handle, $len);
-
-					if ($result === false) {
-						$startReading = false;
-						break;
-					}
-				}
-			}
-
-			if ($startReading) {
-				$end = $to + 1;
-				while (!feof($handle) && ftell($handle) < $end) {
-					$len = $end - ftell($handle);
-					if ($len > $chunkSize) {
-						$len = $chunkSize;
-					}
-					echo fread($handle, $len);
-					flush();
-				}
-				return ftell($handle) - $from;
-			}
-
-			throw new \OCP\Files\UnseekableException('fseek error');
-		}
-		return false;
-	}
-
-	/**
-	 * @param string $path
-	 * @return mixed
-	 */
-	public function isCreatable($path) {
-		return $this->basicOperation('isCreatable', $path);
-	}
-
-	/**
-	 * @param string $path
-	 * @return mixed
-	 */
-	public function isReadable($path) {
-		return $this->basicOperation('isReadable', $path);
-	}
-
-	/**
-	 * @param string $path
-	 * @return mixed
-	 */
-	public function isUpdatable($path) {
-		return $this->basicOperation('isUpdatable', $path);
-	}
-
-	/**
-	 * @param string $path
-	 * @return bool|mixed
-	 */
-	public function isDeletable($path) {
-		$absolutePath = $this->getAbsolutePath($path);
-		$mount = Filesystem::getMountManager()->find($absolutePath);
-		if ($mount->getInternalPath($absolutePath) === '') {
-			return $mount instanceof MoveableMount;
-		}
-		return $this->basicOperation('isDeletable', $path);
-	}
-
-	/**
-	 * @param string $path
-	 * @return mixed
-	 */
-	public function isSharable($path) {
-		return $this->basicOperation('isSharable', $path);
-	}
-
-	/**
-	 * @param string $path
-	 * @return bool|mixed
-	 */
-	public function file_exists($path) {
-		if ($path == '/') {
-			return true;
-		}
-		return $this->basicOperation('file_exists', $path);
-	}
-
-	/**
-	 * @param string $path
-	 * @return mixed
-	 */
-	public function filemtime($path) {
-		return $this->basicOperation('filemtime', $path);
-	}
-
-	/**
-	 * @param string $path
-	 * @param int|string $mtime
-	 * @return bool
-	 */
-	public function touch($path, $mtime = null) {
-		if (!is_null($mtime) and !is_numeric($mtime)) {
-			$mtime = strtotime($mtime);
-		}
-
-		$hooks = array('touch');
-
-		if (!$this->file_exists($path)) {
-			$hooks[] = 'create';
-			$hooks[] = 'write';
-		}
-		$result = $this->basicOperation('touch', $path, $hooks, $mtime);
-		if (!$result) {
-			// If create file fails because of permissions on external storage like SMB folders,
-			// check file exists and return false if not.
-			if (!$this->file_exists($path)) {
-				return false;
-			}
-			if (is_null($mtime)) {
-				$mtime = time();
-			}
-			//if native touch fails, we emulate it by changing the mtime in the cache
-			$this->putFileInfo($path, array('mtime' => floor($mtime)));
-		}
-		return true;
-	}
-
-	/**
-	 * @param string $path
-	 * @return mixed
-	 */
-	public function file_get_contents($path) {
-		return $this->basicOperation('file_get_contents', $path, array('read'));
-	}
-
-	/**
-	 * @param bool $exists
-	 * @param string $path
-	 * @param bool $run
-	 */
-	protected function emit_file_hooks_pre($exists, $path, &$run) {
-		if (!$exists) {
-			\OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_create, array(
-				Filesystem::signal_param_path => $this->getHookPath($path),
-				Filesystem::signal_param_run => &$run,
-			));
-		} else {
-			\OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_update, array(
-				Filesystem::signal_param_path => $this->getHookPath($path),
-				Filesystem::signal_param_run => &$run,
-			));
-		}
-		\OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_write, array(
-			Filesystem::signal_param_path => $this->getHookPath($path),
-			Filesystem::signal_param_run => &$run,
-		));
-	}
-
-	/**
-	 * @param bool $exists
-	 * @param string $path
-	 */
-	protected function emit_file_hooks_post($exists, $path) {
-		if (!$exists) {
-			\OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_post_create, array(
-				Filesystem::signal_param_path => $this->getHookPath($path),
-			));
-		} else {
-			\OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_post_update, array(
-				Filesystem::signal_param_path => $this->getHookPath($path),
-			));
-		}
-		\OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_post_write, array(
-			Filesystem::signal_param_path => $this->getHookPath($path),
-		));
-	}
-
-	/**
-	 * @param string $path
-	 * @param mixed $data
-	 * @return bool|mixed
-	 * @throws \Exception
-	 */
-	public function file_put_contents($path, $data) {
-		if (is_resource($data)) { //not having to deal with streams in file_put_contents makes life easier
-			$absolutePath = Filesystem::normalizePath($this->getAbsolutePath($path));
-			if (Filesystem::isValidPath($path)
-				and !Filesystem::isFileBlacklisted($path)
-			) {
-				$path = $this->getRelativePath($absolutePath);
-
-				$this->lockFile($path, ILockingProvider::LOCK_SHARED);
-
-				$exists = $this->file_exists($path);
-				$run = true;
-				if ($this->shouldEmitHooks($path)) {
-					$this->emit_file_hooks_pre($exists, $path, $run);
-				}
-				if (!$run) {
-					$this->unlockFile($path, ILockingProvider::LOCK_SHARED);
-					return false;
-				}
-
-				$this->changeLock($path, ILockingProvider::LOCK_EXCLUSIVE);
-
-				/** @var \OC\Files\Storage\Storage $storage */
-				list($storage, $internalPath) = $this->resolvePath($path);
-				$target = $storage->fopen($internalPath, 'w');
-				if ($target) {
-					list (, $result) = \OC_Helper::streamCopy($data, $target);
-					fclose($target);
-					fclose($data);
-
-					$this->writeUpdate($storage, $internalPath);
-
-					$this->changeLock($path, ILockingProvider::LOCK_SHARED);
-
-					if ($this->shouldEmitHooks($path) && $result !== false) {
-						$this->emit_file_hooks_post($exists, $path);
-					}
-					$this->unlockFile($path, ILockingProvider::LOCK_SHARED);
-					return $result;
-				} else {
-					$this->unlockFile($path, ILockingProvider::LOCK_EXCLUSIVE);
-					return false;
-				}
-			} else {
-				return false;
-			}
-		} else {
-			$hooks = $this->file_exists($path) ? array('update', 'write') : array('create', 'write');
-			return $this->basicOperation('file_put_contents', $path, $hooks, $data);
-		}
-	}
-
-	/**
-	 * @param string $path
-	 * @return bool|mixed
-	 */
-	public function unlink($path) {
-		if ($path === '' || $path === '/') {
-			// do not allow deleting the root
-			return false;
-		}
-		$postFix = (substr($path, -1) === '/') ? '/' : '';
-		$absolutePath = Filesystem::normalizePath($this->getAbsolutePath($path));
-		$mount = Filesystem::getMountManager()->find($absolutePath . $postFix);
-		if ($mount and $mount->getInternalPath($absolutePath) === '') {
-			return $this->removeMount($mount, $absolutePath);
-		}
-		if ($this->is_dir($path)) {
-			$result = $this->basicOperation('rmdir', $path, ['delete']);
-		} else {
-			$result = $this->basicOperation('unlink', $path, ['delete']);
-		}
-		if (!$result && !$this->file_exists($path)) { //clear ghost files from the cache on delete
-			$storage = $mount->getStorage();
-			$internalPath = $mount->getInternalPath($absolutePath);
-			$storage->getUpdater()->remove($internalPath);
-			return true;
-		} else {
-			return $result;
-		}
-	}
-
-	/**
-	 * @param string $directory
-	 * @return bool|mixed
-	 */
-	public function deleteAll($directory) {
-		return $this->rmdir($directory);
-	}
-
-	/**
-	 * Rename/move a file or folder from the source path to target path.
-	 *
-	 * @param string $path1 source path
-	 * @param string $path2 target path
-	 *
-	 * @return bool|mixed
-	 */
-	public function rename($path1, $path2) {
-		$absolutePath1 = Filesystem::normalizePath($this->getAbsolutePath($path1));
-		$absolutePath2 = Filesystem::normalizePath($this->getAbsolutePath($path2));
-		$result = false;
-		if (
-			Filesystem::isValidPath($path2)
-			and Filesystem::isValidPath($path1)
-			and !Filesystem::isFileBlacklisted($path2)
-		) {
-			$path1 = $this->getRelativePath($absolutePath1);
-			$path2 = $this->getRelativePath($absolutePath2);
-			$exists = $this->file_exists($path2);
-
-			if ($path1 == null or $path2 == null) {
-				return false;
-			}
-
-			$this->lockFile($path1, ILockingProvider::LOCK_SHARED, true);
-			try {
-				$this->lockFile($path2, ILockingProvider::LOCK_SHARED, true);
-
-				$run = true;
-				if ($this->shouldEmitHooks($path1) && (Cache\Scanner::isPartialFile($path1) && !Cache\Scanner::isPartialFile($path2))) {
-					// if it was a rename from a part file to a regular file it was a write and not a rename operation
-					$this->emit_file_hooks_pre($exists, $path2, $run);
-				} elseif ($this->shouldEmitHooks($path1)) {
-					\OC_Hook::emit(
-						Filesystem::CLASSNAME, Filesystem::signal_rename,
-						array(
-							Filesystem::signal_param_oldpath => $this->getHookPath($path1),
-							Filesystem::signal_param_newpath => $this->getHookPath($path2),
-							Filesystem::signal_param_run => &$run
-						)
-					);
-				}
-				if ($run) {
-					$this->verifyPath(dirname($path2), basename($path2));
-
-					$manager = Filesystem::getMountManager();
-					$mount1 = $this->getMount($path1);
-					$mount2 = $this->getMount($path2);
-					$storage1 = $mount1->getStorage();
-					$storage2 = $mount2->getStorage();
-					$internalPath1 = $mount1->getInternalPath($absolutePath1);
-					$internalPath2 = $mount2->getInternalPath($absolutePath2);
-
-					$this->changeLock($path1, ILockingProvider::LOCK_EXCLUSIVE, true);
-					try {
-						$this->changeLock($path2, ILockingProvider::LOCK_EXCLUSIVE, true);
-
-						if ($internalPath1 === '') {
-							if ($mount1 instanceof MoveableMount) {
-								if ($this->isTargetAllowed($absolutePath2)) {
-									/**
-									 * @var \OC\Files\Mount\MountPoint | \OC\Files\Mount\MoveableMount $mount1
-									 */
-									$sourceMountPoint = $mount1->getMountPoint();
-									$result = $mount1->moveMount($absolutePath2);
-									$manager->moveMount($sourceMountPoint, $mount1->getMountPoint());
-								} else {
-									$result = false;
-								}
-							} else {
-								$result = false;
-							}
-							// moving a file/folder within the same mount point
-						} elseif ($storage1 === $storage2) {
-							if ($storage1) {
-								$result = $storage1->rename($internalPath1, $internalPath2);
-							} else {
-								$result = false;
-							}
-							// moving a file/folder between storages (from $storage1 to $storage2)
-						} else {
-							$result = $storage2->moveFromStorage($storage1, $internalPath1, $internalPath2);
-						}
-
-						if ((Cache\Scanner::isPartialFile($path1) && !Cache\Scanner::isPartialFile($path2)) && $result !== false) {
-							// if it was a rename from a part file to a regular file it was a write and not a rename operation
-							$this->writeUpdate($storage2, $internalPath2);
-						} else if ($result) {
-							if ($internalPath1 !== '') { // don't do a cache update for moved mounts
-								$this->renameUpdate($storage1, $storage2, $internalPath1, $internalPath2);
-							}
-						}
-					} catch(\Exception $e) {
-						throw $e;
-					} finally {
-						$this->changeLock($path1, ILockingProvider::LOCK_SHARED, true);
-						$this->changeLock($path2, ILockingProvider::LOCK_SHARED, true);
-					}
-
-					if ((Cache\Scanner::isPartialFile($path1) && !Cache\Scanner::isPartialFile($path2)) && $result !== false) {
-						if ($this->shouldEmitHooks()) {
-							$this->emit_file_hooks_post($exists, $path2);
-						}
-					} elseif ($result) {
-						if ($this->shouldEmitHooks($path1) and $this->shouldEmitHooks($path2)) {
-							\OC_Hook::emit(
-								Filesystem::CLASSNAME,
-								Filesystem::signal_post_rename,
-								array(
-									Filesystem::signal_param_oldpath => $this->getHookPath($path1),
-									Filesystem::signal_param_newpath => $this->getHookPath($path2)
-								)
-							);
-						}
-					}
-				}
-			} catch(\Exception $e) {
-				throw $e;
-			} finally {
-				$this->unlockFile($path1, ILockingProvider::LOCK_SHARED, true);
-				$this->unlockFile($path2, ILockingProvider::LOCK_SHARED, true);
-			}
-		}
-		return $result;
-	}
-
-	/**
-	 * Copy a file/folder from the source path to target path
-	 *
-	 * @param string $path1 source path
-	 * @param string $path2 target path
-	 * @param bool $preserveMtime whether to preserve mtime on the copy
-	 *
-	 * @return bool|mixed
-	 */
-	public function copy($path1, $path2, $preserveMtime = false) {
-		$absolutePath1 = Filesystem::normalizePath($this->getAbsolutePath($path1));
-		$absolutePath2 = Filesystem::normalizePath($this->getAbsolutePath($path2));
-		$result = false;
-		if (
-			Filesystem::isValidPath($path2)
-			and Filesystem::isValidPath($path1)
-			and !Filesystem::isFileBlacklisted($path2)
-		) {
-			$path1 = $this->getRelativePath($absolutePath1);
-			$path2 = $this->getRelativePath($absolutePath2);
-
-			if ($path1 == null or $path2 == null) {
-				return false;
-			}
-			$run = true;
-
-			$this->lockFile($path2, ILockingProvider::LOCK_SHARED);
-			$this->lockFile($path1, ILockingProvider::LOCK_SHARED);
-			$lockTypePath1 = ILockingProvider::LOCK_SHARED;
-			$lockTypePath2 = ILockingProvider::LOCK_SHARED;
-
-			try {
-
-				$exists = $this->file_exists($path2);
-				if ($this->shouldEmitHooks()) {
-					\OC_Hook::emit(
-						Filesystem::CLASSNAME,
-						Filesystem::signal_copy,
-						array(
-							Filesystem::signal_param_oldpath => $this->getHookPath($path1),
-							Filesystem::signal_param_newpath => $this->getHookPath($path2),
-							Filesystem::signal_param_run => &$run
-						)
-					);
-					$this->emit_file_hooks_pre($exists, $path2, $run);
-				}
-				if ($run) {
-					$mount1 = $this->getMount($path1);
-					$mount2 = $this->getMount($path2);
-					$storage1 = $mount1->getStorage();
-					$internalPath1 = $mount1->getInternalPath($absolutePath1);
-					$storage2 = $mount2->getStorage();
-					$internalPath2 = $mount2->getInternalPath($absolutePath2);
-
-					$this->changeLock($path2, ILockingProvider::LOCK_EXCLUSIVE);
-					$lockTypePath2 = ILockingProvider::LOCK_EXCLUSIVE;
-
-					if ($mount1->getMountPoint() == $mount2->getMountPoint()) {
-						if ($storage1) {
-							$result = $storage1->copy($internalPath1, $internalPath2);
-						} else {
-							$result = false;
-						}
-					} else {
-						$result = $storage2->copyFromStorage($storage1, $internalPath1, $internalPath2);
-					}
-
-					$this->writeUpdate($storage2, $internalPath2);
-
-					$this->changeLock($path2, ILockingProvider::LOCK_SHARED);
-					$lockTypePath2 = ILockingProvider::LOCK_SHARED;
-
-					if ($this->shouldEmitHooks() && $result !== false) {
-						\OC_Hook::emit(
-							Filesystem::CLASSNAME,
-							Filesystem::signal_post_copy,
-							array(
-								Filesystem::signal_param_oldpath => $this->getHookPath($path1),
-								Filesystem::signal_param_newpath => $this->getHookPath($path2)
-							)
-						);
-						$this->emit_file_hooks_post($exists, $path2);
-					}
-
-				}
-			} catch (\Exception $e) {
-				$this->unlockFile($path2, $lockTypePath2);
-				$this->unlockFile($path1, $lockTypePath1);
-				throw $e;
-			}
-
-			$this->unlockFile($path2, $lockTypePath2);
-			$this->unlockFile($path1, $lockTypePath1);
-
-		}
-		return $result;
-	}
-
-	/**
-	 * @param string $path
-	 * @param string $mode 'r' or 'w'
-	 * @return resource
-	 */
-	public function fopen($path, $mode) {
-		$mode = str_replace('b', '', $mode); // the binary flag is a windows only feature which we do not support
-		$hooks = array();
-		switch ($mode) {
-			case 'r':
-				$hooks[] = 'read';
-				break;
-			case 'r+':
-			case 'w+':
-			case 'x+':
-			case 'a+':
-				$hooks[] = 'read';
-				$hooks[] = 'write';
-				break;
-			case 'w':
-			case 'x':
-			case 'a':
-				$hooks[] = 'write';
-				break;
-			default:
-				\OCP\Util::writeLog('core', 'invalid mode (' . $mode . ') for ' . $path, ILogger::ERROR);
-		}
-
-		if ($mode !== 'r' && $mode !== 'w') {
-			\OC::$server->getLogger()->info('Trying to open a file with a mode other than "r" or "w" can cause severe performance issues with some backends');
-		}
-
-		return $this->basicOperation('fopen', $path, $hooks, $mode);
-	}
-
-	/**
-	 * @param string $path
-	 * @return bool|string
-	 * @throws \OCP\Files\InvalidPathException
-	 */
-	public function toTmpFile($path) {
-		$this->assertPathLength($path);
-		if (Filesystem::isValidPath($path)) {
-			$source = $this->fopen($path, 'r');
-			if ($source) {
-				$extension = pathinfo($path, PATHINFO_EXTENSION);
-				$tmpFile = \OC::$server->getTempManager()->getTemporaryFile($extension);
-				file_put_contents($tmpFile, $source);
-				return $tmpFile;
-			} else {
-				return false;
-			}
-		} else {
-			return false;
-		}
-	}
-
-	/**
-	 * @param string $tmpFile
-	 * @param string $path
-	 * @return bool|mixed
-	 * @throws \OCP\Files\InvalidPathException
-	 */
-	public function fromTmpFile($tmpFile, $path) {
-		$this->assertPathLength($path);
-		if (Filesystem::isValidPath($path)) {
-
-			// Get directory that the file is going into
-			$filePath = dirname($path);
-
-			// Create the directories if any
-			if (!$this->file_exists($filePath)) {
-				$result = $this->createParentDirectories($filePath);
-				if ($result === false) {
-					return false;
-				}
-			}
-
-			$source = fopen($tmpFile, 'r');
-			if ($source) {
-				$result = $this->file_put_contents($path, $source);
-				// $this->file_put_contents() might have already closed
-				// the resource, so we check it, before trying to close it
-				// to avoid messages in the error log.
-				if (is_resource($source)) {
-					fclose($source);
-				}
-				unlink($tmpFile);
-				return $result;
-			} else {
-				return false;
-			}
-		} else {
-			return false;
-		}
-	}
-
-
-	/**
-	 * @param string $path
-	 * @return mixed
-	 * @throws \OCP\Files\InvalidPathException
-	 */
-	public function getMimeType($path) {
-		$this->assertPathLength($path);
-		return $this->basicOperation('getMimeType', $path);
-	}
-
-	/**
-	 * @param string $type
-	 * @param string $path
-	 * @param bool $raw
-	 * @return bool|null|string
-	 */
-	public function hash($type, $path, $raw = false) {
-		$postFix = (substr($path, -1) === '/') ? '/' : '';
-		$absolutePath = Filesystem::normalizePath($this->getAbsolutePath($path));
-		if (Filesystem::isValidPath($path)) {
-			$path = $this->getRelativePath($absolutePath);
-			if ($path == null) {
-				return false;
-			}
-			if ($this->shouldEmitHooks($path)) {
-				\OC_Hook::emit(
-					Filesystem::CLASSNAME,
-					Filesystem::signal_read,
-					array(Filesystem::signal_param_path => $this->getHookPath($path))
-				);
-			}
-			list($storage, $internalPath) = Filesystem::resolvePath($absolutePath . $postFix);
-			if ($storage) {
-				return $storage->hash($type, $internalPath, $raw);
-			}
-		}
-		return null;
-	}
-
-	/**
-	 * @param string $path
-	 * @return mixed
-	 * @throws \OCP\Files\InvalidPathException
-	 */
-	public function free_space($path = '/') {
-		$this->assertPathLength($path);
-		$result = $this->basicOperation('free_space', $path);
-		if ($result === null) {
-			throw new InvalidPathException();
-		}
-		return $result;
-	}
-
-	/**
-	 * abstraction layer for basic filesystem functions: wrapper for \OC\Files\Storage\Storage
-	 *
-	 * @param string $operation
-	 * @param string $path
-	 * @param array $hooks (optional)
-	 * @param mixed $extraParam (optional)
-	 * @return mixed
-	 * @throws \Exception
-	 *
-	 * This method takes requests for basic filesystem functions (e.g. reading & writing
-	 * files), processes hooks and proxies, sanitises paths, and finally passes them on to
-	 * \OC\Files\Storage\Storage for delegation to a storage backend for execution
-	 */
-	private function basicOperation($operation, $path, $hooks = [], $extraParam = null) {
-		$postFix = (substr($path, -1) === '/') ? '/' : '';
-		$absolutePath = Filesystem::normalizePath($this->getAbsolutePath($path));
-		if (Filesystem::isValidPath($path)
-			and !Filesystem::isFileBlacklisted($path)
-		) {
-			$path = $this->getRelativePath($absolutePath);
-			if ($path == null) {
-				return false;
-			}
-
-			if (in_array('write', $hooks) || in_array('delete', $hooks) || in_array('read', $hooks)) {
-				// always a shared lock during pre-hooks so the hook can read the file
-				$this->lockFile($path, ILockingProvider::LOCK_SHARED);
-			}
-
-			$run = $this->runHooks($hooks, $path);
-			/** @var \OC\Files\Storage\Storage $storage */
-			list($storage, $internalPath) = Filesystem::resolvePath($absolutePath . $postFix);
-			if ($run and $storage) {
-				if (in_array('write', $hooks) || in_array('delete', $hooks)) {
-					$this->changeLock($path, ILockingProvider::LOCK_EXCLUSIVE);
-				}
-				try {
-					if (!is_null($extraParam)) {
-						$result = $storage->$operation($internalPath, $extraParam);
-					} else {
-						$result = $storage->$operation($internalPath);
-					}
-				} catch (\Exception $e) {
-					if (in_array('write', $hooks) || in_array('delete', $hooks)) {
-						$this->unlockFile($path, ILockingProvider::LOCK_EXCLUSIVE);
-					} else if (in_array('read', $hooks)) {
-						$this->unlockFile($path, ILockingProvider::LOCK_SHARED);
-					}
-					throw $e;
-				}
-
-				if ($result && in_array('delete', $hooks) and $result) {
-					$this->removeUpdate($storage, $internalPath);
-				}
-				if ($result && in_array('write', $hooks) and $operation !== 'fopen') {
-					$this->writeUpdate($storage, $internalPath);
-				}
-				if ($result && in_array('touch', $hooks)) {
-					$this->writeUpdate($storage, $internalPath, $extraParam);
-				}
-
-				if ((in_array('write', $hooks) || in_array('delete', $hooks)) && ($operation !== 'fopen' || $result === false)) {
-					$this->changeLock($path, ILockingProvider::LOCK_SHARED);
-				}
-
-				$unlockLater = false;
-				if ($this->lockingEnabled && $operation === 'fopen' && is_resource($result)) {
-					$unlockLater = true;
-					// make sure our unlocking callback will still be called if connection is aborted
-					ignore_user_abort(true);
-					$result = CallbackWrapper::wrap($result, null, null, function () use ($hooks, $path) {
-						if (in_array('write', $hooks)) {
-							$this->unlockFile($path, ILockingProvider::LOCK_EXCLUSIVE);
-						} else if (in_array('read', $hooks)) {
-							$this->unlockFile($path, ILockingProvider::LOCK_SHARED);
-						}
-					});
-				}
-
-				if ($this->shouldEmitHooks($path) && $result !== false) {
-					if ($operation != 'fopen') { //no post hooks for fopen, the file stream is still open
-						$this->runHooks($hooks, $path, true);
-					}
-				}
-
-				if (!$unlockLater
-					&& (in_array('write', $hooks) || in_array('delete', $hooks) || in_array('read', $hooks))
-				) {
-					$this->unlockFile($path, ILockingProvider::LOCK_SHARED);
-				}
-				return $result;
-			} else {
-				$this->unlockFile($path, ILockingProvider::LOCK_SHARED);
-			}
-		}
-		return null;
-	}
-
-	/**
-	 * get the path relative to the default root for hook usage
-	 *
-	 * @param string $path
-	 * @return string
-	 */
-	private function getHookPath($path) {
-		if (!Filesystem::getView()) {
-			return $path;
-		}
-		return Filesystem::getView()->getRelativePath($this->getAbsolutePath($path));
-	}
-
-	private function shouldEmitHooks($path = '') {
-		if ($path && Cache\Scanner::isPartialFile($path)) {
-			return false;
-		}
-		if (!Filesystem::$loaded) {
-			return false;
-		}
-		$defaultRoot = Filesystem::getRoot();
-		if ($defaultRoot === null) {
-			return false;
-		}
-		if ($this->fakeRoot === $defaultRoot) {
-			return true;
-		}
-		$fullPath = $this->getAbsolutePath($path);
-
-		if ($fullPath === $defaultRoot) {
-			return true;
-		}
-
-		return (strlen($fullPath) > strlen($defaultRoot)) && (substr($fullPath, 0, strlen($defaultRoot) + 1) === $defaultRoot . '/');
-	}
-
-	/**
-	 * @param string[] $hooks
-	 * @param string $path
-	 * @param bool $post
-	 * @return bool
-	 */
-	private function runHooks($hooks, $path, $post = false) {
-		$relativePath = $path;
-		$path = $this->getHookPath($path);
-		$prefix = $post ? 'post_' : '';
-		$run = true;
-		if ($this->shouldEmitHooks($relativePath)) {
-			foreach ($hooks as $hook) {
-				if ($hook != 'read') {
-					\OC_Hook::emit(
-						Filesystem::CLASSNAME,
-						$prefix . $hook,
-						array(
-							Filesystem::signal_param_run => &$run,
-							Filesystem::signal_param_path => $path
-						)
-					);
-				} elseif (!$post) {
-					\OC_Hook::emit(
-						Filesystem::CLASSNAME,
-						$prefix . $hook,
-						array(
-							Filesystem::signal_param_path => $path
-						)
-					);
-				}
-			}
-		}
-		return $run;
-	}
-
-	/**
-	 * check if a file or folder has been updated since $time
-	 *
-	 * @param string $path
-	 * @param int $time
-	 * @return bool
-	 */
-	public function hasUpdated($path, $time) {
-		return $this->basicOperation('hasUpdated', $path, array(), $time);
-	}
-
-	/**
-	 * @param string $ownerId
-	 * @return \OC\User\User
-	 */
-	private function getUserObjectForOwner($ownerId) {
-		$owner = $this->userManager->get($ownerId);
-		if ($owner instanceof IUser) {
-			return $owner;
-		} else {
-			return new User($ownerId, null);
-		}
-	}
-
-	/**
-	 * Get file info from cache
-	 *
-	 * If the file is not in cached it will be scanned
-	 * If the file has changed on storage the cache will be updated
-	 *
-	 * @param \OC\Files\Storage\Storage $storage
-	 * @param string $internalPath
-	 * @param string $relativePath
-	 * @return ICacheEntry|bool
-	 */
-	private function getCacheEntry($storage, $internalPath, $relativePath) {
-		$cache = $storage->getCache($internalPath);
-		$data = $cache->get($internalPath);
-		$watcher = $storage->getWatcher($internalPath);
-
-		try {
-			// if the file is not in the cache or needs to be updated, trigger the scanner and reload the data
-			if (!$data || $data['size'] === -1) {
-				$this->lockFile($relativePath, ILockingProvider::LOCK_SHARED);
-				if (!$storage->file_exists($internalPath)) {
-					$this->unlockFile($relativePath, ILockingProvider::LOCK_SHARED);
-					return false;
-				}
-				$scanner = $storage->getScanner($internalPath);
-				$scanner->scan($internalPath, Cache\Scanner::SCAN_SHALLOW);
-				$data = $cache->get($internalPath);
-				$this->unlockFile($relativePath, ILockingProvider::LOCK_SHARED);
-			} else if (!Cache\Scanner::isPartialFile($internalPath) && $watcher->needsUpdate($internalPath, $data)) {
-				$this->lockFile($relativePath, ILockingProvider::LOCK_SHARED);
-				$watcher->update($internalPath, $data);
-				$storage->getPropagator()->propagateChange($internalPath, time());
-				$data = $cache->get($internalPath);
-				$this->unlockFile($relativePath, ILockingProvider::LOCK_SHARED);
-			}
-		} catch (LockedException $e) {
-			// if the file is locked we just use the old cache info
-		}
-
-		return $data;
-	}
-
-	/**
-	 * get the filesystem info
-	 *
-	 * @param string $path
-	 * @param boolean|string $includeMountPoints true to add mountpoint sizes,
-	 * 'ext' to add only ext storage mount point sizes. Defaults to true.
-	 * defaults to true
-	 * @return \OC\Files\FileInfo|false False if file does not exist
-	 */
-	public function getFileInfo($path, $includeMountPoints = true) {
-		$this->assertPathLength($path);
-		if (!Filesystem::isValidPath($path)) {
-			return false;
-		}
-		if (Cache\Scanner::isPartialFile($path)) {
-			return $this->getPartFileInfo($path);
-		}
-		$relativePath = $path;
-		$path = Filesystem::normalizePath($this->fakeRoot . '/' . $path);
-
-		$mount = Filesystem::getMountManager()->find($path);
-		if (!$mount) {
-			return false;
-		}
-		$storage = $mount->getStorage();
-		$internalPath = $mount->getInternalPath($path);
-		if ($storage) {
-			$data = $this->getCacheEntry($storage, $internalPath, $relativePath);
-
-			if (!$data instanceof ICacheEntry) {
-				return false;
-			}
-
-			if ($mount instanceof MoveableMount && $internalPath === '') {
-				$data['permissions'] |= \OCP\Constants::PERMISSION_DELETE;
-			}
-
-			$owner = $this->getUserObjectForOwner($storage->getOwner($internalPath));
-			$info = new FileInfo($path, $storage, $internalPath, $data, $mount, $owner);
-
-			if ($data and isset($data['fileid'])) {
-				if ($includeMountPoints and $data['mimetype'] === 'httpd/unix-directory') {
-					//add the sizes of other mount points to the folder
-					$extOnly = ($includeMountPoints === 'ext');
-					$mounts = Filesystem::getMountManager()->findIn($path);
-					$info->setSubMounts(array_filter($mounts, function (IMountPoint $mount) use ($extOnly) {
-						$subStorage = $mount->getStorage();
-						return !($extOnly && $subStorage instanceof \OCA\Files_Sharing\SharedStorage);
-					}));
-				}
-			}
-
-			return $info;
-		}
-
-		return false;
-	}
-
-	/**
-	 * get the content of a directory
-	 *
-	 * @param string $directory path under datadirectory
-	 * @param string $mimetype_filter limit returned content to this mimetype or mimepart
-	 * @return FileInfo[]
-	 */
-	public function getDirectoryContent($directory, $mimetype_filter = '') {
-		$this->assertPathLength($directory);
-		if (!Filesystem::isValidPath($directory)) {
-			return [];
-		}
-		$path = $this->getAbsolutePath($directory);
-		$path = Filesystem::normalizePath($path);
-		$mount = $this->getMount($directory);
-		if (!$mount) {
-			return [];
-		}
-		$storage = $mount->getStorage();
-		$internalPath = $mount->getInternalPath($path);
-		if ($storage) {
-			$cache = $storage->getCache($internalPath);
-			$user = \OC_User::getUser();
-
-			$data = $this->getCacheEntry($storage, $internalPath, $directory);
-
-			if (!$data instanceof ICacheEntry || !isset($data['fileid']) || !($data->getPermissions() && Constants::PERMISSION_READ)) {
-				return [];
-			}
-
-			$folderId = $data['fileid'];
-			$contents = $cache->getFolderContentsById($folderId); //TODO: mimetype_filter
-
-			$sharingDisabled = \OCP\Util::isSharingDisabledForUser();
-			/**
-			 * @var \OC\Files\FileInfo[] $files
-			 */
-			$files = array_map(function (ICacheEntry $content) use ($path, $storage, $mount, $sharingDisabled) {
-				if ($sharingDisabled) {
-					$content['permissions'] = $content['permissions'] & ~\OCP\Constants::PERMISSION_SHARE;
-				}
-				$owner = $this->getUserObjectForOwner($storage->getOwner($content['path']));
-				return new FileInfo($path . '/' . $content['name'], $storage, $content['path'], $content, $mount, $owner);
-			}, $contents);
-
-			//add a folder for any mountpoint in this directory and add the sizes of other mountpoints to the folders
-			$mounts = Filesystem::getMountManager()->findIn($path);
-			$dirLength = strlen($path);
-			foreach ($mounts as $mount) {
-				$mountPoint = $mount->getMountPoint();
-				$subStorage = $mount->getStorage();
-				if ($subStorage) {
-					$subCache = $subStorage->getCache('');
-
-					$rootEntry = $subCache->get('');
-					if (!$rootEntry) {
-						$subScanner = $subStorage->getScanner('');
-						try {
-							$subScanner->scanFile('');
-						} catch (\OCP\Files\StorageNotAvailableException $e) {
-							continue;
-						} catch (\OCP\Files\StorageInvalidException $e) {
-							continue;
-						} catch (\Exception $e) {
-							// sometimes when the storage is not available it can be any exception
-							\OC::$server->getLogger()->logException($e, [
-								'message' => 'Exception while scanning storage "' . $subStorage->getId() . '"',
-								'level' => ILogger::ERROR,
-								'app' => 'lib',
-							]);
-							continue;
-						}
-						$rootEntry = $subCache->get('');
-					}
-
-					if ($rootEntry && ($rootEntry->getPermissions() && Constants::PERMISSION_READ)) {
-						$relativePath = trim(substr($mountPoint, $dirLength), '/');
-						if ($pos = strpos($relativePath, '/')) {
-							//mountpoint inside subfolder add size to the correct folder
-							$entryName = substr($relativePath, 0, $pos);
-							foreach ($files as &$entry) {
-								if ($entry->getName() === $entryName) {
-									$entry->addSubEntry($rootEntry, $mountPoint);
-								}
-							}
-						} else { //mountpoint in this folder, add an entry for it
-							$rootEntry['name'] = $relativePath;
-							$rootEntry['type'] = $rootEntry['mimetype'] === 'httpd/unix-directory' ? 'dir' : 'file';
-							$permissions = $rootEntry['permissions'];
-							// do not allow renaming/deleting the mount point if they are not shared files/folders
-							// for shared files/folders we use the permissions given by the owner
-							if ($mount instanceof MoveableMount) {
-								$rootEntry['permissions'] = $permissions | \OCP\Constants::PERMISSION_UPDATE | \OCP\Constants::PERMISSION_DELETE;
-							} else {
-								$rootEntry['permissions'] = $permissions & (\OCP\Constants::PERMISSION_ALL - (\OCP\Constants::PERMISSION_UPDATE | \OCP\Constants::PERMISSION_DELETE));
-							}
-
-							//remove any existing entry with the same name
-							foreach ($files as $i => $file) {
-								if ($file['name'] === $rootEntry['name']) {
-									unset($files[$i]);
-									break;
-								}
-							}
-							$rootEntry['path'] = substr(Filesystem::normalizePath($path . '/' . $rootEntry['name']), strlen($user) + 2); // full path without /$user/
-
-							// if sharing was disabled for the user we remove the share permissions
-							if (\OCP\Util::isSharingDisabledForUser()) {
-								$rootEntry['permissions'] = $rootEntry['permissions'] & ~\OCP\Constants::PERMISSION_SHARE;
-							}
-
-							$owner = $this->getUserObjectForOwner($subStorage->getOwner(''));
-							$files[] = new FileInfo($path . '/' . $rootEntry['name'], $subStorage, '', $rootEntry, $mount, $owner);
-						}
-					}
-				}
-			}
-
-			if ($mimetype_filter) {
-				$files = array_filter($files, function (FileInfo $file) use ($mimetype_filter) {
-					if (strpos($mimetype_filter, '/')) {
-						return $file->getMimetype() === $mimetype_filter;
-					} else {
-						return $file->getMimePart() === $mimetype_filter;
-					}
-				});
-			}
-
-			return $files;
-		} else {
-			return [];
-		}
-	}
-
-	/**
-	 * change file metadata
-	 *
-	 * @param string $path
-	 * @param array|\OCP\Files\FileInfo $data
-	 * @return int
-	 *
-	 * returns the fileid of the updated file
-	 */
-	public function putFileInfo($path, $data) {
-		$this->assertPathLength($path);
-		if ($data instanceof FileInfo) {
-			$data = $data->getData();
-		}
-		$path = Filesystem::normalizePath($this->fakeRoot . '/' . $path);
-		/**
-		 * @var \OC\Files\Storage\Storage $storage
-		 * @var string $internalPath
-		 */
-		list($storage, $internalPath) = Filesystem::resolvePath($path);
-		if ($storage) {
-			$cache = $storage->getCache($path);
-
-			if (!$cache->inCache($internalPath)) {
-				$scanner = $storage->getScanner($internalPath);
-				$scanner->scan($internalPath, Cache\Scanner::SCAN_SHALLOW);
-			}
-
-			return $cache->put($internalPath, $data);
-		} else {
-			return -1;
-		}
-	}
-
-	/**
-	 * search for files with the name matching $query
-	 *
-	 * @param string $query
-	 * @return FileInfo[]
-	 */
-	public function search($query) {
-		return $this->searchCommon('search', array('%' . $query . '%'));
-	}
-
-	/**
-	 * search for files with the name matching $query
-	 *
-	 * @param string $query
-	 * @return FileInfo[]
-	 */
-	public function searchRaw($query) {
-		return $this->searchCommon('search', array($query));
-	}
-
-	/**
-	 * search for files by mimetype
-	 *
-	 * @param string $mimetype
-	 * @return FileInfo[]
-	 */
-	public function searchByMime($mimetype) {
-		return $this->searchCommon('searchByMime', array($mimetype));
-	}
-
-	/**
-	 * search for files by tag
-	 *
-	 * @param string|int $tag name or tag id
-	 * @param string $userId owner of the tags
-	 * @return FileInfo[]
-	 */
-	public function searchByTag($tag, $userId) {
-		return $this->searchCommon('searchByTag', array($tag, $userId));
-	}
-
-	/**
-	 * @param string $method cache method
-	 * @param array $args
-	 * @return FileInfo[]
-	 */
-	private function searchCommon($method, $args) {
-		$files = array();
-		$rootLength = strlen($this->fakeRoot);
-
-		$mount = $this->getMount('');
-		$mountPoint = $mount->getMountPoint();
-		$storage = $mount->getStorage();
-		if ($storage) {
-			$cache = $storage->getCache('');
-
-			$results = call_user_func_array(array($cache, $method), $args);
-			foreach ($results as $result) {
-				if (substr($mountPoint . $result['path'], 0, $rootLength + 1) === $this->fakeRoot . '/') {
-					$internalPath = $result['path'];
-					$path = $mountPoint . $result['path'];
-					$result['path'] = substr($mountPoint . $result['path'], $rootLength);
-					$owner = \OC::$server->getUserManager()->get($storage->getOwner($internalPath));
-					$files[] = new FileInfo($path, $storage, $internalPath, $result, $mount, $owner);
-				}
-			}
-
-			$mounts = Filesystem::getMountManager()->findIn($this->fakeRoot);
-			foreach ($mounts as $mount) {
-				$mountPoint = $mount->getMountPoint();
-				$storage = $mount->getStorage();
-				if ($storage) {
-					$cache = $storage->getCache('');
-
-					$relativeMountPoint = substr($mountPoint, $rootLength);
-					$results = call_user_func_array(array($cache, $method), $args);
-					if ($results) {
-						foreach ($results as $result) {
-							$internalPath = $result['path'];
-							$result['path'] = rtrim($relativeMountPoint . $result['path'], '/');
-							$path = rtrim($mountPoint . $internalPath, '/');
-							$owner = \OC::$server->getUserManager()->get($storage->getOwner($internalPath));
-							$files[] = new FileInfo($path, $storage, $internalPath, $result, $mount, $owner);
-						}
-					}
-				}
-			}
-		}
-		return $files;
-	}
-
-	/**
-	 * Get the owner for a file or folder
-	 *
-	 * @param string $path
-	 * @return string the user id of the owner
-	 * @throws NotFoundException
-	 */
-	public function getOwner($path) {
-		$info = $this->getFileInfo($path);
-		if (!$info) {
-			throw new NotFoundException($path . ' not found while trying to get owner');
-		}
-		return $info->getOwner()->getUID();
-	}
-
-	/**
-	 * get the ETag for a file or folder
-	 *
-	 * @param string $path
-	 * @return string
-	 */
-	public function getETag($path) {
-		/**
-		 * @var Storage\Storage $storage
-		 * @var string $internalPath
-		 */
-		list($storage, $internalPath) = $this->resolvePath($path);
-		if ($storage) {
-			return $storage->getETag($internalPath);
-		} else {
-			return null;
-		}
-	}
-
-	/**
-	 * Get the path of a file by id, relative to the view
-	 *
-	 * Note that the resulting path is not guarantied to be unique for the id, multiple paths can point to the same file
-	 *
-	 * @param int $id
-	 * @throws NotFoundException
-	 * @return string
-	 */
-	public function getPath($id) {
-		$id = (int)$id;
-		$manager = Filesystem::getMountManager();
-		$mounts = $manager->findIn($this->fakeRoot);
-		$mounts[] = $manager->find($this->fakeRoot);
-		// reverse the array so we start with the storage this view is in
-		// which is the most likely to contain the file we're looking for
-		$mounts = array_reverse($mounts);
-		foreach ($mounts as $mount) {
-			/**
-			 * @var \OC\Files\Mount\MountPoint $mount
-			 */
-			if ($mount->getStorage()) {
-				$cache = $mount->getStorage()->getCache();
-				$internalPath = $cache->getPathById($id);
-				if (is_string($internalPath)) {
-					$fullPath = $mount->getMountPoint() . $internalPath;
-					if (!is_null($path = $this->getRelativePath($fullPath))) {
-						return $path;
-					}
-				}
-			}
-		}
-		throw new NotFoundException(sprintf('File with id "%s" has not been found.', $id));
-	}
-
-	/**
-	 * @param string $path
-	 * @throws InvalidPathException
-	 */
-	private function assertPathLength($path) {
-		$maxLen = min(PHP_MAXPATHLEN, 4000);
-		// Check for the string length - performed using isset() instead of strlen()
-		// because isset() is about 5x-40x faster.
-		if (isset($path[$maxLen])) {
-			$pathLen = strlen($path);
-			throw new \OCP\Files\InvalidPathException("Path length($pathLen) exceeds max path length($maxLen): $path");
-		}
-	}
-
-	/**
-	 * check if it is allowed to move a mount point to a given target.
-	 * It is not allowed to move a mount point into a different mount point or
-	 * into an already shared folder
-	 *
-	 * @param string $target path
-	 * @return boolean
-	 */
-	private function isTargetAllowed($target) {
-
-		list($targetStorage, $targetInternalPath) = \OC\Files\Filesystem::resolvePath($target);
-		if (!$targetStorage->instanceOfStorage('\OCP\Files\IHomeStorage')) {
-			\OCP\Util::writeLog('files',
-				'It is not allowed to move one mount point into another one',
-				ILogger::DEBUG);
-			return false;
-		}
-
-		// note: cannot use the view because the target is already locked
-		$fileId = (int)$targetStorage->getCache()->getId($targetInternalPath);
-		if ($fileId === -1) {
-			// target might not exist, need to check parent instead
-			$fileId = (int)$targetStorage->getCache()->getId(dirname($targetInternalPath));
-		}
-
-		// check if any of the parents were shared by the current owner (include collections)
-		$shares = \OCP\Share::getItemShared(
-			'folder',
-			$fileId,
-			\OCP\Share::FORMAT_NONE,
-			null,
-			true
-		);
-
-		if (count($shares) > 0) {
-			\OCP\Util::writeLog('files',
-				'It is not allowed to move one mount point into a shared folder',
-				ILogger::DEBUG);
-			return false;
-		}
-
-		return true;
-	}
-
-	/**
-	 * Get a fileinfo object for files that are ignored in the cache (part files)
-	 *
-	 * @param string $path
-	 * @return \OCP\Files\FileInfo
-	 */
-	private function getPartFileInfo($path) {
-		$mount = $this->getMount($path);
-		$storage = $mount->getStorage();
-		$internalPath = $mount->getInternalPath($this->getAbsolutePath($path));
-		$owner = \OC::$server->getUserManager()->get($storage->getOwner($internalPath));
-		return new FileInfo(
-			$this->getAbsolutePath($path),
-			$storage,
-			$internalPath,
-			[
-				'fileid' => null,
-				'mimetype' => $storage->getMimeType($internalPath),
-				'name' => basename($path),
-				'etag' => null,
-				'size' => $storage->filesize($internalPath),
-				'mtime' => $storage->filemtime($internalPath),
-				'encrypted' => false,
-				'permissions' => \OCP\Constants::PERMISSION_ALL
-			],
-			$mount,
-			$owner
-		);
-	}
-
-	/**
-	 * @param string $path
-	 * @param string $fileName
-	 * @throws InvalidPathException
-	 */
-	public function verifyPath($path, $fileName) {
-		try {
-			/** @type \OCP\Files\Storage $storage */
-			list($storage, $internalPath) = $this->resolvePath($path);
-			$storage->verifyPath($internalPath, $fileName);
-		} catch (ReservedWordException $ex) {
-			$l = \OC::$server->getL10N('lib');
-			throw new InvalidPathException($l->t('File name is a reserved word'));
-		} catch (InvalidCharacterInPathException $ex) {
-			$l = \OC::$server->getL10N('lib');
-			throw new InvalidPathException($l->t('File name contains at least one invalid character'));
-		} catch (FileNameTooLongException $ex) {
-			$l = \OC::$server->getL10N('lib');
-			throw new InvalidPathException($l->t('File name is too long'));
-		} catch (InvalidDirectoryException $ex) {
-			$l = \OC::$server->getL10N('lib');
-			throw new InvalidPathException($l->t('Dot files are not allowed'));
-		} catch (EmptyFileNameException $ex) {
-			$l = \OC::$server->getL10N('lib');
-			throw new InvalidPathException($l->t('Empty filename is not allowed'));
-		}
-	}
-
-	/**
-	 * get all parent folders of $path
-	 *
-	 * @param string $path
-	 * @return string[]
-	 */
-	private function getParents($path) {
-		$path = trim($path, '/');
-		if (!$path) {
-			return [];
-		}
-
-		$parts = explode('/', $path);
-
-		// remove the single file
-		array_pop($parts);
-		$result = array('/');
-		$resultPath = '';
-		foreach ($parts as $part) {
-			if ($part) {
-				$resultPath .= '/' . $part;
-				$result[] = $resultPath;
-			}
-		}
-		return $result;
-	}
-
-	/**
-	 * Returns the mount point for which to lock
-	 *
-	 * @param string $absolutePath absolute path
-	 * @param bool $useParentMount true to return parent mount instead of whatever
-	 * is mounted directly on the given path, false otherwise
-	 * @return \OC\Files\Mount\MountPoint mount point for which to apply locks
-	 */
-	private function getMountForLock($absolutePath, $useParentMount = false) {
-		$results = [];
-		$mount = Filesystem::getMountManager()->find($absolutePath);
-		if (!$mount) {
-			return $results;
-		}
-
-		if ($useParentMount) {
-			// find out if something is mounted directly on the path
-			$internalPath = $mount->getInternalPath($absolutePath);
-			if ($internalPath === '') {
-				// resolve the parent mount instead
-				$mount = Filesystem::getMountManager()->find(dirname($absolutePath));
-			}
-		}
-
-		return $mount;
-	}
-
-	/**
-	 * Lock the given path
-	 *
-	 * @param string $path the path of the file to lock, relative to the view
-	 * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
-	 * @param bool $lockMountPoint true to lock the mount point, false to lock the attached mount/storage
-	 *
-	 * @return bool False if the path is excluded from locking, true otherwise
-	 * @throws \OCP\Lock\LockedException if the path is already locked
-	 */
-	private function lockPath($path, $type, $lockMountPoint = false) {
-		$absolutePath = $this->getAbsolutePath($path);
-		$absolutePath = Filesystem::normalizePath($absolutePath);
-		if (!$this->shouldLockFile($absolutePath)) {
-			return false;
-		}
-
-		$mount = $this->getMountForLock($absolutePath, $lockMountPoint);
-		if ($mount) {
-			try {
-				$storage = $mount->getStorage();
-				if ($storage->instanceOfStorage('\OCP\Files\Storage\ILockingStorage')) {
-					$storage->acquireLock(
-						$mount->getInternalPath($absolutePath),
-						$type,
-						$this->lockingProvider
-					);
-				}
-			} catch (\OCP\Lock\LockedException $e) {
-				// rethrow with the a human-readable path
-				throw new \OCP\Lock\LockedException(
-					$this->getPathRelativeToFiles($absolutePath),
-					$e
-				);
-			}
-		}
-
-		return true;
-	}
-
-	/**
-	 * Change the lock type
-	 *
-	 * @param string $path the path of the file to lock, relative to the view
-	 * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
-	 * @param bool $lockMountPoint true to lock the mount point, false to lock the attached mount/storage
-	 *
-	 * @return bool False if the path is excluded from locking, true otherwise
-	 * @throws \OCP\Lock\LockedException if the path is already locked
-	 */
-	public function changeLock($path, $type, $lockMountPoint = false) {
-		$path = Filesystem::normalizePath($path);
-		$absolutePath = $this->getAbsolutePath($path);
-		$absolutePath = Filesystem::normalizePath($absolutePath);
-		if (!$this->shouldLockFile($absolutePath)) {
-			return false;
-		}
-
-		$mount = $this->getMountForLock($absolutePath, $lockMountPoint);
-		if ($mount) {
-			try {
-				$storage = $mount->getStorage();
-				if ($storage->instanceOfStorage('\OCP\Files\Storage\ILockingStorage')) {
-					$storage->changeLock(
-						$mount->getInternalPath($absolutePath),
-						$type,
-						$this->lockingProvider
-					);
-				}
-			} catch (\OCP\Lock\LockedException $e) {
-				try {
-					// rethrow with the a human-readable path
-					throw new \OCP\Lock\LockedException(
-						$this->getPathRelativeToFiles($absolutePath),
-						$e
-					);
-				} catch (\InvalidArgumentException $e) {
-					throw new \OCP\Lock\LockedException(
-						$absolutePath,
-						$e
-					);
-				}
-			}
-		}
-
-		return true;
-	}
-
-	/**
-	 * Unlock the given path
-	 *
-	 * @param string $path the path of the file to unlock, relative to the view
-	 * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
-	 * @param bool $lockMountPoint true to lock the mount point, false to lock the attached mount/storage
-	 *
-	 * @return bool False if the path is excluded from locking, true otherwise
-	 */
-	private function unlockPath($path, $type, $lockMountPoint = false) {
-		$absolutePath = $this->getAbsolutePath($path);
-		$absolutePath = Filesystem::normalizePath($absolutePath);
-		if (!$this->shouldLockFile($absolutePath)) {
-			return false;
-		}
-
-		$mount = $this->getMountForLock($absolutePath, $lockMountPoint);
-		if ($mount) {
-			$storage = $mount->getStorage();
-			if ($storage && $storage->instanceOfStorage('\OCP\Files\Storage\ILockingStorage')) {
-				$storage->releaseLock(
-					$mount->getInternalPath($absolutePath),
-					$type,
-					$this->lockingProvider
-				);
-			}
-		}
-
-		return true;
-	}
-
-	/**
-	 * Lock a path and all its parents up to the root of the view
-	 *
-	 * @param string $path the path of the file to lock relative to the view
-	 * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
-	 * @param bool $lockMountPoint true to lock the mount point, false to lock the attached mount/storage
-	 *
-	 * @return bool False if the path is excluded from locking, true otherwise
-	 */
-	public function lockFile($path, $type, $lockMountPoint = false) {
-		$absolutePath = $this->getAbsolutePath($path);
-		$absolutePath = Filesystem::normalizePath($absolutePath);
-		if (!$this->shouldLockFile($absolutePath)) {
-			return false;
-		}
-
-		$this->lockPath($path, $type, $lockMountPoint);
-
-		$parents = $this->getParents($path);
-		foreach ($parents as $parent) {
-			$this->lockPath($parent, ILockingProvider::LOCK_SHARED);
-		}
-
-		return true;
-	}
-
-	/**
-	 * Unlock a path and all its parents up to the root of the view
-	 *
-	 * @param string $path the path of the file to lock relative to the view
-	 * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
-	 * @param bool $lockMountPoint true to lock the mount point, false to lock the attached mount/storage
-	 *
-	 * @return bool False if the path is excluded from locking, true otherwise
-	 */
-	public function unlockFile($path, $type, $lockMountPoint = false) {
-		$absolutePath = $this->getAbsolutePath($path);
-		$absolutePath = Filesystem::normalizePath($absolutePath);
-		if (!$this->shouldLockFile($absolutePath)) {
-			return false;
-		}
-
-		$this->unlockPath($path, $type, $lockMountPoint);
-
-		$parents = $this->getParents($path);
-		foreach ($parents as $parent) {
-			$this->unlockPath($parent, ILockingProvider::LOCK_SHARED);
-		}
-
-		return true;
-	}
-
-	/**
-	 * Only lock files in data/user/files/
-	 *
-	 * @param string $path Absolute path to the file/folder we try to (un)lock
-	 * @return bool
-	 */
-	protected function shouldLockFile($path) {
-		$path = Filesystem::normalizePath($path);
-
-		$pathSegments = explode('/', $path);
-		if (isset($pathSegments[2])) {
-			// E.g.: /username/files/path-to-file
-			return ($pathSegments[2] === 'files') && (count($pathSegments) > 3);
-		}
-
-		return strpos($path, '/appdata_') !== 0;
-	}
-
-	/**
-	 * Shortens the given absolute path to be relative to
-	 * "$user/files".
-	 *
-	 * @param string $absolutePath absolute path which is under "files"
-	 *
-	 * @return string path relative to "files" with trimmed slashes or null
-	 * if the path was NOT relative to files
-	 *
-	 * @throws \InvalidArgumentException if the given path was not under "files"
-	 * @since 8.1.0
-	 */
-	public function getPathRelativeToFiles($absolutePath) {
-		$path = Filesystem::normalizePath($absolutePath);
-		$parts = explode('/', trim($path, '/'), 3);
-		// "$user", "files", "path/to/dir"
-		if (!isset($parts[1]) || $parts[1] !== 'files') {
-			$this->logger->error(
-				'$absolutePath must be relative to "files", value is "%s"',
-				[
-					$absolutePath
-				]
-			);
-			throw new \InvalidArgumentException('$absolutePath must be relative to "files"');
-		}
-		if (isset($parts[2])) {
-			return $parts[2];
-		}
-		return '';
-	}
-
-	/**
-	 * @param string $filename
-	 * @return array
-	 * @throws \OC\User\NoUserException
-	 * @throws NotFoundException
-	 */
-	public function getUidAndFilename($filename) {
-		$info = $this->getFileInfo($filename);
-		if (!$info instanceof \OCP\Files\FileInfo) {
-			throw new NotFoundException($this->getAbsolutePath($filename) . ' not found');
-		}
-		$uid = $info->getOwner()->getUID();
-		if ($uid != \OCP\User::getUser()) {
-			Filesystem::initMountPoints($uid);
-			$ownerView = new View('/' . $uid . '/files');
-			try {
-				$filename = $ownerView->getPath($info['fileid']);
-			} catch (NotFoundException $e) {
-				throw new NotFoundException('File with id ' . $info['fileid'] . ' not found for user ' . $uid);
-			}
-		}
-		return [$uid, $filename];
-	}
-
-	/**
-	 * Creates parent non-existing folders
-	 *
-	 * @param string $filePath
-	 * @return bool
-	 */
-	private function createParentDirectories($filePath) {
-		$directoryParts = explode('/', $filePath);
-		$directoryParts = array_filter($directoryParts);
-		foreach ($directoryParts as $key => $part) {
-			$currentPathElements = array_slice($directoryParts, 0, $key);
-			$currentPath = '/' . implode('/', $currentPathElements);
-			if ($this->is_file($currentPath)) {
-				return false;
-			}
-			if (!$this->file_exists($currentPath)) {
-				$this->mkdir($currentPath);
-			}
-		}
-
-		return true;
-	}
+    /** @var string */
+    private $fakeRoot = '';
+
+    /**
+     * @var \OCP\Lock\ILockingProvider
+     */
+    protected $lockingProvider;
+
+    private $lockingEnabled;
+
+    private $updaterEnabled = true;
+
+    /** @var \OC\User\Manager */
+    private $userManager;
+
+    /** @var \OCP\ILogger */
+    private $logger;
+
+    /**
+     * @param string $root
+     * @throws \Exception If $root contains an invalid path
+     */
+    public function __construct($root = '') {
+        if (is_null($root)) {
+            throw new \InvalidArgumentException('Root can\'t be null');
+        }
+        if (!Filesystem::isValidPath($root)) {
+            throw new \Exception();
+        }
+
+        $this->fakeRoot = $root;
+        $this->lockingProvider = \OC::$server->getLockingProvider();
+        $this->lockingEnabled = !($this->lockingProvider instanceof \OC\Lock\NoopLockingProvider);
+        $this->userManager = \OC::$server->getUserManager();
+        $this->logger = \OC::$server->getLogger();
+    }
+
+    public function getAbsolutePath($path = '/') {
+        if ($path === null) {
+            return null;
+        }
+        $this->assertPathLength($path);
+        if ($path === '') {
+            $path = '/';
+        }
+        if ($path[0] !== '/') {
+            $path = '/' . $path;
+        }
+        return $this->fakeRoot . $path;
+    }
+
+    /**
+     * change the root to a fake root
+     *
+     * @param string $fakeRoot
+     * @return boolean|null
+     */
+    public function chroot($fakeRoot) {
+        if (!$fakeRoot == '') {
+            if ($fakeRoot[0] !== '/') {
+                $fakeRoot = '/' . $fakeRoot;
+            }
+        }
+        $this->fakeRoot = $fakeRoot;
+    }
+
+    /**
+     * get the fake root
+     *
+     * @return string
+     */
+    public function getRoot() {
+        return $this->fakeRoot;
+    }
+
+    /**
+     * get path relative to the root of the view
+     *
+     * @param string $path
+     * @return string
+     */
+    public function getRelativePath($path) {
+        $this->assertPathLength($path);
+        if ($this->fakeRoot == '') {
+            return $path;
+        }
+
+        if (rtrim($path, '/') === rtrim($this->fakeRoot, '/')) {
+            return '/';
+        }
+
+        // missing slashes can cause wrong matches!
+        $root = rtrim($this->fakeRoot, '/') . '/';
+
+        if (strpos($path, $root) !== 0) {
+            return null;
+        } else {
+            $path = substr($path, strlen($this->fakeRoot));
+            if (strlen($path) === 0) {
+                return '/';
+            } else {
+                return $path;
+            }
+        }
+    }
+
+    /**
+     * get the mountpoint of the storage object for a path
+     * ( note: because a storage is not always mounted inside the fakeroot, the
+     * returned mountpoint is relative to the absolute root of the filesystem
+     * and does not take the chroot into account )
+     *
+     * @param string $path
+     * @return string
+     */
+    public function getMountPoint($path) {
+        return Filesystem::getMountPoint($this->getAbsolutePath($path));
+    }
+
+    /**
+     * get the mountpoint of the storage object for a path
+     * ( note: because a storage is not always mounted inside the fakeroot, the
+     * returned mountpoint is relative to the absolute root of the filesystem
+     * and does not take the chroot into account )
+     *
+     * @param string $path
+     * @return \OCP\Files\Mount\IMountPoint
+     */
+    public function getMount($path) {
+        return Filesystem::getMountManager()->find($this->getAbsolutePath($path));
+    }
+
+    /**
+     * resolve a path to a storage and internal path
+     *
+     * @param string $path
+     * @return array an array consisting of the storage and the internal path
+     */
+    public function resolvePath($path) {
+        $a = $this->getAbsolutePath($path);
+        $p = Filesystem::normalizePath($a);
+        return Filesystem::resolvePath($p);
+    }
+
+    /**
+     * return the path to a local version of the file
+     * we need this because we can't know if a file is stored local or not from
+     * outside the filestorage and for some purposes a local file is needed
+     *
+     * @param string $path
+     * @return string
+     */
+    public function getLocalFile($path) {
+        $parent = substr($path, 0, strrpos($path, '/'));
+        $path = $this->getAbsolutePath($path);
+        list($storage, $internalPath) = Filesystem::resolvePath($path);
+        if (Filesystem::isValidPath($parent) and $storage) {
+            return $storage->getLocalFile($internalPath);
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * @param string $path
+     * @return string
+     */
+    public function getLocalFolder($path) {
+        $parent = substr($path, 0, strrpos($path, '/'));
+        $path = $this->getAbsolutePath($path);
+        list($storage, $internalPath) = Filesystem::resolvePath($path);
+        if (Filesystem::isValidPath($parent) and $storage) {
+            return $storage->getLocalFolder($internalPath);
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * the following functions operate with arguments and return values identical
+     * to those of their PHP built-in equivalents. Mostly they are merely wrappers
+     * for \OC\Files\Storage\Storage via basicOperation().
+     */
+    public function mkdir($path) {
+        return $this->basicOperation('mkdir', $path, array('create', 'write'));
+    }
+
+    /**
+     * remove mount point
+     *
+     * @param \OC\Files\Mount\MoveableMount $mount
+     * @param string $path relative to data/
+     * @return boolean
+     */
+    protected function removeMount($mount, $path) {
+        if ($mount instanceof MoveableMount) {
+            // cut of /user/files to get the relative path to data/user/files
+            $pathParts = explode('/', $path, 4);
+            $relPath = '/' . $pathParts[3];
+            $this->lockFile($relPath, ILockingProvider::LOCK_SHARED, true);
+            \OC_Hook::emit(
+                Filesystem::CLASSNAME, "umount",
+                array(Filesystem::signal_param_path => $relPath)
+            );
+            $this->changeLock($relPath, ILockingProvider::LOCK_EXCLUSIVE, true);
+            $result = $mount->removeMount();
+            $this->changeLock($relPath, ILockingProvider::LOCK_SHARED, true);
+            if ($result) {
+                \OC_Hook::emit(
+                    Filesystem::CLASSNAME, "post_umount",
+                    array(Filesystem::signal_param_path => $relPath)
+                );
+            }
+            $this->unlockFile($relPath, ILockingProvider::LOCK_SHARED, true);
+            return $result;
+        } else {
+            // do not allow deleting the storage's root / the mount point
+            // because for some storages it might delete the whole contents
+            // but isn't supposed to work that way
+            return false;
+        }
+    }
+
+    public function disableCacheUpdate() {
+        $this->updaterEnabled = false;
+    }
+
+    public function enableCacheUpdate() {
+        $this->updaterEnabled = true;
+    }
+
+    protected function writeUpdate(Storage $storage, $internalPath, $time = null) {
+        if ($this->updaterEnabled) {
+            if (is_null($time)) {
+                $time = time();
+            }
+            $storage->getUpdater()->update($internalPath, $time);
+        }
+    }
+
+    protected function removeUpdate(Storage $storage, $internalPath) {
+        if ($this->updaterEnabled) {
+            $storage->getUpdater()->remove($internalPath);
+        }
+    }
+
+    protected function renameUpdate(Storage $sourceStorage, Storage $targetStorage, $sourceInternalPath, $targetInternalPath) {
+        if ($this->updaterEnabled) {
+            $targetStorage->getUpdater()->renameFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath);
+        }
+    }
+
+    /**
+     * @param string $path
+     * @return bool|mixed
+     */
+    public function rmdir($path) {
+        $absolutePath = $this->getAbsolutePath($path);
+        $mount = Filesystem::getMountManager()->find($absolutePath);
+        if ($mount->getInternalPath($absolutePath) === '') {
+            return $this->removeMount($mount, $absolutePath);
+        }
+        if ($this->is_dir($path)) {
+            $result = $this->basicOperation('rmdir', $path, array('delete'));
+        } else {
+            $result = false;
+        }
+
+        if (!$result && !$this->file_exists($path)) { //clear ghost files from the cache on delete
+            $storage = $mount->getStorage();
+            $internalPath = $mount->getInternalPath($absolutePath);
+            $storage->getUpdater()->remove($internalPath);
+        }
+        return $result;
+    }
+
+    /**
+     * @param string $path
+     * @return resource
+     */
+    public function opendir($path) {
+        return $this->basicOperation('opendir', $path, array('read'));
+    }
+
+    /**
+     * @param string $path
+     * @return bool|mixed
+     */
+    public function is_dir($path) {
+        if ($path == '/') {
+            return true;
+        }
+        return $this->basicOperation('is_dir', $path);
+    }
+
+    /**
+     * @param string $path
+     * @return bool|mixed
+     */
+    public function is_file($path) {
+        if ($path == '/') {
+            return false;
+        }
+        return $this->basicOperation('is_file', $path);
+    }
+
+    /**
+     * @param string $path
+     * @return mixed
+     */
+    public function stat($path) {
+        return $this->basicOperation('stat', $path);
+    }
+
+    /**
+     * @param string $path
+     * @return mixed
+     */
+    public function filetype($path) {
+        return $this->basicOperation('filetype', $path);
+    }
+
+    /**
+     * @param string $path
+     * @return mixed
+     */
+    public function filesize($path) {
+        return $this->basicOperation('filesize', $path);
+    }
+
+    /**
+     * @param string $path
+     * @return bool|mixed
+     * @throws \OCP\Files\InvalidPathException
+     */
+    public function readfile($path) {
+        $this->assertPathLength($path);
+        @ob_end_clean();
+        $handle = $this->fopen($path, 'rb');
+        if ($handle) {
+            $chunkSize = 8192; // 8 kB chunks
+            while (!feof($handle)) {
+                echo fread($handle, $chunkSize);
+                flush();
+            }
+            fclose($handle);
+            return $this->filesize($path);
+        }
+        return false;
+    }
+
+    /**
+     * @param string $path
+     * @param int $from
+     * @param int $to
+     * @return bool|mixed
+     * @throws \OCP\Files\InvalidPathException
+     * @throws \OCP\Files\UnseekableException
+     */
+    public function readfilePart($path, $from, $to) {
+        $this->assertPathLength($path);
+        @ob_end_clean();
+        $handle = $this->fopen($path, 'rb');
+        if ($handle) {
+            $chunkSize = 8192; // 8 kB chunks
+            $startReading = true;
+
+            if ($from !== 0 && $from !== '0' && fseek($handle, $from) !== 0) {
+                // forward file handle via chunked fread because fseek seem to have failed
+
+                $end = $from + 1;
+                while (!feof($handle) && ftell($handle) < $end) {
+                    $len = $from - ftell($handle);
+                    if ($len > $chunkSize) {
+                        $len = $chunkSize;
+                    }
+                    $result = fread($handle, $len);
+
+                    if ($result === false) {
+                        $startReading = false;
+                        break;
+                    }
+                }
+            }
+
+            if ($startReading) {
+                $end = $to + 1;
+                while (!feof($handle) && ftell($handle) < $end) {
+                    $len = $end - ftell($handle);
+                    if ($len > $chunkSize) {
+                        $len = $chunkSize;
+                    }
+                    echo fread($handle, $len);
+                    flush();
+                }
+                return ftell($handle) - $from;
+            }
+
+            throw new \OCP\Files\UnseekableException('fseek error');
+        }
+        return false;
+    }
+
+    /**
+     * @param string $path
+     * @return mixed
+     */
+    public function isCreatable($path) {
+        return $this->basicOperation('isCreatable', $path);
+    }
+
+    /**
+     * @param string $path
+     * @return mixed
+     */
+    public function isReadable($path) {
+        return $this->basicOperation('isReadable', $path);
+    }
+
+    /**
+     * @param string $path
+     * @return mixed
+     */
+    public function isUpdatable($path) {
+        return $this->basicOperation('isUpdatable', $path);
+    }
+
+    /**
+     * @param string $path
+     * @return bool|mixed
+     */
+    public function isDeletable($path) {
+        $absolutePath = $this->getAbsolutePath($path);
+        $mount = Filesystem::getMountManager()->find($absolutePath);
+        if ($mount->getInternalPath($absolutePath) === '') {
+            return $mount instanceof MoveableMount;
+        }
+        return $this->basicOperation('isDeletable', $path);
+    }
+
+    /**
+     * @param string $path
+     * @return mixed
+     */
+    public function isSharable($path) {
+        return $this->basicOperation('isSharable', $path);
+    }
+
+    /**
+     * @param string $path
+     * @return bool|mixed
+     */
+    public function file_exists($path) {
+        if ($path == '/') {
+            return true;
+        }
+        return $this->basicOperation('file_exists', $path);
+    }
+
+    /**
+     * @param string $path
+     * @return mixed
+     */
+    public function filemtime($path) {
+        return $this->basicOperation('filemtime', $path);
+    }
+
+    /**
+     * @param string $path
+     * @param int|string $mtime
+     * @return bool
+     */
+    public function touch($path, $mtime = null) {
+        if (!is_null($mtime) and !is_numeric($mtime)) {
+            $mtime = strtotime($mtime);
+        }
+
+        $hooks = array('touch');
+
+        if (!$this->file_exists($path)) {
+            $hooks[] = 'create';
+            $hooks[] = 'write';
+        }
+        $result = $this->basicOperation('touch', $path, $hooks, $mtime);
+        if (!$result) {
+            // If create file fails because of permissions on external storage like SMB folders,
+            // check file exists and return false if not.
+            if (!$this->file_exists($path)) {
+                return false;
+            }
+            if (is_null($mtime)) {
+                $mtime = time();
+            }
+            //if native touch fails, we emulate it by changing the mtime in the cache
+            $this->putFileInfo($path, array('mtime' => floor($mtime)));
+        }
+        return true;
+    }
+
+    /**
+     * @param string $path
+     * @return mixed
+     */
+    public function file_get_contents($path) {
+        return $this->basicOperation('file_get_contents', $path, array('read'));
+    }
+
+    /**
+     * @param bool $exists
+     * @param string $path
+     * @param bool $run
+     */
+    protected function emit_file_hooks_pre($exists, $path, &$run) {
+        if (!$exists) {
+            \OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_create, array(
+                Filesystem::signal_param_path => $this->getHookPath($path),
+                Filesystem::signal_param_run => &$run,
+            ));
+        } else {
+            \OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_update, array(
+                Filesystem::signal_param_path => $this->getHookPath($path),
+                Filesystem::signal_param_run => &$run,
+            ));
+        }
+        \OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_write, array(
+            Filesystem::signal_param_path => $this->getHookPath($path),
+            Filesystem::signal_param_run => &$run,
+        ));
+    }
+
+    /**
+     * @param bool $exists
+     * @param string $path
+     */
+    protected function emit_file_hooks_post($exists, $path) {
+        if (!$exists) {
+            \OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_post_create, array(
+                Filesystem::signal_param_path => $this->getHookPath($path),
+            ));
+        } else {
+            \OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_post_update, array(
+                Filesystem::signal_param_path => $this->getHookPath($path),
+            ));
+        }
+        \OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_post_write, array(
+            Filesystem::signal_param_path => $this->getHookPath($path),
+        ));
+    }
+
+    /**
+     * @param string $path
+     * @param mixed $data
+     * @return bool|mixed
+     * @throws \Exception
+     */
+    public function file_put_contents($path, $data) {
+        if (is_resource($data)) { //not having to deal with streams in file_put_contents makes life easier
+            $absolutePath = Filesystem::normalizePath($this->getAbsolutePath($path));
+            if (Filesystem::isValidPath($path)
+                and !Filesystem::isFileBlacklisted($path)
+            ) {
+                $path = $this->getRelativePath($absolutePath);
+
+                $this->lockFile($path, ILockingProvider::LOCK_SHARED);
+
+                $exists = $this->file_exists($path);
+                $run = true;
+                if ($this->shouldEmitHooks($path)) {
+                    $this->emit_file_hooks_pre($exists, $path, $run);
+                }
+                if (!$run) {
+                    $this->unlockFile($path, ILockingProvider::LOCK_SHARED);
+                    return false;
+                }
+
+                $this->changeLock($path, ILockingProvider::LOCK_EXCLUSIVE);
+
+                /** @var \OC\Files\Storage\Storage $storage */
+                list($storage, $internalPath) = $this->resolvePath($path);
+                $target = $storage->fopen($internalPath, 'w');
+                if ($target) {
+                    list (, $result) = \OC_Helper::streamCopy($data, $target);
+                    fclose($target);
+                    fclose($data);
+
+                    $this->writeUpdate($storage, $internalPath);
+
+                    $this->changeLock($path, ILockingProvider::LOCK_SHARED);
+
+                    if ($this->shouldEmitHooks($path) && $result !== false) {
+                        $this->emit_file_hooks_post($exists, $path);
+                    }
+                    $this->unlockFile($path, ILockingProvider::LOCK_SHARED);
+                    return $result;
+                } else {
+                    $this->unlockFile($path, ILockingProvider::LOCK_EXCLUSIVE);
+                    return false;
+                }
+            } else {
+                return false;
+            }
+        } else {
+            $hooks = $this->file_exists($path) ? array('update', 'write') : array('create', 'write');
+            return $this->basicOperation('file_put_contents', $path, $hooks, $data);
+        }
+    }
+
+    /**
+     * @param string $path
+     * @return bool|mixed
+     */
+    public function unlink($path) {
+        if ($path === '' || $path === '/') {
+            // do not allow deleting the root
+            return false;
+        }
+        $postFix = (substr($path, -1) === '/') ? '/' : '';
+        $absolutePath = Filesystem::normalizePath($this->getAbsolutePath($path));
+        $mount = Filesystem::getMountManager()->find($absolutePath . $postFix);
+        if ($mount and $mount->getInternalPath($absolutePath) === '') {
+            return $this->removeMount($mount, $absolutePath);
+        }
+        if ($this->is_dir($path)) {
+            $result = $this->basicOperation('rmdir', $path, ['delete']);
+        } else {
+            $result = $this->basicOperation('unlink', $path, ['delete']);
+        }
+        if (!$result && !$this->file_exists($path)) { //clear ghost files from the cache on delete
+            $storage = $mount->getStorage();
+            $internalPath = $mount->getInternalPath($absolutePath);
+            $storage->getUpdater()->remove($internalPath);
+            return true;
+        } else {
+            return $result;
+        }
+    }
+
+    /**
+     * @param string $directory
+     * @return bool|mixed
+     */
+    public function deleteAll($directory) {
+        return $this->rmdir($directory);
+    }
+
+    /**
+     * Rename/move a file or folder from the source path to target path.
+     *
+     * @param string $path1 source path
+     * @param string $path2 target path
+     *
+     * @return bool|mixed
+     */
+    public function rename($path1, $path2) {
+        $absolutePath1 = Filesystem::normalizePath($this->getAbsolutePath($path1));
+        $absolutePath2 = Filesystem::normalizePath($this->getAbsolutePath($path2));
+        $result = false;
+        if (
+            Filesystem::isValidPath($path2)
+            and Filesystem::isValidPath($path1)
+            and !Filesystem::isFileBlacklisted($path2)
+        ) {
+            $path1 = $this->getRelativePath($absolutePath1);
+            $path2 = $this->getRelativePath($absolutePath2);
+            $exists = $this->file_exists($path2);
+
+            if ($path1 == null or $path2 == null) {
+                return false;
+            }
+
+            $this->lockFile($path1, ILockingProvider::LOCK_SHARED, true);
+            try {
+                $this->lockFile($path2, ILockingProvider::LOCK_SHARED, true);
+
+                $run = true;
+                if ($this->shouldEmitHooks($path1) && (Cache\Scanner::isPartialFile($path1) && !Cache\Scanner::isPartialFile($path2))) {
+                    // if it was a rename from a part file to a regular file it was a write and not a rename operation
+                    $this->emit_file_hooks_pre($exists, $path2, $run);
+                } elseif ($this->shouldEmitHooks($path1)) {
+                    \OC_Hook::emit(
+                        Filesystem::CLASSNAME, Filesystem::signal_rename,
+                        array(
+                            Filesystem::signal_param_oldpath => $this->getHookPath($path1),
+                            Filesystem::signal_param_newpath => $this->getHookPath($path2),
+                            Filesystem::signal_param_run => &$run
+                        )
+                    );
+                }
+                if ($run) {
+                    $this->verifyPath(dirname($path2), basename($path2));
+
+                    $manager = Filesystem::getMountManager();
+                    $mount1 = $this->getMount($path1);
+                    $mount2 = $this->getMount($path2);
+                    $storage1 = $mount1->getStorage();
+                    $storage2 = $mount2->getStorage();
+                    $internalPath1 = $mount1->getInternalPath($absolutePath1);
+                    $internalPath2 = $mount2->getInternalPath($absolutePath2);
+
+                    $this->changeLock($path1, ILockingProvider::LOCK_EXCLUSIVE, true);
+                    try {
+                        $this->changeLock($path2, ILockingProvider::LOCK_EXCLUSIVE, true);
+
+                        if ($internalPath1 === '') {
+                            if ($mount1 instanceof MoveableMount) {
+                                if ($this->isTargetAllowed($absolutePath2)) {
+                                    /**
+                                     * @var \OC\Files\Mount\MountPoint | \OC\Files\Mount\MoveableMount $mount1
+                                     */
+                                    $sourceMountPoint = $mount1->getMountPoint();
+                                    $result = $mount1->moveMount($absolutePath2);
+                                    $manager->moveMount($sourceMountPoint, $mount1->getMountPoint());
+                                } else {
+                                    $result = false;
+                                }
+                            } else {
+                                $result = false;
+                            }
+                            // moving a file/folder within the same mount point
+                        } elseif ($storage1 === $storage2) {
+                            if ($storage1) {
+                                $result = $storage1->rename($internalPath1, $internalPath2);
+                            } else {
+                                $result = false;
+                            }
+                            // moving a file/folder between storages (from $storage1 to $storage2)
+                        } else {
+                            $result = $storage2->moveFromStorage($storage1, $internalPath1, $internalPath2);
+                        }
+
+                        if ((Cache\Scanner::isPartialFile($path1) && !Cache\Scanner::isPartialFile($path2)) && $result !== false) {
+                            // if it was a rename from a part file to a regular file it was a write and not a rename operation
+                            $this->writeUpdate($storage2, $internalPath2);
+                        } else if ($result) {
+                            if ($internalPath1 !== '') { // don't do a cache update for moved mounts
+                                $this->renameUpdate($storage1, $storage2, $internalPath1, $internalPath2);
+                            }
+                        }
+                    } catch(\Exception $e) {
+                        throw $e;
+                    } finally {
+                        $this->changeLock($path1, ILockingProvider::LOCK_SHARED, true);
+                        $this->changeLock($path2, ILockingProvider::LOCK_SHARED, true);
+                    }
+
+                    if ((Cache\Scanner::isPartialFile($path1) && !Cache\Scanner::isPartialFile($path2)) && $result !== false) {
+                        if ($this->shouldEmitHooks()) {
+                            $this->emit_file_hooks_post($exists, $path2);
+                        }
+                    } elseif ($result) {
+                        if ($this->shouldEmitHooks($path1) and $this->shouldEmitHooks($path2)) {
+                            \OC_Hook::emit(
+                                Filesystem::CLASSNAME,
+                                Filesystem::signal_post_rename,
+                                array(
+                                    Filesystem::signal_param_oldpath => $this->getHookPath($path1),
+                                    Filesystem::signal_param_newpath => $this->getHookPath($path2)
+                                )
+                            );
+                        }
+                    }
+                }
+            } catch(\Exception $e) {
+                throw $e;
+            } finally {
+                $this->unlockFile($path1, ILockingProvider::LOCK_SHARED, true);
+                $this->unlockFile($path2, ILockingProvider::LOCK_SHARED, true);
+            }
+        }
+        return $result;
+    }
+
+    /**
+     * Copy a file/folder from the source path to target path
+     *
+     * @param string $path1 source path
+     * @param string $path2 target path
+     * @param bool $preserveMtime whether to preserve mtime on the copy
+     *
+     * @return bool|mixed
+     */
+    public function copy($path1, $path2, $preserveMtime = false) {
+        $absolutePath1 = Filesystem::normalizePath($this->getAbsolutePath($path1));
+        $absolutePath2 = Filesystem::normalizePath($this->getAbsolutePath($path2));
+        $result = false;
+        if (
+            Filesystem::isValidPath($path2)
+            and Filesystem::isValidPath($path1)
+            and !Filesystem::isFileBlacklisted($path2)
+        ) {
+            $path1 = $this->getRelativePath($absolutePath1);
+            $path2 = $this->getRelativePath($absolutePath2);
+
+            if ($path1 == null or $path2 == null) {
+                return false;
+            }
+            $run = true;
+
+            $this->lockFile($path2, ILockingProvider::LOCK_SHARED);
+            $this->lockFile($path1, ILockingProvider::LOCK_SHARED);
+            $lockTypePath1 = ILockingProvider::LOCK_SHARED;
+            $lockTypePath2 = ILockingProvider::LOCK_SHARED;
+
+            try {
+
+                $exists = $this->file_exists($path2);
+                if ($this->shouldEmitHooks()) {
+                    \OC_Hook::emit(
+                        Filesystem::CLASSNAME,
+                        Filesystem::signal_copy,
+                        array(
+                            Filesystem::signal_param_oldpath => $this->getHookPath($path1),
+                            Filesystem::signal_param_newpath => $this->getHookPath($path2),
+                            Filesystem::signal_param_run => &$run
+                        )
+                    );
+                    $this->emit_file_hooks_pre($exists, $path2, $run);
+                }
+                if ($run) {
+                    $mount1 = $this->getMount($path1);
+                    $mount2 = $this->getMount($path2);
+                    $storage1 = $mount1->getStorage();
+                    $internalPath1 = $mount1->getInternalPath($absolutePath1);
+                    $storage2 = $mount2->getStorage();
+                    $internalPath2 = $mount2->getInternalPath($absolutePath2);
+
+                    $this->changeLock($path2, ILockingProvider::LOCK_EXCLUSIVE);
+                    $lockTypePath2 = ILockingProvider::LOCK_EXCLUSIVE;
+
+                    if ($mount1->getMountPoint() == $mount2->getMountPoint()) {
+                        if ($storage1) {
+                            $result = $storage1->copy($internalPath1, $internalPath2);
+                        } else {
+                            $result = false;
+                        }
+                    } else {
+                        $result = $storage2->copyFromStorage($storage1, $internalPath1, $internalPath2);
+                    }
+
+                    $this->writeUpdate($storage2, $internalPath2);
+
+                    $this->changeLock($path2, ILockingProvider::LOCK_SHARED);
+                    $lockTypePath2 = ILockingProvider::LOCK_SHARED;
+
+                    if ($this->shouldEmitHooks() && $result !== false) {
+                        \OC_Hook::emit(
+                            Filesystem::CLASSNAME,
+                            Filesystem::signal_post_copy,
+                            array(
+                                Filesystem::signal_param_oldpath => $this->getHookPath($path1),
+                                Filesystem::signal_param_newpath => $this->getHookPath($path2)
+                            )
+                        );
+                        $this->emit_file_hooks_post($exists, $path2);
+                    }
+
+                }
+            } catch (\Exception $e) {
+                $this->unlockFile($path2, $lockTypePath2);
+                $this->unlockFile($path1, $lockTypePath1);
+                throw $e;
+            }
+
+            $this->unlockFile($path2, $lockTypePath2);
+            $this->unlockFile($path1, $lockTypePath1);
+
+        }
+        return $result;
+    }
+
+    /**
+     * @param string $path
+     * @param string $mode 'r' or 'w'
+     * @return resource
+     */
+    public function fopen($path, $mode) {
+        $mode = str_replace('b', '', $mode); // the binary flag is a windows only feature which we do not support
+        $hooks = array();
+        switch ($mode) {
+            case 'r':
+                $hooks[] = 'read';
+                break;
+            case 'r+':
+            case 'w+':
+            case 'x+':
+            case 'a+':
+                $hooks[] = 'read';
+                $hooks[] = 'write';
+                break;
+            case 'w':
+            case 'x':
+            case 'a':
+                $hooks[] = 'write';
+                break;
+            default:
+                \OCP\Util::writeLog('core', 'invalid mode (' . $mode . ') for ' . $path, ILogger::ERROR);
+        }
+
+        if ($mode !== 'r' && $mode !== 'w') {
+            \OC::$server->getLogger()->info('Trying to open a file with a mode other than "r" or "w" can cause severe performance issues with some backends');
+        }
+
+        return $this->basicOperation('fopen', $path, $hooks, $mode);
+    }
+
+    /**
+     * @param string $path
+     * @return bool|string
+     * @throws \OCP\Files\InvalidPathException
+     */
+    public function toTmpFile($path) {
+        $this->assertPathLength($path);
+        if (Filesystem::isValidPath($path)) {
+            $source = $this->fopen($path, 'r');
+            if ($source) {
+                $extension = pathinfo($path, PATHINFO_EXTENSION);
+                $tmpFile = \OC::$server->getTempManager()->getTemporaryFile($extension);
+                file_put_contents($tmpFile, $source);
+                return $tmpFile;
+            } else {
+                return false;
+            }
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * @param string $tmpFile
+     * @param string $path
+     * @return bool|mixed
+     * @throws \OCP\Files\InvalidPathException
+     */
+    public function fromTmpFile($tmpFile, $path) {
+        $this->assertPathLength($path);
+        if (Filesystem::isValidPath($path)) {
+
+            // Get directory that the file is going into
+            $filePath = dirname($path);
+
+            // Create the directories if any
+            if (!$this->file_exists($filePath)) {
+                $result = $this->createParentDirectories($filePath);
+                if ($result === false) {
+                    return false;
+                }
+            }
+
+            $source = fopen($tmpFile, 'r');
+            if ($source) {
+                $result = $this->file_put_contents($path, $source);
+                // $this->file_put_contents() might have already closed
+                // the resource, so we check it, before trying to close it
+                // to avoid messages in the error log.
+                if (is_resource($source)) {
+                    fclose($source);
+                }
+                unlink($tmpFile);
+                return $result;
+            } else {
+                return false;
+            }
+        } else {
+            return false;
+        }
+    }
+
+
+    /**
+     * @param string $path
+     * @return mixed
+     * @throws \OCP\Files\InvalidPathException
+     */
+    public function getMimeType($path) {
+        $this->assertPathLength($path);
+        return $this->basicOperation('getMimeType', $path);
+    }
+
+    /**
+     * @param string $type
+     * @param string $path
+     * @param bool $raw
+     * @return bool|null|string
+     */
+    public function hash($type, $path, $raw = false) {
+        $postFix = (substr($path, -1) === '/') ? '/' : '';
+        $absolutePath = Filesystem::normalizePath($this->getAbsolutePath($path));
+        if (Filesystem::isValidPath($path)) {
+            $path = $this->getRelativePath($absolutePath);
+            if ($path == null) {
+                return false;
+            }
+            if ($this->shouldEmitHooks($path)) {
+                \OC_Hook::emit(
+                    Filesystem::CLASSNAME,
+                    Filesystem::signal_read,
+                    array(Filesystem::signal_param_path => $this->getHookPath($path))
+                );
+            }
+            list($storage, $internalPath) = Filesystem::resolvePath($absolutePath . $postFix);
+            if ($storage) {
+                return $storage->hash($type, $internalPath, $raw);
+            }
+        }
+        return null;
+    }
+
+    /**
+     * @param string $path
+     * @return mixed
+     * @throws \OCP\Files\InvalidPathException
+     */
+    public function free_space($path = '/') {
+        $this->assertPathLength($path);
+        $result = $this->basicOperation('free_space', $path);
+        if ($result === null) {
+            throw new InvalidPathException();
+        }
+        return $result;
+    }
+
+    /**
+     * abstraction layer for basic filesystem functions: wrapper for \OC\Files\Storage\Storage
+     *
+     * @param string $operation
+     * @param string $path
+     * @param array $hooks (optional)
+     * @param mixed $extraParam (optional)
+     * @return mixed
+     * @throws \Exception
+     *
+     * This method takes requests for basic filesystem functions (e.g. reading & writing
+     * files), processes hooks and proxies, sanitises paths, and finally passes them on to
+     * \OC\Files\Storage\Storage for delegation to a storage backend for execution
+     */
+    private function basicOperation($operation, $path, $hooks = [], $extraParam = null) {
+        $postFix = (substr($path, -1) === '/') ? '/' : '';
+        $absolutePath = Filesystem::normalizePath($this->getAbsolutePath($path));
+        if (Filesystem::isValidPath($path)
+            and !Filesystem::isFileBlacklisted($path)
+        ) {
+            $path = $this->getRelativePath($absolutePath);
+            if ($path == null) {
+                return false;
+            }
+
+            if (in_array('write', $hooks) || in_array('delete', $hooks) || in_array('read', $hooks)) {
+                // always a shared lock during pre-hooks so the hook can read the file
+                $this->lockFile($path, ILockingProvider::LOCK_SHARED);
+            }
+
+            $run = $this->runHooks($hooks, $path);
+            /** @var \OC\Files\Storage\Storage $storage */
+            list($storage, $internalPath) = Filesystem::resolvePath($absolutePath . $postFix);
+            if ($run and $storage) {
+                if (in_array('write', $hooks) || in_array('delete', $hooks)) {
+                    $this->changeLock($path, ILockingProvider::LOCK_EXCLUSIVE);
+                }
+                try {
+                    if (!is_null($extraParam)) {
+                        $result = $storage->$operation($internalPath, $extraParam);
+                    } else {
+                        $result = $storage->$operation($internalPath);
+                    }
+                } catch (\Exception $e) {
+                    if (in_array('write', $hooks) || in_array('delete', $hooks)) {
+                        $this->unlockFile($path, ILockingProvider::LOCK_EXCLUSIVE);
+                    } else if (in_array('read', $hooks)) {
+                        $this->unlockFile($path, ILockingProvider::LOCK_SHARED);
+                    }
+                    throw $e;
+                }
+
+                if ($result && in_array('delete', $hooks) and $result) {
+                    $this->removeUpdate($storage, $internalPath);
+                }
+                if ($result && in_array('write', $hooks) and $operation !== 'fopen') {
+                    $this->writeUpdate($storage, $internalPath);
+                }
+                if ($result && in_array('touch', $hooks)) {
+                    $this->writeUpdate($storage, $internalPath, $extraParam);
+                }
+
+                if ((in_array('write', $hooks) || in_array('delete', $hooks)) && ($operation !== 'fopen' || $result === false)) {
+                    $this->changeLock($path, ILockingProvider::LOCK_SHARED);
+                }
+
+                $unlockLater = false;
+                if ($this->lockingEnabled && $operation === 'fopen' && is_resource($result)) {
+                    $unlockLater = true;
+                    // make sure our unlocking callback will still be called if connection is aborted
+                    ignore_user_abort(true);
+                    $result = CallbackWrapper::wrap($result, null, null, function () use ($hooks, $path) {
+                        if (in_array('write', $hooks)) {
+                            $this->unlockFile($path, ILockingProvider::LOCK_EXCLUSIVE);
+                        } else if (in_array('read', $hooks)) {
+                            $this->unlockFile($path, ILockingProvider::LOCK_SHARED);
+                        }
+                    });
+                }
+
+                if ($this->shouldEmitHooks($path) && $result !== false) {
+                    if ($operation != 'fopen') { //no post hooks for fopen, the file stream is still open
+                        $this->runHooks($hooks, $path, true);
+                    }
+                }
+
+                if (!$unlockLater
+                    && (in_array('write', $hooks) || in_array('delete', $hooks) || in_array('read', $hooks))
+                ) {
+                    $this->unlockFile($path, ILockingProvider::LOCK_SHARED);
+                }
+                return $result;
+            } else {
+                $this->unlockFile($path, ILockingProvider::LOCK_SHARED);
+            }
+        }
+        return null;
+    }
+
+    /**
+     * get the path relative to the default root for hook usage
+     *
+     * @param string $path
+     * @return string
+     */
+    private function getHookPath($path) {
+        if (!Filesystem::getView()) {
+            return $path;
+        }
+        return Filesystem::getView()->getRelativePath($this->getAbsolutePath($path));
+    }
+
+    private function shouldEmitHooks($path = '') {
+        if ($path && Cache\Scanner::isPartialFile($path)) {
+            return false;
+        }
+        if (!Filesystem::$loaded) {
+            return false;
+        }
+        $defaultRoot = Filesystem::getRoot();
+        if ($defaultRoot === null) {
+            return false;
+        }
+        if ($this->fakeRoot === $defaultRoot) {
+            return true;
+        }
+        $fullPath = $this->getAbsolutePath($path);
+
+        if ($fullPath === $defaultRoot) {
+            return true;
+        }
+
+        return (strlen($fullPath) > strlen($defaultRoot)) && (substr($fullPath, 0, strlen($defaultRoot) + 1) === $defaultRoot . '/');
+    }
+
+    /**
+     * @param string[] $hooks
+     * @param string $path
+     * @param bool $post
+     * @return bool
+     */
+    private function runHooks($hooks, $path, $post = false) {
+        $relativePath = $path;
+        $path = $this->getHookPath($path);
+        $prefix = $post ? 'post_' : '';
+        $run = true;
+        if ($this->shouldEmitHooks($relativePath)) {
+            foreach ($hooks as $hook) {
+                if ($hook != 'read') {
+                    \OC_Hook::emit(
+                        Filesystem::CLASSNAME,
+                        $prefix . $hook,
+                        array(
+                            Filesystem::signal_param_run => &$run,
+                            Filesystem::signal_param_path => $path
+                        )
+                    );
+                } elseif (!$post) {
+                    \OC_Hook::emit(
+                        Filesystem::CLASSNAME,
+                        $prefix . $hook,
+                        array(
+                            Filesystem::signal_param_path => $path
+                        )
+                    );
+                }
+            }
+        }
+        return $run;
+    }
+
+    /**
+     * check if a file or folder has been updated since $time
+     *
+     * @param string $path
+     * @param int $time
+     * @return bool
+     */
+    public function hasUpdated($path, $time) {
+        return $this->basicOperation('hasUpdated', $path, array(), $time);
+    }
+
+    /**
+     * @param string $ownerId
+     * @return \OC\User\User
+     */
+    private function getUserObjectForOwner($ownerId) {
+        $owner = $this->userManager->get($ownerId);
+        if ($owner instanceof IUser) {
+            return $owner;
+        } else {
+            return new User($ownerId, null);
+        }
+    }
+
+    /**
+     * Get file info from cache
+     *
+     * If the file is not in cached it will be scanned
+     * If the file has changed on storage the cache will be updated
+     *
+     * @param \OC\Files\Storage\Storage $storage
+     * @param string $internalPath
+     * @param string $relativePath
+     * @return ICacheEntry|bool
+     */
+    private function getCacheEntry($storage, $internalPath, $relativePath) {
+        $cache = $storage->getCache($internalPath);
+        $data = $cache->get($internalPath);
+        $watcher = $storage->getWatcher($internalPath);
+
+        try {
+            // if the file is not in the cache or needs to be updated, trigger the scanner and reload the data
+            if (!$data || $data['size'] === -1) {
+                $this->lockFile($relativePath, ILockingProvider::LOCK_SHARED);
+                if (!$storage->file_exists($internalPath)) {
+                    $this->unlockFile($relativePath, ILockingProvider::LOCK_SHARED);
+                    return false;
+                }
+                $scanner = $storage->getScanner($internalPath);
+                $scanner->scan($internalPath, Cache\Scanner::SCAN_SHALLOW);
+                $data = $cache->get($internalPath);
+                $this->unlockFile($relativePath, ILockingProvider::LOCK_SHARED);
+            } else if (!Cache\Scanner::isPartialFile($internalPath) && $watcher->needsUpdate($internalPath, $data)) {
+                $this->lockFile($relativePath, ILockingProvider::LOCK_SHARED);
+                $watcher->update($internalPath, $data);
+                $storage->getPropagator()->propagateChange($internalPath, time());
+                $data = $cache->get($internalPath);
+                $this->unlockFile($relativePath, ILockingProvider::LOCK_SHARED);
+            }
+        } catch (LockedException $e) {
+            // if the file is locked we just use the old cache info
+        }
+
+        return $data;
+    }
+
+    /**
+     * get the filesystem info
+     *
+     * @param string $path
+     * @param boolean|string $includeMountPoints true to add mountpoint sizes,
+     * 'ext' to add only ext storage mount point sizes. Defaults to true.
+     * defaults to true
+     * @return \OC\Files\FileInfo|false False if file does not exist
+     */
+    public function getFileInfo($path, $includeMountPoints = true) {
+        $this->assertPathLength($path);
+        if (!Filesystem::isValidPath($path)) {
+            return false;
+        }
+        if (Cache\Scanner::isPartialFile($path)) {
+            return $this->getPartFileInfo($path);
+        }
+        $relativePath = $path;
+        $path = Filesystem::normalizePath($this->fakeRoot . '/' . $path);
+
+        $mount = Filesystem::getMountManager()->find($path);
+        if (!$mount) {
+            return false;
+        }
+        $storage = $mount->getStorage();
+        $internalPath = $mount->getInternalPath($path);
+        if ($storage) {
+            $data = $this->getCacheEntry($storage, $internalPath, $relativePath);
+
+            if (!$data instanceof ICacheEntry) {
+                return false;
+            }
+
+            if ($mount instanceof MoveableMount && $internalPath === '') {
+                $data['permissions'] |= \OCP\Constants::PERMISSION_DELETE;
+            }
+
+            $owner = $this->getUserObjectForOwner($storage->getOwner($internalPath));
+            $info = new FileInfo($path, $storage, $internalPath, $data, $mount, $owner);
+
+            if ($data and isset($data['fileid'])) {
+                if ($includeMountPoints and $data['mimetype'] === 'httpd/unix-directory') {
+                    //add the sizes of other mount points to the folder
+                    $extOnly = ($includeMountPoints === 'ext');
+                    $mounts = Filesystem::getMountManager()->findIn($path);
+                    $info->setSubMounts(array_filter($mounts, function (IMountPoint $mount) use ($extOnly) {
+                        $subStorage = $mount->getStorage();
+                        return !($extOnly && $subStorage instanceof \OCA\Files_Sharing\SharedStorage);
+                    }));
+                }
+            }
+
+            return $info;
+        }
+
+        return false;
+    }
+
+    /**
+     * get the content of a directory
+     *
+     * @param string $directory path under datadirectory
+     * @param string $mimetype_filter limit returned content to this mimetype or mimepart
+     * @return FileInfo[]
+     */
+    public function getDirectoryContent($directory, $mimetype_filter = '') {
+        $this->assertPathLength($directory);
+        if (!Filesystem::isValidPath($directory)) {
+            return [];
+        }
+        $path = $this->getAbsolutePath($directory);
+        $path = Filesystem::normalizePath($path);
+        $mount = $this->getMount($directory);
+        if (!$mount) {
+            return [];
+        }
+        $storage = $mount->getStorage();
+        $internalPath = $mount->getInternalPath($path);
+        if ($storage) {
+            $cache = $storage->getCache($internalPath);
+            $user = \OC_User::getUser();
+
+            $data = $this->getCacheEntry($storage, $internalPath, $directory);
+
+            if (!$data instanceof ICacheEntry || !isset($data['fileid']) || !($data->getPermissions() && Constants::PERMISSION_READ)) {
+                return [];
+            }
+
+            $folderId = $data['fileid'];
+            $contents = $cache->getFolderContentsById($folderId); //TODO: mimetype_filter
+
+            $sharingDisabled = \OCP\Util::isSharingDisabledForUser();
+            /**
+             * @var \OC\Files\FileInfo[] $files
+             */
+            $files = array_map(function (ICacheEntry $content) use ($path, $storage, $mount, $sharingDisabled) {
+                if ($sharingDisabled) {
+                    $content['permissions'] = $content['permissions'] & ~\OCP\Constants::PERMISSION_SHARE;
+                }
+                $owner = $this->getUserObjectForOwner($storage->getOwner($content['path']));
+                return new FileInfo($path . '/' . $content['name'], $storage, $content['path'], $content, $mount, $owner);
+            }, $contents);
+
+            //add a folder for any mountpoint in this directory and add the sizes of other mountpoints to the folders
+            $mounts = Filesystem::getMountManager()->findIn($path);
+            $dirLength = strlen($path);
+            foreach ($mounts as $mount) {
+                $mountPoint = $mount->getMountPoint();
+                $subStorage = $mount->getStorage();
+                if ($subStorage) {
+                    $subCache = $subStorage->getCache('');
+
+                    $rootEntry = $subCache->get('');
+                    if (!$rootEntry) {
+                        $subScanner = $subStorage->getScanner('');
+                        try {
+                            $subScanner->scanFile('');
+                        } catch (\OCP\Files\StorageNotAvailableException $e) {
+                            continue;
+                        } catch (\OCP\Files\StorageInvalidException $e) {
+                            continue;
+                        } catch (\Exception $e) {
+                            // sometimes when the storage is not available it can be any exception
+                            \OC::$server->getLogger()->logException($e, [
+                                'message' => 'Exception while scanning storage "' . $subStorage->getId() . '"',
+                                'level' => ILogger::ERROR,
+                                'app' => 'lib',
+                            ]);
+                            continue;
+                        }
+                        $rootEntry = $subCache->get('');
+                    }
+
+                    if ($rootEntry && ($rootEntry->getPermissions() && Constants::PERMISSION_READ)) {
+                        $relativePath = trim(substr($mountPoint, $dirLength), '/');
+                        if ($pos = strpos($relativePath, '/')) {
+                            //mountpoint inside subfolder add size to the correct folder
+                            $entryName = substr($relativePath, 0, $pos);
+                            foreach ($files as &$entry) {
+                                if ($entry->getName() === $entryName) {
+                                    $entry->addSubEntry($rootEntry, $mountPoint);
+                                }
+                            }
+                        } else { //mountpoint in this folder, add an entry for it
+                            $rootEntry['name'] = $relativePath;
+                            $rootEntry['type'] = $rootEntry['mimetype'] === 'httpd/unix-directory' ? 'dir' : 'file';
+                            $permissions = $rootEntry['permissions'];
+                            // do not allow renaming/deleting the mount point if they are not shared files/folders
+                            // for shared files/folders we use the permissions given by the owner
+                            if ($mount instanceof MoveableMount) {
+                                $rootEntry['permissions'] = $permissions | \OCP\Constants::PERMISSION_UPDATE | \OCP\Constants::PERMISSION_DELETE;
+                            } else {
+                                $rootEntry['permissions'] = $permissions & (\OCP\Constants::PERMISSION_ALL - (\OCP\Constants::PERMISSION_UPDATE | \OCP\Constants::PERMISSION_DELETE));
+                            }
+
+                            //remove any existing entry with the same name
+                            foreach ($files as $i => $file) {
+                                if ($file['name'] === $rootEntry['name']) {
+                                    unset($files[$i]);
+                                    break;
+                                }
+                            }
+                            $rootEntry['path'] = substr(Filesystem::normalizePath($path . '/' . $rootEntry['name']), strlen($user) + 2); // full path without /$user/
+
+                            // if sharing was disabled for the user we remove the share permissions
+                            if (\OCP\Util::isSharingDisabledForUser()) {
+                                $rootEntry['permissions'] = $rootEntry['permissions'] & ~\OCP\Constants::PERMISSION_SHARE;
+                            }
+
+                            $owner = $this->getUserObjectForOwner($subStorage->getOwner(''));
+                            $files[] = new FileInfo($path . '/' . $rootEntry['name'], $subStorage, '', $rootEntry, $mount, $owner);
+                        }
+                    }
+                }
+            }
+
+            if ($mimetype_filter) {
+                $files = array_filter($files, function (FileInfo $file) use ($mimetype_filter) {
+                    if (strpos($mimetype_filter, '/')) {
+                        return $file->getMimetype() === $mimetype_filter;
+                    } else {
+                        return $file->getMimePart() === $mimetype_filter;
+                    }
+                });
+            }
+
+            return $files;
+        } else {
+            return [];
+        }
+    }
+
+    /**
+     * change file metadata
+     *
+     * @param string $path
+     * @param array|\OCP\Files\FileInfo $data
+     * @return int
+     *
+     * returns the fileid of the updated file
+     */
+    public function putFileInfo($path, $data) {
+        $this->assertPathLength($path);
+        if ($data instanceof FileInfo) {
+            $data = $data->getData();
+        }
+        $path = Filesystem::normalizePath($this->fakeRoot . '/' . $path);
+        /**
+         * @var \OC\Files\Storage\Storage $storage
+         * @var string $internalPath
+         */
+        list($storage, $internalPath) = Filesystem::resolvePath($path);
+        if ($storage) {
+            $cache = $storage->getCache($path);
+
+            if (!$cache->inCache($internalPath)) {
+                $scanner = $storage->getScanner($internalPath);
+                $scanner->scan($internalPath, Cache\Scanner::SCAN_SHALLOW);
+            }
+
+            return $cache->put($internalPath, $data);
+        } else {
+            return -1;
+        }
+    }
+
+    /**
+     * search for files with the name matching $query
+     *
+     * @param string $query
+     * @return FileInfo[]
+     */
+    public function search($query) {
+        return $this->searchCommon('search', array('%' . $query . '%'));
+    }
+
+    /**
+     * search for files with the name matching $query
+     *
+     * @param string $query
+     * @return FileInfo[]
+     */
+    public function searchRaw($query) {
+        return $this->searchCommon('search', array($query));
+    }
+
+    /**
+     * search for files by mimetype
+     *
+     * @param string $mimetype
+     * @return FileInfo[]
+     */
+    public function searchByMime($mimetype) {
+        return $this->searchCommon('searchByMime', array($mimetype));
+    }
+
+    /**
+     * search for files by tag
+     *
+     * @param string|int $tag name or tag id
+     * @param string $userId owner of the tags
+     * @return FileInfo[]
+     */
+    public function searchByTag($tag, $userId) {
+        return $this->searchCommon('searchByTag', array($tag, $userId));
+    }
+
+    /**
+     * @param string $method cache method
+     * @param array $args
+     * @return FileInfo[]
+     */
+    private function searchCommon($method, $args) {
+        $files = array();
+        $rootLength = strlen($this->fakeRoot);
+
+        $mount = $this->getMount('');
+        $mountPoint = $mount->getMountPoint();
+        $storage = $mount->getStorage();
+        if ($storage) {
+            $cache = $storage->getCache('');
+
+            $results = call_user_func_array(array($cache, $method), $args);
+            foreach ($results as $result) {
+                if (substr($mountPoint . $result['path'], 0, $rootLength + 1) === $this->fakeRoot . '/') {
+                    $internalPath = $result['path'];
+                    $path = $mountPoint . $result['path'];
+                    $result['path'] = substr($mountPoint . $result['path'], $rootLength);
+                    $owner = \OC::$server->getUserManager()->get($storage->getOwner($internalPath));
+                    $files[] = new FileInfo($path, $storage, $internalPath, $result, $mount, $owner);
+                }
+            }
+
+            $mounts = Filesystem::getMountManager()->findIn($this->fakeRoot);
+            foreach ($mounts as $mount) {
+                $mountPoint = $mount->getMountPoint();
+                $storage = $mount->getStorage();
+                if ($storage) {
+                    $cache = $storage->getCache('');
+
+                    $relativeMountPoint = substr($mountPoint, $rootLength);
+                    $results = call_user_func_array(array($cache, $method), $args);
+                    if ($results) {
+                        foreach ($results as $result) {
+                            $internalPath = $result['path'];
+                            $result['path'] = rtrim($relativeMountPoint . $result['path'], '/');
+                            $path = rtrim($mountPoint . $internalPath, '/');
+                            $owner = \OC::$server->getUserManager()->get($storage->getOwner($internalPath));
+                            $files[] = new FileInfo($path, $storage, $internalPath, $result, $mount, $owner);
+                        }
+                    }
+                }
+            }
+        }
+        return $files;
+    }
+
+    /**
+     * Get the owner for a file or folder
+     *
+     * @param string $path
+     * @return string the user id of the owner
+     * @throws NotFoundException
+     */
+    public function getOwner($path) {
+        $info = $this->getFileInfo($path);
+        if (!$info) {
+            throw new NotFoundException($path . ' not found while trying to get owner');
+        }
+        return $info->getOwner()->getUID();
+    }
+
+    /**
+     * get the ETag for a file or folder
+     *
+     * @param string $path
+     * @return string
+     */
+    public function getETag($path) {
+        /**
+         * @var Storage\Storage $storage
+         * @var string $internalPath
+         */
+        list($storage, $internalPath) = $this->resolvePath($path);
+        if ($storage) {
+            return $storage->getETag($internalPath);
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * Get the path of a file by id, relative to the view
+     *
+     * Note that the resulting path is not guarantied to be unique for the id, multiple paths can point to the same file
+     *
+     * @param int $id
+     * @throws NotFoundException
+     * @return string
+     */
+    public function getPath($id) {
+        $id = (int)$id;
+        $manager = Filesystem::getMountManager();
+        $mounts = $manager->findIn($this->fakeRoot);
+        $mounts[] = $manager->find($this->fakeRoot);
+        // reverse the array so we start with the storage this view is in
+        // which is the most likely to contain the file we're looking for
+        $mounts = array_reverse($mounts);
+        foreach ($mounts as $mount) {
+            /**
+             * @var \OC\Files\Mount\MountPoint $mount
+             */
+            if ($mount->getStorage()) {
+                $cache = $mount->getStorage()->getCache();
+                $internalPath = $cache->getPathById($id);
+                if (is_string($internalPath)) {
+                    $fullPath = $mount->getMountPoint() . $internalPath;
+                    if (!is_null($path = $this->getRelativePath($fullPath))) {
+                        return $path;
+                    }
+                }
+            }
+        }
+        throw new NotFoundException(sprintf('File with id "%s" has not been found.', $id));
+    }
+
+    /**
+     * @param string $path
+     * @throws InvalidPathException
+     */
+    private function assertPathLength($path) {
+        $maxLen = min(PHP_MAXPATHLEN, 4000);
+        // Check for the string length - performed using isset() instead of strlen()
+        // because isset() is about 5x-40x faster.
+        if (isset($path[$maxLen])) {
+            $pathLen = strlen($path);
+            throw new \OCP\Files\InvalidPathException("Path length($pathLen) exceeds max path length($maxLen): $path");
+        }
+    }
+
+    /**
+     * check if it is allowed to move a mount point to a given target.
+     * It is not allowed to move a mount point into a different mount point or
+     * into an already shared folder
+     *
+     * @param string $target path
+     * @return boolean
+     */
+    private function isTargetAllowed($target) {
+
+        list($targetStorage, $targetInternalPath) = \OC\Files\Filesystem::resolvePath($target);
+        if (!$targetStorage->instanceOfStorage('\OCP\Files\IHomeStorage')) {
+            \OCP\Util::writeLog('files',
+                'It is not allowed to move one mount point into another one',
+                ILogger::DEBUG);
+            return false;
+        }
+
+        // note: cannot use the view because the target is already locked
+        $fileId = (int)$targetStorage->getCache()->getId($targetInternalPath);
+        if ($fileId === -1) {
+            // target might not exist, need to check parent instead
+            $fileId = (int)$targetStorage->getCache()->getId(dirname($targetInternalPath));
+        }
+
+        // check if any of the parents were shared by the current owner (include collections)
+        $shares = \OCP\Share::getItemShared(
+            'folder',
+            $fileId,
+            \OCP\Share::FORMAT_NONE,
+            null,
+            true
+        );
+
+        if (count($shares) > 0) {
+            \OCP\Util::writeLog('files',
+                'It is not allowed to move one mount point into a shared folder',
+                ILogger::DEBUG);
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * Get a fileinfo object for files that are ignored in the cache (part files)
+     *
+     * @param string $path
+     * @return \OCP\Files\FileInfo
+     */
+    private function getPartFileInfo($path) {
+        $mount = $this->getMount($path);
+        $storage = $mount->getStorage();
+        $internalPath = $mount->getInternalPath($this->getAbsolutePath($path));
+        $owner = \OC::$server->getUserManager()->get($storage->getOwner($internalPath));
+        return new FileInfo(
+            $this->getAbsolutePath($path),
+            $storage,
+            $internalPath,
+            [
+                'fileid' => null,
+                'mimetype' => $storage->getMimeType($internalPath),
+                'name' => basename($path),
+                'etag' => null,
+                'size' => $storage->filesize($internalPath),
+                'mtime' => $storage->filemtime($internalPath),
+                'encrypted' => false,
+                'permissions' => \OCP\Constants::PERMISSION_ALL
+            ],
+            $mount,
+            $owner
+        );
+    }
+
+    /**
+     * @param string $path
+     * @param string $fileName
+     * @throws InvalidPathException
+     */
+    public function verifyPath($path, $fileName) {
+        try {
+            /** @type \OCP\Files\Storage $storage */
+            list($storage, $internalPath) = $this->resolvePath($path);
+            $storage->verifyPath($internalPath, $fileName);
+        } catch (ReservedWordException $ex) {
+            $l = \OC::$server->getL10N('lib');
+            throw new InvalidPathException($l->t('File name is a reserved word'));
+        } catch (InvalidCharacterInPathException $ex) {
+            $l = \OC::$server->getL10N('lib');
+            throw new InvalidPathException($l->t('File name contains at least one invalid character'));
+        } catch (FileNameTooLongException $ex) {
+            $l = \OC::$server->getL10N('lib');
+            throw new InvalidPathException($l->t('File name is too long'));
+        } catch (InvalidDirectoryException $ex) {
+            $l = \OC::$server->getL10N('lib');
+            throw new InvalidPathException($l->t('Dot files are not allowed'));
+        } catch (EmptyFileNameException $ex) {
+            $l = \OC::$server->getL10N('lib');
+            throw new InvalidPathException($l->t('Empty filename is not allowed'));
+        }
+    }
+
+    /**
+     * get all parent folders of $path
+     *
+     * @param string $path
+     * @return string[]
+     */
+    private function getParents($path) {
+        $path = trim($path, '/');
+        if (!$path) {
+            return [];
+        }
+
+        $parts = explode('/', $path);
+
+        // remove the single file
+        array_pop($parts);
+        $result = array('/');
+        $resultPath = '';
+        foreach ($parts as $part) {
+            if ($part) {
+                $resultPath .= '/' . $part;
+                $result[] = $resultPath;
+            }
+        }
+        return $result;
+    }
+
+    /**
+     * Returns the mount point for which to lock
+     *
+     * @param string $absolutePath absolute path
+     * @param bool $useParentMount true to return parent mount instead of whatever
+     * is mounted directly on the given path, false otherwise
+     * @return \OC\Files\Mount\MountPoint mount point for which to apply locks
+     */
+    private function getMountForLock($absolutePath, $useParentMount = false) {
+        $results = [];
+        $mount = Filesystem::getMountManager()->find($absolutePath);
+        if (!$mount) {
+            return $results;
+        }
+
+        if ($useParentMount) {
+            // find out if something is mounted directly on the path
+            $internalPath = $mount->getInternalPath($absolutePath);
+            if ($internalPath === '') {
+                // resolve the parent mount instead
+                $mount = Filesystem::getMountManager()->find(dirname($absolutePath));
+            }
+        }
+
+        return $mount;
+    }
+
+    /**
+     * Lock the given path
+     *
+     * @param string $path the path of the file to lock, relative to the view
+     * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
+     * @param bool $lockMountPoint true to lock the mount point, false to lock the attached mount/storage
+     *
+     * @return bool False if the path is excluded from locking, true otherwise
+     * @throws \OCP\Lock\LockedException if the path is already locked
+     */
+    private function lockPath($path, $type, $lockMountPoint = false) {
+        $absolutePath = $this->getAbsolutePath($path);
+        $absolutePath = Filesystem::normalizePath($absolutePath);
+        if (!$this->shouldLockFile($absolutePath)) {
+            return false;
+        }
+
+        $mount = $this->getMountForLock($absolutePath, $lockMountPoint);
+        if ($mount) {
+            try {
+                $storage = $mount->getStorage();
+                if ($storage->instanceOfStorage('\OCP\Files\Storage\ILockingStorage')) {
+                    $storage->acquireLock(
+                        $mount->getInternalPath($absolutePath),
+                        $type,
+                        $this->lockingProvider
+                    );
+                }
+            } catch (\OCP\Lock\LockedException $e) {
+                // rethrow with the a human-readable path
+                throw new \OCP\Lock\LockedException(
+                    $this->getPathRelativeToFiles($absolutePath),
+                    $e
+                );
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * Change the lock type
+     *
+     * @param string $path the path of the file to lock, relative to the view
+     * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
+     * @param bool $lockMountPoint true to lock the mount point, false to lock the attached mount/storage
+     *
+     * @return bool False if the path is excluded from locking, true otherwise
+     * @throws \OCP\Lock\LockedException if the path is already locked
+     */
+    public function changeLock($path, $type, $lockMountPoint = false) {
+        $path = Filesystem::normalizePath($path);
+        $absolutePath = $this->getAbsolutePath($path);
+        $absolutePath = Filesystem::normalizePath($absolutePath);
+        if (!$this->shouldLockFile($absolutePath)) {
+            return false;
+        }
+
+        $mount = $this->getMountForLock($absolutePath, $lockMountPoint);
+        if ($mount) {
+            try {
+                $storage = $mount->getStorage();
+                if ($storage->instanceOfStorage('\OCP\Files\Storage\ILockingStorage')) {
+                    $storage->changeLock(
+                        $mount->getInternalPath($absolutePath),
+                        $type,
+                        $this->lockingProvider
+                    );
+                }
+            } catch (\OCP\Lock\LockedException $e) {
+                try {
+                    // rethrow with the a human-readable path
+                    throw new \OCP\Lock\LockedException(
+                        $this->getPathRelativeToFiles($absolutePath),
+                        $e
+                    );
+                } catch (\InvalidArgumentException $e) {
+                    throw new \OCP\Lock\LockedException(
+                        $absolutePath,
+                        $e
+                    );
+                }
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * Unlock the given path
+     *
+     * @param string $path the path of the file to unlock, relative to the view
+     * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
+     * @param bool $lockMountPoint true to lock the mount point, false to lock the attached mount/storage
+     *
+     * @return bool False if the path is excluded from locking, true otherwise
+     */
+    private function unlockPath($path, $type, $lockMountPoint = false) {
+        $absolutePath = $this->getAbsolutePath($path);
+        $absolutePath = Filesystem::normalizePath($absolutePath);
+        if (!$this->shouldLockFile($absolutePath)) {
+            return false;
+        }
+
+        $mount = $this->getMountForLock($absolutePath, $lockMountPoint);
+        if ($mount) {
+            $storage = $mount->getStorage();
+            if ($storage && $storage->instanceOfStorage('\OCP\Files\Storage\ILockingStorage')) {
+                $storage->releaseLock(
+                    $mount->getInternalPath($absolutePath),
+                    $type,
+                    $this->lockingProvider
+                );
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * Lock a path and all its parents up to the root of the view
+     *
+     * @param string $path the path of the file to lock relative to the view
+     * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
+     * @param bool $lockMountPoint true to lock the mount point, false to lock the attached mount/storage
+     *
+     * @return bool False if the path is excluded from locking, true otherwise
+     */
+    public function lockFile($path, $type, $lockMountPoint = false) {
+        $absolutePath = $this->getAbsolutePath($path);
+        $absolutePath = Filesystem::normalizePath($absolutePath);
+        if (!$this->shouldLockFile($absolutePath)) {
+            return false;
+        }
+
+        $this->lockPath($path, $type, $lockMountPoint);
+
+        $parents = $this->getParents($path);
+        foreach ($parents as $parent) {
+            $this->lockPath($parent, ILockingProvider::LOCK_SHARED);
+        }
+
+        return true;
+    }
+
+    /**
+     * Unlock a path and all its parents up to the root of the view
+     *
+     * @param string $path the path of the file to lock relative to the view
+     * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
+     * @param bool $lockMountPoint true to lock the mount point, false to lock the attached mount/storage
+     *
+     * @return bool False if the path is excluded from locking, true otherwise
+     */
+    public function unlockFile($path, $type, $lockMountPoint = false) {
+        $absolutePath = $this->getAbsolutePath($path);
+        $absolutePath = Filesystem::normalizePath($absolutePath);
+        if (!$this->shouldLockFile($absolutePath)) {
+            return false;
+        }
+
+        $this->unlockPath($path, $type, $lockMountPoint);
+
+        $parents = $this->getParents($path);
+        foreach ($parents as $parent) {
+            $this->unlockPath($parent, ILockingProvider::LOCK_SHARED);
+        }
+
+        return true;
+    }
+
+    /**
+     * Only lock files in data/user/files/
+     *
+     * @param string $path Absolute path to the file/folder we try to (un)lock
+     * @return bool
+     */
+    protected function shouldLockFile($path) {
+        $path = Filesystem::normalizePath($path);
+
+        $pathSegments = explode('/', $path);
+        if (isset($pathSegments[2])) {
+            // E.g.: /username/files/path-to-file
+            return ($pathSegments[2] === 'files') && (count($pathSegments) > 3);
+        }
+
+        return strpos($path, '/appdata_') !== 0;
+    }
+
+    /**
+     * Shortens the given absolute path to be relative to
+     * "$user/files".
+     *
+     * @param string $absolutePath absolute path which is under "files"
+     *
+     * @return string path relative to "files" with trimmed slashes or null
+     * if the path was NOT relative to files
+     *
+     * @throws \InvalidArgumentException if the given path was not under "files"
+     * @since 8.1.0
+     */
+    public function getPathRelativeToFiles($absolutePath) {
+        $path = Filesystem::normalizePath($absolutePath);
+        $parts = explode('/', trim($path, '/'), 3);
+        // "$user", "files", "path/to/dir"
+        if (!isset($parts[1]) || $parts[1] !== 'files') {
+            $this->logger->error(
+                '$absolutePath must be relative to "files", value is "%s"',
+                [
+                    $absolutePath
+                ]
+            );
+            throw new \InvalidArgumentException('$absolutePath must be relative to "files"');
+        }
+        if (isset($parts[2])) {
+            return $parts[2];
+        }
+        return '';
+    }
+
+    /**
+     * @param string $filename
+     * @return array
+     * @throws \OC\User\NoUserException
+     * @throws NotFoundException
+     */
+    public function getUidAndFilename($filename) {
+        $info = $this->getFileInfo($filename);
+        if (!$info instanceof \OCP\Files\FileInfo) {
+            throw new NotFoundException($this->getAbsolutePath($filename) . ' not found');
+        }
+        $uid = $info->getOwner()->getUID();
+        if ($uid != \OCP\User::getUser()) {
+            Filesystem::initMountPoints($uid);
+            $ownerView = new View('/' . $uid . '/files');
+            try {
+                $filename = $ownerView->getPath($info['fileid']);
+            } catch (NotFoundException $e) {
+                throw new NotFoundException('File with id ' . $info['fileid'] . ' not found for user ' . $uid);
+            }
+        }
+        return [$uid, $filename];
+    }
+
+    /**
+     * Creates parent non-existing folders
+     *
+     * @param string $filePath
+     * @return bool
+     */
+    private function createParentDirectories($filePath) {
+        $directoryParts = explode('/', $filePath);
+        $directoryParts = array_filter($directoryParts);
+        foreach ($directoryParts as $key => $part) {
+            $currentPathElements = array_slice($directoryParts, 0, $key);
+            $currentPath = '/' . implode('/', $currentPathElements);
+            if ($this->is_file($currentPath)) {
+                return false;
+            }
+            if (!$this->file_exists($currentPath)) {
+                $this->mkdir($currentPath);
+            }
+        }
+
+        return true;
+    }
 }

lib/private/Files/Mount/MountPoint.php

Indentation +219 added lines, -219 removed lines

@@ -36,247 +36,247 @@
 use OCP\ILogger;
 
 class MountPoint implements IMountPoint {
-	/**
-	 * @var \OC\Files\Storage\Storage $storage
-	 */
-	protected $storage = null;
-	protected $class;
-	protected $storageId;
-	protected $rootId = null;
+    /**
+     * @var \OC\Files\Storage\Storage $storage
+     */
+    protected $storage = null;
+    protected $class;
+    protected $storageId;
+    protected $rootId = null;
 
-	/**
-	 * Configuration options for the storage backend
-	 *
-	 * @var array
-	 */
-	protected $arguments = array();
-	protected $mountPoint;
+    /**
+     * Configuration options for the storage backend
+     *
+     * @var array
+     */
+    protected $arguments = array();
+    protected $mountPoint;
 
-	/**
-	 * Mount specific options
-	 *
-	 * @var array
-	 */
-	protected $mountOptions = array();
+    /**
+     * Mount specific options
+     *
+     * @var array
+     */
+    protected $mountOptions = array();
 
-	/**
-	 * @var \OC\Files\Storage\StorageFactory $loader
-	 */
-	private $loader;
+    /**
+     * @var \OC\Files\Storage\StorageFactory $loader
+     */
+    private $loader;
 
-	/**
-	 * Specified whether the storage is invalid after failing to
-	 * instantiate it.
-	 *
-	 * @var bool
-	 */
-	private $invalidStorage = false;
+    /**
+     * Specified whether the storage is invalid after failing to
+     * instantiate it.
+     *
+     * @var bool
+     */
+    private $invalidStorage = false;
 
-	/** @var int|null */
-	protected $mountId;
+    /** @var int|null */
+    protected $mountId;
 
-	/**
-	 * @param string|\OC\Files\Storage\Storage $storage
-	 * @param string $mountpoint
-	 * @param array $arguments (optional) configuration for the storage backend
-	 * @param \OCP\Files\Storage\IStorageFactory $loader
-	 * @param array $mountOptions mount specific options
-	 * @param int|null $mountId
-	 * @throws \Exception
-	 */
-	public function __construct($storage, $mountpoint, $arguments = null, $loader = null, $mountOptions = null, $mountId = null) {
-		if (is_null($arguments)) {
-			$arguments = array();
-		}
-		if (is_null($loader)) {
-			$this->loader = new StorageFactory();
-		} else {
-			$this->loader = $loader;
-		}
+    /**
+     * @param string|\OC\Files\Storage\Storage $storage
+     * @param string $mountpoint
+     * @param array $arguments (optional) configuration for the storage backend
+     * @param \OCP\Files\Storage\IStorageFactory $loader
+     * @param array $mountOptions mount specific options
+     * @param int|null $mountId
+     * @throws \Exception
+     */
+    public function __construct($storage, $mountpoint, $arguments = null, $loader = null, $mountOptions = null, $mountId = null) {
+        if (is_null($arguments)) {
+            $arguments = array();
+        }
+        if (is_null($loader)) {
+            $this->loader = new StorageFactory();
+        } else {
+            $this->loader = $loader;
+        }
 
-		if (!is_null($mountOptions)) {
-			$this->mountOptions = $mountOptions;
-		}
+        if (!is_null($mountOptions)) {
+            $this->mountOptions = $mountOptions;
+        }
 
-		$mountpoint = $this->formatPath($mountpoint);
-		$this->mountPoint = $mountpoint;
-		if ($storage instanceof Storage) {
-			$this->class = get_class($storage);
-			$this->storage = $this->loader->wrap($this, $storage);
-		} else {
-			// Update old classes to new namespace
-			if (strpos($storage, 'OC_Filestorage_') !== false) {
-				$storage = '\OC\Files\Storage\\' . substr($storage, 15);
-			}
-			$this->class = $storage;
-			$this->arguments = $arguments;
-		}
-		$this->mountId = $mountId;
-	}
+        $mountpoint = $this->formatPath($mountpoint);
+        $this->mountPoint = $mountpoint;
+        if ($storage instanceof Storage) {
+            $this->class = get_class($storage);
+            $this->storage = $this->loader->wrap($this, $storage);
+        } else {
+            // Update old classes to new namespace
+            if (strpos($storage, 'OC_Filestorage_') !== false) {
+                $storage = '\OC\Files\Storage\\' . substr($storage, 15);
+            }
+            $this->class = $storage;
+            $this->arguments = $arguments;
+        }
+        $this->mountId = $mountId;
+    }
 
-	/**
-	 * get complete path to the mount point, relative to data/
-	 *
-	 * @return string
-	 */
-	public function getMountPoint() {
-		return $this->mountPoint;
-	}
+    /**
+     * get complete path to the mount point, relative to data/
+     *
+     * @return string
+     */
+    public function getMountPoint() {
+        return $this->mountPoint;
+    }
 
-	/**
-	 * Sets the mount point path, relative to data/
-	 *
-	 * @param string $mountPoint new mount point
-	 */
-	public function setMountPoint($mountPoint) {
-		$this->mountPoint = $this->formatPath($mountPoint);
-	}
+    /**
+     * Sets the mount point path, relative to data/
+     *
+     * @param string $mountPoint new mount point
+     */
+    public function setMountPoint($mountPoint) {
+        $this->mountPoint = $this->formatPath($mountPoint);
+    }
 
-	/**
-	 * create the storage that is mounted
-	 */
-	private function createStorage() {
-		if ($this->invalidStorage) {
-			return;
-		}
+    /**
+     * create the storage that is mounted
+     */
+    private function createStorage() {
+        if ($this->invalidStorage) {
+            return;
+        }
 
-		if (class_exists($this->class)) {
-			try {
-				$class = $this->class;
-				// prevent recursion by setting the storage before applying wrappers
-				$this->storage = new $class($this->arguments);
-				$this->storage = $this->loader->wrap($this, $this->storage);
-			} catch (\Exception $exception) {
-				$this->storage = null;
-				$this->invalidStorage = true;
-				if ($this->mountPoint === '/') {
-					// the root storage could not be initialized, show the user!
-					throw new \Exception('The root storage could not be initialized. Please contact your local administrator.', $exception->getCode(), $exception);
-				} else {
-					\OC::$server->getLogger()->logException($exception, ['level' => ILogger::ERROR]);
-				}
-				return;
-			}
-		} else {
-			\OCP\Util::writeLog('core', 'storage backend ' . $this->class . ' not found', ILogger::ERROR);
-			$this->invalidStorage = true;
-			return;
-		}
-	}
+        if (class_exists($this->class)) {
+            try {
+                $class = $this->class;
+                // prevent recursion by setting the storage before applying wrappers
+                $this->storage = new $class($this->arguments);
+                $this->storage = $this->loader->wrap($this, $this->storage);
+            } catch (\Exception $exception) {
+                $this->storage = null;
+                $this->invalidStorage = true;
+                if ($this->mountPoint === '/') {
+                    // the root storage could not be initialized, show the user!
+                    throw new \Exception('The root storage could not be initialized. Please contact your local administrator.', $exception->getCode(), $exception);
+                } else {
+                    \OC::$server->getLogger()->logException($exception, ['level' => ILogger::ERROR]);
+                }
+                return;
+            }
+        } else {
+            \OCP\Util::writeLog('core', 'storage backend ' . $this->class . ' not found', ILogger::ERROR);
+            $this->invalidStorage = true;
+            return;
+        }
+    }
 
-	/**
-	 * @return \OC\Files\Storage\Storage
-	 */
-	public function getStorage() {
-		if (is_null($this->storage)) {
-			$this->createStorage();
-		}
-		return $this->storage;
-	}
+    /**
+     * @return \OC\Files\Storage\Storage
+     */
+    public function getStorage() {
+        if (is_null($this->storage)) {
+            $this->createStorage();
+        }
+        return $this->storage;
+    }
 
-	/**
-	 * @return string
-	 */
-	public function getStorageId() {
-		if (!$this->storageId) {
-			if (is_null($this->storage)) {
-				$storage = $this->createStorage(); //FIXME: start using exceptions
-				if (is_null($storage)) {
-					return null;
-				}
+    /**
+     * @return string
+     */
+    public function getStorageId() {
+        if (!$this->storageId) {
+            if (is_null($this->storage)) {
+                $storage = $this->createStorage(); //FIXME: start using exceptions
+                if (is_null($storage)) {
+                    return null;
+                }
 
-				$this->storage = $storage;
-			}
-			$this->storageId = $this->storage->getId();
-			if (strlen($this->storageId) > 64) {
-				$this->storageId = md5($this->storageId);
-			}
-		}
-		return $this->storageId;
-	}
+                $this->storage = $storage;
+            }
+            $this->storageId = $this->storage->getId();
+            if (strlen($this->storageId) > 64) {
+                $this->storageId = md5($this->storageId);
+            }
+        }
+        return $this->storageId;
+    }
 
-	/**
-	 * @return int
-	 */
-	public function getNumericStorageId() {
-		return $this->getStorage()->getStorageCache()->getNumericId();
-	}
+    /**
+     * @return int
+     */
+    public function getNumericStorageId() {
+        return $this->getStorage()->getStorageCache()->getNumericId();
+    }
 
-	/**
-	 * @param string $path
-	 * @return string
-	 */
-	public function getInternalPath($path) {
-		$path = Filesystem::normalizePath($path, true, false, true);
-		if ($this->mountPoint === $path or $this->mountPoint . '/' === $path) {
-			$internalPath = '';
-		} else {
-			$internalPath = substr($path, strlen($this->mountPoint));
-		}
-		// substr returns false instead of an empty string, we always want a string
-		return (string)$internalPath;
-	}
+    /**
+     * @param string $path
+     * @return string
+     */
+    public function getInternalPath($path) {
+        $path = Filesystem::normalizePath($path, true, false, true);
+        if ($this->mountPoint === $path or $this->mountPoint . '/' === $path) {
+            $internalPath = '';
+        } else {
+            $internalPath = substr($path, strlen($this->mountPoint));
+        }
+        // substr returns false instead of an empty string, we always want a string
+        return (string)$internalPath;
+    }
 
-	/**
-	 * @param string $path
-	 * @return string
-	 */
-	private function formatPath($path) {
-		$path = Filesystem::normalizePath($path);
-		if (strlen($path) > 1) {
-			$path .= '/';
-		}
-		return $path;
-	}
+    /**
+     * @param string $path
+     * @return string
+     */
+    private function formatPath($path) {
+        $path = Filesystem::normalizePath($path);
+        if (strlen($path) > 1) {
+            $path .= '/';
+        }
+        return $path;
+    }
 
-	/**
-	 * @param callable $wrapper
-	 */
-	public function wrapStorage($wrapper) {
-		$storage = $this->getStorage();
-		// storage can be null if it couldn't be initialized
-		if ($storage != null) {
-			$this->storage = $wrapper($this->mountPoint, $storage, $this);
-		}
-	}
+    /**
+     * @param callable $wrapper
+     */
+    public function wrapStorage($wrapper) {
+        $storage = $this->getStorage();
+        // storage can be null if it couldn't be initialized
+        if ($storage != null) {
+            $this->storage = $wrapper($this->mountPoint, $storage, $this);
+        }
+    }
 
-	/**
-	 * Get a mount option
-	 *
-	 * @param string $name Name of the mount option to get
-	 * @param mixed $default Default value for the mount option
-	 * @return mixed
-	 */
-	public function getOption($name, $default) {
-		return isset($this->mountOptions[$name]) ? $this->mountOptions[$name] : $default;
-	}
+    /**
+     * Get a mount option
+     *
+     * @param string $name Name of the mount option to get
+     * @param mixed $default Default value for the mount option
+     * @return mixed
+     */
+    public function getOption($name, $default) {
+        return isset($this->mountOptions[$name]) ? $this->mountOptions[$name] : $default;
+    }
 
-	/**
-	 * Get all options for the mount
-	 *
-	 * @return array
-	 */
-	public function getOptions() {
-		return $this->mountOptions;
-	}
+    /**
+     * Get all options for the mount
+     *
+     * @return array
+     */
+    public function getOptions() {
+        return $this->mountOptions;
+    }
 
-	/**
-	 * Get the file id of the root of the storage
-	 *
-	 * @return int
-	 */
-	public function getStorageRootId() {
-		if (is_null($this->rootId)) {
-			$this->rootId = (int)$this->getStorage()->getCache()->getId('');
-		}
-		return $this->rootId;
-	}
+    /**
+     * Get the file id of the root of the storage
+     *
+     * @return int
+     */
+    public function getStorageRootId() {
+        if (is_null($this->rootId)) {
+            $this->rootId = (int)$this->getStorage()->getCache()->getId('');
+        }
+        return $this->rootId;
+    }
 
-	public function getMountId() {
-		return $this->mountId;
-	}
+    public function getMountId() {
+        return $this->mountId;
+    }
 
-	public function getMountType() {
-		return '';
-	}
+    public function getMountType() {
+        return '';
+    }
 }

lib/private/Files/Mount/ObjectHomeMountProvider.php

Indentation +100 added lines, -100 removed lines

@@ -33,107 +33,107 @@
  * Mount provider for object store home storages
  */
 class ObjectHomeMountProvider implements IHomeMountProvider {
-	/**
-	 * @var IConfig
-	 */
-	private $config;
-
-	/**
-	 * ObjectStoreHomeMountProvider constructor.
-	 *
-	 * @param IConfig $config
-	 */
-	public function __construct(IConfig $config) {
-		$this->config = $config;
-	}
-
-	/**
-	 * Get the cache mount for a user
-	 *
-	 * @param IUser $user
-	 * @param IStorageFactory $loader
-	 * @return \OCP\Files\Mount\IMountPoint
-	 */
-	public function getHomeMountForUser(IUser $user, IStorageFactory $loader) {
-
-		$config = $this->getMultiBucketObjectStoreConfig($user);
-		if ($config === null) {
-			$config = $this->getSingleBucketObjectStoreConfig($user);
-		}
-
-		if ($config === null) {
-			return null;
-		}
-
-		return new MountPoint('\OC\Files\ObjectStore\HomeObjectStoreStorage', '/' . $user->getUID(), $config['arguments'], $loader);
-	}
-
-	/**
-	 * @param IUser $user
-	 * @return array|null
-	 */
-	private function getSingleBucketObjectStoreConfig(IUser $user) {
-		$config = $this->config->getSystemValue('objectstore');
-		if (!is_array($config)) {
-			return null;
-		}
-
-		// sanity checks
-		if (empty($config['class'])) {
-			\OCP\Util::writeLog('files', 'No class given for objectstore', ILogger::ERROR);
-		}
-		if (!isset($config['arguments'])) {
-			$config['arguments'] = [];
-		}
-		// instantiate object store implementation
-		$config['arguments']['objectstore'] = new $config['class']($config['arguments']);
-
-		$config['arguments']['user'] = $user;
-
-		return $config;
-	}
-
-	/**
-	 * @param IUser $user
-	 * @return array|null
-	 */
-	private function getMultiBucketObjectStoreConfig(IUser $user) {
-		$config = $this->config->getSystemValue('objectstore_multibucket');
-		if (!is_array($config)) {
-			return null;
-		}
-
-		// sanity checks
-		if (empty($config['class'])) {
-			\OCP\Util::writeLog('files', 'No class given for objectstore', ILogger::ERROR);
-		}
-		if (!isset($config['arguments'])) {
-			$config['arguments'] = [];
-		}
-		$config['arguments']['user'] = $user;
-
-		$bucket = $this->config->getUserValue($user->getUID(), 'homeobjectstore', 'bucket', null);
-
-		if ($bucket === null) {
-			/*
+    /**
+     * @var IConfig
+     */
+    private $config;
+
+    /**
+     * ObjectStoreHomeMountProvider constructor.
+     *
+     * @param IConfig $config
+     */
+    public function __construct(IConfig $config) {
+        $this->config = $config;
+    }
+
+    /**
+     * Get the cache mount for a user
+     *
+     * @param IUser $user
+     * @param IStorageFactory $loader
+     * @return \OCP\Files\Mount\IMountPoint
+     */
+    public function getHomeMountForUser(IUser $user, IStorageFactory $loader) {
+
+        $config = $this->getMultiBucketObjectStoreConfig($user);
+        if ($config === null) {
+            $config = $this->getSingleBucketObjectStoreConfig($user);
+        }
+
+        if ($config === null) {
+            return null;
+        }
+
+        return new MountPoint('\OC\Files\ObjectStore\HomeObjectStoreStorage', '/' . $user->getUID(), $config['arguments'], $loader);
+    }
+
+    /**
+     * @param IUser $user
+     * @return array|null
+     */
+    private function getSingleBucketObjectStoreConfig(IUser $user) {
+        $config = $this->config->getSystemValue('objectstore');
+        if (!is_array($config)) {
+            return null;
+        }
+
+        // sanity checks
+        if (empty($config['class'])) {
+            \OCP\Util::writeLog('files', 'No class given for objectstore', ILogger::ERROR);
+        }
+        if (!isset($config['arguments'])) {
+            $config['arguments'] = [];
+        }
+        // instantiate object store implementation
+        $config['arguments']['objectstore'] = new $config['class']($config['arguments']);
+
+        $config['arguments']['user'] = $user;
+
+        return $config;
+    }
+
+    /**
+     * @param IUser $user
+     * @return array|null
+     */
+    private function getMultiBucketObjectStoreConfig(IUser $user) {
+        $config = $this->config->getSystemValue('objectstore_multibucket');
+        if (!is_array($config)) {
+            return null;
+        }
+
+        // sanity checks
+        if (empty($config['class'])) {
+            \OCP\Util::writeLog('files', 'No class given for objectstore', ILogger::ERROR);
+        }
+        if (!isset($config['arguments'])) {
+            $config['arguments'] = [];
+        }
+        $config['arguments']['user'] = $user;
+
+        $bucket = $this->config->getUserValue($user->getUID(), 'homeobjectstore', 'bucket', null);
+
+        if ($bucket === null) {
+            /*
 			 * Use any provided bucket argument as prefix
 			 * and add the mapping from username => bucket
 			 */
-			if (!isset($config['arguments']['bucket'])) {
-				$config['arguments']['bucket'] = '';
-			}
-			$mapper = new \OC\Files\ObjectStore\Mapper($user);
-			$numBuckets = isset($config['arguments']['num_buckets']) ? $config['arguments']['num_buckets'] : 64;
-			$config['arguments']['bucket'] .= $mapper->getBucket($numBuckets);
-
-			$this->config->setUserValue($user->getUID(), 'homeobjectstore', 'bucket', $config['arguments']['bucket']);
-		} else {
-			$config['arguments']['bucket'] = $bucket;
-		}
-
-		// instantiate object store implementation
-		$config['arguments']['objectstore'] = new $config['class']($config['arguments']);
-
-		return $config;
-	}
+            if (!isset($config['arguments']['bucket'])) {
+                $config['arguments']['bucket'] = '';
+            }
+            $mapper = new \OC\Files\ObjectStore\Mapper($user);
+            $numBuckets = isset($config['arguments']['num_buckets']) ? $config['arguments']['num_buckets'] : 64;
+            $config['arguments']['bucket'] .= $mapper->getBucket($numBuckets);
+
+            $this->config->setUserValue($user->getUID(), 'homeobjectstore', 'bucket', $config['arguments']['bucket']);
+        } else {
+            $config['arguments']['bucket'] = $bucket;
+        }
+
+        // instantiate object store implementation
+        $config['arguments']['objectstore'] = new $config['class']($config['arguments']);
+
+        return $config;
+    }
 }

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

Indentation +976 added lines, -976 removed lines

@@ -48,981 +48,981 @@
 
 class Encryption extends Wrapper {
 
-	use LocalTempFileTrait;
-
-	/** @var string */
-	private $mountPoint;
-
-	/** @var \OC\Encryption\Util */
-	private $util;
-
-	/** @var \OCP\Encryption\IManager */
-	private $encryptionManager;
-
-	/** @var \OCP\ILogger */
-	private $logger;
-
-	/** @var string */
-	private $uid;
-
-	/** @var array */
-	protected $unencryptedSize;
-
-	/** @var \OCP\Encryption\IFile */
-	private $fileHelper;
-
-	/** @var IMountPoint */
-	private $mount;
-
-	/** @var IStorage */
-	private $keyStorage;
-
-	/** @var Update */
-	private $update;
-
-	/** @var Manager */
-	private $mountManager;
-
-	/** @var array remember for which path we execute the repair step to avoid recursions */
-	private $fixUnencryptedSizeOf = array();
-
-	/** @var  ArrayCache */
-	private $arrayCache;
-
-	/**
-	 * @param array $parameters
-	 * @param IManager $encryptionManager
-	 * @param Util $util
-	 * @param ILogger $logger
-	 * @param IFile $fileHelper
-	 * @param string $uid
-	 * @param IStorage $keyStorage
-	 * @param Update $update
-	 * @param Manager $mountManager
-	 * @param ArrayCache $arrayCache
-	 */
-	public function __construct(
-			$parameters,
-			IManager $encryptionManager = null,
-			Util $util = null,
-			ILogger $logger = null,
-			IFile $fileHelper = null,
-			$uid = null,
-			IStorage $keyStorage = null,
-			Update $update = null,
-			Manager $mountManager = null,
-			ArrayCache $arrayCache = null
-		) {
-
-		$this->mountPoint = $parameters['mountPoint'];
-		$this->mount = $parameters['mount'];
-		$this->encryptionManager = $encryptionManager;
-		$this->util = $util;
-		$this->logger = $logger;
-		$this->uid = $uid;
-		$this->fileHelper = $fileHelper;
-		$this->keyStorage = $keyStorage;
-		$this->unencryptedSize = array();
-		$this->update = $update;
-		$this->mountManager = $mountManager;
-		$this->arrayCache = $arrayCache;
-		parent::__construct($parameters);
-	}
-
-	/**
-	 * see http://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
-	 */
-	public function filesize($path) {
-		$fullPath = $this->getFullPath($path);
-
-		/** @var CacheEntry $info */
-		$info = $this->getCache()->get($path);
-		if (isset($this->unencryptedSize[$fullPath])) {
-			$size = $this->unencryptedSize[$fullPath];
-			// update file cache
-			if ($info instanceof ICacheEntry) {
-				$info = $info->getData();
-				$info['encrypted'] = $info['encryptedVersion'];
-			} else {
-				if (!is_array($info)) {
-					$info = [];
-				}
-				$info['encrypted'] = true;
-			}
-
-			$info['size'] = $size;
-			$this->getCache()->put($path, $info);
-
-			return $size;
-		}
-
-		if (isset($info['fileid']) && $info['encrypted']) {
-			return $this->verifyUnencryptedSize($path, $info['size']);
-		}
-
-		return $this->storage->filesize($path);
-	}
-
-	/**
-	 * @param string $path
-	 * @return array
-	 */
-	public function getMetaData($path) {
-		$data = $this->storage->getMetaData($path);
-		if (is_null($data)) {
-			return null;
-		}
-		$fullPath = $this->getFullPath($path);
-		$info = $this->getCache()->get($path);
-
-		if (isset($this->unencryptedSize[$fullPath])) {
-			$data['encrypted'] = true;
-			$data['size'] = $this->unencryptedSize[$fullPath];
-		} else {
-			if (isset($info['fileid']) && $info['encrypted']) {
-				$data['size'] = $this->verifyUnencryptedSize($path, $info['size']);
-				$data['encrypted'] = true;
-			}
-		}
-
-		if (isset($info['encryptedVersion']) && $info['encryptedVersion'] > 1) {
-			$data['encryptedVersion'] = $info['encryptedVersion'];
-		}
-
-		return $data;
-	}
-
-	/**
-	 * see http://php.net/manual/en/function.file_get_contents.php
-	 *
-	 * @param string $path
-	 * @return string
-	 */
-	public function file_get_contents($path) {
-
-		$encryptionModule = $this->getEncryptionModule($path);
-
-		if ($encryptionModule) {
-			$handle = $this->fopen($path, "r");
-			if (!$handle) {
-				return false;
-			}
-			$data = stream_get_contents($handle);
-			fclose($handle);
-			return $data;
-		}
-		return $this->storage->file_get_contents($path);
-	}
-
-	/**
-	 * see http://php.net/manual/en/function.file_put_contents.php
-	 *
-	 * @param string $path
-	 * @param string $data
-	 * @return bool
-	 */
-	public function file_put_contents($path, $data) {
-		// file put content will always be translated to a stream write
-		$handle = $this->fopen($path, 'w');
-		if (is_resource($handle)) {
-			$written = fwrite($handle, $data);
-			fclose($handle);
-			return $written;
-		}
-
-		return false;
-	}
-
-	/**
-	 * see http://php.net/manual/en/function.unlink.php
-	 *
-	 * @param string $path
-	 * @return bool
-	 */
-	public function unlink($path) {
-		$fullPath = $this->getFullPath($path);
-		if ($this->util->isExcluded($fullPath)) {
-			return $this->storage->unlink($path);
-		}
-
-		$encryptionModule = $this->getEncryptionModule($path);
-		if ($encryptionModule) {
-			$this->keyStorage->deleteAllFileKeys($this->getFullPath($path));
-		}
-
-		return $this->storage->unlink($path);
-	}
-
-	/**
-	 * see http://php.net/manual/en/function.rename.php
-	 *
-	 * @param string $path1
-	 * @param string $path2
-	 * @return bool
-	 */
-	public function rename($path1, $path2) {
-
-		$result = $this->storage->rename($path1, $path2);
-
-		if ($result &&
-			// versions always use the keys from the original file, so we can skip
-			// this step for versions
-			$this->isVersion($path2) === false &&
-			$this->encryptionManager->isEnabled()) {
-			$source = $this->getFullPath($path1);
-			if (!$this->util->isExcluded($source)) {
-				$target = $this->getFullPath($path2);
-				if (isset($this->unencryptedSize[$source])) {
-					$this->unencryptedSize[$target] = $this->unencryptedSize[$source];
-				}
-				$this->keyStorage->renameKeys($source, $target);
-				$module = $this->getEncryptionModule($path2);
-				if ($module) {
-					$module->update($target, $this->uid, []);
-				}
-			}
-		}
-
-		return $result;
-	}
-
-	/**
-	 * see http://php.net/manual/en/function.rmdir.php
-	 *
-	 * @param string $path
-	 * @return bool
-	 */
-	public function rmdir($path) {
-		$result = $this->storage->rmdir($path);
-		$fullPath = $this->getFullPath($path);
-		if ($result &&
-			$this->util->isExcluded($fullPath) === false &&
-			$this->encryptionManager->isEnabled()
-		) {
-			$this->keyStorage->deleteAllFileKeys($fullPath);
-		}
-
-		return $result;
-	}
-
-	/**
-	 * check if a file can be read
-	 *
-	 * @param string $path
-	 * @return bool
-	 */
-	public function isReadable($path) {
-
-		$isReadable = true;
-
-		$metaData = $this->getMetaData($path);
-		if (
-			!$this->is_dir($path) &&
-			isset($metaData['encrypted']) &&
-			$metaData['encrypted'] === true
-		) {
-			$fullPath = $this->getFullPath($path);
-			$module = $this->getEncryptionModule($path);
-			$isReadable = $module->isReadable($fullPath, $this->uid);
-		}
-
-		return $this->storage->isReadable($path) && $isReadable;
-	}
-
-	/**
-	 * see http://php.net/manual/en/function.copy.php
-	 *
-	 * @param string $path1
-	 * @param string $path2
-	 * @return bool
-	 */
-	public function copy($path1, $path2) {
-
-		$source = $this->getFullPath($path1);
-
-		if ($this->util->isExcluded($source)) {
-			return $this->storage->copy($path1, $path2);
-		}
-
-		// need to stream copy file by file in case we copy between a encrypted
-		// and a unencrypted storage
-		$this->unlink($path2);
-		return $this->copyFromStorage($this, $path1, $path2);
-	}
-
-	/**
-	 * see http://php.net/manual/en/function.fopen.php
-	 *
-	 * @param string $path
-	 * @param string $mode
-	 * @return resource|bool
-	 * @throws GenericEncryptionException
-	 * @throws ModuleDoesNotExistsException
-	 */
-	public function fopen($path, $mode) {
-
-		// check if the file is stored in the array cache, this means that we
-		// copy a file over to the versions folder, in this case we don't want to
-		// decrypt it
-		if ($this->arrayCache->hasKey('encryption_copy_version_' . $path)) {
-			$this->arrayCache->remove('encryption_copy_version_' . $path);
-			return $this->storage->fopen($path, $mode);
-		}
-
-		$encryptionEnabled = $this->encryptionManager->isEnabled();
-		$shouldEncrypt = false;
-		$encryptionModule = null;
-		$header = $this->getHeader($path);
-		$signed = isset($header['signed']) && $header['signed'] === 'true';
-		$fullPath = $this->getFullPath($path);
-		$encryptionModuleId = $this->util->getEncryptionModuleId($header);
-
-		if ($this->util->isExcluded($fullPath) === false) {
-
-			$size = $unencryptedSize = 0;
-			$realFile = $this->util->stripPartialFileExtension($path);
-			$targetExists = $this->file_exists($realFile) || $this->file_exists($path);
-			$targetIsEncrypted = false;
-			if ($targetExists) {
-				// in case the file exists we require the explicit module as
-				// specified in the file header - otherwise we need to fail hard to
-				// prevent data loss on client side
-				if (!empty($encryptionModuleId)) {
-					$targetIsEncrypted = true;
-					$encryptionModule = $this->encryptionManager->getEncryptionModule($encryptionModuleId);
-				}
-
-				if ($this->file_exists($path)) {
-					$size = $this->storage->filesize($path);
-					$unencryptedSize = $this->filesize($path);
-				} else {
-					$size = $unencryptedSize = 0;
-				}
-			}
-
-			try {
-
-				if (
-					$mode === 'w'
-					|| $mode === 'w+'
-					|| $mode === 'wb'
-					|| $mode === 'wb+'
-				) {
-					// don't overwrite encrypted files if encryption is not enabled
-					if ($targetIsEncrypted && $encryptionEnabled === false) {
-						throw new GenericEncryptionException('Tried to access encrypted file but encryption is not enabled');
-					}
-					if ($encryptionEnabled) {
-						// if $encryptionModuleId is empty, the default module will be used
-						$encryptionModule = $this->encryptionManager->getEncryptionModule($encryptionModuleId);
-						$shouldEncrypt = $encryptionModule->shouldEncrypt($fullPath);
-						$signed = true;
-					}
-				} else {
-					$info = $this->getCache()->get($path);
-					// only get encryption module if we found one in the header
-					// or if file should be encrypted according to the file cache
-					if (!empty($encryptionModuleId)) {
-						$encryptionModule = $this->encryptionManager->getEncryptionModule($encryptionModuleId);
-						$shouldEncrypt = true;
-					} else if (empty($encryptionModuleId) && $info['encrypted'] === true) {
-						// we come from a old installation. No header and/or no module defined
-						// but the file is encrypted. In this case we need to use the
-						// OC_DEFAULT_MODULE to read the file
-						$encryptionModule = $this->encryptionManager->getEncryptionModule('OC_DEFAULT_MODULE');
-						$shouldEncrypt = true;
-						$targetIsEncrypted = true;
-					}
-				}
-			} catch (ModuleDoesNotExistsException $e) {
-				$this->logger->logException($e, [
-					'message' => 'Encryption module "' . $encryptionModuleId . '" not found, file will be stored unencrypted',
-					'level' => ILogger::WARN,
-					'app' => 'core',
-				]);
-			}
-
-			// encryption disabled on write of new file and write to existing unencrypted file -> don't encrypt
-			if (!$encryptionEnabled || !$this->shouldEncrypt($path)) {
-				if (!$targetExists || !$targetIsEncrypted) {
-					$shouldEncrypt = false;
-				}
-			}
-
-			if ($shouldEncrypt === true && $encryptionModule !== null) {
-				$headerSize = $this->getHeaderSize($path);
-				$source = $this->storage->fopen($path, $mode);
-				if (!is_resource($source)) {
-					return false;
-				}
-				$handle = \OC\Files\Stream\Encryption::wrap($source, $path, $fullPath, $header,
-					$this->uid, $encryptionModule, $this->storage, $this, $this->util, $this->fileHelper, $mode,
-					$size, $unencryptedSize, $headerSize, $signed);
-				return $handle;
-			}
-
-		}
-
-		return $this->storage->fopen($path, $mode);
-	}
-
-
-	/**
-	 * perform some plausibility checks if the the unencrypted size is correct.
-	 * If not, we calculate the correct unencrypted size and return it
-	 *
-	 * @param string $path internal path relative to the storage root
-	 * @param int $unencryptedSize size of the unencrypted file
-	 *
-	 * @return int unencrypted size
-	 */
-	protected function verifyUnencryptedSize($path, $unencryptedSize) {
-
-		$size = $this->storage->filesize($path);
-		$result = $unencryptedSize;
-
-		if ($unencryptedSize < 0 ||
-			($size > 0 && $unencryptedSize === $size)
-		) {
-			// check if we already calculate the unencrypted size for the
-			// given path to avoid recursions
-			if (isset($this->fixUnencryptedSizeOf[$this->getFullPath($path)]) === false) {
-				$this->fixUnencryptedSizeOf[$this->getFullPath($path)] = true;
-				try {
-					$result = $this->fixUnencryptedSize($path, $size, $unencryptedSize);
-				} catch (\Exception $e) {
-					$this->logger->error('Couldn\'t re-calculate unencrypted size for '. $path);
-					$this->logger->logException($e);
-				}
-				unset($this->fixUnencryptedSizeOf[$this->getFullPath($path)]);
-			}
-		}
-
-		return $result;
-	}
-
-	/**
-	 * calculate the unencrypted size
-	 *
-	 * @param string $path internal path relative to the storage root
-	 * @param int $size size of the physical file
-	 * @param int $unencryptedSize size of the unencrypted file
-	 *
-	 * @return int calculated unencrypted size
-	 */
-	protected function fixUnencryptedSize($path, $size, $unencryptedSize) {
-
-		$headerSize = $this->getHeaderSize($path);
-		$header = $this->getHeader($path);
-		$encryptionModule = $this->getEncryptionModule($path);
-
-		$stream = $this->storage->fopen($path, 'r');
-
-		// if we couldn't open the file we return the old unencrypted size
-		if (!is_resource($stream)) {
-			$this->logger->error('Could not open ' . $path . '. Recalculation of unencrypted size aborted.');
-			return $unencryptedSize;
-		}
-
-		$newUnencryptedSize = 0;
-		$size -= $headerSize;
-		$blockSize = $this->util->getBlockSize();
-
-		// if a header exists we skip it
-		if ($headerSize > 0) {
-			fread($stream, $headerSize);
-		}
-
-		// fast path, else the calculation for $lastChunkNr is bogus
-		if ($size === 0) {
-			return 0;
-		}
-
-		$signed = isset($header['signed']) && $header['signed'] === 'true';
-		$unencryptedBlockSize = $encryptionModule->getUnencryptedBlockSize($signed);
-
-		// calculate last chunk nr
-		// next highest is end of chunks, one subtracted is last one
-		// we have to read the last chunk, we can't just calculate it (because of padding etc)
-
-		$lastChunkNr = ceil($size/ $blockSize)-1;
-		// calculate last chunk position
-		$lastChunkPos = ($lastChunkNr * $blockSize);
-		// try to fseek to the last chunk, if it fails we have to read the whole file
-		if (@fseek($stream, $lastChunkPos, SEEK_CUR) === 0) {
-			$newUnencryptedSize += $lastChunkNr * $unencryptedBlockSize;
-		}
-
-		$lastChunkContentEncrypted='';
-		$count = $blockSize;
-
-		while ($count > 0) {
-			$data=fread($stream, $blockSize);
-			$count=strlen($data);
-			$lastChunkContentEncrypted .= $data;
-			if(strlen($lastChunkContentEncrypted) > $blockSize) {
-				$newUnencryptedSize += $unencryptedBlockSize;
-				$lastChunkContentEncrypted=substr($lastChunkContentEncrypted, $blockSize);
-			}
-		}
-
-		fclose($stream);
-
-		// we have to decrypt the last chunk to get it actual size
-		$encryptionModule->begin($this->getFullPath($path), $this->uid, 'r', $header, []);
-		$decryptedLastChunk = $encryptionModule->decrypt($lastChunkContentEncrypted, $lastChunkNr . 'end');
-		$decryptedLastChunk .= $encryptionModule->end($this->getFullPath($path), $lastChunkNr . 'end');
-
-		// calc the real file size with the size of the last chunk
-		$newUnencryptedSize += strlen($decryptedLastChunk);
-
-		$this->updateUnencryptedSize($this->getFullPath($path), $newUnencryptedSize);
-
-		// write to cache if applicable
-		$cache = $this->storage->getCache();
-		if ($cache) {
-			$entry = $cache->get($path);
-			$cache->update($entry['fileid'], ['size' => $newUnencryptedSize]);
-		}
-
-		return $newUnencryptedSize;
-	}
-
-	/**
-	 * @param Storage\IStorage $sourceStorage
-	 * @param string $sourceInternalPath
-	 * @param string $targetInternalPath
-	 * @param bool $preserveMtime
-	 * @return bool
-	 */
-	public function moveFromStorage(Storage\IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath, $preserveMtime = true) {
-		if ($sourceStorage === $this) {
-			return $this->rename($sourceInternalPath, $targetInternalPath);
-		}
-
-		// TODO clean this up once the underlying moveFromStorage in OC\Files\Storage\Wrapper\Common is fixed:
-		// - call $this->storage->moveFromStorage() instead of $this->copyBetweenStorage
-		// - copy the file cache update from  $this->copyBetweenStorage to this method
-		// - copy the copyKeys() call from  $this->copyBetweenStorage to this method
-		// - remove $this->copyBetweenStorage
-
-		if (!$sourceStorage->isDeletable($sourceInternalPath)) {
-			return false;
-		}
-
-		$result = $this->copyBetweenStorage($sourceStorage, $sourceInternalPath, $targetInternalPath, $preserveMtime, true);
-		if ($result) {
-			if ($sourceStorage->is_dir($sourceInternalPath)) {
-				$result &= $sourceStorage->rmdir($sourceInternalPath);
-			} else {
-				$result &= $sourceStorage->unlink($sourceInternalPath);
-			}
-		}
-		return $result;
-	}
-
-
-	/**
-	 * @param Storage\IStorage $sourceStorage
-	 * @param string $sourceInternalPath
-	 * @param string $targetInternalPath
-	 * @param bool $preserveMtime
-	 * @param bool $isRename
-	 * @return bool
-	 */
-	public function copyFromStorage(Storage\IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath, $preserveMtime = false, $isRename = false) {
-
-		// TODO clean this up once the underlying moveFromStorage in OC\Files\Storage\Wrapper\Common is fixed:
-		// - call $this->storage->copyFromStorage() instead of $this->copyBetweenStorage
-		// - copy the file cache update from  $this->copyBetweenStorage to this method
-		// - copy the copyKeys() call from  $this->copyBetweenStorage to this method
-		// - remove $this->copyBetweenStorage
-
-		return $this->copyBetweenStorage($sourceStorage, $sourceInternalPath, $targetInternalPath, $preserveMtime, $isRename);
-	}
-
-	/**
-	 * Update the encrypted cache version in the database
-	 *
-	 * @param Storage\IStorage $sourceStorage
-	 * @param string $sourceInternalPath
-	 * @param string $targetInternalPath
-	 * @param bool $isRename
-	 * @param bool $keepEncryptionVersion
-	 */
-	private function updateEncryptedVersion(Storage\IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath, $isRename, $keepEncryptionVersion) {
-		$isEncrypted = $this->encryptionManager->isEnabled() && $this->shouldEncrypt($targetInternalPath);
-		$cacheInformation = [
-			'encrypted' => $isEncrypted,
-		];
-		if($isEncrypted) {
-			$encryptedVersion = $sourceStorage->getCache()->get($sourceInternalPath)['encryptedVersion'];
-
-			// In case of a move operation from an unencrypted to an encrypted
-			// storage the old encrypted version would stay with "0" while the
-			// correct value would be "1". Thus we manually set the value to "1"
-			// for those cases.
-			// See also https://github.com/owncloud/core/issues/23078
-			if($encryptedVersion === 0 || !$keepEncryptionVersion) {
-				$encryptedVersion = 1;
-			}
-
-			$cacheInformation['encryptedVersion'] = $encryptedVersion;
-		}
-
-		// in case of a rename we need to manipulate the source cache because
-		// this information will be kept for the new target
-		if ($isRename) {
-			$sourceStorage->getCache()->put($sourceInternalPath, $cacheInformation);
-		} else {
-			$this->getCache()->put($targetInternalPath, $cacheInformation);
-		}
-	}
-
-	/**
-	 * copy file between two storages
-	 *
-	 * @param Storage\IStorage $sourceStorage
-	 * @param string $sourceInternalPath
-	 * @param string $targetInternalPath
-	 * @param bool $preserveMtime
-	 * @param bool $isRename
-	 * @return bool
-	 * @throws \Exception
-	 */
-	private function copyBetweenStorage(Storage\IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath, $preserveMtime, $isRename) {
-
-		// for versions we have nothing to do, because versions should always use the
-		// key from the original file. Just create a 1:1 copy and done
-		if ($this->isVersion($targetInternalPath) ||
-			$this->isVersion($sourceInternalPath)) {
-			// remember that we try to create a version so that we can detect it during
-			// fopen($sourceInternalPath) and by-pass the encryption in order to
-			// create a 1:1 copy of the file
-			$this->arrayCache->set('encryption_copy_version_' . $sourceInternalPath, true);
-			$result = $this->storage->copyFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath);
-			$this->arrayCache->remove('encryption_copy_version_' . $sourceInternalPath);
-			if ($result) {
-				$info = $this->getCache('', $sourceStorage)->get($sourceInternalPath);
-				// make sure that we update the unencrypted size for the version
-				if (isset($info['encrypted']) && $info['encrypted'] === true) {
-					$this->updateUnencryptedSize(
-						$this->getFullPath($targetInternalPath),
-						$info['size']
-					);
-				}
-				$this->updateEncryptedVersion($sourceStorage, $sourceInternalPath, $targetInternalPath, $isRename, true);
-			}
-			return $result;
-		}
-
-		// first copy the keys that we reuse the existing file key on the target location
-		// and don't create a new one which would break versions for example.
-		$mount = $this->mountManager->findByStorageId($sourceStorage->getId());
-		if (count($mount) === 1) {
-			$mountPoint = $mount[0]->getMountPoint();
-			$source = $mountPoint . '/' . $sourceInternalPath;
-			$target = $this->getFullPath($targetInternalPath);
-			$this->copyKeys($source, $target);
-		} else {
-			$this->logger->error('Could not find mount point, can\'t keep encryption keys');
-		}
-
-		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, false, $isRename);
-					}
-				}
-			}
-		} else {
-			try {
-				$source = $sourceStorage->fopen($sourceInternalPath, 'r');
-				$target = $this->fopen($targetInternalPath, 'w');
-				list(, $result) = \OC_Helper::streamCopy($source, $target);
-				fclose($source);
-				fclose($target);
-			} catch (\Exception $e) {
-				fclose($source);
-				fclose($target);
-				throw $e;
-			}
-			if($result) {
-				if ($preserveMtime) {
-					$this->touch($targetInternalPath, $sourceStorage->filemtime($sourceInternalPath));
-				}
-				$this->updateEncryptedVersion($sourceStorage, $sourceInternalPath, $targetInternalPath, $isRename, false);
-			} else {
-				// delete partially written target file
-				$this->unlink($targetInternalPath);
-				// delete cache entry that was created by fopen
-				$this->getCache()->remove($targetInternalPath);
-			}
-		}
-		return (bool)$result;
-
-	}
-
-	/**
-	 * 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
-	 */
-	public function getLocalFile($path) {
-		if ($this->encryptionManager->isEnabled()) {
-			$cachedFile = $this->getCachedFile($path);
-			if (is_string($cachedFile)) {
-				return $cachedFile;
-			}
-		}
-		return $this->storage->getLocalFile($path);
-	}
-
-	/**
-	 * Returns the wrapped storage's value for isLocal()
-	 *
-	 * @return bool wrapped storage's isLocal() value
-	 */
-	public function isLocal() {
-		if ($this->encryptionManager->isEnabled()) {
-			return false;
-		}
-		return $this->storage->isLocal();
-	}
-
-	/**
-	 * see http://php.net/manual/en/function.stat.php
-	 * only the following keys are required in the result: size and mtime
-	 *
-	 * @param string $path
-	 * @return array
-	 */
-	public function stat($path) {
-		$stat = $this->storage->stat($path);
-		$fileSize = $this->filesize($path);
-		$stat['size'] = $fileSize;
-		$stat[7] = $fileSize;
-		return $stat;
-	}
-
-	/**
-	 * see http://php.net/manual/en/function.hash.php
-	 *
-	 * @param string $type
-	 * @param string $path
-	 * @param bool $raw
-	 * @return string
-	 */
-	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);
-	}
-
-	/**
-	 * return full path, including mount point
-	 *
-	 * @param string $path relative to mount point
-	 * @return string full path including mount point
-	 */
-	protected function getFullPath($path) {
-		return Filesystem::normalizePath($this->mountPoint . '/' . $path);
-	}
-
-	/**
-	 * read first block of encrypted file, typically this will contain the
-	 * encryption header
-	 *
-	 * @param string $path
-	 * @return string
-	 */
-	protected function readFirstBlock($path) {
-		$firstBlock = '';
-		if ($this->storage->file_exists($path)) {
-			$handle = $this->storage->fopen($path, 'r');
-			$firstBlock = fread($handle, $this->util->getHeaderSize());
-			fclose($handle);
-		}
-		return $firstBlock;
-	}
-
-	/**
-	 * return header size of given file
-	 *
-	 * @param string $path
-	 * @return int
-	 */
-	protected function getHeaderSize($path) {
-		$headerSize = 0;
-		$realFile = $this->util->stripPartialFileExtension($path);
-		if ($this->storage->file_exists($realFile)) {
-			$path = $realFile;
-		}
-		$firstBlock = $this->readFirstBlock($path);
-
-		if (substr($firstBlock, 0, strlen(Util::HEADER_START)) === Util::HEADER_START) {
-			$headerSize = $this->util->getHeaderSize();
-		}
-
-		return $headerSize;
-	}
-
-	/**
-	 * parse raw header to array
-	 *
-	 * @param string $rawHeader
-	 * @return array
-	 */
-	protected function parseRawHeader($rawHeader) {
-		$result = array();
-		if (substr($rawHeader, 0, strlen(Util::HEADER_START)) === Util::HEADER_START) {
-			$header = $rawHeader;
-			$endAt = strpos($header, Util::HEADER_END);
-			if ($endAt !== false) {
-				$header = substr($header, 0, $endAt + strlen(Util::HEADER_END));
-
-				// +1 to not start with an ':' which would result in empty element at the beginning
-				$exploded = explode(':', substr($header, strlen(Util::HEADER_START)+1));
-
-				$element = array_shift($exploded);
-				while ($element !== Util::HEADER_END) {
-					$result[$element] = array_shift($exploded);
-					$element = array_shift($exploded);
-				}
-			}
-		}
-
-		return $result;
-	}
-
-	/**
-	 * read header from file
-	 *
-	 * @param string $path
-	 * @return array
-	 */
-	protected function getHeader($path) {
-		$realFile = $this->util->stripPartialFileExtension($path);
-		$exists = $this->storage->file_exists($realFile);
-		if ($exists) {
-			$path = $realFile;
-		}
-
-		$firstBlock = $this->readFirstBlock($path);
-		$result = $this->parseRawHeader($firstBlock);
-
-		// if the header doesn't contain a encryption module we check if it is a
-		// legacy file. If true, we add the default encryption module
-		if (!isset($result[Util::HEADER_ENCRYPTION_MODULE_KEY])) {
-			if (!empty($result)) {
-				$result[Util::HEADER_ENCRYPTION_MODULE_KEY] = 'OC_DEFAULT_MODULE';
-			} else if ($exists) {
-				// if the header was empty we have to check first if it is a encrypted file at all
-				// We would do query to filecache only if we know that entry in filecache exists
-				$info = $this->getCache()->get($path);
-				if (isset($info['encrypted']) && $info['encrypted'] === true) {
-					$result[Util::HEADER_ENCRYPTION_MODULE_KEY] = 'OC_DEFAULT_MODULE';
-				}
-			}
-		}
-
-		return $result;
-	}
-
-	/**
-	 * read encryption module needed to read/write the file located at $path
-	 *
-	 * @param string $path
-	 * @return null|\OCP\Encryption\IEncryptionModule
-	 * @throws ModuleDoesNotExistsException
-	 * @throws \Exception
-	 */
-	protected function getEncryptionModule($path) {
-		$encryptionModule = null;
-		$header = $this->getHeader($path);
-		$encryptionModuleId = $this->util->getEncryptionModuleId($header);
-		if (!empty($encryptionModuleId)) {
-			try {
-				$encryptionModule = $this->encryptionManager->getEncryptionModule($encryptionModuleId);
-			} catch (ModuleDoesNotExistsException $e) {
-				$this->logger->critical('Encryption module defined in "' . $path . '" not loaded!');
-				throw $e;
-			}
-		}
-
-		return $encryptionModule;
-	}
-
-	/**
-	 * @param string $path
-	 * @param int $unencryptedSize
-	 */
-	public function updateUnencryptedSize($path, $unencryptedSize) {
-		$this->unencryptedSize[$path] = $unencryptedSize;
-	}
-
-	/**
-	 * copy keys to new location
-	 *
-	 * @param string $source path relative to data/
-	 * @param string $target path relative to data/
-	 * @return bool
-	 */
-	protected function copyKeys($source, $target) {
-		if (!$this->util->isExcluded($source)) {
-			return $this->keyStorage->copyKeys($source, $target);
-		}
-
-		return false;
-	}
-
-	/**
-	 * check if path points to a files version
-	 *
-	 * @param $path
-	 * @return bool
-	 */
-	protected function isVersion($path) {
-		$normalized = Filesystem::normalizePath($path);
-		return substr($normalized, 0, strlen('/files_versions/')) === '/files_versions/';
-	}
-
-	/**
-	 * check if the given storage should be encrypted or not
-	 *
-	 * @param $path
-	 * @return bool
-	 */
-	protected function shouldEncrypt($path) {
-		$fullPath = $this->getFullPath($path);
-		$mountPointConfig = $this->mount->getOption('encrypt', true);
-		if ($mountPointConfig === false) {
-			return false;
-		}
-
-		try {
-			$encryptionModule = $this->getEncryptionModule($fullPath);
-		} catch (ModuleDoesNotExistsException $e) {
-			return false;
-		}
-
-		if ($encryptionModule === null) {
-			$encryptionModule = $this->encryptionManager->getEncryptionModule();
-		}
-
-		return $encryptionModule->shouldEncrypt($fullPath);
-
-	}
+    use LocalTempFileTrait;
+
+    /** @var string */
+    private $mountPoint;
+
+    /** @var \OC\Encryption\Util */
+    private $util;
+
+    /** @var \OCP\Encryption\IManager */
+    private $encryptionManager;
+
+    /** @var \OCP\ILogger */
+    private $logger;
+
+    /** @var string */
+    private $uid;
+
+    /** @var array */
+    protected $unencryptedSize;
+
+    /** @var \OCP\Encryption\IFile */
+    private $fileHelper;
+
+    /** @var IMountPoint */
+    private $mount;
+
+    /** @var IStorage */
+    private $keyStorage;
+
+    /** @var Update */
+    private $update;
+
+    /** @var Manager */
+    private $mountManager;
+
+    /** @var array remember for which path we execute the repair step to avoid recursions */
+    private $fixUnencryptedSizeOf = array();
+
+    /** @var  ArrayCache */
+    private $arrayCache;
+
+    /**
+     * @param array $parameters
+     * @param IManager $encryptionManager
+     * @param Util $util
+     * @param ILogger $logger
+     * @param IFile $fileHelper
+     * @param string $uid
+     * @param IStorage $keyStorage
+     * @param Update $update
+     * @param Manager $mountManager
+     * @param ArrayCache $arrayCache
+     */
+    public function __construct(
+            $parameters,
+            IManager $encryptionManager = null,
+            Util $util = null,
+            ILogger $logger = null,
+            IFile $fileHelper = null,
+            $uid = null,
+            IStorage $keyStorage = null,
+            Update $update = null,
+            Manager $mountManager = null,
+            ArrayCache $arrayCache = null
+        ) {
+
+        $this->mountPoint = $parameters['mountPoint'];
+        $this->mount = $parameters['mount'];
+        $this->encryptionManager = $encryptionManager;
+        $this->util = $util;
+        $this->logger = $logger;
+        $this->uid = $uid;
+        $this->fileHelper = $fileHelper;
+        $this->keyStorage = $keyStorage;
+        $this->unencryptedSize = array();
+        $this->update = $update;
+        $this->mountManager = $mountManager;
+        $this->arrayCache = $arrayCache;
+        parent::__construct($parameters);
+    }
+
+    /**
+     * see http://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
+     */
+    public function filesize($path) {
+        $fullPath = $this->getFullPath($path);
+
+        /** @var CacheEntry $info */
+        $info = $this->getCache()->get($path);
+        if (isset($this->unencryptedSize[$fullPath])) {
+            $size = $this->unencryptedSize[$fullPath];
+            // update file cache
+            if ($info instanceof ICacheEntry) {
+                $info = $info->getData();
+                $info['encrypted'] = $info['encryptedVersion'];
+            } else {
+                if (!is_array($info)) {
+                    $info = [];
+                }
+                $info['encrypted'] = true;
+            }
+
+            $info['size'] = $size;
+            $this->getCache()->put($path, $info);
+
+            return $size;
+        }
+
+        if (isset($info['fileid']) && $info['encrypted']) {
+            return $this->verifyUnencryptedSize($path, $info['size']);
+        }
+
+        return $this->storage->filesize($path);
+    }
+
+    /**
+     * @param string $path
+     * @return array
+     */
+    public function getMetaData($path) {
+        $data = $this->storage->getMetaData($path);
+        if (is_null($data)) {
+            return null;
+        }
+        $fullPath = $this->getFullPath($path);
+        $info = $this->getCache()->get($path);
+
+        if (isset($this->unencryptedSize[$fullPath])) {
+            $data['encrypted'] = true;
+            $data['size'] = $this->unencryptedSize[$fullPath];
+        } else {
+            if (isset($info['fileid']) && $info['encrypted']) {
+                $data['size'] = $this->verifyUnencryptedSize($path, $info['size']);
+                $data['encrypted'] = true;
+            }
+        }
+
+        if (isset($info['encryptedVersion']) && $info['encryptedVersion'] > 1) {
+            $data['encryptedVersion'] = $info['encryptedVersion'];
+        }
+
+        return $data;
+    }
+
+    /**
+     * see http://php.net/manual/en/function.file_get_contents.php
+     *
+     * @param string $path
+     * @return string
+     */
+    public function file_get_contents($path) {
+
+        $encryptionModule = $this->getEncryptionModule($path);
+
+        if ($encryptionModule) {
+            $handle = $this->fopen($path, "r");
+            if (!$handle) {
+                return false;
+            }
+            $data = stream_get_contents($handle);
+            fclose($handle);
+            return $data;
+        }
+        return $this->storage->file_get_contents($path);
+    }
+
+    /**
+     * see http://php.net/manual/en/function.file_put_contents.php
+     *
+     * @param string $path
+     * @param string $data
+     * @return bool
+     */
+    public function file_put_contents($path, $data) {
+        // file put content will always be translated to a stream write
+        $handle = $this->fopen($path, 'w');
+        if (is_resource($handle)) {
+            $written = fwrite($handle, $data);
+            fclose($handle);
+            return $written;
+        }
+
+        return false;
+    }
+
+    /**
+     * see http://php.net/manual/en/function.unlink.php
+     *
+     * @param string $path
+     * @return bool
+     */
+    public function unlink($path) {
+        $fullPath = $this->getFullPath($path);
+        if ($this->util->isExcluded($fullPath)) {
+            return $this->storage->unlink($path);
+        }
+
+        $encryptionModule = $this->getEncryptionModule($path);
+        if ($encryptionModule) {
+            $this->keyStorage->deleteAllFileKeys($this->getFullPath($path));
+        }
+
+        return $this->storage->unlink($path);
+    }
+
+    /**
+     * see http://php.net/manual/en/function.rename.php
+     *
+     * @param string $path1
+     * @param string $path2
+     * @return bool
+     */
+    public function rename($path1, $path2) {
+
+        $result = $this->storage->rename($path1, $path2);
+
+        if ($result &&
+            // versions always use the keys from the original file, so we can skip
+            // this step for versions
+            $this->isVersion($path2) === false &&
+            $this->encryptionManager->isEnabled()) {
+            $source = $this->getFullPath($path1);
+            if (!$this->util->isExcluded($source)) {
+                $target = $this->getFullPath($path2);
+                if (isset($this->unencryptedSize[$source])) {
+                    $this->unencryptedSize[$target] = $this->unencryptedSize[$source];
+                }
+                $this->keyStorage->renameKeys($source, $target);
+                $module = $this->getEncryptionModule($path2);
+                if ($module) {
+                    $module->update($target, $this->uid, []);
+                }
+            }
+        }
+
+        return $result;
+    }
+
+    /**
+     * see http://php.net/manual/en/function.rmdir.php
+     *
+     * @param string $path
+     * @return bool
+     */
+    public function rmdir($path) {
+        $result = $this->storage->rmdir($path);
+        $fullPath = $this->getFullPath($path);
+        if ($result &&
+            $this->util->isExcluded($fullPath) === false &&
+            $this->encryptionManager->isEnabled()
+        ) {
+            $this->keyStorage->deleteAllFileKeys($fullPath);
+        }
+
+        return $result;
+    }
+
+    /**
+     * check if a file can be read
+     *
+     * @param string $path
+     * @return bool
+     */
+    public function isReadable($path) {
+
+        $isReadable = true;
+
+        $metaData = $this->getMetaData($path);
+        if (
+            !$this->is_dir($path) &&
+            isset($metaData['encrypted']) &&
+            $metaData['encrypted'] === true
+        ) {
+            $fullPath = $this->getFullPath($path);
+            $module = $this->getEncryptionModule($path);
+            $isReadable = $module->isReadable($fullPath, $this->uid);
+        }
+
+        return $this->storage->isReadable($path) && $isReadable;
+    }
+
+    /**
+     * see http://php.net/manual/en/function.copy.php
+     *
+     * @param string $path1
+     * @param string $path2
+     * @return bool
+     */
+    public function copy($path1, $path2) {
+
+        $source = $this->getFullPath($path1);
+
+        if ($this->util->isExcluded($source)) {
+            return $this->storage->copy($path1, $path2);
+        }
+
+        // need to stream copy file by file in case we copy between a encrypted
+        // and a unencrypted storage
+        $this->unlink($path2);
+        return $this->copyFromStorage($this, $path1, $path2);
+    }
+
+    /**
+     * see http://php.net/manual/en/function.fopen.php
+     *
+     * @param string $path
+     * @param string $mode
+     * @return resource|bool
+     * @throws GenericEncryptionException
+     * @throws ModuleDoesNotExistsException
+     */
+    public function fopen($path, $mode) {
+
+        // check if the file is stored in the array cache, this means that we
+        // copy a file over to the versions folder, in this case we don't want to
+        // decrypt it
+        if ($this->arrayCache->hasKey('encryption_copy_version_' . $path)) {
+            $this->arrayCache->remove('encryption_copy_version_' . $path);
+            return $this->storage->fopen($path, $mode);
+        }
+
+        $encryptionEnabled = $this->encryptionManager->isEnabled();
+        $shouldEncrypt = false;
+        $encryptionModule = null;
+        $header = $this->getHeader($path);
+        $signed = isset($header['signed']) && $header['signed'] === 'true';
+        $fullPath = $this->getFullPath($path);
+        $encryptionModuleId = $this->util->getEncryptionModuleId($header);
+
+        if ($this->util->isExcluded($fullPath) === false) {
+
+            $size = $unencryptedSize = 0;
+            $realFile = $this->util->stripPartialFileExtension($path);
+            $targetExists = $this->file_exists($realFile) || $this->file_exists($path);
+            $targetIsEncrypted = false;
+            if ($targetExists) {
+                // in case the file exists we require the explicit module as
+                // specified in the file header - otherwise we need to fail hard to
+                // prevent data loss on client side
+                if (!empty($encryptionModuleId)) {
+                    $targetIsEncrypted = true;
+                    $encryptionModule = $this->encryptionManager->getEncryptionModule($encryptionModuleId);
+                }
+
+                if ($this->file_exists($path)) {
+                    $size = $this->storage->filesize($path);
+                    $unencryptedSize = $this->filesize($path);
+                } else {
+                    $size = $unencryptedSize = 0;
+                }
+            }
+
+            try {
+
+                if (
+                    $mode === 'w'
+                    || $mode === 'w+'
+                    || $mode === 'wb'
+                    || $mode === 'wb+'
+                ) {
+                    // don't overwrite encrypted files if encryption is not enabled
+                    if ($targetIsEncrypted && $encryptionEnabled === false) {
+                        throw new GenericEncryptionException('Tried to access encrypted file but encryption is not enabled');
+                    }
+                    if ($encryptionEnabled) {
+                        // if $encryptionModuleId is empty, the default module will be used
+                        $encryptionModule = $this->encryptionManager->getEncryptionModule($encryptionModuleId);
+                        $shouldEncrypt = $encryptionModule->shouldEncrypt($fullPath);
+                        $signed = true;
+                    }
+                } else {
+                    $info = $this->getCache()->get($path);
+                    // only get encryption module if we found one in the header
+                    // or if file should be encrypted according to the file cache
+                    if (!empty($encryptionModuleId)) {
+                        $encryptionModule = $this->encryptionManager->getEncryptionModule($encryptionModuleId);
+                        $shouldEncrypt = true;
+                    } else if (empty($encryptionModuleId) && $info['encrypted'] === true) {
+                        // we come from a old installation. No header and/or no module defined
+                        // but the file is encrypted. In this case we need to use the
+                        // OC_DEFAULT_MODULE to read the file
+                        $encryptionModule = $this->encryptionManager->getEncryptionModule('OC_DEFAULT_MODULE');
+                        $shouldEncrypt = true;
+                        $targetIsEncrypted = true;
+                    }
+                }
+            } catch (ModuleDoesNotExistsException $e) {
+                $this->logger->logException($e, [
+                    'message' => 'Encryption module "' . $encryptionModuleId . '" not found, file will be stored unencrypted',
+                    'level' => ILogger::WARN,
+                    'app' => 'core',
+                ]);
+            }
+
+            // encryption disabled on write of new file and write to existing unencrypted file -> don't encrypt
+            if (!$encryptionEnabled || !$this->shouldEncrypt($path)) {
+                if (!$targetExists || !$targetIsEncrypted) {
+                    $shouldEncrypt = false;
+                }
+            }
+
+            if ($shouldEncrypt === true && $encryptionModule !== null) {
+                $headerSize = $this->getHeaderSize($path);
+                $source = $this->storage->fopen($path, $mode);
+                if (!is_resource($source)) {
+                    return false;
+                }
+                $handle = \OC\Files\Stream\Encryption::wrap($source, $path, $fullPath, $header,
+                    $this->uid, $encryptionModule, $this->storage, $this, $this->util, $this->fileHelper, $mode,
+                    $size, $unencryptedSize, $headerSize, $signed);
+                return $handle;
+            }
+
+        }
+
+        return $this->storage->fopen($path, $mode);
+    }
+
+
+    /**
+     * perform some plausibility checks if the the unencrypted size is correct.
+     * If not, we calculate the correct unencrypted size and return it
+     *
+     * @param string $path internal path relative to the storage root
+     * @param int $unencryptedSize size of the unencrypted file
+     *
+     * @return int unencrypted size
+     */
+    protected function verifyUnencryptedSize($path, $unencryptedSize) {
+
+        $size = $this->storage->filesize($path);
+        $result = $unencryptedSize;
+
+        if ($unencryptedSize < 0 ||
+            ($size > 0 && $unencryptedSize === $size)
+        ) {
+            // check if we already calculate the unencrypted size for the
+            // given path to avoid recursions
+            if (isset($this->fixUnencryptedSizeOf[$this->getFullPath($path)]) === false) {
+                $this->fixUnencryptedSizeOf[$this->getFullPath($path)] = true;
+                try {
+                    $result = $this->fixUnencryptedSize($path, $size, $unencryptedSize);
+                } catch (\Exception $e) {
+                    $this->logger->error('Couldn\'t re-calculate unencrypted size for '. $path);
+                    $this->logger->logException($e);
+                }
+                unset($this->fixUnencryptedSizeOf[$this->getFullPath($path)]);
+            }
+        }
+
+        return $result;
+    }
+
+    /**
+     * calculate the unencrypted size
+     *
+     * @param string $path internal path relative to the storage root
+     * @param int $size size of the physical file
+     * @param int $unencryptedSize size of the unencrypted file
+     *
+     * @return int calculated unencrypted size
+     */
+    protected function fixUnencryptedSize($path, $size, $unencryptedSize) {
+
+        $headerSize = $this->getHeaderSize($path);
+        $header = $this->getHeader($path);
+        $encryptionModule = $this->getEncryptionModule($path);
+
+        $stream = $this->storage->fopen($path, 'r');
+
+        // if we couldn't open the file we return the old unencrypted size
+        if (!is_resource($stream)) {
+            $this->logger->error('Could not open ' . $path . '. Recalculation of unencrypted size aborted.');
+            return $unencryptedSize;
+        }
+
+        $newUnencryptedSize = 0;
+        $size -= $headerSize;
+        $blockSize = $this->util->getBlockSize();
+
+        // if a header exists we skip it
+        if ($headerSize > 0) {
+            fread($stream, $headerSize);
+        }
+
+        // fast path, else the calculation for $lastChunkNr is bogus
+        if ($size === 0) {
+            return 0;
+        }
+
+        $signed = isset($header['signed']) && $header['signed'] === 'true';
+        $unencryptedBlockSize = $encryptionModule->getUnencryptedBlockSize($signed);
+
+        // calculate last chunk nr
+        // next highest is end of chunks, one subtracted is last one
+        // we have to read the last chunk, we can't just calculate it (because of padding etc)
+
+        $lastChunkNr = ceil($size/ $blockSize)-1;
+        // calculate last chunk position
+        $lastChunkPos = ($lastChunkNr * $blockSize);
+        // try to fseek to the last chunk, if it fails we have to read the whole file
+        if (@fseek($stream, $lastChunkPos, SEEK_CUR) === 0) {
+            $newUnencryptedSize += $lastChunkNr * $unencryptedBlockSize;
+        }
+
+        $lastChunkContentEncrypted='';
+        $count = $blockSize;
+
+        while ($count > 0) {
+            $data=fread($stream, $blockSize);
+            $count=strlen($data);
+            $lastChunkContentEncrypted .= $data;
+            if(strlen($lastChunkContentEncrypted) > $blockSize) {
+                $newUnencryptedSize += $unencryptedBlockSize;
+                $lastChunkContentEncrypted=substr($lastChunkContentEncrypted, $blockSize);
+            }
+        }
+
+        fclose($stream);
+
+        // we have to decrypt the last chunk to get it actual size
+        $encryptionModule->begin($this->getFullPath($path), $this->uid, 'r', $header, []);
+        $decryptedLastChunk = $encryptionModule->decrypt($lastChunkContentEncrypted, $lastChunkNr . 'end');
+        $decryptedLastChunk .= $encryptionModule->end($this->getFullPath($path), $lastChunkNr . 'end');
+
+        // calc the real file size with the size of the last chunk
+        $newUnencryptedSize += strlen($decryptedLastChunk);
+
+        $this->updateUnencryptedSize($this->getFullPath($path), $newUnencryptedSize);
+
+        // write to cache if applicable
+        $cache = $this->storage->getCache();
+        if ($cache) {
+            $entry = $cache->get($path);
+            $cache->update($entry['fileid'], ['size' => $newUnencryptedSize]);
+        }
+
+        return $newUnencryptedSize;
+    }
+
+    /**
+     * @param Storage\IStorage $sourceStorage
+     * @param string $sourceInternalPath
+     * @param string $targetInternalPath
+     * @param bool $preserveMtime
+     * @return bool
+     */
+    public function moveFromStorage(Storage\IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath, $preserveMtime = true) {
+        if ($sourceStorage === $this) {
+            return $this->rename($sourceInternalPath, $targetInternalPath);
+        }
+
+        // TODO clean this up once the underlying moveFromStorage in OC\Files\Storage\Wrapper\Common is fixed:
+        // - call $this->storage->moveFromStorage() instead of $this->copyBetweenStorage
+        // - copy the file cache update from  $this->copyBetweenStorage to this method
+        // - copy the copyKeys() call from  $this->copyBetweenStorage to this method
+        // - remove $this->copyBetweenStorage
+
+        if (!$sourceStorage->isDeletable($sourceInternalPath)) {
+            return false;
+        }
+
+        $result = $this->copyBetweenStorage($sourceStorage, $sourceInternalPath, $targetInternalPath, $preserveMtime, true);
+        if ($result) {
+            if ($sourceStorage->is_dir($sourceInternalPath)) {
+                $result &= $sourceStorage->rmdir($sourceInternalPath);
+            } else {
+                $result &= $sourceStorage->unlink($sourceInternalPath);
+            }
+        }
+        return $result;
+    }
+
+
+    /**
+     * @param Storage\IStorage $sourceStorage
+     * @param string $sourceInternalPath
+     * @param string $targetInternalPath
+     * @param bool $preserveMtime
+     * @param bool $isRename
+     * @return bool
+     */
+    public function copyFromStorage(Storage\IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath, $preserveMtime = false, $isRename = false) {
+
+        // TODO clean this up once the underlying moveFromStorage in OC\Files\Storage\Wrapper\Common is fixed:
+        // - call $this->storage->copyFromStorage() instead of $this->copyBetweenStorage
+        // - copy the file cache update from  $this->copyBetweenStorage to this method
+        // - copy the copyKeys() call from  $this->copyBetweenStorage to this method
+        // - remove $this->copyBetweenStorage
+
+        return $this->copyBetweenStorage($sourceStorage, $sourceInternalPath, $targetInternalPath, $preserveMtime, $isRename);
+    }
+
+    /**
+     * Update the encrypted cache version in the database
+     *
+     * @param Storage\IStorage $sourceStorage
+     * @param string $sourceInternalPath
+     * @param string $targetInternalPath
+     * @param bool $isRename
+     * @param bool $keepEncryptionVersion
+     */
+    private function updateEncryptedVersion(Storage\IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath, $isRename, $keepEncryptionVersion) {
+        $isEncrypted = $this->encryptionManager->isEnabled() && $this->shouldEncrypt($targetInternalPath);
+        $cacheInformation = [
+            'encrypted' => $isEncrypted,
+        ];
+        if($isEncrypted) {
+            $encryptedVersion = $sourceStorage->getCache()->get($sourceInternalPath)['encryptedVersion'];
+
+            // In case of a move operation from an unencrypted to an encrypted
+            // storage the old encrypted version would stay with "0" while the
+            // correct value would be "1". Thus we manually set the value to "1"
+            // for those cases.
+            // See also https://github.com/owncloud/core/issues/23078
+            if($encryptedVersion === 0 || !$keepEncryptionVersion) {
+                $encryptedVersion = 1;
+            }
+
+            $cacheInformation['encryptedVersion'] = $encryptedVersion;
+        }
+
+        // in case of a rename we need to manipulate the source cache because
+        // this information will be kept for the new target
+        if ($isRename) {
+            $sourceStorage->getCache()->put($sourceInternalPath, $cacheInformation);
+        } else {
+            $this->getCache()->put($targetInternalPath, $cacheInformation);
+        }
+    }
+
+    /**
+     * copy file between two storages
+     *
+     * @param Storage\IStorage $sourceStorage
+     * @param string $sourceInternalPath
+     * @param string $targetInternalPath
+     * @param bool $preserveMtime
+     * @param bool $isRename
+     * @return bool
+     * @throws \Exception
+     */
+    private function copyBetweenStorage(Storage\IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath, $preserveMtime, $isRename) {
+
+        // for versions we have nothing to do, because versions should always use the
+        // key from the original file. Just create a 1:1 copy and done
+        if ($this->isVersion($targetInternalPath) ||
+            $this->isVersion($sourceInternalPath)) {
+            // remember that we try to create a version so that we can detect it during
+            // fopen($sourceInternalPath) and by-pass the encryption in order to
+            // create a 1:1 copy of the file
+            $this->arrayCache->set('encryption_copy_version_' . $sourceInternalPath, true);
+            $result = $this->storage->copyFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath);
+            $this->arrayCache->remove('encryption_copy_version_' . $sourceInternalPath);
+            if ($result) {
+                $info = $this->getCache('', $sourceStorage)->get($sourceInternalPath);
+                // make sure that we update the unencrypted size for the version
+                if (isset($info['encrypted']) && $info['encrypted'] === true) {
+                    $this->updateUnencryptedSize(
+                        $this->getFullPath($targetInternalPath),
+                        $info['size']
+                    );
+                }
+                $this->updateEncryptedVersion($sourceStorage, $sourceInternalPath, $targetInternalPath, $isRename, true);
+            }
+            return $result;
+        }
+
+        // first copy the keys that we reuse the existing file key on the target location
+        // and don't create a new one which would break versions for example.
+        $mount = $this->mountManager->findByStorageId($sourceStorage->getId());
+        if (count($mount) === 1) {
+            $mountPoint = $mount[0]->getMountPoint();
+            $source = $mountPoint . '/' . $sourceInternalPath;
+            $target = $this->getFullPath($targetInternalPath);
+            $this->copyKeys($source, $target);
+        } else {
+            $this->logger->error('Could not find mount point, can\'t keep encryption keys');
+        }
+
+        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, false, $isRename);
+                    }
+                }
+            }
+        } else {
+            try {
+                $source = $sourceStorage->fopen($sourceInternalPath, 'r');
+                $target = $this->fopen($targetInternalPath, 'w');
+                list(, $result) = \OC_Helper::streamCopy($source, $target);
+                fclose($source);
+                fclose($target);
+            } catch (\Exception $e) {
+                fclose($source);
+                fclose($target);
+                throw $e;
+            }
+            if($result) {
+                if ($preserveMtime) {
+                    $this->touch($targetInternalPath, $sourceStorage->filemtime($sourceInternalPath));
+                }
+                $this->updateEncryptedVersion($sourceStorage, $sourceInternalPath, $targetInternalPath, $isRename, false);
+            } else {
+                // delete partially written target file
+                $this->unlink($targetInternalPath);
+                // delete cache entry that was created by fopen
+                $this->getCache()->remove($targetInternalPath);
+            }
+        }
+        return (bool)$result;
+
+    }
+
+    /**
+     * 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
+     */
+    public function getLocalFile($path) {
+        if ($this->encryptionManager->isEnabled()) {
+            $cachedFile = $this->getCachedFile($path);
+            if (is_string($cachedFile)) {
+                return $cachedFile;
+            }
+        }
+        return $this->storage->getLocalFile($path);
+    }
+
+    /**
+     * Returns the wrapped storage's value for isLocal()
+     *
+     * @return bool wrapped storage's isLocal() value
+     */
+    public function isLocal() {
+        if ($this->encryptionManager->isEnabled()) {
+            return false;
+        }
+        return $this->storage->isLocal();
+    }
+
+    /**
+     * see http://php.net/manual/en/function.stat.php
+     * only the following keys are required in the result: size and mtime
+     *
+     * @param string $path
+     * @return array
+     */
+    public function stat($path) {
+        $stat = $this->storage->stat($path);
+        $fileSize = $this->filesize($path);
+        $stat['size'] = $fileSize;
+        $stat[7] = $fileSize;
+        return $stat;
+    }
+
+    /**
+     * see http://php.net/manual/en/function.hash.php
+     *
+     * @param string $type
+     * @param string $path
+     * @param bool $raw
+     * @return string
+     */
+    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);
+    }
+
+    /**
+     * return full path, including mount point
+     *
+     * @param string $path relative to mount point
+     * @return string full path including mount point
+     */
+    protected function getFullPath($path) {
+        return Filesystem::normalizePath($this->mountPoint . '/' . $path);
+    }
+
+    /**
+     * read first block of encrypted file, typically this will contain the
+     * encryption header
+     *
+     * @param string $path
+     * @return string
+     */
+    protected function readFirstBlock($path) {
+        $firstBlock = '';
+        if ($this->storage->file_exists($path)) {
+            $handle = $this->storage->fopen($path, 'r');
+            $firstBlock = fread($handle, $this->util->getHeaderSize());
+            fclose($handle);
+        }
+        return $firstBlock;
+    }
+
+    /**
+     * return header size of given file
+     *
+     * @param string $path
+     * @return int
+     */
+    protected function getHeaderSize($path) {
+        $headerSize = 0;
+        $realFile = $this->util->stripPartialFileExtension($path);
+        if ($this->storage->file_exists($realFile)) {
+            $path = $realFile;
+        }
+        $firstBlock = $this->readFirstBlock($path);
+
+        if (substr($firstBlock, 0, strlen(Util::HEADER_START)) === Util::HEADER_START) {
+            $headerSize = $this->util->getHeaderSize();
+        }
+
+        return $headerSize;
+    }
+
+    /**
+     * parse raw header to array
+     *
+     * @param string $rawHeader
+     * @return array
+     */
+    protected function parseRawHeader($rawHeader) {
+        $result = array();
+        if (substr($rawHeader, 0, strlen(Util::HEADER_START)) === Util::HEADER_START) {
+            $header = $rawHeader;
+            $endAt = strpos($header, Util::HEADER_END);
+            if ($endAt !== false) {
+                $header = substr($header, 0, $endAt + strlen(Util::HEADER_END));
+
+                // +1 to not start with an ':' which would result in empty element at the beginning
+                $exploded = explode(':', substr($header, strlen(Util::HEADER_START)+1));
+
+                $element = array_shift($exploded);
+                while ($element !== Util::HEADER_END) {
+                    $result[$element] = array_shift($exploded);
+                    $element = array_shift($exploded);
+                }
+            }
+        }
+
+        return $result;
+    }
+
+    /**
+     * read header from file
+     *
+     * @param string $path
+     * @return array
+     */
+    protected function getHeader($path) {
+        $realFile = $this->util->stripPartialFileExtension($path);
+        $exists = $this->storage->file_exists($realFile);
+        if ($exists) {
+            $path = $realFile;
+        }
+
+        $firstBlock = $this->readFirstBlock($path);
+        $result = $this->parseRawHeader($firstBlock);
+
+        // if the header doesn't contain a encryption module we check if it is a
+        // legacy file. If true, we add the default encryption module
+        if (!isset($result[Util::HEADER_ENCRYPTION_MODULE_KEY])) {
+            if (!empty($result)) {
+                $result[Util::HEADER_ENCRYPTION_MODULE_KEY] = 'OC_DEFAULT_MODULE';
+            } else if ($exists) {
+                // if the header was empty we have to check first if it is a encrypted file at all
+                // We would do query to filecache only if we know that entry in filecache exists
+                $info = $this->getCache()->get($path);
+                if (isset($info['encrypted']) && $info['encrypted'] === true) {
+                    $result[Util::HEADER_ENCRYPTION_MODULE_KEY] = 'OC_DEFAULT_MODULE';
+                }
+            }
+        }
+
+        return $result;
+    }
+
+    /**
+     * read encryption module needed to read/write the file located at $path
+     *
+     * @param string $path
+     * @return null|\OCP\Encryption\IEncryptionModule
+     * @throws ModuleDoesNotExistsException
+     * @throws \Exception
+     */
+    protected function getEncryptionModule($path) {
+        $encryptionModule = null;
+        $header = $this->getHeader($path);
+        $encryptionModuleId = $this->util->getEncryptionModuleId($header);
+        if (!empty($encryptionModuleId)) {
+            try {
+                $encryptionModule = $this->encryptionManager->getEncryptionModule($encryptionModuleId);
+            } catch (ModuleDoesNotExistsException $e) {
+                $this->logger->critical('Encryption module defined in "' . $path . '" not loaded!');
+                throw $e;
+            }
+        }
+
+        return $encryptionModule;
+    }
+
+    /**
+     * @param string $path
+     * @param int $unencryptedSize
+     */
+    public function updateUnencryptedSize($path, $unencryptedSize) {
+        $this->unencryptedSize[$path] = $unencryptedSize;
+    }
+
+    /**
+     * copy keys to new location
+     *
+     * @param string $source path relative to data/
+     * @param string $target path relative to data/
+     * @return bool
+     */
+    protected function copyKeys($source, $target) {
+        if (!$this->util->isExcluded($source)) {
+            return $this->keyStorage->copyKeys($source, $target);
+        }
+
+        return false;
+    }
+
+    /**
+     * check if path points to a files version
+     *
+     * @param $path
+     * @return bool
+     */
+    protected function isVersion($path) {
+        $normalized = Filesystem::normalizePath($path);
+        return substr($normalized, 0, strlen('/files_versions/')) === '/files_versions/';
+    }
+
+    /**
+     * check if the given storage should be encrypted or not
+     *
+     * @param $path
+     * @return bool
+     */
+    protected function shouldEncrypt($path) {
+        $fullPath = $this->getFullPath($path);
+        $mountPointConfig = $this->mount->getOption('encrypt', true);
+        if ($mountPointConfig === false) {
+            return false;
+        }
+
+        try {
+            $encryptionModule = $this->getEncryptionModule($fullPath);
+        } catch (ModuleDoesNotExistsException $e) {
+            return false;
+        }
+
+        if ($encryptionModule === null) {
+            $encryptionModule = $this->encryptionManager->getEncryptionModule();
+        }
+
+        return $encryptionModule->shouldEncrypt($fullPath);
+
+    }
 
 }

lib/private/Files/Storage/Local.php

Indentation +414 added lines, -414 removed lines

@@ -48,418 +48,418 @@
  * for local filestore, we only have to map the paths
  */
 class Local extends \OC\Files\Storage\Common {
-	protected $datadir;
-
-	protected $dataDirLength;
-
-	protected $allowSymlinks = false;
-
-	protected $realDataDir;
-
-	public function __construct($arguments) {
-		if (!isset($arguments['datadir']) || !is_string($arguments['datadir'])) {
-			throw new \InvalidArgumentException('No data directory set for local storage');
-		}
-		$this->datadir = str_replace('//', '/', $arguments['datadir']);
-		// some crazy code uses a local storage on root...
-		if ($this->datadir === '/') {
-			$this->realDataDir = $this->datadir;
-		} else {
-			$realPath = realpath($this->datadir) ?: $this->datadir;
-			$this->realDataDir = rtrim($realPath, '/') . '/';
-		}
-		if (substr($this->datadir, -1) !== '/') {
-			$this->datadir .= '/';
-		}
-		$this->dataDirLength = strlen($this->realDataDir);
-	}
-
-	public function __destruct() {
-	}
-
-	public function getId() {
-		return 'local::' . $this->datadir;
-	}
-
-	public function mkdir($path) {
-		return @mkdir($this->getSourcePath($path), 0777, true);
-	}
-
-	public function rmdir($path) {
-		if (!$this->isDeletable($path)) {
-			return false;
-		}
-		try {
-			$it = new \RecursiveIteratorIterator(
-				new \RecursiveDirectoryIterator($this->getSourcePath($path)),
-				\RecursiveIteratorIterator::CHILD_FIRST
-			);
-			/**
-			 * RecursiveDirectoryIterator on an NFS path isn't iterable with foreach
-			 * This bug is fixed in PHP 5.5.9 or before
-			 * See #8376
-			 */
-			$it->rewind();
-			while ($it->valid()) {
-				/**
-				 * @var \SplFileInfo $file
-				 */
-				$file = $it->current();
-				if (in_array($file->getBasename(), array('.', '..'))) {
-					$it->next();
-					continue;
-				} elseif ($file->isDir()) {
-					rmdir($file->getPathname());
-				} elseif ($file->isFile() || $file->isLink()) {
-					unlink($file->getPathname());
-				}
-				$it->next();
-			}
-			return rmdir($this->getSourcePath($path));
-		} catch (\UnexpectedValueException $e) {
-			return false;
-		}
-	}
-
-	public function opendir($path) {
-		return opendir($this->getSourcePath($path));
-	}
-
-	public function is_dir($path) {
-		if (substr($path, -1) == '/') {
-			$path = substr($path, 0, -1);
-		}
-		return is_dir($this->getSourcePath($path));
-	}
-
-	public function is_file($path) {
-		return is_file($this->getSourcePath($path));
-	}
-
-	public function stat($path) {
-		clearstatcache();
-		$fullPath = $this->getSourcePath($path);
-		$statResult = stat($fullPath);
-		if (PHP_INT_SIZE === 4 && !$this->is_dir($path)) {
-			$filesize = $this->filesize($path);
-			$statResult['size'] = $filesize;
-			$statResult[7] = $filesize;
-		}
-		return $statResult;
-	}
-
-	public function filetype($path) {
-		$filetype = filetype($this->getSourcePath($path));
-		if ($filetype == 'link') {
-			$filetype = filetype(realpath($this->getSourcePath($path)));
-		}
-		return $filetype;
-	}
-
-	public function filesize($path) {
-		if ($this->is_dir($path)) {
-			return 0;
-		}
-		$fullPath = $this->getSourcePath($path);
-		if (PHP_INT_SIZE === 4) {
-			$helper = new \OC\LargeFileHelper;
-			return $helper->getFileSize($fullPath);
-		}
-		return filesize($fullPath);
-	}
-
-	public function isReadable($path) {
-		return is_readable($this->getSourcePath($path));
-	}
-
-	public function isUpdatable($path) {
-		return is_writable($this->getSourcePath($path));
-	}
-
-	public function file_exists($path) {
-		return file_exists($this->getSourcePath($path));
-	}
-
-	public function filemtime($path) {
-		$fullPath = $this->getSourcePath($path);
-		clearstatcache(true, $fullPath);
-		if (!$this->file_exists($path)) {
-			return false;
-		}
-		if (PHP_INT_SIZE === 4) {
-			$helper = new \OC\LargeFileHelper();
-			return $helper->getFileMtime($fullPath);
-		}
-		return filemtime($fullPath);
-	}
-
-	public function touch($path, $mtime = null) {
-		// sets the modification time of the file to the given value.
-		// If mtime is nil the current time is set.
-		// note that the access time of the file always changes to the current time.
-		if ($this->file_exists($path) and !$this->isUpdatable($path)) {
-			return false;
-		}
-		if (!is_null($mtime)) {
-			$result = touch($this->getSourcePath($path), $mtime);
-		} else {
-			$result = touch($this->getSourcePath($path));
-		}
-		if ($result) {
-			clearstatcache(true, $this->getSourcePath($path));
-		}
-
-		return $result;
-	}
-
-	public function file_get_contents($path) {
-		return file_get_contents($this->getSourcePath($path));
-	}
-
-	public function file_put_contents($path, $data) {
-		return file_put_contents($this->getSourcePath($path), $data);
-	}
-
-	public function unlink($path) {
-		if ($this->is_dir($path)) {
-			return $this->rmdir($path);
-		} else if ($this->is_file($path)) {
-			return unlink($this->getSourcePath($path));
-		} else {
-			return false;
-		}
-
-	}
-
-	public function rename($path1, $path2) {
-		$srcParent = dirname($path1);
-		$dstParent = dirname($path2);
-
-		if (!$this->isUpdatable($srcParent)) {
-			\OCP\Util::writeLog('core', 'unable to rename, source directory is not writable : ' . $srcParent, ILogger::ERROR);
-			return false;
-		}
-
-		if (!$this->isUpdatable($dstParent)) {
-			\OCP\Util::writeLog('core', 'unable to rename, destination directory is not writable : ' . $dstParent, ILogger::ERROR);
-			return false;
-		}
-
-		if (!$this->file_exists($path1)) {
-			\OCP\Util::writeLog('core', 'unable to rename, file does not exists : ' . $path1, ILogger::ERROR);
-			return false;
-		}
-
-		if ($this->is_dir($path2)) {
-			$this->rmdir($path2);
-		} else if ($this->is_file($path2)) {
-			$this->unlink($path2);
-		}
-
-		if ($this->is_dir($path1)) {
-			// we can't move folders across devices, use copy instead
-			$stat1 = stat(dirname($this->getSourcePath($path1)));
-			$stat2 = stat(dirname($this->getSourcePath($path2)));
-			if ($stat1['dev'] !== $stat2['dev']) {
-				$result = $this->copy($path1, $path2);
-				if ($result) {
-					$result &= $this->rmdir($path1);
-				}
-				return $result;
-			}
-		}
-
-		return rename($this->getSourcePath($path1), $this->getSourcePath($path2));
-	}
-
-	public function copy($path1, $path2) {
-		if ($this->is_dir($path1)) {
-			return parent::copy($path1, $path2);
-		} else {
-			return copy($this->getSourcePath($path1), $this->getSourcePath($path2));
-		}
-	}
-
-	public function fopen($path, $mode) {
-		return fopen($this->getSourcePath($path), $mode);
-	}
-
-	public function hash($type, $path, $raw = false) {
-		return hash_file($type, $this->getSourcePath($path), $raw);
-	}
-
-	public function free_space($path) {
-		$sourcePath = $this->getSourcePath($path);
-		// using !is_dir because $sourcePath might be a part file or
-		// non-existing file, so we'd still want to use the parent dir
-		// in such cases
-		if (!is_dir($sourcePath)) {
-			// disk_free_space doesn't work on files
-			$sourcePath = dirname($sourcePath);
-		}
-		$space = @disk_free_space($sourcePath);
-		if ($space === false || is_null($space)) {
-			return \OCP\Files\FileInfo::SPACE_UNKNOWN;
-		}
-		return $space;
-	}
-
-	public function search($query) {
-		return $this->searchInDir($query);
-	}
-
-	public function getLocalFile($path) {
-		return $this->getSourcePath($path);
-	}
-
-	public function getLocalFolder($path) {
-		return $this->getSourcePath($path);
-	}
-
-	/**
-	 * @param string $query
-	 * @param string $dir
-	 * @return array
-	 */
-	protected function searchInDir($query, $dir = '') {
-		$files = array();
-		$physicalDir = $this->getSourcePath($dir);
-		foreach (scandir($physicalDir) as $item) {
-			if (\OC\Files\Filesystem::isIgnoredDir($item))
-				continue;
-			$physicalItem = $physicalDir . '/' . $item;
-
-			if (strstr(strtolower($item), strtolower($query)) !== false) {
-				$files[] = $dir . '/' . $item;
-			}
-			if (is_dir($physicalItem)) {
-				$files = array_merge($files, $this->searchInDir($query, $dir . '/' . $item));
-			}
-		}
-		return $files;
-	}
-
-	/**
-	 * 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 ($this->file_exists($path)) {
-			return $this->filemtime($path) > $time;
-		} else {
-			return true;
-		}
-	}
-
-	/**
-	 * Get the source path (on disk) of a given path
-	 *
-	 * @param string $path
-	 * @return string
-	 * @throws ForbiddenException
-	 */
-	public function getSourcePath($path) {
-		$fullPath = $this->datadir . $path;
-		$currentPath = $path;
-		if ($this->allowSymlinks || $currentPath === '') {
-			return $fullPath;
-		}
-		$pathToResolve = $fullPath;
-		$realPath = realpath($pathToResolve);
-		while ($realPath === false) { // for non existing files check the parent directory
-			$currentPath = dirname($currentPath);
-			if ($currentPath === '' || $currentPath === '.') {
-				return $fullPath;
-			}
-			$realPath = realpath($this->datadir . $currentPath);
-		}
-		if ($realPath) {
-			$realPath = $realPath . '/';
-		}
-		if (substr($realPath, 0, $this->dataDirLength) === $this->realDataDir) {
-			return $fullPath;
-		}
-
-		\OCP\Util::writeLog('core', "Following symlinks is not allowed ('$fullPath' -> '$realPath' not inside '{$this->realDataDir}')", ILogger::ERROR);
-		throw new ForbiddenException('Following symlinks is not allowed', false);
-	}
-
-	/**
-	 * {@inheritdoc}
-	 */
-	public function isLocal() {
-		return true;
-	}
-
-	/**
-	 * get the ETag for a file or folder
-	 *
-	 * @param string $path
-	 * @return string
-	 */
-	public function getETag($path) {
-		if ($this->is_file($path)) {
-			$stat = $this->stat($path);
-			return md5(
-				$stat['mtime'] .
-				$stat['ino'] .
-				$stat['dev'] .
-				$stat['size']
-			);
-		} else {
-			return parent::getETag($path);
-		}
-	}
-
-	/**
-	 * @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->instanceOfStorage(Local::class)) {
-			if ($sourceStorage->instanceOfStorage(Jail::class)) {
-				/**
-				 * @var \OC\Files\Storage\Wrapper\Jail $sourceStorage
-				 */
-				$sourceInternalPath = $sourceStorage->getUnjailedPath($sourceInternalPath);
-			}
-			/**
-			 * @var \OC\Files\Storage\Local $sourceStorage
-			 */
-			$rootStorage = new Local(['datadir' => '/']);
-			return $rootStorage->copy($sourceStorage->getSourcePath($sourceInternalPath), $this->getSourcePath($targetInternalPath));
-		} else {
-			return parent::copyFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath);
-		}
-	}
-
-	/**
-	 * @param IStorage $sourceStorage
-	 * @param string $sourceInternalPath
-	 * @param string $targetInternalPath
-	 * @return bool
-	 */
-	public function moveFromStorage(IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath) {
-		if ($sourceStorage->instanceOfStorage(Local::class)) {
-			if ($sourceStorage->instanceOfStorage(Jail::class)) {
-				/**
-				 * @var \OC\Files\Storage\Wrapper\Jail $sourceStorage
-				 */
-				$sourceInternalPath = $sourceStorage->getUnjailedPath($sourceInternalPath);
-			}
-			/**
-			 * @var \OC\Files\Storage\Local $sourceStorage
-			 */
-			$rootStorage = new Local(['datadir' => '/']);
-			return $rootStorage->rename($sourceStorage->getSourcePath($sourceInternalPath), $this->getSourcePath($targetInternalPath));
-		} else {
-			return parent::moveFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath);
-		}
-	}
+    protected $datadir;
+
+    protected $dataDirLength;
+
+    protected $allowSymlinks = false;
+
+    protected $realDataDir;
+
+    public function __construct($arguments) {
+        if (!isset($arguments['datadir']) || !is_string($arguments['datadir'])) {
+            throw new \InvalidArgumentException('No data directory set for local storage');
+        }
+        $this->datadir = str_replace('//', '/', $arguments['datadir']);
+        // some crazy code uses a local storage on root...
+        if ($this->datadir === '/') {
+            $this->realDataDir = $this->datadir;
+        } else {
+            $realPath = realpath($this->datadir) ?: $this->datadir;
+            $this->realDataDir = rtrim($realPath, '/') . '/';
+        }
+        if (substr($this->datadir, -1) !== '/') {
+            $this->datadir .= '/';
+        }
+        $this->dataDirLength = strlen($this->realDataDir);
+    }
+
+    public function __destruct() {
+    }
+
+    public function getId() {
+        return 'local::' . $this->datadir;
+    }
+
+    public function mkdir($path) {
+        return @mkdir($this->getSourcePath($path), 0777, true);
+    }
+
+    public function rmdir($path) {
+        if (!$this->isDeletable($path)) {
+            return false;
+        }
+        try {
+            $it = new \RecursiveIteratorIterator(
+                new \RecursiveDirectoryIterator($this->getSourcePath($path)),
+                \RecursiveIteratorIterator::CHILD_FIRST
+            );
+            /**
+             * RecursiveDirectoryIterator on an NFS path isn't iterable with foreach
+             * This bug is fixed in PHP 5.5.9 or before
+             * See #8376
+             */
+            $it->rewind();
+            while ($it->valid()) {
+                /**
+                 * @var \SplFileInfo $file
+                 */
+                $file = $it->current();
+                if (in_array($file->getBasename(), array('.', '..'))) {
+                    $it->next();
+                    continue;
+                } elseif ($file->isDir()) {
+                    rmdir($file->getPathname());
+                } elseif ($file->isFile() || $file->isLink()) {
+                    unlink($file->getPathname());
+                }
+                $it->next();
+            }
+            return rmdir($this->getSourcePath($path));
+        } catch (\UnexpectedValueException $e) {
+            return false;
+        }
+    }
+
+    public function opendir($path) {
+        return opendir($this->getSourcePath($path));
+    }
+
+    public function is_dir($path) {
+        if (substr($path, -1) == '/') {
+            $path = substr($path, 0, -1);
+        }
+        return is_dir($this->getSourcePath($path));
+    }
+
+    public function is_file($path) {
+        return is_file($this->getSourcePath($path));
+    }
+
+    public function stat($path) {
+        clearstatcache();
+        $fullPath = $this->getSourcePath($path);
+        $statResult = stat($fullPath);
+        if (PHP_INT_SIZE === 4 && !$this->is_dir($path)) {
+            $filesize = $this->filesize($path);
+            $statResult['size'] = $filesize;
+            $statResult[7] = $filesize;
+        }
+        return $statResult;
+    }
+
+    public function filetype($path) {
+        $filetype = filetype($this->getSourcePath($path));
+        if ($filetype == 'link') {
+            $filetype = filetype(realpath($this->getSourcePath($path)));
+        }
+        return $filetype;
+    }
+
+    public function filesize($path) {
+        if ($this->is_dir($path)) {
+            return 0;
+        }
+        $fullPath = $this->getSourcePath($path);
+        if (PHP_INT_SIZE === 4) {
+            $helper = new \OC\LargeFileHelper;
+            return $helper->getFileSize($fullPath);
+        }
+        return filesize($fullPath);
+    }
+
+    public function isReadable($path) {
+        return is_readable($this->getSourcePath($path));
+    }
+
+    public function isUpdatable($path) {
+        return is_writable($this->getSourcePath($path));
+    }
+
+    public function file_exists($path) {
+        return file_exists($this->getSourcePath($path));
+    }
+
+    public function filemtime($path) {
+        $fullPath = $this->getSourcePath($path);
+        clearstatcache(true, $fullPath);
+        if (!$this->file_exists($path)) {
+            return false;
+        }
+        if (PHP_INT_SIZE === 4) {
+            $helper = new \OC\LargeFileHelper();
+            return $helper->getFileMtime($fullPath);
+        }
+        return filemtime($fullPath);
+    }
+
+    public function touch($path, $mtime = null) {
+        // sets the modification time of the file to the given value.
+        // If mtime is nil the current time is set.
+        // note that the access time of the file always changes to the current time.
+        if ($this->file_exists($path) and !$this->isUpdatable($path)) {
+            return false;
+        }
+        if (!is_null($mtime)) {
+            $result = touch($this->getSourcePath($path), $mtime);
+        } else {
+            $result = touch($this->getSourcePath($path));
+        }
+        if ($result) {
+            clearstatcache(true, $this->getSourcePath($path));
+        }
+
+        return $result;
+    }
+
+    public function file_get_contents($path) {
+        return file_get_contents($this->getSourcePath($path));
+    }
+
+    public function file_put_contents($path, $data) {
+        return file_put_contents($this->getSourcePath($path), $data);
+    }
+
+    public function unlink($path) {
+        if ($this->is_dir($path)) {
+            return $this->rmdir($path);
+        } else if ($this->is_file($path)) {
+            return unlink($this->getSourcePath($path));
+        } else {
+            return false;
+        }
+
+    }
+
+    public function rename($path1, $path2) {
+        $srcParent = dirname($path1);
+        $dstParent = dirname($path2);
+
+        if (!$this->isUpdatable($srcParent)) {
+            \OCP\Util::writeLog('core', 'unable to rename, source directory is not writable : ' . $srcParent, ILogger::ERROR);
+            return false;
+        }
+
+        if (!$this->isUpdatable($dstParent)) {
+            \OCP\Util::writeLog('core', 'unable to rename, destination directory is not writable : ' . $dstParent, ILogger::ERROR);
+            return false;
+        }
+
+        if (!$this->file_exists($path1)) {
+            \OCP\Util::writeLog('core', 'unable to rename, file does not exists : ' . $path1, ILogger::ERROR);
+            return false;
+        }
+
+        if ($this->is_dir($path2)) {
+            $this->rmdir($path2);
+        } else if ($this->is_file($path2)) {
+            $this->unlink($path2);
+        }
+
+        if ($this->is_dir($path1)) {
+            // we can't move folders across devices, use copy instead
+            $stat1 = stat(dirname($this->getSourcePath($path1)));
+            $stat2 = stat(dirname($this->getSourcePath($path2)));
+            if ($stat1['dev'] !== $stat2['dev']) {
+                $result = $this->copy($path1, $path2);
+                if ($result) {
+                    $result &= $this->rmdir($path1);
+                }
+                return $result;
+            }
+        }
+
+        return rename($this->getSourcePath($path1), $this->getSourcePath($path2));
+    }
+
+    public function copy($path1, $path2) {
+        if ($this->is_dir($path1)) {
+            return parent::copy($path1, $path2);
+        } else {
+            return copy($this->getSourcePath($path1), $this->getSourcePath($path2));
+        }
+    }
+
+    public function fopen($path, $mode) {
+        return fopen($this->getSourcePath($path), $mode);
+    }
+
+    public function hash($type, $path, $raw = false) {
+        return hash_file($type, $this->getSourcePath($path), $raw);
+    }
+
+    public function free_space($path) {
+        $sourcePath = $this->getSourcePath($path);
+        // using !is_dir because $sourcePath might be a part file or
+        // non-existing file, so we'd still want to use the parent dir
+        // in such cases
+        if (!is_dir($sourcePath)) {
+            // disk_free_space doesn't work on files
+            $sourcePath = dirname($sourcePath);
+        }
+        $space = @disk_free_space($sourcePath);
+        if ($space === false || is_null($space)) {
+            return \OCP\Files\FileInfo::SPACE_UNKNOWN;
+        }
+        return $space;
+    }
+
+    public function search($query) {
+        return $this->searchInDir($query);
+    }
+
+    public function getLocalFile($path) {
+        return $this->getSourcePath($path);
+    }
+
+    public function getLocalFolder($path) {
+        return $this->getSourcePath($path);
+    }
+
+    /**
+     * @param string $query
+     * @param string $dir
+     * @return array
+     */
+    protected function searchInDir($query, $dir = '') {
+        $files = array();
+        $physicalDir = $this->getSourcePath($dir);
+        foreach (scandir($physicalDir) as $item) {
+            if (\OC\Files\Filesystem::isIgnoredDir($item))
+                continue;
+            $physicalItem = $physicalDir . '/' . $item;
+
+            if (strstr(strtolower($item), strtolower($query)) !== false) {
+                $files[] = $dir . '/' . $item;
+            }
+            if (is_dir($physicalItem)) {
+                $files = array_merge($files, $this->searchInDir($query, $dir . '/' . $item));
+            }
+        }
+        return $files;
+    }
+
+    /**
+     * 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 ($this->file_exists($path)) {
+            return $this->filemtime($path) > $time;
+        } else {
+            return true;
+        }
+    }
+
+    /**
+     * Get the source path (on disk) of a given path
+     *
+     * @param string $path
+     * @return string
+     * @throws ForbiddenException
+     */
+    public function getSourcePath($path) {
+        $fullPath = $this->datadir . $path;
+        $currentPath = $path;
+        if ($this->allowSymlinks || $currentPath === '') {
+            return $fullPath;
+        }
+        $pathToResolve = $fullPath;
+        $realPath = realpath($pathToResolve);
+        while ($realPath === false) { // for non existing files check the parent directory
+            $currentPath = dirname($currentPath);
+            if ($currentPath === '' || $currentPath === '.') {
+                return $fullPath;
+            }
+            $realPath = realpath($this->datadir . $currentPath);
+        }
+        if ($realPath) {
+            $realPath = $realPath . '/';
+        }
+        if (substr($realPath, 0, $this->dataDirLength) === $this->realDataDir) {
+            return $fullPath;
+        }
+
+        \OCP\Util::writeLog('core', "Following symlinks is not allowed ('$fullPath' -> '$realPath' not inside '{$this->realDataDir}')", ILogger::ERROR);
+        throw new ForbiddenException('Following symlinks is not allowed', false);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function isLocal() {
+        return true;
+    }
+
+    /**
+     * get the ETag for a file or folder
+     *
+     * @param string $path
+     * @return string
+     */
+    public function getETag($path) {
+        if ($this->is_file($path)) {
+            $stat = $this->stat($path);
+            return md5(
+                $stat['mtime'] .
+                $stat['ino'] .
+                $stat['dev'] .
+                $stat['size']
+            );
+        } else {
+            return parent::getETag($path);
+        }
+    }
+
+    /**
+     * @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->instanceOfStorage(Local::class)) {
+            if ($sourceStorage->instanceOfStorage(Jail::class)) {
+                /**
+                 * @var \OC\Files\Storage\Wrapper\Jail $sourceStorage
+                 */
+                $sourceInternalPath = $sourceStorage->getUnjailedPath($sourceInternalPath);
+            }
+            /**
+             * @var \OC\Files\Storage\Local $sourceStorage
+             */
+            $rootStorage = new Local(['datadir' => '/']);
+            return $rootStorage->copy($sourceStorage->getSourcePath($sourceInternalPath), $this->getSourcePath($targetInternalPath));
+        } else {
+            return parent::copyFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath);
+        }
+    }
+
+    /**
+     * @param IStorage $sourceStorage
+     * @param string $sourceInternalPath
+     * @param string $targetInternalPath
+     * @return bool
+     */
+    public function moveFromStorage(IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath) {
+        if ($sourceStorage->instanceOfStorage(Local::class)) {
+            if ($sourceStorage->instanceOfStorage(Jail::class)) {
+                /**
+                 * @var \OC\Files\Storage\Wrapper\Jail $sourceStorage
+                 */
+                $sourceInternalPath = $sourceStorage->getUnjailedPath($sourceInternalPath);
+            }
+            /**
+             * @var \OC\Files\Storage\Local $sourceStorage
+             */
+            $rootStorage = new Local(['datadir' => '/']);
+            return $rootStorage->rename($sourceStorage->getSourcePath($sourceInternalPath), $this->getSourcePath($targetInternalPath));
+        } else {
+            return parent::moveFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath);
+        }
+    }
 }

lib/private/Files/Storage/DAV.php

Indentation +796 added lines, -796 removed lines

@@ -58,801 +58,801 @@
  * @package OC\Files\Storage
  */
 class DAV extends Common {
-	/** @var string */
-	protected $password;
-	/** @var string */
-	protected $user;
-	/** @var string */
-	protected $authType;
-	/** @var string */
-	protected $host;
-	/** @var bool */
-	protected $secure;
-	/** @var string */
-	protected $root;
-	/** @var string */
-	protected $certPath;
-	/** @var bool */
-	protected $ready;
-	/** @var Client */
-	protected $client;
-	/** @var ArrayCache */
-	protected $statCache;
-	/** @var \OCP\Http\Client\IClientService */
-	protected $httpClientService;
-
-	/**
-	 * @param array $params
-	 * @throws \Exception
-	 */
-	public function __construct($params) {
-		$this->statCache = new ArrayCache();
-		$this->httpClientService = \OC::$server->getHTTPClientService();
-		if (isset($params['host']) && isset($params['user']) && isset($params['password'])) {
-			$host = $params['host'];
-			//remove leading http[s], will be generated in createBaseUri()
-			if (substr($host, 0, 8) == "https://") $host = substr($host, 8);
-			else if (substr($host, 0, 7) == "http://") $host = substr($host, 7);
-			$this->host = $host;
-			$this->user = $params['user'];
-			$this->password = $params['password'];
-			if (isset($params['authType'])) {
-				$this->authType = $params['authType'];
-			}
-			if (isset($params['secure'])) {
-				if (is_string($params['secure'])) {
-					$this->secure = ($params['secure'] === 'true');
-				} else {
-					$this->secure = (bool)$params['secure'];
-				}
-			} else {
-				$this->secure = false;
-			}
-			if ($this->secure === true) {
-				// inject mock for testing
-				$certManager = \OC::$server->getCertificateManager();
-				if (is_null($certManager)) { //no user
-					$certManager = \OC::$server->getCertificateManager(null);
-				}
-				$certPath = $certManager->getAbsoluteBundlePath();
-				if (file_exists($certPath)) {
-					$this->certPath = $certPath;
-				}
-			}
-			$this->root = $params['root'] ?? '/';
-			$this->root = '/' . ltrim($this->root, '/');
-			$this->root = rtrim($this->root, '/') . '/';
-		} else {
-			throw new \Exception('Invalid webdav storage configuration');
-		}
-	}
-
-	protected function init() {
-		if ($this->ready) {
-			return;
-		}
-		$this->ready = true;
-
-		$settings = [
-			'baseUri' => $this->createBaseUri(),
-			'userName' => $this->user,
-			'password' => $this->password,
-		];
-		if (isset($this->authType)) {
-			$settings['authType'] = $this->authType;
-		}
-
-		$proxy = \OC::$server->getConfig()->getSystemValue('proxy', '');
-		if ($proxy !== '') {
-			$settings['proxy'] = $proxy;
-		}
-
-		$this->client = new Client($settings);
-		$this->client->setThrowExceptions(true);
-		if ($this->secure === true && $this->certPath) {
-			$this->client->addCurlSetting(CURLOPT_CAINFO, $this->certPath);
-		}
-	}
-
-	/**
-	 * Clear the stat cache
-	 */
-	public function clearStatCache() {
-		$this->statCache->clear();
-	}
-
-	/** {@inheritdoc} */
-	public function getId() {
-		return 'webdav::' . $this->user . '@' . $this->host . '/' . $this->root;
-	}
-
-	/** {@inheritdoc} */
-	public function createBaseUri() {
-		$baseUri = 'http';
-		if ($this->secure) {
-			$baseUri .= 's';
-		}
-		$baseUri .= '://' . $this->host . $this->root;
-		return $baseUri;
-	}
-
-	/** {@inheritdoc} */
-	public function mkdir($path) {
-		$this->init();
-		$path = $this->cleanPath($path);
-		$result = $this->simpleResponse('MKCOL', $path, null, 201);
-		if ($result) {
-			$this->statCache->set($path, true);
-		}
-		return $result;
-	}
-
-	/** {@inheritdoc} */
-	public function rmdir($path) {
-		$this->init();
-		$path = $this->cleanPath($path);
-		// FIXME: some WebDAV impl return 403 when trying to DELETE
-		// a non-empty folder
-		$result = $this->simpleResponse('DELETE', $path . '/', null, 204);
-		$this->statCache->clear($path . '/');
-		$this->statCache->remove($path);
-		return $result;
-	}
-
-	/** {@inheritdoc} */
-	public function opendir($path) {
-		$this->init();
-		$path = $this->cleanPath($path);
-		try {
-			$response = $this->client->propFind(
-				$this->encodePath($path),
-				['{DAV:}href'],
-				1
-			);
-			if ($response === false) {
-				return false;
-			}
-			$content = [];
-			$files = array_keys($response);
-			array_shift($files); //the first entry is the current directory
-
-			if (!$this->statCache->hasKey($path)) {
-				$this->statCache->set($path, true);
-			}
-			foreach ($files as $file) {
-				$file = urldecode($file);
-				// do not store the real entry, we might not have all properties
-				if (!$this->statCache->hasKey($path)) {
-					$this->statCache->set($file, true);
-				}
-				$file = basename($file);
-				$content[] = $file;
-			}
-			return IteratorDirectory::wrap($content);
-		} catch (\Exception $e) {
-			$this->convertException($e, $path);
-		}
-		return false;
-	}
-
-	/**
-	 * Propfind call with cache handling.
-	 *
-	 * First checks if information is cached.
-	 * If not, request it from the server then store to cache.
-	 *
-	 * @param string $path path to propfind
-	 *
-	 * @return array|boolean propfind response or false if the entry was not found
-	 *
-	 * @throws ClientHttpException
-	 */
-	protected function propfind($path) {
-		$path = $this->cleanPath($path);
-		$cachedResponse = $this->statCache->get($path);
-		// we either don't know it, or we know it exists but need more details
-		if (is_null($cachedResponse) || $cachedResponse === true) {
-			$this->init();
-			try {
-				$response = $this->client->propFind(
-					$this->encodePath($path),
-					array(
-						'{DAV:}getlastmodified',
-						'{DAV:}getcontentlength',
-						'{DAV:}getcontenttype',
-						'{http://owncloud.org/ns}permissions',
-						'{http://open-collaboration-services.org/ns}share-permissions',
-						'{DAV:}resourcetype',
-						'{DAV:}getetag',
-					)
-				);
-				$this->statCache->set($path, $response);
-			} catch (ClientHttpException $e) {
-				if ($e->getHttpStatus() === 404) {
-					$this->statCache->clear($path . '/');
-					$this->statCache->set($path, false);
-					return false;
-				}
-				$this->convertException($e, $path);
-			} catch (\Exception $e) {
-				$this->convertException($e, $path);
-			}
-		} else {
-			$response = $cachedResponse;
-		}
-		return $response;
-	}
-
-	/** {@inheritdoc} */
-	public function filetype($path) {
-		try {
-			$response = $this->propfind($path);
-			if ($response === false) {
-				return false;
-			}
-			$responseType = [];
-			if (isset($response["{DAV:}resourcetype"])) {
-				/** @var ResourceType[] $response */
-				$responseType = $response["{DAV:}resourcetype"]->getValue();
-			}
-			return (count($responseType) > 0 and $responseType[0] == "{DAV:}collection") ? 'dir' : 'file';
-		} catch (\Exception $e) {
-			$this->convertException($e, $path);
-		}
-		return false;
-	}
-
-	/** {@inheritdoc} */
-	public function file_exists($path) {
-		try {
-			$path = $this->cleanPath($path);
-			$cachedState = $this->statCache->get($path);
-			if ($cachedState === false) {
-				// we know the file doesn't exist
-				return false;
-			} else if (!is_null($cachedState)) {
-				return true;
-			}
-			// need to get from server
-			return ($this->propfind($path) !== false);
-		} catch (\Exception $e) {
-			$this->convertException($e, $path);
-		}
-		return false;
-	}
-
-	/** {@inheritdoc} */
-	public function unlink($path) {
-		$this->init();
-		$path = $this->cleanPath($path);
-		$result = $this->simpleResponse('DELETE', $path, null, 204);
-		$this->statCache->clear($path . '/');
-		$this->statCache->remove($path);
-		return $result;
-	}
-
-	/** {@inheritdoc} */
-	public function fopen($path, $mode) {
-		$this->init();
-		$path = $this->cleanPath($path);
-		switch ($mode) {
-			case 'r':
-			case 'rb':
-				try {
-					$response = $this->httpClientService
-						->newClient()
-						->get($this->createBaseUri() . $this->encodePath($path), [
-							'auth' => [$this->user, $this->password],
-							'stream' => true
-						]);
-				} catch (\GuzzleHttp\Exception\ClientException $e) {
-					if ($e->getResponse() instanceof ResponseInterface
-						&& $e->getResponse()->getStatusCode() === 404) {
-						return false;
-					} else {
-						throw $e;
-					}
-				}
-
-				if ($response->getStatusCode() !== Http::STATUS_OK) {
-					if ($response->getStatusCode() === Http::STATUS_LOCKED) {
-						throw new \OCP\Lock\LockedException($path);
-					} else {
-						Util::writeLog("webdav client", 'Guzzle get returned status code ' . $response->getStatusCode(), ILogger::ERROR);
-					}
-				}
-
-				return $response->getBody();
-			case 'w':
-			case 'wb':
-			case 'a':
-			case 'ab':
-			case 'r+':
-			case 'w+':
-			case 'wb+':
-			case 'a+':
-			case 'x':
-			case 'x+':
-			case 'c':
-			case 'c+':
-				//emulate these
-				$tempManager = \OC::$server->getTempManager();
-				if (strrpos($path, '.') !== false) {
-					$ext = substr($path, strrpos($path, '.'));
-				} else {
-					$ext = '';
-				}
-				if ($this->file_exists($path)) {
-					if (!$this->isUpdatable($path)) {
-						return false;
-					}
-					if ($mode === 'w' or $mode === 'w+') {
-						$tmpFile = $tempManager->getTemporaryFile($ext);
-					} else {
-						$tmpFile = $this->getCachedFile($path);
-					}
-				} else {
-					if (!$this->isCreatable(dirname($path))) {
-						return false;
-					}
-					$tmpFile = $tempManager->getTemporaryFile($ext);
-				}
-				$handle = fopen($tmpFile, $mode);
-				return CallbackWrapper::wrap($handle, null, null, function () use ($path, $tmpFile) {
-					$this->writeBack($tmpFile, $path);
-				});
-		}
-	}
-
-	/**
-	 * @param string $tmpFile
-	 */
-	public function writeBack($tmpFile, $path) {
-		$this->uploadFile($tmpFile, $path);
-		unlink($tmpFile);
-	}
-
-	/** {@inheritdoc} */
-	public function free_space($path) {
-		$this->init();
-		$path = $this->cleanPath($path);
-		try {
-			// TODO: cacheable ?
-			$response = $this->client->propfind($this->encodePath($path), ['{DAV:}quota-available-bytes']);
-			if ($response === false) {
-				return FileInfo::SPACE_UNKNOWN;
-			}
-			if (isset($response['{DAV:}quota-available-bytes'])) {
-				return (int)$response['{DAV:}quota-available-bytes'];
-			} else {
-				return FileInfo::SPACE_UNKNOWN;
-			}
-		} catch (\Exception $e) {
-			return FileInfo::SPACE_UNKNOWN;
-		}
-	}
-
-	/** {@inheritdoc} */
-	public function touch($path, $mtime = null) {
-		$this->init();
-		if (is_null($mtime)) {
-			$mtime = time();
-		}
-		$path = $this->cleanPath($path);
-
-		// if file exists, update the mtime, else create a new empty file
-		if ($this->file_exists($path)) {
-			try {
-				$this->statCache->remove($path);
-				$this->client->proppatch($this->encodePath($path), ['{DAV:}lastmodified' => $mtime]);
-				// non-owncloud clients might not have accepted the property, need to recheck it
-				$response = $this->client->propfind($this->encodePath($path), ['{DAV:}getlastmodified'], 0);
-				if ($response === false) {
-					return false;
-				}
-				if (isset($response['{DAV:}getlastmodified'])) {
-					$remoteMtime = strtotime($response['{DAV:}getlastmodified']);
-					if ($remoteMtime !== $mtime) {
-						// server has not accepted the mtime
-						return false;
-					}
-				}
-			} catch (ClientHttpException $e) {
-				if ($e->getHttpStatus() === 501) {
-					return false;
-				}
-				$this->convertException($e, $path);
-				return false;
-			} catch (\Exception $e) {
-				$this->convertException($e, $path);
-				return false;
-			}
-		} else {
-			$this->file_put_contents($path, '');
-		}
-		return true;
-	}
-
-	/**
-	 * @param string $path
-	 * @param string $data
-	 * @return int
-	 */
-	public function file_put_contents($path, $data) {
-		$path = $this->cleanPath($path);
-		$result = parent::file_put_contents($path, $data);
-		$this->statCache->remove($path);
-		return $result;
-	}
-
-	/**
-	 * @param string $path
-	 * @param string $target
-	 */
-	protected function uploadFile($path, $target) {
-		$this->init();
-
-		// invalidate
-		$target = $this->cleanPath($target);
-		$this->statCache->remove($target);
-		$source = fopen($path, 'r');
-
-		$this->httpClientService
-			->newClient()
-			->put($this->createBaseUri() . $this->encodePath($target), [
-				'body' => $source,
-				'auth' => [$this->user, $this->password]
-			]);
-
-		$this->removeCachedFile($target);
-	}
-
-	/** {@inheritdoc} */
-	public function rename($path1, $path2) {
-		$this->init();
-		$path1 = $this->cleanPath($path1);
-		$path2 = $this->cleanPath($path2);
-		try {
-			// overwrite directory ?
-			if ($this->is_dir($path2)) {
-				// needs trailing slash in destination
-				$path2 = rtrim($path2, '/') . '/';
-			}
-			$this->client->request(
-				'MOVE',
-				$this->encodePath($path1),
-				null,
-				[
-					'Destination' => $this->createBaseUri() . $this->encodePath($path2),
-				]
-			);
-			$this->statCache->clear($path1 . '/');
-			$this->statCache->clear($path2 . '/');
-			$this->statCache->set($path1, false);
-			$this->statCache->set($path2, true);
-			$this->removeCachedFile($path1);
-			$this->removeCachedFile($path2);
-			return true;
-		} catch (\Exception $e) {
-			$this->convertException($e);
-		}
-		return false;
-	}
-
-	/** {@inheritdoc} */
-	public function copy($path1, $path2) {
-		$this->init();
-		$path1 = $this->cleanPath($path1);
-		$path2 = $this->cleanPath($path2);
-		try {
-			// overwrite directory ?
-			if ($this->is_dir($path2)) {
-				// needs trailing slash in destination
-				$path2 = rtrim($path2, '/') . '/';
-			}
-			$this->client->request(
-				'COPY',
-				$this->encodePath($path1),
-				null,
-				[
-					'Destination' => $this->createBaseUri() . $this->encodePath($path2),
-				]
-			);
-			$this->statCache->clear($path2 . '/');
-			$this->statCache->set($path2, true);
-			$this->removeCachedFile($path2);
-			return true;
-		} catch (\Exception $e) {
-			$this->convertException($e);
-		}
-		return false;
-	}
-
-	/** {@inheritdoc} */
-	public function stat($path) {
-		try {
-			$response = $this->propfind($path);
-			if (!$response) {
-				return false;
-			}
-			return [
-				'mtime' => strtotime($response['{DAV:}getlastmodified']),
-				'size' => (int)isset($response['{DAV:}getcontentlength']) ? $response['{DAV:}getcontentlength'] : 0,
-			];
-		} catch (\Exception $e) {
-			$this->convertException($e, $path);
-		}
-		return array();
-	}
-
-	/** {@inheritdoc} */
-	public function getMimeType($path) {
-		$remoteMimetype = $this->getMimeTypeFromRemote($path);
-		if ($remoteMimetype === 'application/octet-stream') {
-			return \OC::$server->getMimeTypeDetector()->detectPath($path);
-		} else {
-			return $remoteMimetype;
-		}
-	}
-
-	public function getMimeTypeFromRemote($path) {
-		try {
-			$response = $this->propfind($path);
-			if ($response === false) {
-				return false;
-			}
-			$responseType = [];
-			if (isset($response["{DAV:}resourcetype"])) {
-				/** @var ResourceType[] $response */
-				$responseType = $response["{DAV:}resourcetype"]->getValue();
-			}
-			$type = (count($responseType) > 0 and $responseType[0] == "{DAV:}collection") ? 'dir' : 'file';
-			if ($type == 'dir') {
-				return 'httpd/unix-directory';
-			} elseif (isset($response['{DAV:}getcontenttype'])) {
-				return $response['{DAV:}getcontenttype'];
-			} else {
-				return 'application/octet-stream';
-			}
-		} catch (\Exception $e) {
-			return false;
-		}
-	}
-
-	/**
-	 * @param string $path
-	 * @return string
-	 */
-	public function cleanPath($path) {
-		if ($path === '') {
-			return $path;
-		}
-		$path = Filesystem::normalizePath($path);
-		// remove leading slash
-		return substr($path, 1);
-	}
-
-	/**
-	 * URL encodes the given path but keeps the slashes
-	 *
-	 * @param string $path to encode
-	 * @return string encoded path
-	 */
-	protected function encodePath($path) {
-		// slashes need to stay
-		return str_replace('%2F', '/', rawurlencode($path));
-	}
-
-	/**
-	 * @param string $method
-	 * @param string $path
-	 * @param string|resource|null $body
-	 * @param int $expected
-	 * @return bool
-	 * @throws StorageInvalidException
-	 * @throws StorageNotAvailableException
-	 */
-	protected function simpleResponse($method, $path, $body, $expected) {
-		$path = $this->cleanPath($path);
-		try {
-			$response = $this->client->request($method, $this->encodePath($path), $body);
-			return $response['statusCode'] == $expected;
-		} catch (ClientHttpException $e) {
-			if ($e->getHttpStatus() === 404 && $method === 'DELETE') {
-				$this->statCache->clear($path . '/');
-				$this->statCache->set($path, false);
-				return false;
-			}
-
-			$this->convertException($e, $path);
-		} catch (\Exception $e) {
-			$this->convertException($e, $path);
-		}
-		return false;
-	}
-
-	/**
-	 * check if curl is installed
-	 */
-	public static function checkDependencies() {
-		return true;
-	}
-
-	/** {@inheritdoc} */
-	public function isUpdatable($path) {
-		return (bool)($this->getPermissions($path) & Constants::PERMISSION_UPDATE);
-	}
-
-	/** {@inheritdoc} */
-	public function isCreatable($path) {
-		return (bool)($this->getPermissions($path) & Constants::PERMISSION_CREATE);
-	}
-
-	/** {@inheritdoc} */
-	public function isSharable($path) {
-		return (bool)($this->getPermissions($path) & Constants::PERMISSION_SHARE);
-	}
-
-	/** {@inheritdoc} */
-	public function isDeletable($path) {
-		return (bool)($this->getPermissions($path) & Constants::PERMISSION_DELETE);
-	}
-
-	/** {@inheritdoc} */
-	public function getPermissions($path) {
-		$this->init();
-		$path = $this->cleanPath($path);
-		$response = $this->propfind($path);
-		if ($response === false) {
-			return 0;
-		}
-		if (isset($response['{http://owncloud.org/ns}permissions'])) {
-			return $this->parsePermissions($response['{http://owncloud.org/ns}permissions']);
-		} else if ($this->is_dir($path)) {
-			return Constants::PERMISSION_ALL;
-		} else if ($this->file_exists($path)) {
-			return Constants::PERMISSION_ALL - Constants::PERMISSION_CREATE;
-		} else {
-			return 0;
-		}
-	}
-
-	/** {@inheritdoc} */
-	public function getETag($path) {
-		$this->init();
-		$path = $this->cleanPath($path);
-		$response = $this->propfind($path);
-		if ($response === false) {
-			return null;
-		}
-		if (isset($response['{DAV:}getetag'])) {
-			return trim($response['{DAV:}getetag'], '"');
-		}
-		return parent::getEtag($path);
-	}
-
-	/**
-	 * @param string $permissionsString
-	 * @return int
-	 */
-	protected function parsePermissions($permissionsString) {
-		$permissions = Constants::PERMISSION_READ;
-		if (strpos($permissionsString, 'R') !== false) {
-			$permissions |= Constants::PERMISSION_SHARE;
-		}
-		if (strpos($permissionsString, 'D') !== false) {
-			$permissions |= Constants::PERMISSION_DELETE;
-		}
-		if (strpos($permissionsString, 'W') !== false) {
-			$permissions |= Constants::PERMISSION_UPDATE;
-		}
-		if (strpos($permissionsString, 'CK') !== false) {
-			$permissions |= Constants::PERMISSION_CREATE;
-			$permissions |= Constants::PERMISSION_UPDATE;
-		}
-		return $permissions;
-	}
-
-	/**
-	 * check if a file or folder has been updated since $time
-	 *
-	 * @param string $path
-	 * @param int $time
-	 * @throws \OCP\Files\StorageNotAvailableException
-	 * @return bool
-	 */
-	public function hasUpdated($path, $time) {
-		$this->init();
-		$path = $this->cleanPath($path);
-		try {
-			// force refresh for $path
-			$this->statCache->remove($path);
-			$response = $this->propfind($path);
-			if ($response === false) {
-				if ($path === '') {
-					// if root is gone it means the storage is not available
-					throw new StorageNotAvailableException('root is gone');
-				}
-				return false;
-			}
-			if (isset($response['{DAV:}getetag'])) {
-				$cachedData = $this->getCache()->get($path);
-				$etag = null;
-				if (isset($response['{DAV:}getetag'])) {
-					$etag = trim($response['{DAV:}getetag'], '"');
-				}
-				if (!empty($etag) && $cachedData['etag'] !== $etag) {
-					return true;
-				} else if (isset($response['{http://open-collaboration-services.org/ns}share-permissions'])) {
-					$sharePermissions = (int)$response['{http://open-collaboration-services.org/ns}share-permissions'];
-					return $sharePermissions !== $cachedData['permissions'];
-				} else if (isset($response['{http://owncloud.org/ns}permissions'])) {
-					$permissions = $this->parsePermissions($response['{http://owncloud.org/ns}permissions']);
-					return $permissions !== $cachedData['permissions'];
-				} else {
-					return false;
-				}
-			} else {
-				$remoteMtime = strtotime($response['{DAV:}getlastmodified']);
-				return $remoteMtime > $time;
-			}
-		} catch (ClientHttpException $e) {
-			if ($e->getHttpStatus() === 405) {
-				if ($path === '') {
-					// if root is gone it means the storage is not available
-					throw new StorageNotAvailableException(get_class($e) . ': ' . $e->getMessage());
-				}
-				return false;
-			}
-			$this->convertException($e, $path);
-			return false;
-		} catch (\Exception $e) {
-			$this->convertException($e, $path);
-			return false;
-		}
-	}
-
-	/**
-	 * Interpret the given exception and decide whether it is due to an
-	 * unavailable storage, invalid storage or other.
-	 * This will either throw StorageInvalidException, StorageNotAvailableException
-	 * or do nothing.
-	 *
-	 * @param Exception $e sabre exception
-	 * @param string $path optional path from the operation
-	 *
-	 * @throws StorageInvalidException if the storage is invalid, for example
-	 * when the authentication expired or is invalid
-	 * @throws StorageNotAvailableException if the storage is not available,
-	 * which might be temporary
-	 */
-	protected function convertException(Exception $e, $path = '') {
-		\OC::$server->getLogger()->logException($e, ['app' => 'files_external']);
-		if ($e instanceof ClientHttpException) {
-			if ($e->getHttpStatus() === Http::STATUS_LOCKED) {
-				throw new \OCP\Lock\LockedException($path);
-			}
-			if ($e->getHttpStatus() === Http::STATUS_UNAUTHORIZED) {
-				// either password was changed or was invalid all along
-				throw new StorageInvalidException(get_class($e) . ': ' . $e->getMessage());
-			} else if ($e->getHttpStatus() === Http::STATUS_METHOD_NOT_ALLOWED) {
-				// ignore exception for MethodNotAllowed, false will be returned
-				return;
-			}
-			throw new StorageNotAvailableException(get_class($e) . ': ' . $e->getMessage());
-		} else if ($e instanceof ClientException) {
-			// connection timeout or refused, server could be temporarily down
-			throw new StorageNotAvailableException(get_class($e) . ': ' . $e->getMessage());
-		} else if ($e instanceof \InvalidArgumentException) {
-			// parse error because the server returned HTML instead of XML,
-			// possibly temporarily down
-			throw new StorageNotAvailableException(get_class($e) . ': ' . $e->getMessage());
-		} else if (($e instanceof StorageNotAvailableException) || ($e instanceof StorageInvalidException)) {
-			// rethrow
-			throw $e;
-		}
-
-		// TODO: only log for now, but in the future need to wrap/rethrow exception
-	}
+    /** @var string */
+    protected $password;
+    /** @var string */
+    protected $user;
+    /** @var string */
+    protected $authType;
+    /** @var string */
+    protected $host;
+    /** @var bool */
+    protected $secure;
+    /** @var string */
+    protected $root;
+    /** @var string */
+    protected $certPath;
+    /** @var bool */
+    protected $ready;
+    /** @var Client */
+    protected $client;
+    /** @var ArrayCache */
+    protected $statCache;
+    /** @var \OCP\Http\Client\IClientService */
+    protected $httpClientService;
+
+    /**
+     * @param array $params
+     * @throws \Exception
+     */
+    public function __construct($params) {
+        $this->statCache = new ArrayCache();
+        $this->httpClientService = \OC::$server->getHTTPClientService();
+        if (isset($params['host']) && isset($params['user']) && isset($params['password'])) {
+            $host = $params['host'];
+            //remove leading http[s], will be generated in createBaseUri()
+            if (substr($host, 0, 8) == "https://") $host = substr($host, 8);
+            else if (substr($host, 0, 7) == "http://") $host = substr($host, 7);
+            $this->host = $host;
+            $this->user = $params['user'];
+            $this->password = $params['password'];
+            if (isset($params['authType'])) {
+                $this->authType = $params['authType'];
+            }
+            if (isset($params['secure'])) {
+                if (is_string($params['secure'])) {
+                    $this->secure = ($params['secure'] === 'true');
+                } else {
+                    $this->secure = (bool)$params['secure'];
+                }
+            } else {
+                $this->secure = false;
+            }
+            if ($this->secure === true) {
+                // inject mock for testing
+                $certManager = \OC::$server->getCertificateManager();
+                if (is_null($certManager)) { //no user
+                    $certManager = \OC::$server->getCertificateManager(null);
+                }
+                $certPath = $certManager->getAbsoluteBundlePath();
+                if (file_exists($certPath)) {
+                    $this->certPath = $certPath;
+                }
+            }
+            $this->root = $params['root'] ?? '/';
+            $this->root = '/' . ltrim($this->root, '/');
+            $this->root = rtrim($this->root, '/') . '/';
+        } else {
+            throw new \Exception('Invalid webdav storage configuration');
+        }
+    }
+
+    protected function init() {
+        if ($this->ready) {
+            return;
+        }
+        $this->ready = true;
+
+        $settings = [
+            'baseUri' => $this->createBaseUri(),
+            'userName' => $this->user,
+            'password' => $this->password,
+        ];
+        if (isset($this->authType)) {
+            $settings['authType'] = $this->authType;
+        }
+
+        $proxy = \OC::$server->getConfig()->getSystemValue('proxy', '');
+        if ($proxy !== '') {
+            $settings['proxy'] = $proxy;
+        }
+
+        $this->client = new Client($settings);
+        $this->client->setThrowExceptions(true);
+        if ($this->secure === true && $this->certPath) {
+            $this->client->addCurlSetting(CURLOPT_CAINFO, $this->certPath);
+        }
+    }
+
+    /**
+     * Clear the stat cache
+     */
+    public function clearStatCache() {
+        $this->statCache->clear();
+    }
+
+    /** {@inheritdoc} */
+    public function getId() {
+        return 'webdav::' . $this->user . '@' . $this->host . '/' . $this->root;
+    }
+
+    /** {@inheritdoc} */
+    public function createBaseUri() {
+        $baseUri = 'http';
+        if ($this->secure) {
+            $baseUri .= 's';
+        }
+        $baseUri .= '://' . $this->host . $this->root;
+        return $baseUri;
+    }
+
+    /** {@inheritdoc} */
+    public function mkdir($path) {
+        $this->init();
+        $path = $this->cleanPath($path);
+        $result = $this->simpleResponse('MKCOL', $path, null, 201);
+        if ($result) {
+            $this->statCache->set($path, true);
+        }
+        return $result;
+    }
+
+    /** {@inheritdoc} */
+    public function rmdir($path) {
+        $this->init();
+        $path = $this->cleanPath($path);
+        // FIXME: some WebDAV impl return 403 when trying to DELETE
+        // a non-empty folder
+        $result = $this->simpleResponse('DELETE', $path . '/', null, 204);
+        $this->statCache->clear($path . '/');
+        $this->statCache->remove($path);
+        return $result;
+    }
+
+    /** {@inheritdoc} */
+    public function opendir($path) {
+        $this->init();
+        $path = $this->cleanPath($path);
+        try {
+            $response = $this->client->propFind(
+                $this->encodePath($path),
+                ['{DAV:}href'],
+                1
+            );
+            if ($response === false) {
+                return false;
+            }
+            $content = [];
+            $files = array_keys($response);
+            array_shift($files); //the first entry is the current directory
+
+            if (!$this->statCache->hasKey($path)) {
+                $this->statCache->set($path, true);
+            }
+            foreach ($files as $file) {
+                $file = urldecode($file);
+                // do not store the real entry, we might not have all properties
+                if (!$this->statCache->hasKey($path)) {
+                    $this->statCache->set($file, true);
+                }
+                $file = basename($file);
+                $content[] = $file;
+            }
+            return IteratorDirectory::wrap($content);
+        } catch (\Exception $e) {
+            $this->convertException($e, $path);
+        }
+        return false;
+    }
+
+    /**
+     * Propfind call with cache handling.
+     *
+     * First checks if information is cached.
+     * If not, request it from the server then store to cache.
+     *
+     * @param string $path path to propfind
+     *
+     * @return array|boolean propfind response or false if the entry was not found
+     *
+     * @throws ClientHttpException
+     */
+    protected function propfind($path) {
+        $path = $this->cleanPath($path);
+        $cachedResponse = $this->statCache->get($path);
+        // we either don't know it, or we know it exists but need more details
+        if (is_null($cachedResponse) || $cachedResponse === true) {
+            $this->init();
+            try {
+                $response = $this->client->propFind(
+                    $this->encodePath($path),
+                    array(
+                        '{DAV:}getlastmodified',
+                        '{DAV:}getcontentlength',
+                        '{DAV:}getcontenttype',
+                        '{http://owncloud.org/ns}permissions',
+                        '{http://open-collaboration-services.org/ns}share-permissions',
+                        '{DAV:}resourcetype',
+                        '{DAV:}getetag',
+                    )
+                );
+                $this->statCache->set($path, $response);
+            } catch (ClientHttpException $e) {
+                if ($e->getHttpStatus() === 404) {
+                    $this->statCache->clear($path . '/');
+                    $this->statCache->set($path, false);
+                    return false;
+                }
+                $this->convertException($e, $path);
+            } catch (\Exception $e) {
+                $this->convertException($e, $path);
+            }
+        } else {
+            $response = $cachedResponse;
+        }
+        return $response;
+    }
+
+    /** {@inheritdoc} */
+    public function filetype($path) {
+        try {
+            $response = $this->propfind($path);
+            if ($response === false) {
+                return false;
+            }
+            $responseType = [];
+            if (isset($response["{DAV:}resourcetype"])) {
+                /** @var ResourceType[] $response */
+                $responseType = $response["{DAV:}resourcetype"]->getValue();
+            }
+            return (count($responseType) > 0 and $responseType[0] == "{DAV:}collection") ? 'dir' : 'file';
+        } catch (\Exception $e) {
+            $this->convertException($e, $path);
+        }
+        return false;
+    }
+
+    /** {@inheritdoc} */
+    public function file_exists($path) {
+        try {
+            $path = $this->cleanPath($path);
+            $cachedState = $this->statCache->get($path);
+            if ($cachedState === false) {
+                // we know the file doesn't exist
+                return false;
+            } else if (!is_null($cachedState)) {
+                return true;
+            }
+            // need to get from server
+            return ($this->propfind($path) !== false);
+        } catch (\Exception $e) {
+            $this->convertException($e, $path);
+        }
+        return false;
+    }
+
+    /** {@inheritdoc} */
+    public function unlink($path) {
+        $this->init();
+        $path = $this->cleanPath($path);
+        $result = $this->simpleResponse('DELETE', $path, null, 204);
+        $this->statCache->clear($path . '/');
+        $this->statCache->remove($path);
+        return $result;
+    }
+
+    /** {@inheritdoc} */
+    public function fopen($path, $mode) {
+        $this->init();
+        $path = $this->cleanPath($path);
+        switch ($mode) {
+            case 'r':
+            case 'rb':
+                try {
+                    $response = $this->httpClientService
+                        ->newClient()
+                        ->get($this->createBaseUri() . $this->encodePath($path), [
+                            'auth' => [$this->user, $this->password],
+                            'stream' => true
+                        ]);
+                } catch (\GuzzleHttp\Exception\ClientException $e) {
+                    if ($e->getResponse() instanceof ResponseInterface
+                        && $e->getResponse()->getStatusCode() === 404) {
+                        return false;
+                    } else {
+                        throw $e;
+                    }
+                }
+
+                if ($response->getStatusCode() !== Http::STATUS_OK) {
+                    if ($response->getStatusCode() === Http::STATUS_LOCKED) {
+                        throw new \OCP\Lock\LockedException($path);
+                    } else {
+                        Util::writeLog("webdav client", 'Guzzle get returned status code ' . $response->getStatusCode(), ILogger::ERROR);
+                    }
+                }
+
+                return $response->getBody();
+            case 'w':
+            case 'wb':
+            case 'a':
+            case 'ab':
+            case 'r+':
+            case 'w+':
+            case 'wb+':
+            case 'a+':
+            case 'x':
+            case 'x+':
+            case 'c':
+            case 'c+':
+                //emulate these
+                $tempManager = \OC::$server->getTempManager();
+                if (strrpos($path, '.') !== false) {
+                    $ext = substr($path, strrpos($path, '.'));
+                } else {
+                    $ext = '';
+                }
+                if ($this->file_exists($path)) {
+                    if (!$this->isUpdatable($path)) {
+                        return false;
+                    }
+                    if ($mode === 'w' or $mode === 'w+') {
+                        $tmpFile = $tempManager->getTemporaryFile($ext);
+                    } else {
+                        $tmpFile = $this->getCachedFile($path);
+                    }
+                } else {
+                    if (!$this->isCreatable(dirname($path))) {
+                        return false;
+                    }
+                    $tmpFile = $tempManager->getTemporaryFile($ext);
+                }
+                $handle = fopen($tmpFile, $mode);
+                return CallbackWrapper::wrap($handle, null, null, function () use ($path, $tmpFile) {
+                    $this->writeBack($tmpFile, $path);
+                });
+        }
+    }
+
+    /**
+     * @param string $tmpFile
+     */
+    public function writeBack($tmpFile, $path) {
+        $this->uploadFile($tmpFile, $path);
+        unlink($tmpFile);
+    }
+
+    /** {@inheritdoc} */
+    public function free_space($path) {
+        $this->init();
+        $path = $this->cleanPath($path);
+        try {
+            // TODO: cacheable ?
+            $response = $this->client->propfind($this->encodePath($path), ['{DAV:}quota-available-bytes']);
+            if ($response === false) {
+                return FileInfo::SPACE_UNKNOWN;
+            }
+            if (isset($response['{DAV:}quota-available-bytes'])) {
+                return (int)$response['{DAV:}quota-available-bytes'];
+            } else {
+                return FileInfo::SPACE_UNKNOWN;
+            }
+        } catch (\Exception $e) {
+            return FileInfo::SPACE_UNKNOWN;
+        }
+    }
+
+    /** {@inheritdoc} */
+    public function touch($path, $mtime = null) {
+        $this->init();
+        if (is_null($mtime)) {
+            $mtime = time();
+        }
+        $path = $this->cleanPath($path);
+
+        // if file exists, update the mtime, else create a new empty file
+        if ($this->file_exists($path)) {
+            try {
+                $this->statCache->remove($path);
+                $this->client->proppatch($this->encodePath($path), ['{DAV:}lastmodified' => $mtime]);
+                // non-owncloud clients might not have accepted the property, need to recheck it
+                $response = $this->client->propfind($this->encodePath($path), ['{DAV:}getlastmodified'], 0);
+                if ($response === false) {
+                    return false;
+                }
+                if (isset($response['{DAV:}getlastmodified'])) {
+                    $remoteMtime = strtotime($response['{DAV:}getlastmodified']);
+                    if ($remoteMtime !== $mtime) {
+                        // server has not accepted the mtime
+                        return false;
+                    }
+                }
+            } catch (ClientHttpException $e) {
+                if ($e->getHttpStatus() === 501) {
+                    return false;
+                }
+                $this->convertException($e, $path);
+                return false;
+            } catch (\Exception $e) {
+                $this->convertException($e, $path);
+                return false;
+            }
+        } else {
+            $this->file_put_contents($path, '');
+        }
+        return true;
+    }
+
+    /**
+     * @param string $path
+     * @param string $data
+     * @return int
+     */
+    public function file_put_contents($path, $data) {
+        $path = $this->cleanPath($path);
+        $result = parent::file_put_contents($path, $data);
+        $this->statCache->remove($path);
+        return $result;
+    }
+
+    /**
+     * @param string $path
+     * @param string $target
+     */
+    protected function uploadFile($path, $target) {
+        $this->init();
+
+        // invalidate
+        $target = $this->cleanPath($target);
+        $this->statCache->remove($target);
+        $source = fopen($path, 'r');
+
+        $this->httpClientService
+            ->newClient()
+            ->put($this->createBaseUri() . $this->encodePath($target), [
+                'body' => $source,
+                'auth' => [$this->user, $this->password]
+            ]);
+
+        $this->removeCachedFile($target);
+    }
+
+    /** {@inheritdoc} */
+    public function rename($path1, $path2) {
+        $this->init();
+        $path1 = $this->cleanPath($path1);
+        $path2 = $this->cleanPath($path2);
+        try {
+            // overwrite directory ?
+            if ($this->is_dir($path2)) {
+                // needs trailing slash in destination
+                $path2 = rtrim($path2, '/') . '/';
+            }
+            $this->client->request(
+                'MOVE',
+                $this->encodePath($path1),
+                null,
+                [
+                    'Destination' => $this->createBaseUri() . $this->encodePath($path2),
+                ]
+            );
+            $this->statCache->clear($path1 . '/');
+            $this->statCache->clear($path2 . '/');
+            $this->statCache->set($path1, false);
+            $this->statCache->set($path2, true);
+            $this->removeCachedFile($path1);
+            $this->removeCachedFile($path2);
+            return true;
+        } catch (\Exception $e) {
+            $this->convertException($e);
+        }
+        return false;
+    }
+
+    /** {@inheritdoc} */
+    public function copy($path1, $path2) {
+        $this->init();
+        $path1 = $this->cleanPath($path1);
+        $path2 = $this->cleanPath($path2);
+        try {
+            // overwrite directory ?
+            if ($this->is_dir($path2)) {
+                // needs trailing slash in destination
+                $path2 = rtrim($path2, '/') . '/';
+            }
+            $this->client->request(
+                'COPY',
+                $this->encodePath($path1),
+                null,
+                [
+                    'Destination' => $this->createBaseUri() . $this->encodePath($path2),
+                ]
+            );
+            $this->statCache->clear($path2 . '/');
+            $this->statCache->set($path2, true);
+            $this->removeCachedFile($path2);
+            return true;
+        } catch (\Exception $e) {
+            $this->convertException($e);
+        }
+        return false;
+    }
+
+    /** {@inheritdoc} */
+    public function stat($path) {
+        try {
+            $response = $this->propfind($path);
+            if (!$response) {
+                return false;
+            }
+            return [
+                'mtime' => strtotime($response['{DAV:}getlastmodified']),
+                'size' => (int)isset($response['{DAV:}getcontentlength']) ? $response['{DAV:}getcontentlength'] : 0,
+            ];
+        } catch (\Exception $e) {
+            $this->convertException($e, $path);
+        }
+        return array();
+    }
+
+    /** {@inheritdoc} */
+    public function getMimeType($path) {
+        $remoteMimetype = $this->getMimeTypeFromRemote($path);
+        if ($remoteMimetype === 'application/octet-stream') {
+            return \OC::$server->getMimeTypeDetector()->detectPath($path);
+        } else {
+            return $remoteMimetype;
+        }
+    }
+
+    public function getMimeTypeFromRemote($path) {
+        try {
+            $response = $this->propfind($path);
+            if ($response === false) {
+                return false;
+            }
+            $responseType = [];
+            if (isset($response["{DAV:}resourcetype"])) {
+                /** @var ResourceType[] $response */
+                $responseType = $response["{DAV:}resourcetype"]->getValue();
+            }
+            $type = (count($responseType) > 0 and $responseType[0] == "{DAV:}collection") ? 'dir' : 'file';
+            if ($type == 'dir') {
+                return 'httpd/unix-directory';
+            } elseif (isset($response['{DAV:}getcontenttype'])) {
+                return $response['{DAV:}getcontenttype'];
+            } else {
+                return 'application/octet-stream';
+            }
+        } catch (\Exception $e) {
+            return false;
+        }
+    }
+
+    /**
+     * @param string $path
+     * @return string
+     */
+    public function cleanPath($path) {
+        if ($path === '') {
+            return $path;
+        }
+        $path = Filesystem::normalizePath($path);
+        // remove leading slash
+        return substr($path, 1);
+    }
+
+    /**
+     * URL encodes the given path but keeps the slashes
+     *
+     * @param string $path to encode
+     * @return string encoded path
+     */
+    protected function encodePath($path) {
+        // slashes need to stay
+        return str_replace('%2F', '/', rawurlencode($path));
+    }
+
+    /**
+     * @param string $method
+     * @param string $path
+     * @param string|resource|null $body
+     * @param int $expected
+     * @return bool
+     * @throws StorageInvalidException
+     * @throws StorageNotAvailableException
+     */
+    protected function simpleResponse($method, $path, $body, $expected) {
+        $path = $this->cleanPath($path);
+        try {
+            $response = $this->client->request($method, $this->encodePath($path), $body);
+            return $response['statusCode'] == $expected;
+        } catch (ClientHttpException $e) {
+            if ($e->getHttpStatus() === 404 && $method === 'DELETE') {
+                $this->statCache->clear($path . '/');
+                $this->statCache->set($path, false);
+                return false;
+            }
+
+            $this->convertException($e, $path);
+        } catch (\Exception $e) {
+            $this->convertException($e, $path);
+        }
+        return false;
+    }
+
+    /**
+     * check if curl is installed
+     */
+    public static function checkDependencies() {
+        return true;
+    }
+
+    /** {@inheritdoc} */
+    public function isUpdatable($path) {
+        return (bool)($this->getPermissions($path) & Constants::PERMISSION_UPDATE);
+    }
+
+    /** {@inheritdoc} */
+    public function isCreatable($path) {
+        return (bool)($this->getPermissions($path) & Constants::PERMISSION_CREATE);
+    }
+
+    /** {@inheritdoc} */
+    public function isSharable($path) {
+        return (bool)($this->getPermissions($path) & Constants::PERMISSION_SHARE);
+    }
+
+    /** {@inheritdoc} */
+    public function isDeletable($path) {
+        return (bool)($this->getPermissions($path) & Constants::PERMISSION_DELETE);
+    }
+
+    /** {@inheritdoc} */
+    public function getPermissions($path) {
+        $this->init();
+        $path = $this->cleanPath($path);
+        $response = $this->propfind($path);
+        if ($response === false) {
+            return 0;
+        }
+        if (isset($response['{http://owncloud.org/ns}permissions'])) {
+            return $this->parsePermissions($response['{http://owncloud.org/ns}permissions']);
+        } else if ($this->is_dir($path)) {
+            return Constants::PERMISSION_ALL;
+        } else if ($this->file_exists($path)) {
+            return Constants::PERMISSION_ALL - Constants::PERMISSION_CREATE;
+        } else {
+            return 0;
+        }
+    }
+
+    /** {@inheritdoc} */
+    public function getETag($path) {
+        $this->init();
+        $path = $this->cleanPath($path);
+        $response = $this->propfind($path);
+        if ($response === false) {
+            return null;
+        }
+        if (isset($response['{DAV:}getetag'])) {
+            return trim($response['{DAV:}getetag'], '"');
+        }
+        return parent::getEtag($path);
+    }
+
+    /**
+     * @param string $permissionsString
+     * @return int
+     */
+    protected function parsePermissions($permissionsString) {
+        $permissions = Constants::PERMISSION_READ;
+        if (strpos($permissionsString, 'R') !== false) {
+            $permissions |= Constants::PERMISSION_SHARE;
+        }
+        if (strpos($permissionsString, 'D') !== false) {
+            $permissions |= Constants::PERMISSION_DELETE;
+        }
+        if (strpos($permissionsString, 'W') !== false) {
+            $permissions |= Constants::PERMISSION_UPDATE;
+        }
+        if (strpos($permissionsString, 'CK') !== false) {
+            $permissions |= Constants::PERMISSION_CREATE;
+            $permissions |= Constants::PERMISSION_UPDATE;
+        }
+        return $permissions;
+    }
+
+    /**
+     * check if a file or folder has been updated since $time
+     *
+     * @param string $path
+     * @param int $time
+     * @throws \OCP\Files\StorageNotAvailableException
+     * @return bool
+     */
+    public function hasUpdated($path, $time) {
+        $this->init();
+        $path = $this->cleanPath($path);
+        try {
+            // force refresh for $path
+            $this->statCache->remove($path);
+            $response = $this->propfind($path);
+            if ($response === false) {
+                if ($path === '') {
+                    // if root is gone it means the storage is not available
+                    throw new StorageNotAvailableException('root is gone');
+                }
+                return false;
+            }
+            if (isset($response['{DAV:}getetag'])) {
+                $cachedData = $this->getCache()->get($path);
+                $etag = null;
+                if (isset($response['{DAV:}getetag'])) {
+                    $etag = trim($response['{DAV:}getetag'], '"');
+                }
+                if (!empty($etag) && $cachedData['etag'] !== $etag) {
+                    return true;
+                } else if (isset($response['{http://open-collaboration-services.org/ns}share-permissions'])) {
+                    $sharePermissions = (int)$response['{http://open-collaboration-services.org/ns}share-permissions'];
+                    return $sharePermissions !== $cachedData['permissions'];
+                } else if (isset($response['{http://owncloud.org/ns}permissions'])) {
+                    $permissions = $this->parsePermissions($response['{http://owncloud.org/ns}permissions']);
+                    return $permissions !== $cachedData['permissions'];
+                } else {
+                    return false;
+                }
+            } else {
+                $remoteMtime = strtotime($response['{DAV:}getlastmodified']);
+                return $remoteMtime > $time;
+            }
+        } catch (ClientHttpException $e) {
+            if ($e->getHttpStatus() === 405) {
+                if ($path === '') {
+                    // if root is gone it means the storage is not available
+                    throw new StorageNotAvailableException(get_class($e) . ': ' . $e->getMessage());
+                }
+                return false;
+            }
+            $this->convertException($e, $path);
+            return false;
+        } catch (\Exception $e) {
+            $this->convertException($e, $path);
+            return false;
+        }
+    }
+
+    /**
+     * Interpret the given exception and decide whether it is due to an
+     * unavailable storage, invalid storage or other.
+     * This will either throw StorageInvalidException, StorageNotAvailableException
+     * or do nothing.
+     *
+     * @param Exception $e sabre exception
+     * @param string $path optional path from the operation
+     *
+     * @throws StorageInvalidException if the storage is invalid, for example
+     * when the authentication expired or is invalid
+     * @throws StorageNotAvailableException if the storage is not available,
+     * which might be temporary
+     */
+    protected function convertException(Exception $e, $path = '') {
+        \OC::$server->getLogger()->logException($e, ['app' => 'files_external']);
+        if ($e instanceof ClientHttpException) {
+            if ($e->getHttpStatus() === Http::STATUS_LOCKED) {
+                throw new \OCP\Lock\LockedException($path);
+            }
+            if ($e->getHttpStatus() === Http::STATUS_UNAUTHORIZED) {
+                // either password was changed or was invalid all along
+                throw new StorageInvalidException(get_class($e) . ': ' . $e->getMessage());
+            } else if ($e->getHttpStatus() === Http::STATUS_METHOD_NOT_ALLOWED) {
+                // ignore exception for MethodNotAllowed, false will be returned
+                return;
+            }
+            throw new StorageNotAvailableException(get_class($e) . ': ' . $e->getMessage());
+        } else if ($e instanceof ClientException) {
+            // connection timeout or refused, server could be temporarily down
+            throw new StorageNotAvailableException(get_class($e) . ': ' . $e->getMessage());
+        } else if ($e instanceof \InvalidArgumentException) {
+            // parse error because the server returned HTML instead of XML,
+            // possibly temporarily down
+            throw new StorageNotAvailableException(get_class($e) . ': ' . $e->getMessage());
+        } else if (($e instanceof StorageNotAvailableException) || ($e instanceof StorageInvalidException)) {
+            // rethrow
+            throw $e;
+        }
+
+        // TODO: only log for now, but in the future need to wrap/rethrow exception
+    }
 }
 

lib/private/Files/Storage/Common.php

Indentation +736 added lines, -736 removed lines

@@ -71,744 +71,744 @@
  */
 abstract class Common implements Storage, ILockingStorage {
 
-	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);
-		} else if ($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');
-			list(, $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 = array();
-		$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)) {
-			$storage->propagator = new Propagator($storage, \OC::$server->getDatabaseConnection());
-		}
-		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 = array();
-		foreach (explode('/', $path) as $chunk) {
-			if ($chunk == '..') {
-				array_pop($output);
-			} else if ($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()->info("External storage not available: " . $e->getMessage());
-			\OC::$server->getLogger()->logException($e, ['level' => ILogger::DEBUG]);
-			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);
+        } else if ($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');
+            list(, $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 = array();
+        $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)) {
+            $storage->propagator = new Propagator($storage, \OC::$server->getDatabaseConnection());
+        }
+        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 = array();
+        foreach (explode('/', $path) as $chunk) {
+            if ($chunk == '..') {
+                array_pop($output);
+            } else if ($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()->info("External storage not available: " . $e->getMessage());
+            \OC::$server->getLogger()->logException($e, ['level' => ILogger::DEBUG]);
+            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();
-			}
-		}
-
-		if (isset($fileName[255])) {
-			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');
-			// TODO: call fopen in a way that we execute again all storage wrappers
-			// to avoid that we bypass storage wrappers which perform important actions
-			// for this operation. Same is true for all other operations which
-			// are not the same as the original one.Once this is fixed we also
-			// need to adjust the encryption wrapper.
-			$target = $this->fopen($targetInternalPath, 'w');
-			list(, $result) = \OC_Helper::streamCopy($source, $target);
-			if ($result and $preserveMtime) {
-				$this->touch($targetInternalPath, $sourceStorage->filemtime($sourceInternalPath));
-			}
-			fclose($source);
-			fclose($target);
-
-			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;
-	}
-
-	/**
-	 * @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);
-		}
-
-		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;
-
-		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);
-		} catch (LockedException $e) {
-			if ($logger) {
-				$logger->logException($e);
-			}
-			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);
-			}
-			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) {
-			if ($logger) {
-				$logger->logException($e);
-			}
-			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;
-	}
+                throw new InvalidCharacterInPathException();
+            }
+        }
+
+        if (isset($fileName[255])) {
+            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');
+            // TODO: call fopen in a way that we execute again all storage wrappers
+            // to avoid that we bypass storage wrappers which perform important actions
+            // for this operation. Same is true for all other operations which
+            // are not the same as the original one.Once this is fixed we also
+            // need to adjust the encryption wrapper.
+            $target = $this->fopen($targetInternalPath, 'w');
+            list(, $result) = \OC_Helper::streamCopy($source, $target);
+            if ($result and $preserveMtime) {
+                $this->touch($targetInternalPath, $sourceStorage->filemtime($sourceInternalPath));
+            }
+            fclose($source);
+            fclose($target);
+
+            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;
+    }
+
+    /**
+     * @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);
+        }
+
+        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;
+
+        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);
+        } catch (LockedException $e) {
+            if ($logger) {
+                $logger->logException($e);
+            }
+            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);
+            }
+            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) {
+            if ($logger) {
+                $logger->logException($e);
+            }
+            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;
+    }
 }

lib/private/Files/Cache/Scanner.php

Indentation +497 added lines, -497 removed lines

@@ -53,501 +53,501 @@
  * @package OC\Files\Cache
  */
 class Scanner extends BasicEmitter implements IScanner {
-	/**
-	 * @var \OC\Files\Storage\Storage $storage
-	 */
-	protected $storage;
-
-	/**
-	 * @var string $storageId
-	 */
-	protected $storageId;
-
-	/**
-	 * @var \OC\Files\Cache\Cache $cache
-	 */
-	protected $cache;
-
-	/**
-	 * @var boolean $cacheActive If true, perform cache operations, if false, do not affect cache
-	 */
-	protected $cacheActive;
-
-	/**
-	 * @var bool $useTransactions whether to use transactions
-	 */
-	protected $useTransactions = true;
-
-	/**
-	 * @var \OCP\Lock\ILockingProvider
-	 */
-	protected $lockingProvider;
-
-	public function __construct(\OC\Files\Storage\Storage $storage) {
-		$this->storage = $storage;
-		$this->storageId = $this->storage->getId();
-		$this->cache = $storage->getCache();
-		$this->cacheActive = !\OC::$server->getConfig()->getSystemValue('filesystem_cache_readonly', false);
-		$this->lockingProvider = \OC::$server->getLockingProvider();
-	}
-
-	/**
-	 * Whether to wrap the scanning of a folder in a database transaction
-	 * On default transactions are used
-	 *
-	 * @param bool $useTransactions
-	 */
-	public function setUseTransactions($useTransactions) {
-		$this->useTransactions = $useTransactions;
-	}
-
-	/**
-	 * get all the metadata of a file or folder
-	 * *
-	 *
-	 * @param string $path
-	 * @return array an array of metadata of the file
-	 */
-	protected function getData($path) {
-		$data = $this->storage->getMetaData($path);
-		if (is_null($data)) {
-			\OCP\Util::writeLog(Scanner::class, "!!! Path '$path' is not accessible or present !!!", ILogger::DEBUG);
-		}
-		return $data;
-	}
-
-	/**
-	 * scan a single file and store it in the cache
-	 *
-	 * @param string $file
-	 * @param int $reuseExisting
-	 * @param int $parentId
-	 * @param array | null $cacheData existing data in the cache for the file to be scanned
-	 * @param bool $lock set to false to disable getting an additional read lock during scanning
-	 * @return array an array of metadata of the scanned file
-	 * @throws \OC\ServerNotAvailableException
-	 * @throws \OCP\Lock\LockedException
-	 */
-	public function scanFile($file, $reuseExisting = 0, $parentId = -1, $cacheData = null, $lock = true) {
-		if ($file !== '') {
-			try {
-				$this->storage->verifyPath(dirname($file), basename($file));
-			} catch (\Exception $e) {
-				return null;
-			}
-		}
-		// only proceed if $file is not a partial file nor a blacklisted file
-		if (!self::isPartialFile($file) and !Filesystem::isFileBlacklisted($file)) {
-
-			//acquire a lock
-			if ($lock) {
-				if ($this->storage->instanceOfStorage('\OCP\Files\Storage\ILockingStorage')) {
-					$this->storage->acquireLock($file, ILockingProvider::LOCK_SHARED, $this->lockingProvider);
-				}
-			}
-
-			try {
-				$data = $this->getData($file);
-			} catch (ForbiddenException $e) {
-				if ($lock) {
-					if ($this->storage->instanceOfStorage('\OCP\Files\Storage\ILockingStorage')) {
-						$this->storage->releaseLock($file, ILockingProvider::LOCK_SHARED, $this->lockingProvider);
-					}
-				}
-
-				return null;
-			}
-
-			try {
-				if ($data) {
-
-					// pre-emit only if it was a file. By that we avoid counting/treating folders as files
-					if ($data['mimetype'] !== 'httpd/unix-directory') {
-						$this->emit('\OC\Files\Cache\Scanner', 'scanFile', array($file, $this->storageId));
-						\OC_Hook::emit('\OC\Files\Cache\Scanner', 'scan_file', array('path' => $file, 'storage' => $this->storageId));
-					}
-
-					$parent = dirname($file);
-					if ($parent === '.' or $parent === '/') {
-						$parent = '';
-					}
-					if ($parentId === -1) {
-						$parentId = $this->cache->getParentId($file);
-					}
-
-					// scan the parent if it's not in the cache (id -1) and the current file is not the root folder
-					if ($file and $parentId === -1) {
-						$parentData = $this->scanFile($parent);
-						if (!$parentData) {
-							return null;
-						}
-						$parentId = $parentData['fileid'];
-					}
-					if ($parent) {
-						$data['parent'] = $parentId;
-					}
-					if (is_null($cacheData)) {
-						/** @var CacheEntry $cacheData */
-						$cacheData = $this->cache->get($file);
-					}
-					if ($cacheData and $reuseExisting and isset($cacheData['fileid'])) {
-						// prevent empty etag
-						if (empty($cacheData['etag'])) {
-							$etag = $data['etag'];
-						} else {
-							$etag = $cacheData['etag'];
-						}
-						$fileId = $cacheData['fileid'];
-						$data['fileid'] = $fileId;
-						// only reuse data if the file hasn't explicitly changed
-						if (isset($data['storage_mtime']) && isset($cacheData['storage_mtime']) && $data['storage_mtime'] === $cacheData['storage_mtime']) {
-							$data['mtime'] = $cacheData['mtime'];
-							if (($reuseExisting & self::REUSE_SIZE) && ($data['size'] === -1)) {
-								$data['size'] = $cacheData['size'];
-							}
-							if ($reuseExisting & self::REUSE_ETAG) {
-								$data['etag'] = $etag;
-							}
-						}
-						// Only update metadata that has changed
-						$newData = array_diff_assoc($data, $cacheData->getData());
-					} else {
-						$newData = $data;
-						$fileId = -1;
-					}
-					if (!empty($newData)) {
-						// Reset the checksum if the data has changed
-						$newData['checksum'] = '';
-						$data['fileid'] = $this->addToCache($file, $newData, $fileId);
-					}
-					if (isset($cacheData['size'])) {
-						$data['oldSize'] = $cacheData['size'];
-					} else {
-						$data['oldSize'] = 0;
-					}
-
-					if (isset($cacheData['encrypted'])) {
-						$data['encrypted'] = $cacheData['encrypted'];
-					}
-
-					// post-emit only if it was a file. By that we avoid counting/treating folders as files
-					if ($data['mimetype'] !== 'httpd/unix-directory') {
-						$this->emit('\OC\Files\Cache\Scanner', 'postScanFile', array($file, $this->storageId));
-						\OC_Hook::emit('\OC\Files\Cache\Scanner', 'post_scan_file', array('path' => $file, 'storage' => $this->storageId));
-					}
-
-				} else {
-					$this->removeFromCache($file);
-				}
-			} catch (\Exception $e) {
-				if ($lock) {
-					if ($this->storage->instanceOfStorage('\OCP\Files\Storage\ILockingStorage')) {
-						$this->storage->releaseLock($file, ILockingProvider::LOCK_SHARED, $this->lockingProvider);
-					}
-				}
-				throw $e;
-			}
-
-			//release the acquired lock
-			if ($lock) {
-				if ($this->storage->instanceOfStorage('\OCP\Files\Storage\ILockingStorage')) {
-					$this->storage->releaseLock($file, ILockingProvider::LOCK_SHARED, $this->lockingProvider);
-				}
-			}
-
-			if ($data && !isset($data['encrypted'])) {
-				$data['encrypted'] = false;
-			}
-			return $data;
-		}
-
-		return null;
-	}
-
-	protected function removeFromCache($path) {
-		\OC_Hook::emit('Scanner', 'removeFromCache', array('file' => $path));
-		$this->emit('\OC\Files\Cache\Scanner', 'removeFromCache', array($path));
-		if ($this->cacheActive) {
-			$this->cache->remove($path);
-		}
-	}
-
-	/**
-	 * @param string $path
-	 * @param array $data
-	 * @param int $fileId
-	 * @return int the id of the added file
-	 */
-	protected function addToCache($path, $data, $fileId = -1) {
-		if (isset($data['scan_permissions'])) {
-			$data['permissions'] = $data['scan_permissions'];
-		}
-		\OC_Hook::emit('Scanner', 'addToCache', array('file' => $path, 'data' => $data));
-		$this->emit('\OC\Files\Cache\Scanner', 'addToCache', array($path, $this->storageId, $data));
-		if ($this->cacheActive) {
-			if ($fileId !== -1) {
-				$this->cache->update($fileId, $data);
-				return $fileId;
-			} else {
-				return $this->cache->put($path, $data);
-			}
-		} else {
-			return -1;
-		}
-	}
-
-	/**
-	 * @param string $path
-	 * @param array $data
-	 * @param int $fileId
-	 */
-	protected function updateCache($path, $data, $fileId = -1) {
-		\OC_Hook::emit('Scanner', 'addToCache', array('file' => $path, 'data' => $data));
-		$this->emit('\OC\Files\Cache\Scanner', 'updateCache', array($path, $this->storageId, $data));
-		if ($this->cacheActive) {
-			if ($fileId !== -1) {
-				$this->cache->update($fileId, $data);
-			} else {
-				$this->cache->put($path, $data);
-			}
-		}
-	}
-
-	/**
-	 * scan a folder and all it's children
-	 *
-	 * @param string $path
-	 * @param bool $recursive
-	 * @param int $reuse
-	 * @param bool $lock set to false to disable getting an additional read lock during scanning
-	 * @return array an array of the meta data of the scanned file or folder
-	 */
-	public function scan($path, $recursive = self::SCAN_RECURSIVE, $reuse = -1, $lock = true) {
-		if ($reuse === -1) {
-			$reuse = ($recursive === self::SCAN_SHALLOW) ? self::REUSE_ETAG | self::REUSE_SIZE : self::REUSE_ETAG;
-		}
-		if ($lock) {
-			if ($this->storage->instanceOfStorage('\OCP\Files\Storage\ILockingStorage')) {
-				$this->storage->acquireLock('scanner::' . $path, ILockingProvider::LOCK_EXCLUSIVE, $this->lockingProvider);
-				$this->storage->acquireLock($path, ILockingProvider::LOCK_SHARED, $this->lockingProvider);
-			}
-		}
-		$data = $this->scanFile($path, $reuse, -1, null, $lock);
-		if ($data and $data['mimetype'] === 'httpd/unix-directory') {
-			$size = $this->scanChildren($path, $recursive, $reuse, $data['fileid'], $lock);
-			$data['size'] = $size;
-		}
-		if ($lock) {
-			if ($this->storage->instanceOfStorage('\OCP\Files\Storage\ILockingStorage')) {
-				$this->storage->releaseLock($path, ILockingProvider::LOCK_SHARED, $this->lockingProvider);
-				$this->storage->releaseLock('scanner::' . $path, ILockingProvider::LOCK_EXCLUSIVE, $this->lockingProvider);
-			}
-		}
-		return $data;
-	}
-
-	/**
-	 * Get the children currently in the cache
-	 *
-	 * @param int $folderId
-	 * @return array[]
-	 */
-	protected function getExistingChildren($folderId) {
-		$existingChildren = array();
-		$children = $this->cache->getFolderContentsById($folderId);
-		foreach ($children as $child) {
-			$existingChildren[$child['name']] = $child;
-		}
-		return $existingChildren;
-	}
-
-	/**
-	 * Get the children from the storage
-	 *
-	 * @param string $folder
-	 * @return string[]
-	 */
-	protected function getNewChildren($folder) {
-		$children = array();
-		if ($dh = $this->storage->opendir($folder)) {
-			if (is_resource($dh)) {
-				while (($file = readdir($dh)) !== false) {
-					if (!Filesystem::isIgnoredDir($file)) {
-						$children[] = trim(\OC\Files\Filesystem::normalizePath($file), '/');
-					}
-				}
-			}
-		}
-		return $children;
-	}
-
-	/**
-	 * scan all the files and folders in a folder
-	 *
-	 * @param string $path
-	 * @param bool $recursive
-	 * @param int $reuse
-	 * @param int $folderId id for the folder to be scanned
-	 * @param bool $lock set to false to disable getting an additional read lock during scanning
-	 * @return int the size of the scanned folder or -1 if the size is unknown at this stage
-	 */
-	protected function scanChildren($path, $recursive = self::SCAN_RECURSIVE, $reuse = -1, $folderId = null, $lock = true) {
-		if ($reuse === -1) {
-			$reuse = ($recursive === self::SCAN_SHALLOW) ? self::REUSE_ETAG | self::REUSE_SIZE : self::REUSE_ETAG;
-		}
-		$this->emit('\OC\Files\Cache\Scanner', 'scanFolder', array($path, $this->storageId));
-		$size = 0;
-		if (!is_null($folderId)) {
-			$folderId = $this->cache->getId($path);
-		}
-		$childQueue = $this->handleChildren($path, $recursive, $reuse, $folderId, $lock, $size);
-
-		foreach ($childQueue as $child => $childId) {
-			$childSize = $this->scanChildren($child, $recursive, $reuse, $childId, $lock);
-			if ($childSize === -1) {
-				$size = -1;
-			} else if ($size !== -1) {
-				$size += $childSize;
-			}
-		}
-		if ($this->cacheActive) {
-			$this->cache->update($folderId, array('size' => $size));
-		}
-		$this->emit('\OC\Files\Cache\Scanner', 'postScanFolder', array($path, $this->storageId));
-		return $size;
-	}
-
-	private function handleChildren($path, $recursive, $reuse, $folderId, $lock, &$size) {
-		// we put this in it's own function so it cleans up the memory before we start recursing
-		$existingChildren = $this->getExistingChildren($folderId);
-		$newChildren = $this->getNewChildren($path);
-
-		if ($this->useTransactions) {
-			\OC::$server->getDatabaseConnection()->beginTransaction();
-		}
-
-		$exceptionOccurred = false;
-		$childQueue = [];
-		foreach ($newChildren as $file) {
-			$child = $path ? $path . '/' . $file : $file;
-			try {
-				$existingData = isset($existingChildren[$file]) ? $existingChildren[$file] : null;
-				$data = $this->scanFile($child, $reuse, $folderId, $existingData, $lock);
-				if ($data) {
-					if ($data['mimetype'] === 'httpd/unix-directory' and $recursive === self::SCAN_RECURSIVE) {
-						$childQueue[$child] = $data['fileid'];
-					} else if ($data['mimetype'] === 'httpd/unix-directory' and $recursive === self::SCAN_RECURSIVE_INCOMPLETE and $data['size'] === -1) {
-						// only recurse into folders which aren't fully scanned
-						$childQueue[$child] = $data['fileid'];
-					} else if ($data['size'] === -1) {
-						$size = -1;
-					} else if ($size !== -1) {
-						$size += $data['size'];
-					}
-				}
-			} catch (\Doctrine\DBAL\DBALException $ex) {
-				// might happen if inserting duplicate while a scanning
-				// process is running in parallel
-				// log and ignore
-				if ($this->useTransactions) {
-					\OC::$server->getDatabaseConnection()->rollback();
-					\OC::$server->getDatabaseConnection()->beginTransaction();
-				}
-				\OC::$server->getLogger()->logException($ex, [
-					'message' => 'Exception while scanning file "' . $child . '"',
-					'level' => ILogger::DEBUG,
-					'app' => 'core',
-				]);
-				$exceptionOccurred = true;
-			} catch (\OCP\Lock\LockedException $e) {
-				if ($this->useTransactions) {
-					\OC::$server->getDatabaseConnection()->rollback();
-				}
-				throw $e;
-			}
-		}
-		$removedChildren = \array_diff(array_keys($existingChildren), $newChildren);
-		foreach ($removedChildren as $childName) {
-			$child = $path ? $path . '/' . $childName : $childName;
-			$this->removeFromCache($child);
-		}
-		if ($this->useTransactions) {
-			\OC::$server->getDatabaseConnection()->commit();
-		}
-		if ($exceptionOccurred) {
-			// It might happen that the parallel scan process has already
-			// inserted mimetypes but those weren't available yet inside the transaction
-			// To make sure to have the updated mime types in such cases,
-			// we reload them here
-			\OC::$server->getMimeTypeLoader()->reset();
-		}
-		return $childQueue;
-	}
-
-	/**
-	 * check if the file should be ignored when scanning
-	 * NOTE: files with a '.part' extension are ignored as well!
-	 *       prevents unfinished put requests to be scanned
-	 *
-	 * @param string $file
-	 * @return boolean
-	 */
-	public static function isPartialFile($file) {
-		if (pathinfo($file, PATHINFO_EXTENSION) === 'part') {
-			return true;
-		}
-		if (strpos($file, '.part/') !== false) {
-			return true;
-		}
-
-		return false;
-	}
-
-	/**
-	 * walk over any folders that are not fully scanned yet and scan them
-	 */
-	public function backgroundScan() {
-		if (!$this->cache->inCache('')) {
-			$this->runBackgroundScanJob(function () {
-				$this->scan('', self::SCAN_RECURSIVE, self::REUSE_ETAG);
-			}, '');
-		} else {
-			$lastPath = null;
-			while (($path = $this->cache->getIncomplete()) !== false && $path !== $lastPath) {
-				$this->runBackgroundScanJob(function () use ($path) {
-					$this->scan($path, self::SCAN_RECURSIVE_INCOMPLETE, self::REUSE_ETAG | self::REUSE_SIZE);
-				}, $path);
-				// FIXME: this won't proceed with the next item, needs revamping of getIncomplete()
-				// to make this possible
-				$lastPath = $path;
-			}
-		}
-	}
-
-	private function runBackgroundScanJob(callable $callback, $path) {
-		try {
-			$callback();
-			\OC_Hook::emit('Scanner', 'correctFolderSize', array('path' => $path));
-			if ($this->cacheActive && $this->cache instanceof Cache) {
-				$this->cache->correctFolderSize($path);
-			}
-		} catch (\OCP\Files\StorageInvalidException $e) {
-			// skip unavailable storages
-		} catch (\OCP\Files\StorageNotAvailableException $e) {
-			// skip unavailable storages
-		} catch (\OCP\Files\ForbiddenException $e) {
-			// skip forbidden storages
-		} catch (\OCP\Lock\LockedException $e) {
-			// skip unavailable storages
-		}
-	}
-
-	/**
-	 * Set whether the cache is affected by scan operations
-	 *
-	 * @param boolean $active The active state of the cache
-	 */
-	public function setCacheActive($active) {
-		$this->cacheActive = $active;
-	}
+    /**
+     * @var \OC\Files\Storage\Storage $storage
+     */
+    protected $storage;
+
+    /**
+     * @var string $storageId
+     */
+    protected $storageId;
+
+    /**
+     * @var \OC\Files\Cache\Cache $cache
+     */
+    protected $cache;
+
+    /**
+     * @var boolean $cacheActive If true, perform cache operations, if false, do not affect cache
+     */
+    protected $cacheActive;
+
+    /**
+     * @var bool $useTransactions whether to use transactions
+     */
+    protected $useTransactions = true;
+
+    /**
+     * @var \OCP\Lock\ILockingProvider
+     */
+    protected $lockingProvider;
+
+    public function __construct(\OC\Files\Storage\Storage $storage) {
+        $this->storage = $storage;
+        $this->storageId = $this->storage->getId();
+        $this->cache = $storage->getCache();
+        $this->cacheActive = !\OC::$server->getConfig()->getSystemValue('filesystem_cache_readonly', false);
+        $this->lockingProvider = \OC::$server->getLockingProvider();
+    }
+
+    /**
+     * Whether to wrap the scanning of a folder in a database transaction
+     * On default transactions are used
+     *
+     * @param bool $useTransactions
+     */
+    public function setUseTransactions($useTransactions) {
+        $this->useTransactions = $useTransactions;
+    }
+
+    /**
+     * get all the metadata of a file or folder
+     * *
+     *
+     * @param string $path
+     * @return array an array of metadata of the file
+     */
+    protected function getData($path) {
+        $data = $this->storage->getMetaData($path);
+        if (is_null($data)) {
+            \OCP\Util::writeLog(Scanner::class, "!!! Path '$path' is not accessible or present !!!", ILogger::DEBUG);
+        }
+        return $data;
+    }
+
+    /**
+     * scan a single file and store it in the cache
+     *
+     * @param string $file
+     * @param int $reuseExisting
+     * @param int $parentId
+     * @param array | null $cacheData existing data in the cache for the file to be scanned
+     * @param bool $lock set to false to disable getting an additional read lock during scanning
+     * @return array an array of metadata of the scanned file
+     * @throws \OC\ServerNotAvailableException
+     * @throws \OCP\Lock\LockedException
+     */
+    public function scanFile($file, $reuseExisting = 0, $parentId = -1, $cacheData = null, $lock = true) {
+        if ($file !== '') {
+            try {
+                $this->storage->verifyPath(dirname($file), basename($file));
+            } catch (\Exception $e) {
+                return null;
+            }
+        }
+        // only proceed if $file is not a partial file nor a blacklisted file
+        if (!self::isPartialFile($file) and !Filesystem::isFileBlacklisted($file)) {
+
+            //acquire a lock
+            if ($lock) {
+                if ($this->storage->instanceOfStorage('\OCP\Files\Storage\ILockingStorage')) {
+                    $this->storage->acquireLock($file, ILockingProvider::LOCK_SHARED, $this->lockingProvider);
+                }
+            }
+
+            try {
+                $data = $this->getData($file);
+            } catch (ForbiddenException $e) {
+                if ($lock) {
+                    if ($this->storage->instanceOfStorage('\OCP\Files\Storage\ILockingStorage')) {
+                        $this->storage->releaseLock($file, ILockingProvider::LOCK_SHARED, $this->lockingProvider);
+                    }
+                }
+
+                return null;
+            }
+
+            try {
+                if ($data) {
+
+                    // pre-emit only if it was a file. By that we avoid counting/treating folders as files
+                    if ($data['mimetype'] !== 'httpd/unix-directory') {
+                        $this->emit('\OC\Files\Cache\Scanner', 'scanFile', array($file, $this->storageId));
+                        \OC_Hook::emit('\OC\Files\Cache\Scanner', 'scan_file', array('path' => $file, 'storage' => $this->storageId));
+                    }
+
+                    $parent = dirname($file);
+                    if ($parent === '.' or $parent === '/') {
+                        $parent = '';
+                    }
+                    if ($parentId === -1) {
+                        $parentId = $this->cache->getParentId($file);
+                    }
+
+                    // scan the parent if it's not in the cache (id -1) and the current file is not the root folder
+                    if ($file and $parentId === -1) {
+                        $parentData = $this->scanFile($parent);
+                        if (!$parentData) {
+                            return null;
+                        }
+                        $parentId = $parentData['fileid'];
+                    }
+                    if ($parent) {
+                        $data['parent'] = $parentId;
+                    }
+                    if (is_null($cacheData)) {
+                        /** @var CacheEntry $cacheData */
+                        $cacheData = $this->cache->get($file);
+                    }
+                    if ($cacheData and $reuseExisting and isset($cacheData['fileid'])) {
+                        // prevent empty etag
+                        if (empty($cacheData['etag'])) {
+                            $etag = $data['etag'];
+                        } else {
+                            $etag = $cacheData['etag'];
+                        }
+                        $fileId = $cacheData['fileid'];
+                        $data['fileid'] = $fileId;
+                        // only reuse data if the file hasn't explicitly changed
+                        if (isset($data['storage_mtime']) && isset($cacheData['storage_mtime']) && $data['storage_mtime'] === $cacheData['storage_mtime']) {
+                            $data['mtime'] = $cacheData['mtime'];
+                            if (($reuseExisting & self::REUSE_SIZE) && ($data['size'] === -1)) {
+                                $data['size'] = $cacheData['size'];
+                            }
+                            if ($reuseExisting & self::REUSE_ETAG) {
+                                $data['etag'] = $etag;
+                            }
+                        }
+                        // Only update metadata that has changed
+                        $newData = array_diff_assoc($data, $cacheData->getData());
+                    } else {
+                        $newData = $data;
+                        $fileId = -1;
+                    }
+                    if (!empty($newData)) {
+                        // Reset the checksum if the data has changed
+                        $newData['checksum'] = '';
+                        $data['fileid'] = $this->addToCache($file, $newData, $fileId);
+                    }
+                    if (isset($cacheData['size'])) {
+                        $data['oldSize'] = $cacheData['size'];
+                    } else {
+                        $data['oldSize'] = 0;
+                    }
+
+                    if (isset($cacheData['encrypted'])) {
+                        $data['encrypted'] = $cacheData['encrypted'];
+                    }
+
+                    // post-emit only if it was a file. By that we avoid counting/treating folders as files
+                    if ($data['mimetype'] !== 'httpd/unix-directory') {
+                        $this->emit('\OC\Files\Cache\Scanner', 'postScanFile', array($file, $this->storageId));
+                        \OC_Hook::emit('\OC\Files\Cache\Scanner', 'post_scan_file', array('path' => $file, 'storage' => $this->storageId));
+                    }
+
+                } else {
+                    $this->removeFromCache($file);
+                }
+            } catch (\Exception $e) {
+                if ($lock) {
+                    if ($this->storage->instanceOfStorage('\OCP\Files\Storage\ILockingStorage')) {
+                        $this->storage->releaseLock($file, ILockingProvider::LOCK_SHARED, $this->lockingProvider);
+                    }
+                }
+                throw $e;
+            }
+
+            //release the acquired lock
+            if ($lock) {
+                if ($this->storage->instanceOfStorage('\OCP\Files\Storage\ILockingStorage')) {
+                    $this->storage->releaseLock($file, ILockingProvider::LOCK_SHARED, $this->lockingProvider);
+                }
+            }
+
+            if ($data && !isset($data['encrypted'])) {
+                $data['encrypted'] = false;
+            }
+            return $data;
+        }
+
+        return null;
+    }
+
+    protected function removeFromCache($path) {
+        \OC_Hook::emit('Scanner', 'removeFromCache', array('file' => $path));
+        $this->emit('\OC\Files\Cache\Scanner', 'removeFromCache', array($path));
+        if ($this->cacheActive) {
+            $this->cache->remove($path);
+        }
+    }
+
+    /**
+     * @param string $path
+     * @param array $data
+     * @param int $fileId
+     * @return int the id of the added file
+     */
+    protected function addToCache($path, $data, $fileId = -1) {
+        if (isset($data['scan_permissions'])) {
+            $data['permissions'] = $data['scan_permissions'];
+        }
+        \OC_Hook::emit('Scanner', 'addToCache', array('file' => $path, 'data' => $data));
+        $this->emit('\OC\Files\Cache\Scanner', 'addToCache', array($path, $this->storageId, $data));
+        if ($this->cacheActive) {
+            if ($fileId !== -1) {
+                $this->cache->update($fileId, $data);
+                return $fileId;
+            } else {
+                return $this->cache->put($path, $data);
+            }
+        } else {
+            return -1;
+        }
+    }
+
+    /**
+     * @param string $path
+     * @param array $data
+     * @param int $fileId
+     */
+    protected function updateCache($path, $data, $fileId = -1) {
+        \OC_Hook::emit('Scanner', 'addToCache', array('file' => $path, 'data' => $data));
+        $this->emit('\OC\Files\Cache\Scanner', 'updateCache', array($path, $this->storageId, $data));
+        if ($this->cacheActive) {
+            if ($fileId !== -1) {
+                $this->cache->update($fileId, $data);
+            } else {
+                $this->cache->put($path, $data);
+            }
+        }
+    }
+
+    /**
+     * scan a folder and all it's children
+     *
+     * @param string $path
+     * @param bool $recursive
+     * @param int $reuse
+     * @param bool $lock set to false to disable getting an additional read lock during scanning
+     * @return array an array of the meta data of the scanned file or folder
+     */
+    public function scan($path, $recursive = self::SCAN_RECURSIVE, $reuse = -1, $lock = true) {
+        if ($reuse === -1) {
+            $reuse = ($recursive === self::SCAN_SHALLOW) ? self::REUSE_ETAG | self::REUSE_SIZE : self::REUSE_ETAG;
+        }
+        if ($lock) {
+            if ($this->storage->instanceOfStorage('\OCP\Files\Storage\ILockingStorage')) {
+                $this->storage->acquireLock('scanner::' . $path, ILockingProvider::LOCK_EXCLUSIVE, $this->lockingProvider);
+                $this->storage->acquireLock($path, ILockingProvider::LOCK_SHARED, $this->lockingProvider);
+            }
+        }
+        $data = $this->scanFile($path, $reuse, -1, null, $lock);
+        if ($data and $data['mimetype'] === 'httpd/unix-directory') {
+            $size = $this->scanChildren($path, $recursive, $reuse, $data['fileid'], $lock);
+            $data['size'] = $size;
+        }
+        if ($lock) {
+            if ($this->storage->instanceOfStorage('\OCP\Files\Storage\ILockingStorage')) {
+                $this->storage->releaseLock($path, ILockingProvider::LOCK_SHARED, $this->lockingProvider);
+                $this->storage->releaseLock('scanner::' . $path, ILockingProvider::LOCK_EXCLUSIVE, $this->lockingProvider);
+            }
+        }
+        return $data;
+    }
+
+    /**
+     * Get the children currently in the cache
+     *
+     * @param int $folderId
+     * @return array[]
+     */
+    protected function getExistingChildren($folderId) {
+        $existingChildren = array();
+        $children = $this->cache->getFolderContentsById($folderId);
+        foreach ($children as $child) {
+            $existingChildren[$child['name']] = $child;
+        }
+        return $existingChildren;
+    }
+
+    /**
+     * Get the children from the storage
+     *
+     * @param string $folder
+     * @return string[]
+     */
+    protected function getNewChildren($folder) {
+        $children = array();
+        if ($dh = $this->storage->opendir($folder)) {
+            if (is_resource($dh)) {
+                while (($file = readdir($dh)) !== false) {
+                    if (!Filesystem::isIgnoredDir($file)) {
+                        $children[] = trim(\OC\Files\Filesystem::normalizePath($file), '/');
+                    }
+                }
+            }
+        }
+        return $children;
+    }
+
+    /**
+     * scan all the files and folders in a folder
+     *
+     * @param string $path
+     * @param bool $recursive
+     * @param int $reuse
+     * @param int $folderId id for the folder to be scanned
+     * @param bool $lock set to false to disable getting an additional read lock during scanning
+     * @return int the size of the scanned folder or -1 if the size is unknown at this stage
+     */
+    protected function scanChildren($path, $recursive = self::SCAN_RECURSIVE, $reuse = -1, $folderId = null, $lock = true) {
+        if ($reuse === -1) {
+            $reuse = ($recursive === self::SCAN_SHALLOW) ? self::REUSE_ETAG | self::REUSE_SIZE : self::REUSE_ETAG;
+        }
+        $this->emit('\OC\Files\Cache\Scanner', 'scanFolder', array($path, $this->storageId));
+        $size = 0;
+        if (!is_null($folderId)) {
+            $folderId = $this->cache->getId($path);
+        }
+        $childQueue = $this->handleChildren($path, $recursive, $reuse, $folderId, $lock, $size);
+
+        foreach ($childQueue as $child => $childId) {
+            $childSize = $this->scanChildren($child, $recursive, $reuse, $childId, $lock);
+            if ($childSize === -1) {
+                $size = -1;
+            } else if ($size !== -1) {
+                $size += $childSize;
+            }
+        }
+        if ($this->cacheActive) {
+            $this->cache->update($folderId, array('size' => $size));
+        }
+        $this->emit('\OC\Files\Cache\Scanner', 'postScanFolder', array($path, $this->storageId));
+        return $size;
+    }
+
+    private function handleChildren($path, $recursive, $reuse, $folderId, $lock, &$size) {
+        // we put this in it's own function so it cleans up the memory before we start recursing
+        $existingChildren = $this->getExistingChildren($folderId);
+        $newChildren = $this->getNewChildren($path);
+
+        if ($this->useTransactions) {
+            \OC::$server->getDatabaseConnection()->beginTransaction();
+        }
+
+        $exceptionOccurred = false;
+        $childQueue = [];
+        foreach ($newChildren as $file) {
+            $child = $path ? $path . '/' . $file : $file;
+            try {
+                $existingData = isset($existingChildren[$file]) ? $existingChildren[$file] : null;
+                $data = $this->scanFile($child, $reuse, $folderId, $existingData, $lock);
+                if ($data) {
+                    if ($data['mimetype'] === 'httpd/unix-directory' and $recursive === self::SCAN_RECURSIVE) {
+                        $childQueue[$child] = $data['fileid'];
+                    } else if ($data['mimetype'] === 'httpd/unix-directory' and $recursive === self::SCAN_RECURSIVE_INCOMPLETE and $data['size'] === -1) {
+                        // only recurse into folders which aren't fully scanned
+                        $childQueue[$child] = $data['fileid'];
+                    } else if ($data['size'] === -1) {
+                        $size = -1;
+                    } else if ($size !== -1) {
+                        $size += $data['size'];
+                    }
+                }
+            } catch (\Doctrine\DBAL\DBALException $ex) {
+                // might happen if inserting duplicate while a scanning
+                // process is running in parallel
+                // log and ignore
+                if ($this->useTransactions) {
+                    \OC::$server->getDatabaseConnection()->rollback();
+                    \OC::$server->getDatabaseConnection()->beginTransaction();
+                }
+                \OC::$server->getLogger()->logException($ex, [
+                    'message' => 'Exception while scanning file "' . $child . '"',
+                    'level' => ILogger::DEBUG,
+                    'app' => 'core',
+                ]);
+                $exceptionOccurred = true;
+            } catch (\OCP\Lock\LockedException $e) {
+                if ($this->useTransactions) {
+                    \OC::$server->getDatabaseConnection()->rollback();
+                }
+                throw $e;
+            }
+        }
+        $removedChildren = \array_diff(array_keys($existingChildren), $newChildren);
+        foreach ($removedChildren as $childName) {
+            $child = $path ? $path . '/' . $childName : $childName;
+            $this->removeFromCache($child);
+        }
+        if ($this->useTransactions) {
+            \OC::$server->getDatabaseConnection()->commit();
+        }
+        if ($exceptionOccurred) {
+            // It might happen that the parallel scan process has already
+            // inserted mimetypes but those weren't available yet inside the transaction
+            // To make sure to have the updated mime types in such cases,
+            // we reload them here
+            \OC::$server->getMimeTypeLoader()->reset();
+        }
+        return $childQueue;
+    }
+
+    /**
+     * check if the file should be ignored when scanning
+     * NOTE: files with a '.part' extension are ignored as well!
+     *       prevents unfinished put requests to be scanned
+     *
+     * @param string $file
+     * @return boolean
+     */
+    public static function isPartialFile($file) {
+        if (pathinfo($file, PATHINFO_EXTENSION) === 'part') {
+            return true;
+        }
+        if (strpos($file, '.part/') !== false) {
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * walk over any folders that are not fully scanned yet and scan them
+     */
+    public function backgroundScan() {
+        if (!$this->cache->inCache('')) {
+            $this->runBackgroundScanJob(function () {
+                $this->scan('', self::SCAN_RECURSIVE, self::REUSE_ETAG);
+            }, '');
+        } else {
+            $lastPath = null;
+            while (($path = $this->cache->getIncomplete()) !== false && $path !== $lastPath) {
+                $this->runBackgroundScanJob(function () use ($path) {
+                    $this->scan($path, self::SCAN_RECURSIVE_INCOMPLETE, self::REUSE_ETAG | self::REUSE_SIZE);
+                }, $path);
+                // FIXME: this won't proceed with the next item, needs revamping of getIncomplete()
+                // to make this possible
+                $lastPath = $path;
+            }
+        }
+    }
+
+    private function runBackgroundScanJob(callable $callback, $path) {
+        try {
+            $callback();
+            \OC_Hook::emit('Scanner', 'correctFolderSize', array('path' => $path));
+            if ($this->cacheActive && $this->cache instanceof Cache) {
+                $this->cache->correctFolderSize($path);
+            }
+        } catch (\OCP\Files\StorageInvalidException $e) {
+            // skip unavailable storages
+        } catch (\OCP\Files\StorageNotAvailableException $e) {
+            // skip unavailable storages
+        } catch (\OCP\Files\ForbiddenException $e) {
+            // skip forbidden storages
+        } catch (\OCP\Lock\LockedException $e) {
+            // skip unavailable storages
+        }
+    }
+
+    /**
+     * Set whether the cache is affected by scan operations
+     *
+     * @param boolean $active The active state of the cache
+     */
+    public function setCacheActive($active) {
+        $this->cacheActive = $active;
+    }
 }

lib/private/Log/LogFactory.php

Indentation +44 added lines, -44 removed lines

@@ -31,54 +31,54 @@
 use OCP\Log\IWriter;
 
 class LogFactory implements ILogFactory {
-	/** @var IServerContainer */
-	private $c;
+    /** @var IServerContainer */
+    private $c;
 
-	public function __construct(IServerContainer $c) {
-		$this->c = $c;
-	}
+    public function __construct(IServerContainer $c) {
+        $this->c = $c;
+    }
 
-	/**
-	 * @param $type
-	 * @return \OC\Log\Errorlog|File|\stdClass
-	 * @throws \OCP\AppFramework\QueryException
-	 */
-	public function get(string $type):IWriter {
-		switch (strtolower($type)) {
-			case 'errorlog':
-				return new Errorlog();
-			case 'syslog':
-				return $this->c->resolve(Syslog::class);
-			case 'file':
-				return $this->buildLogFile();
+    /**
+     * @param $type
+     * @return \OC\Log\Errorlog|File|\stdClass
+     * @throws \OCP\AppFramework\QueryException
+     */
+    public function get(string $type):IWriter {
+        switch (strtolower($type)) {
+            case 'errorlog':
+                return new Errorlog();
+            case 'syslog':
+                return $this->c->resolve(Syslog::class);
+            case 'file':
+                return $this->buildLogFile();
 
-			// Backwards compatibility for old and fallback for unknown log types
-			case 'owncloud':
-			case 'nextcloud':
-			default:
-				return $this->buildLogFile();
-		}
-	}
+            // Backwards compatibility for old and fallback for unknown log types
+            case 'owncloud':
+            case 'nextcloud':
+            default:
+                return $this->buildLogFile();
+        }
+    }
 
-	public function getCustomLogger(string $path):ILogger {
-		$systemConfig = null;
-		$iconfig = $this->c->getConfig();
-		if($iconfig instanceof AllConfig) {
-			// Log is bound to SystemConfig, but fetches it from \OC::$server if not supplied
-			$systemConfig = $iconfig->getSystemConfig();
-		}
-		$log = $this->buildLogFile($path);
-		return new Log($log, $systemConfig);
-	}
+    public function getCustomLogger(string $path):ILogger {
+        $systemConfig = null;
+        $iconfig = $this->c->getConfig();
+        if($iconfig instanceof AllConfig) {
+            // Log is bound to SystemConfig, but fetches it from \OC::$server if not supplied
+            $systemConfig = $iconfig->getSystemConfig();
+        }
+        $log = $this->buildLogFile($path);
+        return new Log($log, $systemConfig);
+    }
 
-	protected function buildLogFile(string $logFile = ''):File {
-		$config = $this->c->getConfig();
-		$defaultLogFile = $config->getSystemValue('datadirectory', \OC::$SERVERROOT.'/data').'/nextcloud.log';
-		if($logFile === '') {
-			$logFile = $config->getSystemValue('logfile', $defaultLogFile);
-		}
-		$fallback = $defaultLogFile !== $logFile ? $defaultLogFile : '';
+    protected function buildLogFile(string $logFile = ''):File {
+        $config = $this->c->getConfig();
+        $defaultLogFile = $config->getSystemValue('datadirectory', \OC::$SERVERROOT.'/data').'/nextcloud.log';
+        if($logFile === '') {
+            $logFile = $config->getSystemValue('logfile', $defaultLogFile);
+        }
+        $fallback = $defaultLogFile !== $logFile ? $defaultLogFile : '';
 
-		return new File($logFile, $fallback, $config);
-	}
+        return new File($logFile, $fallback, $config);
+    }
 }