migrate therinaldos.com data

wedding-pics/lib/private/Files/Storage/Wrapper/Availability.php

@@ -0,0 +1,484 @@
+<?php
+/**
+ * @copyright Copyright (c) 2016, ownCloud, Inc.
+ *
+ * @author Arthur Schiwon <blizzz@arthur-schiwon.de>
+ * @author Christoph Wurst <christoph@winzerhof-wurst.at>
+ * @author Lukas Reschke <lukas@statuscode.ch>
+ * @author Robin Appelman <robin@icewind.nl>
+ * @author Robin McCorkell <robin@mccorkell.me.uk>
+ * @author Roeland Jago Douma <roeland@famdouma.nl>
+ *
+ * @license AGPL-3.0
+ *
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License, version 3,
+ * along with this program. If not, see <http://www.gnu.org/licenses/>
+ *
+ */
+namespace OC\Files\Storage\Wrapper;
+
+use OCP\Files\Storage\IStorage;
+use OCP\Files\StorageAuthException;
+use OCP\Files\StorageNotAvailableException;
+use OCP\IConfig;
+
+/**
+ * Availability checker for storages
+ *
+ * Throws a StorageNotAvailableException for storages with known failures
+ */
+class Availability extends Wrapper {
+	public const RECHECK_TTL_SEC = 600; // 10 minutes
+
+	/** @var IConfig */
+	protected $config;
+
+	public function __construct($parameters) {
+		$this->config = $parameters['config'] ?? \OC::$server->getConfig();
+		parent::__construct($parameters);
+	}
+
+	public static function shouldRecheck($availability) {
+		if (!$availability['available']) {
+			// trigger a recheck if TTL reached
+			if ((time() - $availability['last_checked']) > self::RECHECK_TTL_SEC) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	/**
+	 * Only called if availability === false
+	 *
+	 * @return bool
+	 */
+	private function updateAvailability() {
+		// reset availability to false so that multiple requests don't recheck concurrently
+		$this->setAvailability(false);
+		try {
+			$result = $this->test();
+		} catch (\Exception $e) {
+			$result = false;
+		}
+		$this->setAvailability($result);
+		return $result;
+	}
+
+	/**
+	 * @return bool
+	 */
+	private function isAvailable() {
+		$availability = $this->getAvailability();
+		if (self::shouldRecheck($availability)) {
+			return $this->updateAvailability();
+		}
+		return $availability['available'];
+	}
+
+	/**
+	 * @throws StorageNotAvailableException
+	 */
+	private function checkAvailability() {
+		if (!$this->isAvailable()) {
+			throw new StorageNotAvailableException();
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function mkdir($path) {
+		$this->checkAvailability();
+		try {
+			return parent::mkdir($path);
+		} catch (StorageNotAvailableException $e) {
+			$this->setUnavailable($e);
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function rmdir($path) {
+		$this->checkAvailability();
+		try {
+			return parent::rmdir($path);
+		} catch (StorageNotAvailableException $e) {
+			$this->setUnavailable($e);
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function opendir($path) {
+		$this->checkAvailability();
+		try {
+			return parent::opendir($path);
+		} catch (StorageNotAvailableException $e) {
+			$this->setUnavailable($e);
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function is_dir($path) {
+		$this->checkAvailability();
+		try {
+			return parent::is_dir($path);
+		} catch (StorageNotAvailableException $e) {
+			$this->setUnavailable($e);
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function is_file($path) {
+		$this->checkAvailability();
+		try {
+			return parent::is_file($path);
+		} catch (StorageNotAvailableException $e) {
+			$this->setUnavailable($e);
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function stat($path) {
+		$this->checkAvailability();
+		try {
+			return parent::stat($path);
+		} catch (StorageNotAvailableException $e) {
+			$this->setUnavailable($e);
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function filetype($path) {
+		$this->checkAvailability();
+		try {
+			return parent::filetype($path);
+		} catch (StorageNotAvailableException $e) {
+			$this->setUnavailable($e);
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function filesize($path): false|int|float {
+		$this->checkAvailability();
+		try {
+			return parent::filesize($path);
+		} catch (StorageNotAvailableException $e) {
+			$this->setUnavailable($e);
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function isCreatable($path) {
+		$this->checkAvailability();
+		try {
+			return parent::isCreatable($path);
+		} catch (StorageNotAvailableException $e) {
+			$this->setUnavailable($e);
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function isReadable($path) {
+		$this->checkAvailability();
+		try {
+			return parent::isReadable($path);
+		} catch (StorageNotAvailableException $e) {
+			$this->setUnavailable($e);
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function isUpdatable($path) {
+		$this->checkAvailability();
+		try {
+			return parent::isUpdatable($path);
+		} catch (StorageNotAvailableException $e) {
+			$this->setUnavailable($e);
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function isDeletable($path) {
+		$this->checkAvailability();
+		try {
+			return parent::isDeletable($path);
+		} catch (StorageNotAvailableException $e) {
+			$this->setUnavailable($e);
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function isSharable($path) {
+		$this->checkAvailability();
+		try {
+			return parent::isSharable($path);
+		} catch (StorageNotAvailableException $e) {
+			$this->setUnavailable($e);
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function getPermissions($path) {
+		$this->checkAvailability();
+		try {
+			return parent::getPermissions($path);
+		} catch (StorageNotAvailableException $e) {
+			$this->setUnavailable($e);
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function file_exists($path) {
+		if ($path === '') {
+			return true;
+		}
+		$this->checkAvailability();
+		try {
+			return parent::file_exists($path);
+		} catch (StorageNotAvailableException $e) {
+			$this->setUnavailable($e);
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function filemtime($path) {
+		$this->checkAvailability();
+		try {
+			return parent::filemtime($path);
+		} catch (StorageNotAvailableException $e) {
+			$this->setUnavailable($e);
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function file_get_contents($path) {
+		$this->checkAvailability();
+		try {
+			return parent::file_get_contents($path);
+		} catch (StorageNotAvailableException $e) {
+			$this->setUnavailable($e);
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function file_put_contents($path, $data) {
+		$this->checkAvailability();
+		try {
+			return parent::file_put_contents($path, $data);
+		} catch (StorageNotAvailableException $e) {
+			$this->setUnavailable($e);
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function unlink($path) {
+		$this->checkAvailability();
+		try {
+			return parent::unlink($path);
+		} catch (StorageNotAvailableException $e) {
+			$this->setUnavailable($e);
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function rename($source, $target) {
+		$this->checkAvailability();
+		try {
+			return parent::rename($source, $target);
+		} catch (StorageNotAvailableException $e) {
+			$this->setUnavailable($e);
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function copy($source, $target) {
+		$this->checkAvailability();
+		try {
+			return parent::copy($source, $target);
+		} catch (StorageNotAvailableException $e) {
+			$this->setUnavailable($e);
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function fopen($path, $mode) {
+		$this->checkAvailability();
+		try {
+			return parent::fopen($path, $mode);
+		} catch (StorageNotAvailableException $e) {
+			$this->setUnavailable($e);
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function getMimeType($path) {
+		$this->checkAvailability();
+		try {
+			return parent::getMimeType($path);
+		} catch (StorageNotAvailableException $e) {
+			$this->setUnavailable($e);
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function hash($type, $path, $raw = false) {
+		$this->checkAvailability();
+		try {
+			return parent::hash($type, $path, $raw);
+		} catch (StorageNotAvailableException $e) {
+			$this->setUnavailable($e);
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function free_space($path) {
+		$this->checkAvailability();
+		try {
+			return parent::free_space($path);
+		} catch (StorageNotAvailableException $e) {
+			$this->setUnavailable($e);
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function search($query) {
+		$this->checkAvailability();
+		try {
+			return parent::search($query);
+		} catch (StorageNotAvailableException $e) {
+			$this->setUnavailable($e);
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function touch($path, $mtime = null) {
+		$this->checkAvailability();
+		try {
+			return parent::touch($path, $mtime);
+		} catch (StorageNotAvailableException $e) {
+			$this->setUnavailable($e);
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function getLocalFile($path) {
+		$this->checkAvailability();
+		try {
+			return parent::getLocalFile($path);
+		} catch (StorageNotAvailableException $e) {
+			$this->setUnavailable($e);
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function hasUpdated($path, $time) {
+		if (!$this->isAvailable()) {
+			return false;
+		}
+		try {
+			return parent::hasUpdated($path, $time);
+		} catch (StorageNotAvailableException $e) {
+			// set unavailable but don't rethrow
+			$this->setUnavailable(null);
+			return false;
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function getOwner($path) {
+		try {
+			return parent::getOwner($path);
+		} catch (StorageNotAvailableException $e) {
+			$this->setUnavailable($e);
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function getETag($path) {
+		$this->checkAvailability();
+		try {
+			return parent::getETag($path);
+		} catch (StorageNotAvailableException $e) {
+			$this->setUnavailable($e);
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function getDirectDownload($path) {
+		$this->checkAvailability();
+		try {
+			return parent::getDirectDownload($path);
+		} catch (StorageNotAvailableException $e) {
+			$this->setUnavailable($e);
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function copyFromStorage(IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath) {
+		$this->checkAvailability();
+		try {
+			return parent::copyFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath);
+		} catch (StorageNotAvailableException $e) {
+			$this->setUnavailable($e);
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function moveFromStorage(IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath) {
+		$this->checkAvailability();
+		try {
+			return parent::moveFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath);
+		} catch (StorageNotAvailableException $e) {
+			$this->setUnavailable($e);
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function getMetaData($path) {
+		$this->checkAvailability();
+		try {
+			return parent::getMetaData($path);
+		} catch (StorageNotAvailableException $e) {
+			$this->setUnavailable($e);
+		}
+	}
+
+	/**
+	 * @template T of StorageNotAvailableException|null
+	 * @param T $e
+	 * @psalm-return (T is null ? void : never)
+	 * @throws StorageNotAvailableException
+	 */
+	protected function setUnavailable(?StorageNotAvailableException $e): void {
+		$delay = self::RECHECK_TTL_SEC;
+		if ($e instanceof StorageAuthException) {
+			$delay = max(
+				// 30min
+				$this->config->getSystemValueInt('external_storage.auth_availability_delay', 1800),
+				self::RECHECK_TTL_SEC
+			);
+		}
+		$this->getStorageCache()->setAvailability(false, $delay);
+		if ($e !== null) {
+			throw $e;
+		}
+	}
+
+
+
+	public function getDirectoryContent($directory): \Traversable {
+		$this->checkAvailability();
+		try {
+			return parent::getDirectoryContent($directory);
+		} catch (StorageNotAvailableException $e) {
+			$this->setUnavailable($e);
+		}
+	}
+}

wedding-pics/lib/private/Files/Storage/Wrapper/Encoding.php

@@ -0,0 +1,545 @@
+<?php
+/**
+ * @copyright Copyright (c) 2016, ownCloud, Inc.
+ *
+ * @author Christoph Wurst <christoph@winzerhof-wurst.at>
+ * @author J0WI <J0WI@users.noreply.github.com>
+ * @author Lukas Reschke <lukas@statuscode.ch>
+ * @author Morris Jobke <hey@morrisjobke.de>
+ * @author Robin Appelman <robin@icewind.nl>
+ * @author Roeland Jago Douma <roeland@famdouma.nl>
+ * @author Tigran Mkrtchyan <tigran.mkrtchyan@desy.de>
+ * @author Vincent Petry <vincent@nextcloud.com>
+ *
+ * @license AGPL-3.0
+ *
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License, version 3,
+ * along with this program. If not, see <http://www.gnu.org/licenses/>
+ *
+ */
+namespace OC\Files\Storage\Wrapper;
+
+use OC\Files\Filesystem;
+use OCP\Cache\CappedMemoryCache;
+use OCP\Files\Storage\IStorage;
+use OCP\ICache;
+
+/**
+ * Encoding wrapper that deals with file names that use unsupported encodings like NFD.
+ *
+ * When applied and a UTF-8 path name was given, the wrapper will first attempt to access
+ * the actual given name and then try its NFD form.
+ */
+class Encoding extends Wrapper {
+	/**
+	 * @var ICache
+	 */
+	private $namesCache;
+
+	/**
+	 * @param array $parameters
+	 */
+	public function __construct($parameters) {
+		$this->storage = $parameters['storage'];
+		$this->namesCache = new CappedMemoryCache();
+	}
+
+	/**
+	 * Returns whether the given string is only made of ASCII characters
+	 *
+	 * @param string $str string
+	 *
+	 * @return bool true if the string is all ASCII, false otherwise
+	 */
+	private function isAscii($str) {
+		return !preg_match('/[\\x80-\\xff]+/', $str);
+	}
+
+	/**
+	 * Checks whether the given path exists in NFC or NFD form after checking
+	 * each form for each path section and returns the correct form.
+	 * If no existing path found, returns the path as it was given.
+	 *
+	 * @param string $fullPath path to check
+	 *
+	 * @return string original or converted path
+	 */
+	private function findPathToUse($fullPath) {
+		$cachedPath = $this->namesCache[$fullPath];
+		if ($cachedPath !== null) {
+			return $cachedPath;
+		}
+
+		$sections = explode('/', $fullPath);
+		$path = '';
+		foreach ($sections as $section) {
+			$convertedPath = $this->findPathToUseLastSection($path, $section);
+			if ($convertedPath === null) {
+				// no point in continuing if the section was not found, use original path
+				return $fullPath;
+			}
+			$path = $convertedPath . '/';
+		}
+		$path = rtrim($path, '/');
+		return $path;
+	}
+
+	/**
+	 * Checks whether the last path section of the given path exists in NFC or NFD form
+	 * and returns the correct form. If no existing path found, returns null.
+	 *
+	 * @param string $basePath base path to check
+	 * @param string $lastSection last section of the path to check for NFD/NFC variations
+	 *
+	 * @return string|null original or converted path, or null if none of the forms was found
+	 */
+	private function findPathToUseLastSection($basePath, $lastSection) {
+		$fullPath = $basePath . $lastSection;
+		if ($lastSection === '' || $this->isAscii($lastSection) || $this->storage->file_exists($fullPath)) {
+			$this->namesCache[$fullPath] = $fullPath;
+			return $fullPath;
+		}
+
+		// swap encoding
+		if (\Normalizer::isNormalized($lastSection, \Normalizer::FORM_C)) {
+			$otherFormPath = \Normalizer::normalize($lastSection, \Normalizer::FORM_D);
+		} else {
+			$otherFormPath = \Normalizer::normalize($lastSection, \Normalizer::FORM_C);
+		}
+		$otherFullPath = $basePath . $otherFormPath;
+		if ($this->storage->file_exists($otherFullPath)) {
+			$this->namesCache[$fullPath] = $otherFullPath;
+			return $otherFullPath;
+		}
+
+		// return original path, file did not exist at all
+		$this->namesCache[$fullPath] = $fullPath;
+		return null;
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.mkdir.php
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function mkdir($path) {
+		// note: no conversion here, method should not be called with non-NFC names!
+		$result = $this->storage->mkdir($path);
+		if ($result) {
+			$this->namesCache[$path] = $path;
+		}
+		return $result;
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.rmdir.php
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function rmdir($path) {
+		$result = $this->storage->rmdir($this->findPathToUse($path));
+		if ($result) {
+			unset($this->namesCache[$path]);
+		}
+		return $result;
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.opendir.php
+	 *
+	 * @param string $path
+	 * @return resource|false
+	 */
+	public function opendir($path) {
+		$handle = $this->storage->opendir($this->findPathToUse($path));
+		return EncodingDirectoryWrapper::wrap($handle);
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.is_dir.php
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function is_dir($path) {
+		return $this->storage->is_dir($this->findPathToUse($path));
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.is_file.php
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function is_file($path) {
+		return $this->storage->is_file($this->findPathToUse($path));
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.stat.php
+	 * only the following keys are required in the result: size and mtime
+	 *
+	 * @param string $path
+	 * @return array|bool
+	 */
+	public function stat($path) {
+		return $this->storage->stat($this->findPathToUse($path));
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.filetype.php
+	 *
+	 * @param string $path
+	 * @return string|bool
+	 */
+	public function filetype($path) {
+		return $this->storage->filetype($this->findPathToUse($path));
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.filesize.php
+	 * The result for filesize when called on a folder is required to be 0
+	 */
+	public function filesize($path): false|int|float {
+		return $this->storage->filesize($this->findPathToUse($path));
+	}
+
+	/**
+	 * check if a file can be created in $path
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function isCreatable($path) {
+		return $this->storage->isCreatable($this->findPathToUse($path));
+	}
+
+	/**
+	 * check if a file can be read
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function isReadable($path) {
+		return $this->storage->isReadable($this->findPathToUse($path));
+	}
+
+	/**
+	 * check if a file can be written to
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function isUpdatable($path) {
+		return $this->storage->isUpdatable($this->findPathToUse($path));
+	}
+
+	/**
+	 * check if a file can be deleted
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function isDeletable($path) {
+		return $this->storage->isDeletable($this->findPathToUse($path));
+	}
+
+	/**
+	 * check if a file can be shared
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function isSharable($path) {
+		return $this->storage->isSharable($this->findPathToUse($path));
+	}
+
+	/**
+	 * get the full permissions of a path.
+	 * Should return a combination of the PERMISSION_ constants defined in lib/public/constants.php
+	 *
+	 * @param string $path
+	 * @return int
+	 */
+	public function getPermissions($path) {
+		return $this->storage->getPermissions($this->findPathToUse($path));
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.file_exists.php
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function file_exists($path) {
+		return $this->storage->file_exists($this->findPathToUse($path));
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.filemtime.php
+	 *
+	 * @param string $path
+	 * @return int|bool
+	 */
+	public function filemtime($path) {
+		return $this->storage->filemtime($this->findPathToUse($path));
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.file_get_contents.php
+	 *
+	 * @param string $path
+	 * @return string|false
+	 */
+	public function file_get_contents($path) {
+		return $this->storage->file_get_contents($this->findPathToUse($path));
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.file_put_contents.php
+	 *
+	 * @param string $path
+	 * @param mixed $data
+	 * @return int|float|false
+	 */
+	public function file_put_contents($path, $data) {
+		return $this->storage->file_put_contents($this->findPathToUse($path), $data);
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.unlink.php
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function unlink($path) {
+		$result = $this->storage->unlink($this->findPathToUse($path));
+		if ($result) {
+			unset($this->namesCache[$path]);
+		}
+		return $result;
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.rename.php
+	 *
+	 * @param string $source
+	 * @param string $target
+	 * @return bool
+	 */
+	public function rename($source, $target) {
+		// second name always NFC
+		return $this->storage->rename($this->findPathToUse($source), $this->findPathToUse($target));
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.copy.php
+	 *
+	 * @param string $source
+	 * @param string $target
+	 * @return bool
+	 */
+	public function copy($source, $target) {
+		return $this->storage->copy($this->findPathToUse($source), $this->findPathToUse($target));
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.fopen.php
+	 *
+	 * @param string $path
+	 * @param string $mode
+	 * @return resource|bool
+	 */
+	public function fopen($path, $mode) {
+		$result = $this->storage->fopen($this->findPathToUse($path), $mode);
+		if ($result && $mode !== 'r' && $mode !== 'rb') {
+			unset($this->namesCache[$path]);
+		}
+		return $result;
+	}
+
+	/**
+	 * get the mimetype for a file or folder
+	 * The mimetype for a folder is required to be "httpd/unix-directory"
+	 *
+	 * @param string $path
+	 * @return string|bool
+	 */
+	public function getMimeType($path) {
+		return $this->storage->getMimeType($this->findPathToUse($path));
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.hash.php
+	 *
+	 * @param string $type
+	 * @param string $path
+	 * @param bool $raw
+	 * @return string|bool
+	 */
+	public function hash($type, $path, $raw = false) {
+		return $this->storage->hash($type, $this->findPathToUse($path), $raw);
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.free_space.php
+	 *
+	 * @param string $path
+	 * @return int|float|bool
+	 */
+	public function free_space($path) {
+		return $this->storage->free_space($this->findPathToUse($path));
+	}
+
+	/**
+	 * search for occurrences of $query in file names
+	 *
+	 * @param string $query
+	 * @return array|bool
+	 */
+	public function search($query) {
+		return $this->storage->search($query);
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.touch.php
+	 * If the backend does not support the operation, false should be returned
+	 *
+	 * @param string $path
+	 * @param int $mtime
+	 * @return bool
+	 */
+	public function touch($path, $mtime = null) {
+		return $this->storage->touch($this->findPathToUse($path), $mtime);
+	}
+
+	/**
+	 * get the path to a local version of the file.
+	 * The local version of the file can be temporary and doesn't have to be persistent across requests
+	 *
+	 * @param string $path
+	 * @return string|false
+	 */
+	public function getLocalFile($path) {
+		return $this->storage->getLocalFile($this->findPathToUse($path));
+	}
+
+	/**
+	 * check if a file or folder has been updated since $time
+	 *
+	 * @param string $path
+	 * @param int $time
+	 * @return bool
+	 *
+	 * hasUpdated for folders should return at least true if a file inside the folder is add, removed or renamed.
+	 * returning true for other changes in the folder is optional
+	 */
+	public function hasUpdated($path, $time) {
+		return $this->storage->hasUpdated($this->findPathToUse($path), $time);
+	}
+
+	/**
+	 * get a cache instance for the storage
+	 *
+	 * @param string $path
+	 * @param \OC\Files\Storage\Storage (optional) the storage to pass to the cache
+	 * @return \OC\Files\Cache\Cache
+	 */
+	public function getCache($path = '', $storage = null) {
+		if (!$storage) {
+			$storage = $this;
+		}
+		return $this->storage->getCache($this->findPathToUse($path), $storage);
+	}
+
+	/**
+	 * get a scanner instance for the storage
+	 *
+	 * @param string $path
+	 * @param \OC\Files\Storage\Storage (optional) the storage to pass to the scanner
+	 * @return \OC\Files\Cache\Scanner
+	 */
+	public function getScanner($path = '', $storage = null) {
+		if (!$storage) {
+			$storage = $this;
+		}
+		return $this->storage->getScanner($this->findPathToUse($path), $storage);
+	}
+
+	/**
+	 * get the ETag for a file or folder
+	 *
+	 * @param string $path
+	 * @return string|false
+	 */
+	public function getETag($path) {
+		return $this->storage->getETag($this->findPathToUse($path));
+	}
+
+	/**
+	 * @param IStorage $sourceStorage
+	 * @param string $sourceInternalPath
+	 * @param string $targetInternalPath
+	 * @return bool
+	 */
+	public function copyFromStorage(IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath) {
+		if ($sourceStorage === $this) {
+			return $this->copy($sourceInternalPath, $this->findPathToUse($targetInternalPath));
+		}
+
+		$result = $this->storage->copyFromStorage($sourceStorage, $sourceInternalPath, $this->findPathToUse($targetInternalPath));
+		if ($result) {
+			unset($this->namesCache[$targetInternalPath]);
+		}
+		return $result;
+	}
+
+	/**
+	 * @param IStorage $sourceStorage
+	 * @param string $sourceInternalPath
+	 * @param string $targetInternalPath
+	 * @return bool
+	 */
+	public function moveFromStorage(IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath) {
+		if ($sourceStorage === $this) {
+			$result = $this->rename($sourceInternalPath, $this->findPathToUse($targetInternalPath));
+			if ($result) {
+				unset($this->namesCache[$sourceInternalPath]);
+				unset($this->namesCache[$targetInternalPath]);
+			}
+			return $result;
+		}
+
+		$result = $this->storage->moveFromStorage($sourceStorage, $sourceInternalPath, $this->findPathToUse($targetInternalPath));
+		if ($result) {
+			unset($this->namesCache[$sourceInternalPath]);
+			unset($this->namesCache[$targetInternalPath]);
+		}
+		return $result;
+	}
+
+	public function getMetaData($path) {
+		$entry = $this->storage->getMetaData($this->findPathToUse($path));
+		$entry['name'] = trim(Filesystem::normalizePath($entry['name']), '/');
+		return $entry;
+	}
+
+	public function getDirectoryContent($directory): \Traversable {
+		$entries = $this->storage->getDirectoryContent($this->findPathToUse($directory));
+		foreach ($entries as $entry) {
+			$entry['name'] = trim(Filesystem::normalizePath($entry['name']), '/');
+			yield $entry;
+		}
+	}
+}

wedding-pics/lib/private/Files/Storage/Wrapper/EncodingDirectoryWrapper.php

@@ -0,0 +1,56 @@
+<?php
+/**
+ * @copyright Copyright (c) 2021, Nextcloud GmbH.
+ *
+ * @author Robin Appelman <robin@icewind.nl>
+ * @author Vincent Petry <vincent@nextcloud.com>
+ *
+ * @license AGPL-3.0
+ *
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License, version 3,
+ * along with this program. If not, see <http://www.gnu.org/licenses/>
+ *
+ */
+
+namespace OC\Files\Storage\Wrapper;
+
+use Icewind\Streams\DirectoryWrapper;
+use OC\Files\Filesystem;
+
+/**
+ * Normalize file names while reading directory entries
+ */
+class EncodingDirectoryWrapper extends DirectoryWrapper {
+	/**
+	 * @psalm-suppress ImplementedReturnTypeMismatch Until return type is fixed upstream
+	 * @return string|false
+	 */
+	public function dir_readdir() {
+		$file = readdir($this->source);
+		if ($file !== false && $file !== '.' && $file !== '..') {
+			$file = trim(Filesystem::normalizePath($file), '/');
+		}
+
+		return $file;
+	}
+
+	/**
+	 * @param resource $source
+	 * @param callable $filter
+	 * @return resource|false
+	 */
+	public static function wrap($source) {
+		return self::wrapSource($source, [
+			'source' => $source,
+		]);
+	}
+}

wedding-pics/lib/private/Files/Storage/Wrapper/Jail.php

@@ -0,0 +1,534 @@
+<?php
+/**
+ * @copyright Copyright (c) 2016, ownCloud, Inc.
+ *
+ * @author Christoph Wurst <christoph@winzerhof-wurst.at>
+ * @author J0WI <J0WI@users.noreply.github.com>
+ * @author Julius Härtl <jus@bitgrid.net>
+ * @author Lukas Reschke <lukas@statuscode.ch>
+ * @author Morris Jobke <hey@morrisjobke.de>
+ * @author Robin Appelman <robin@icewind.nl>
+ * @author Roeland Jago Douma <roeland@famdouma.nl>
+ * @author Tigran Mkrtchyan <tigran.mkrtchyan@desy.de>
+ *
+ * @license AGPL-3.0
+ *
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License, version 3,
+ * along with this program. If not, see <http://www.gnu.org/licenses/>
+ *
+ */
+namespace OC\Files\Storage\Wrapper;
+
+use OC\Files\Cache\Wrapper\CacheJail;
+use OC\Files\Cache\Wrapper\JailPropagator;
+use OC\Files\Filesystem;
+use OCP\Files\Storage\IStorage;
+use OCP\Files\Storage\IWriteStreamStorage;
+use OCP\Lock\ILockingProvider;
+
+/**
+ * Jail to a subdirectory of the wrapped storage
+ *
+ * This restricts access to a subfolder of the wrapped storage with the subfolder becoming the root folder new storage
+ */
+class Jail extends Wrapper {
+	/**
+	 * @var string
+	 */
+	protected $rootPath;
+
+	/**
+	 * @param array $arguments ['storage' => $storage, 'root' => $root]
+	 *
+	 * $storage: The storage that will be wrapper
+	 * $root: The folder in the wrapped storage that will become the root folder of the wrapped storage
+	 */
+	public function __construct($arguments) {
+		parent::__construct($arguments);
+		$this->rootPath = $arguments['root'];
+	}
+
+	public function getUnjailedPath($path) {
+		return trim(Filesystem::normalizePath($this->rootPath . '/' . $path), '/');
+	}
+
+	/**
+	 * This is separate from Wrapper::getWrapperStorage so we can get the jailed storage consistently even if the jail is inside another wrapper
+	 */
+	public function getUnjailedStorage() {
+		return $this->storage;
+	}
+
+
+	public function getJailedPath($path) {
+		$root = rtrim($this->rootPath, '/') . '/';
+
+		if ($path !== $this->rootPath && !str_starts_with($path, $root)) {
+			return null;
+		} else {
+			$path = substr($path, strlen($this->rootPath));
+			return trim($path, '/');
+		}
+	}
+
+	public function getId() {
+		return parent::getId();
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.mkdir.php
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function mkdir($path) {
+		return $this->getWrapperStorage()->mkdir($this->getUnjailedPath($path));
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.rmdir.php
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function rmdir($path) {
+		return $this->getWrapperStorage()->rmdir($this->getUnjailedPath($path));
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.opendir.php
+	 *
+	 * @param string $path
+	 * @return resource|false
+	 */
+	public function opendir($path) {
+		return $this->getWrapperStorage()->opendir($this->getUnjailedPath($path));
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.is_dir.php
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function is_dir($path) {
+		return $this->getWrapperStorage()->is_dir($this->getUnjailedPath($path));
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.is_file.php
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function is_file($path) {
+		return $this->getWrapperStorage()->is_file($this->getUnjailedPath($path));
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.stat.php
+	 * only the following keys are required in the result: size and mtime
+	 *
+	 * @param string $path
+	 * @return array|bool
+	 */
+	public function stat($path) {
+		return $this->getWrapperStorage()->stat($this->getUnjailedPath($path));
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.filetype.php
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function filetype($path) {
+		return $this->getWrapperStorage()->filetype($this->getUnjailedPath($path));
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.filesize.php
+	 * The result for filesize when called on a folder is required to be 0
+	 */
+	public function filesize($path): false|int|float {
+		return $this->getWrapperStorage()->filesize($this->getUnjailedPath($path));
+	}
+
+	/**
+	 * check if a file can be created in $path
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function isCreatable($path) {
+		return $this->getWrapperStorage()->isCreatable($this->getUnjailedPath($path));
+	}
+
+	/**
+	 * check if a file can be read
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function isReadable($path) {
+		return $this->getWrapperStorage()->isReadable($this->getUnjailedPath($path));
+	}
+
+	/**
+	 * check if a file can be written to
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function isUpdatable($path) {
+		return $this->getWrapperStorage()->isUpdatable($this->getUnjailedPath($path));
+	}
+
+	/**
+	 * check if a file can be deleted
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function isDeletable($path) {
+		return $this->getWrapperStorage()->isDeletable($this->getUnjailedPath($path));
+	}
+
+	/**
+	 * check if a file can be shared
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function isSharable($path) {
+		return $this->getWrapperStorage()->isSharable($this->getUnjailedPath($path));
+	}
+
+	/**
+	 * get the full permissions of a path.
+	 * Should return a combination of the PERMISSION_ constants defined in lib/public/constants.php
+	 *
+	 * @param string $path
+	 * @return int
+	 */
+	public function getPermissions($path) {
+		return $this->getWrapperStorage()->getPermissions($this->getUnjailedPath($path));
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.file_exists.php
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function file_exists($path) {
+		return $this->getWrapperStorage()->file_exists($this->getUnjailedPath($path));
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.filemtime.php
+	 *
+	 * @param string $path
+	 * @return int|bool
+	 */
+	public function filemtime($path) {
+		return $this->getWrapperStorage()->filemtime($this->getUnjailedPath($path));
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.file_get_contents.php
+	 *
+	 * @param string $path
+	 * @return string|false
+	 */
+	public function file_get_contents($path) {
+		return $this->getWrapperStorage()->file_get_contents($this->getUnjailedPath($path));
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.file_put_contents.php
+	 *
+	 * @param string $path
+	 * @param mixed $data
+	 * @return int|float|false
+	 */
+	public function file_put_contents($path, $data) {
+		return $this->getWrapperStorage()->file_put_contents($this->getUnjailedPath($path), $data);
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.unlink.php
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function unlink($path) {
+		return $this->getWrapperStorage()->unlink($this->getUnjailedPath($path));
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.rename.php
+	 *
+	 * @param string $source
+	 * @param string $target
+	 * @return bool
+	 */
+	public function rename($source, $target) {
+		return $this->getWrapperStorage()->rename($this->getUnjailedPath($source), $this->getUnjailedPath($target));
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.copy.php
+	 *
+	 * @param string $source
+	 * @param string $target
+	 * @return bool
+	 */
+	public function copy($source, $target) {
+		return $this->getWrapperStorage()->copy($this->getUnjailedPath($source), $this->getUnjailedPath($target));
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.fopen.php
+	 *
+	 * @param string $path
+	 * @param string $mode
+	 * @return resource|bool
+	 */
+	public function fopen($path, $mode) {
+		return $this->getWrapperStorage()->fopen($this->getUnjailedPath($path), $mode);
+	}
+
+	/**
+	 * get the mimetype for a file or folder
+	 * The mimetype for a folder is required to be "httpd/unix-directory"
+	 *
+	 * @param string $path
+	 * @return string|bool
+	 */
+	public function getMimeType($path) {
+		return $this->getWrapperStorage()->getMimeType($this->getUnjailedPath($path));
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.hash.php
+	 *
+	 * @param string $type
+	 * @param string $path
+	 * @param bool $raw
+	 * @return string|bool
+	 */
+	public function hash($type, $path, $raw = false) {
+		return $this->getWrapperStorage()->hash($type, $this->getUnjailedPath($path), $raw);
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.free_space.php
+	 *
+	 * @param string $path
+	 * @return int|float|bool
+	 */
+	public function free_space($path) {
+		return $this->getWrapperStorage()->free_space($this->getUnjailedPath($path));
+	}
+
+	/**
+	 * search for occurrences of $query in file names
+	 *
+	 * @param string $query
+	 * @return array|bool
+	 */
+	public function search($query) {
+		return $this->getWrapperStorage()->search($query);
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.touch.php
+	 * If the backend does not support the operation, false should be returned
+	 *
+	 * @param string $path
+	 * @param int $mtime
+	 * @return bool
+	 */
+	public function touch($path, $mtime = null) {
+		return $this->getWrapperStorage()->touch($this->getUnjailedPath($path), $mtime);
+	}
+
+	/**
+	 * get the path to a local version of the file.
+	 * The local version of the file can be temporary and doesn't have to be persistent across requests
+	 *
+	 * @param string $path
+	 * @return string|false
+	 */
+	public function getLocalFile($path) {
+		return $this->getWrapperStorage()->getLocalFile($this->getUnjailedPath($path));
+	}
+
+	/**
+	 * check if a file or folder has been updated since $time
+	 *
+	 * @param string $path
+	 * @param int $time
+	 * @return bool
+	 *
+	 * hasUpdated for folders should return at least true if a file inside the folder is add, removed or renamed.
+	 * returning true for other changes in the folder is optional
+	 */
+	public function hasUpdated($path, $time) {
+		return $this->getWrapperStorage()->hasUpdated($this->getUnjailedPath($path), $time);
+	}
+
+	/**
+	 * get a cache instance for the storage
+	 *
+	 * @param string $path
+	 * @param \OC\Files\Storage\Storage|null (optional) the storage to pass to the cache
+	 * @return \OC\Files\Cache\Cache
+	 */
+	public function getCache($path = '', $storage = null) {
+		$sourceCache = $this->getWrapperStorage()->getCache($this->getUnjailedPath($path));
+		return new CacheJail($sourceCache, $this->rootPath);
+	}
+
+	/**
+	 * get the user id of the owner of a file or folder
+	 *
+	 * @param string $path
+	 * @return string
+	 */
+	public function getOwner($path) {
+		return $this->getWrapperStorage()->getOwner($this->getUnjailedPath($path));
+	}
+
+	/**
+	 * get a watcher instance for the cache
+	 *
+	 * @param string $path
+	 * @param \OC\Files\Storage\Storage (optional) the storage to pass to the watcher
+	 * @return \OC\Files\Cache\Watcher
+	 */
+	public function getWatcher($path = '', $storage = null) {
+		if (!$storage) {
+			$storage = $this;
+		}
+		return $this->getWrapperStorage()->getWatcher($this->getUnjailedPath($path), $storage);
+	}
+
+	/**
+	 * get the ETag for a file or folder
+	 *
+	 * @param string $path
+	 * @return string|false
+	 */
+	public function getETag($path) {
+		return $this->getWrapperStorage()->getETag($this->getUnjailedPath($path));
+	}
+
+	public function getMetaData($path) {
+		return $this->getWrapperStorage()->getMetaData($this->getUnjailedPath($path));
+	}
+
+	/**
+	 * @param string $path
+	 * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
+	 * @param \OCP\Lock\ILockingProvider $provider
+	 * @throws \OCP\Lock\LockedException
+	 */
+	public function acquireLock($path, $type, ILockingProvider $provider) {
+		$this->getWrapperStorage()->acquireLock($this->getUnjailedPath($path), $type, $provider);
+	}
+
+	/**
+	 * @param string $path
+	 * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
+	 * @param \OCP\Lock\ILockingProvider $provider
+	 */
+	public function releaseLock($path, $type, ILockingProvider $provider) {
+		$this->getWrapperStorage()->releaseLock($this->getUnjailedPath($path), $type, $provider);
+	}
+
+	/**
+	 * @param string $path
+	 * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
+	 * @param \OCP\Lock\ILockingProvider $provider
+	 */
+	public function changeLock($path, $type, ILockingProvider $provider) {
+		$this->getWrapperStorage()->changeLock($this->getUnjailedPath($path), $type, $provider);
+	}
+
+	/**
+	 * Resolve the path for the source of the share
+	 *
+	 * @param string $path
+	 * @return array
+	 */
+	public function resolvePath($path) {
+		return [$this->getWrapperStorage(), $this->getUnjailedPath($path)];
+	}
+
+	/**
+	 * @param IStorage $sourceStorage
+	 * @param string $sourceInternalPath
+	 * @param string $targetInternalPath
+	 * @return bool
+	 */
+	public function copyFromStorage(IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath) {
+		if ($sourceStorage === $this) {
+			return $this->copy($sourceInternalPath, $targetInternalPath);
+		}
+		return $this->getWrapperStorage()->copyFromStorage($sourceStorage, $sourceInternalPath, $this->getUnjailedPath($targetInternalPath));
+	}
+
+	/**
+	 * @param IStorage $sourceStorage
+	 * @param string $sourceInternalPath
+	 * @param string $targetInternalPath
+	 * @return bool
+	 */
+	public function moveFromStorage(IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath) {
+		if ($sourceStorage === $this) {
+			return $this->rename($sourceInternalPath, $targetInternalPath);
+		}
+		return $this->getWrapperStorage()->moveFromStorage($sourceStorage, $sourceInternalPath, $this->getUnjailedPath($targetInternalPath));
+	}
+
+	public function getPropagator($storage = null) {
+		if (isset($this->propagator)) {
+			return $this->propagator;
+		}
+
+		if (!$storage) {
+			$storage = $this;
+		}
+		$this->propagator = new JailPropagator($storage, \OC::$server->getDatabaseConnection());
+		return $this->propagator;
+	}
+
+	public function writeStream(string $path, $stream, int $size = null): int {
+		$storage = $this->getWrapperStorage();
+		if ($storage->instanceOfStorage(IWriteStreamStorage::class)) {
+			/** @var IWriteStreamStorage $storage */
+			return $storage->writeStream($this->getUnjailedPath($path), $stream, $size);
+		} else {
+			$target = $this->fopen($path, 'w');
+			[$count, $result] = \OC_Helper::streamCopy($stream, $target);
+			fclose($stream);
+			fclose($target);
+			return $count;
+		}
+	}
+
+	public function getDirectoryContent($directory): \Traversable {
+		return $this->getWrapperStorage()->getDirectoryContent($this->getUnjailedPath($directory));
+	}
+}

wedding-pics/lib/private/Files/Storage/Wrapper/KnownMtime.php

@@ -0,0 +1,142 @@
+<?php
+
+namespace OC\Files\Storage\Wrapper;
+
+use OCP\Cache\CappedMemoryCache;
+use OCP\Files\Storage\IStorage;
+use Psr\Clock\ClockInterface;
+
+/**
+ * Wrapper that overwrites the mtime return by stat/getMetaData if the returned value
+ * is lower than when we last modified the file.
+ *
+ * This is useful because some storage servers can return an outdated mtime right after writes
+ */
+class KnownMtime extends Wrapper {
+	private CappedMemoryCache $knowMtimes;
+	private ClockInterface $clock;
+
+	public function __construct($arguments) {
+		parent::__construct($arguments);
+		$this->knowMtimes = new CappedMemoryCache();
+		$this->clock = $arguments['clock'];
+	}
+
+	public function file_put_contents($path, $data) {
+		$result = parent::file_put_contents($path, $data);
+		if ($result) {
+			$now = $this->clock->now()->getTimestamp();
+			$this->knowMtimes->set($path, $this->clock->now()->getTimestamp());
+		}
+		return $result;
+	}
+
+	public function stat($path) {
+		$stat = parent::stat($path);
+		if ($stat) {
+			$this->applyKnownMtime($path, $stat);
+		}
+		return $stat;
+	}
+
+	public function getMetaData($path) {
+		$stat = parent::getMetaData($path);
+		if ($stat) {
+			$this->applyKnownMtime($path, $stat);
+		}
+		return $stat;
+	}
+
+	private function applyKnownMtime(string $path, array &$stat) {
+		if (isset($stat['mtime'])) {
+			$knownMtime = $this->knowMtimes->get($path) ?? 0;
+			$stat['mtime'] = max($stat['mtime'], $knownMtime);
+		}
+	}
+
+	public function filemtime($path) {
+		$knownMtime = $this->knowMtimes->get($path) ?? 0;
+		return max(parent::filemtime($path), $knownMtime);
+	}
+
+	public function mkdir($path) {
+		$result = parent::mkdir($path);
+		if ($result) {
+			$this->knowMtimes->set($path, $this->clock->now()->getTimestamp());
+		}
+		return $result;
+	}
+
+	public function rmdir($path) {
+		$result = parent::rmdir($path);
+		if ($result) {
+			$this->knowMtimes->set($path, $this->clock->now()->getTimestamp());
+		}
+		return $result;
+	}
+
+	public function unlink($path) {
+		$result = parent::unlink($path);
+		if ($result) {
+			$this->knowMtimes->set($path, $this->clock->now()->getTimestamp());
+		}
+		return $result;
+	}
+
+	public function rename($source, $target) {
+		$result = parent::rename($source, $target);
+		if ($result) {
+			$this->knowMtimes->set($target, $this->clock->now()->getTimestamp());
+			$this->knowMtimes->set($source, $this->clock->now()->getTimestamp());
+		}
+		return $result;
+	}
+
+	public function copy($source, $target) {
+		$result = parent::copy($source, $target);
+		if ($result) {
+			$this->knowMtimes->set($target, $this->clock->now()->getTimestamp());
+		}
+		return $result;
+	}
+
+	public function fopen($path, $mode) {
+		$result = parent::fopen($path, $mode);
+		if ($result && $mode === 'w') {
+			$this->knowMtimes->set($path, $this->clock->now()->getTimestamp());
+		}
+		return $result;
+	}
+
+	public function touch($path, $mtime = null) {
+		$result = parent::touch($path, $mtime);
+		if ($result) {
+			$this->knowMtimes->set($path, $mtime ?? $this->clock->now()->getTimestamp());
+		}
+		return $result;
+	}
+
+	public function copyFromStorage(IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath) {
+		$result = parent::copyFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath);
+		if ($result) {
+			$this->knowMtimes->set($targetInternalPath, $this->clock->now()->getTimestamp());
+		}
+		return $result;
+	}
+
+	public function moveFromStorage(IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath) {
+		$result = parent::moveFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath);
+		if ($result) {
+			$this->knowMtimes->set($targetInternalPath, $this->clock->now()->getTimestamp());
+		}
+		return $result;
+	}
+
+	public function writeStream(string $path, $stream, int $size = null): int {
+		$result = parent::writeStream($path, $stream, $size);
+		if ($result) {
+			$this->knowMtimes->set($path, $this->clock->now()->getTimestamp());
+		}
+		return $result;
+	}
+}

wedding-pics/lib/private/Files/Storage/Wrapper/PermissionsMask.php

@@ -0,0 +1,164 @@
+<?php
+/**
+ * @copyright Copyright (c) 2016, ownCloud, Inc.
+ *
+ * @author Joas Schilling <coding@schilljs.com>
+ * @author Jörn Friedrich Dreyer <jfd@butonic.de>
+ * @author Morris Jobke <hey@morrisjobke.de>
+ * @author Robin Appelman <robin@icewind.nl>
+ * @author Robin McCorkell <robin@mccorkell.me.uk>
+ * @author Roeland Jago Douma <roeland@famdouma.nl>
+ * @author Stefan Weil <sw@weilnetz.de>
+ *
+ * @license AGPL-3.0
+ *
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License, version 3,
+ * along with this program. If not, see <http://www.gnu.org/licenses/>
+ *
+ */
+namespace OC\Files\Storage\Wrapper;
+
+use OC\Files\Cache\Wrapper\CachePermissionsMask;
+use OCP\Constants;
+
+/**
+ * Mask the permissions of a storage
+ *
+ * This can be used to restrict update, create, delete and/or share permissions of a storage
+ *
+ * Note that the read permissions can't be masked
+ */
+class PermissionsMask extends Wrapper {
+	/**
+	 * @var int the permissions bits we want to keep
+	 */
+	private $mask;
+
+	/**
+	 * @param array $arguments ['storage' => $storage, 'mask' => $mask]
+	 *
+	 * $storage: The storage the permissions mask should be applied on
+	 * $mask: The permission bits that should be kept, a combination of the \OCP\Constant::PERMISSION_ constants
+	 */
+	public function __construct($arguments) {
+		parent::__construct($arguments);
+		$this->mask = $arguments['mask'];
+	}
+
+	private function checkMask($permissions) {
+		return ($this->mask & $permissions) === $permissions;
+	}
+
+	public function isUpdatable($path) {
+		return $this->checkMask(Constants::PERMISSION_UPDATE) and parent::isUpdatable($path);
+	}
+
+	public function isCreatable($path) {
+		return $this->checkMask(Constants::PERMISSION_CREATE) and parent::isCreatable($path);
+	}
+
+	public function isDeletable($path) {
+		return $this->checkMask(Constants::PERMISSION_DELETE) and parent::isDeletable($path);
+	}
+
+	public function isSharable($path) {
+		return $this->checkMask(Constants::PERMISSION_SHARE) and parent::isSharable($path);
+	}
+
+	public function getPermissions($path) {
+		return $this->storage->getPermissions($path) & $this->mask;
+	}
+
+	public function rename($source, $target) {
+		//This is a rename of the transfer file to the original file
+		if (dirname($source) === dirname($target) && strpos($source, '.ocTransferId') > 0) {
+			return $this->checkMask(Constants::PERMISSION_CREATE) and parent::rename($source, $target);
+		}
+		return $this->checkMask(Constants::PERMISSION_UPDATE) and parent::rename($source, $target);
+	}
+
+	public function copy($source, $target) {
+		return $this->checkMask(Constants::PERMISSION_CREATE) and parent::copy($source, $target);
+	}
+
+	public function touch($path, $mtime = null) {
+		$permissions = $this->file_exists($path) ? Constants::PERMISSION_UPDATE : Constants::PERMISSION_CREATE;
+		return $this->checkMask($permissions) and parent::touch($path, $mtime);
+	}
+
+	public function mkdir($path) {
+		return $this->checkMask(Constants::PERMISSION_CREATE) and parent::mkdir($path);
+	}
+
+	public function rmdir($path) {
+		return $this->checkMask(Constants::PERMISSION_DELETE) and parent::rmdir($path);
+	}
+
+	public function unlink($path) {
+		return $this->checkMask(Constants::PERMISSION_DELETE) and parent::unlink($path);
+	}
+
+	public function file_put_contents($path, $data) {
+		$permissions = $this->file_exists($path) ? Constants::PERMISSION_UPDATE : Constants::PERMISSION_CREATE;
+		return $this->checkMask($permissions) ? parent::file_put_contents($path, $data) : false;
+	}
+
+	public function fopen($path, $mode) {
+		if ($mode === 'r' or $mode === 'rb') {
+			return parent::fopen($path, $mode);
+		} else {
+			$permissions = $this->file_exists($path) ? Constants::PERMISSION_UPDATE : Constants::PERMISSION_CREATE;
+			return $this->checkMask($permissions) ? parent::fopen($path, $mode) : false;
+		}
+	}
+
+	/**
+	 * get a cache instance for the storage
+	 *
+	 * @param string $path
+	 * @param \OC\Files\Storage\Storage (optional) the storage to pass to the cache
+	 * @return \OC\Files\Cache\Cache
+	 */
+	public function getCache($path = '', $storage = null) {
+		if (!$storage) {
+			$storage = $this;
+		}
+		$sourceCache = parent::getCache($path, $storage);
+		return new CachePermissionsMask($sourceCache, $this->mask);
+	}
+
+	public function getMetaData($path) {
+		$data = parent::getMetaData($path);
+
+		if ($data && isset($data['permissions'])) {
+			$data['scan_permissions'] = $data['scan_permissions'] ?? $data['permissions'];
+			$data['permissions'] &= $this->mask;
+		}
+		return $data;
+	}
+
+	public function getScanner($path = '', $storage = null) {
+		if (!$storage) {
+			$storage = $this->storage;
+		}
+		return parent::getScanner($path, $storage);
+	}
+
+	public function getDirectoryContent($directory): \Traversable {
+		foreach ($this->getWrapperStorage()->getDirectoryContent($directory) as $data) {
+			$data['scan_permissions'] = $data['scan_permissions'] ?? $data['permissions'];
+			$data['permissions'] &= $this->mask;
+
+			yield $data;
+		}
+	}
+}

wedding-pics/lib/private/Files/Storage/Wrapper/Quota.php

@@ -0,0 +1,273 @@
+<?php
+/**
+ * @copyright Copyright (c) 2016, ownCloud, Inc.
+ *
+ * @author Christoph Wurst <christoph@winzerhof-wurst.at>
+ * @author J0WI <J0WI@users.noreply.github.com>
+ * @author John Molakvoæ <skjnldsv@protonmail.com>
+ * @author Jörn Friedrich Dreyer <jfd@butonic.de>
+ * @author Julius Härtl <jus@bitgrid.net>
+ * @author Lukas Reschke <lukas@statuscode.ch>
+ * @author Morris Jobke <hey@morrisjobke.de>
+ * @author Robin Appelman <robin@icewind.nl>
+ * @author Robin McCorkell <robin@mccorkell.me.uk>
+ * @author Roeland Jago Douma <roeland@famdouma.nl>
+ * @author Tigran Mkrtchyan <tigran.mkrtchyan@desy.de>
+ * @author Vincent Petry <vincent@nextcloud.com>
+ *
+ * @license AGPL-3.0
+ *
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License, version 3,
+ * along with this program. If not, see <http://www.gnu.org/licenses/>
+ *
+ */
+namespace OC\Files\Storage\Wrapper;
+
+use OC\Files\Filesystem;
+use OC\SystemConfig;
+use OCP\Files\Cache\ICacheEntry;
+use OCP\Files\FileInfo;
+use OCP\Files\Storage\IStorage;
+
+class Quota extends Wrapper {
+	/** @var callable|null */
+	protected $quotaCallback;
+	/** @var int|float|null int on 64bits, float on 32bits for bigint */
+	protected int|float|null $quota;
+	protected string $sizeRoot;
+	private SystemConfig $config;
+	private bool $quotaIncludeExternalStorage;
+
+	/**
+	 * @param array $parameters
+	 */
+	public function __construct($parameters) {
+		parent::__construct($parameters);
+		$this->quota = $parameters['quota'] ?? null;
+		$this->quotaCallback = $parameters['quotaCallback'] ?? null;
+		$this->sizeRoot = $parameters['root'] ?? '';
+		$this->quotaIncludeExternalStorage = $parameters['include_external_storage'] ?? false;
+	}
+
+	/**
+	 * @return int|float quota value
+	 */
+	public function getQuota(): int|float {
+		if ($this->quota === null) {
+			$quotaCallback = $this->quotaCallback;
+			if ($quotaCallback === null) {
+				throw new \Exception("No quota or quota callback provider");
+			}
+			$this->quota = $quotaCallback();
+		}
+
+		return $this->quota;
+	}
+
+	private function hasQuota(): bool {
+		return $this->getQuota() !== FileInfo::SPACE_UNLIMITED;
+	}
+
+	/**
+	 * @param string $path
+	 * @param IStorage $storage
+	 * @return int|float
+	 */
+	protected function getSize($path, $storage = null) {
+		if ($this->quotaIncludeExternalStorage) {
+			$rootInfo = Filesystem::getFileInfo('', 'ext');
+			if ($rootInfo) {
+				return $rootInfo->getSize(true);
+			}
+			return FileInfo::SPACE_NOT_COMPUTED;
+		} else {
+			$cache = is_null($storage) ? $this->getCache() : $storage->getCache();
+			$data = $cache->get($path);
+			if ($data instanceof ICacheEntry && isset($data['size'])) {
+				return $data['size'];
+			} else {
+				return FileInfo::SPACE_NOT_COMPUTED;
+			}
+		}
+	}
+
+	/**
+	 * Get free space as limited by the quota
+	 *
+	 * @param string $path
+	 * @return int|float|bool
+	 */
+	public function free_space($path) {
+		if (!$this->hasQuota()) {
+			return $this->storage->free_space($path);
+		}
+		if ($this->getQuota() < 0 || str_starts_with($path, 'cache') || str_starts_with($path, 'uploads')) {
+			return $this->storage->free_space($path);
+		} else {
+			$used = $this->getSize($this->sizeRoot);
+			if ($used < 0) {
+				return FileInfo::SPACE_NOT_COMPUTED;
+			} else {
+				$free = $this->storage->free_space($path);
+				$quotaFree = max($this->getQuota() - $used, 0);
+				// if free space is known
+				$free = $free >= 0 ? min($free, $quotaFree) : $quotaFree;
+				return $free;
+			}
+		}
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.file_put_contents.php
+	 *
+	 * @param string $path
+	 * @param mixed $data
+	 * @return int|float|false
+	 */
+	public function file_put_contents($path, $data) {
+		if (!$this->hasQuota()) {
+			return $this->storage->file_put_contents($path, $data);
+		}
+		$free = $this->free_space($path);
+		if ($free < 0 || strlen($data) < $free) {
+			return $this->storage->file_put_contents($path, $data);
+		} else {
+			return false;
+		}
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.copy.php
+	 *
+	 * @param string $source
+	 * @param string $target
+	 * @return bool
+	 */
+	public function copy($source, $target) {
+		if (!$this->hasQuota()) {
+			return $this->storage->copy($source, $target);
+		}
+		$free = $this->free_space($target);
+		if ($free < 0 || $this->getSize($source) < $free) {
+			return $this->storage->copy($source, $target);
+		} else {
+			return false;
+		}
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.fopen.php
+	 *
+	 * @param string $path
+	 * @param string $mode
+	 * @return resource|bool
+	 */
+	public function fopen($path, $mode) {
+		if (!$this->hasQuota()) {
+			return $this->storage->fopen($path, $mode);
+		}
+		$source = $this->storage->fopen($path, $mode);
+
+		// don't apply quota for part files
+		if (!$this->isPartFile($path)) {
+			$free = $this->free_space($path);
+			if ($source && (is_int($free) || is_float($free)) && $free >= 0 && $mode !== 'r' && $mode !== 'rb') {
+				// only apply quota for files, not metadata, trash or others
+				if ($this->shouldApplyQuota($path)) {
+					return \OC\Files\Stream\Quota::wrap($source, $free);
+				}
+			}
+		}
+
+		return $source;
+	}
+
+	/**
+	 * Checks whether the given path is a part file
+	 *
+	 * @param string $path Path that may identify a .part file
+	 * @return bool
+	 * @note this is needed for reusing keys
+	 */
+	private function isPartFile($path) {
+		$extension = pathinfo($path, PATHINFO_EXTENSION);
+
+		return ($extension === 'part');
+	}
+
+	/**
+	 * Only apply quota for files, not metadata, trash or others
+	 */
+	private function shouldApplyQuota(string $path): bool {
+		return str_starts_with(ltrim($path, '/'), 'files/');
+	}
+
+	/**
+	 * @param IStorage $sourceStorage
+	 * @param string $sourceInternalPath
+	 * @param string $targetInternalPath
+	 * @return bool
+	 */
+	public function copyFromStorage(IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath) {
+		if (!$this->hasQuota()) {
+			return $this->storage->copyFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath);
+		}
+		$free = $this->free_space($targetInternalPath);
+		if ($free < 0 || $this->getSize($sourceInternalPath, $sourceStorage) < $free) {
+			return $this->storage->copyFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath);
+		} else {
+			return false;
+		}
+	}
+
+	/**
+	 * @param IStorage $sourceStorage
+	 * @param string $sourceInternalPath
+	 * @param string $targetInternalPath
+	 * @return bool
+	 */
+	public function moveFromStorage(IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath) {
+		if (!$this->hasQuota()) {
+			return $this->storage->moveFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath);
+		}
+		$free = $this->free_space($targetInternalPath);
+		if ($free < 0 || $this->getSize($sourceInternalPath, $sourceStorage) < $free) {
+			return $this->storage->moveFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath);
+		} else {
+			return false;
+		}
+	}
+
+	public function mkdir($path) {
+		if (!$this->hasQuota()) {
+			return $this->storage->mkdir($path);
+		}
+		$free = $this->free_space($path);
+		if ($this->shouldApplyQuota($path) && $free == 0) {
+			return false;
+		}
+
+		return parent::mkdir($path);
+	}
+
+	public function touch($path, $mtime = null) {
+		if (!$this->hasQuota()) {
+			return $this->storage->touch($path, $mtime);
+		}
+		$free = $this->free_space($path);
+		if ($free == 0) {
+			return false;
+		}
+
+		return parent::touch($path, $mtime);
+	}
+}

wedding-pics/lib/private/Files/Storage/Wrapper/Wrapper.php

@@ -0,0 +1,657 @@
+<?php
+/**
+ * @copyright Copyright (c) 2016, ownCloud, Inc.
+ *
+ * @author Christoph Wurst <christoph@winzerhof-wurst.at>
+ * @author J0WI <J0WI@users.noreply.github.com>
+ * @author Joas Schilling <coding@schilljs.com>
+ * @author Lukas Reschke <lukas@statuscode.ch>
+ * @author Morris Jobke <hey@morrisjobke.de>
+ * @author Robin Appelman <robin@icewind.nl>
+ * @author Robin McCorkell <robin@mccorkell.me.uk>
+ * @author Thomas Müller <thomas.mueller@tmit.eu>
+ * @author Tigran Mkrtchyan <tigran.mkrtchyan@desy.de>
+ * @author Vincent Petry <vincent@nextcloud.com>
+ * @author Vinicius Cubas Brand <vinicius@eita.org.br>
+ *
+ * @license AGPL-3.0
+ *
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License, version 3,
+ * along with this program. If not, see <http://www.gnu.org/licenses/>
+ *
+ */
+namespace OC\Files\Storage\Wrapper;
+
+use OCP\Files\InvalidPathException;
+use OCP\Files\Storage\ILockingStorage;
+use OCP\Files\Storage\IStorage;
+use OCP\Files\Storage\IWriteStreamStorage;
+use OCP\Lock\ILockingProvider;
+
+class Wrapper implements \OC\Files\Storage\Storage, ILockingStorage, IWriteStreamStorage {
+	/**
+	 * @var \OC\Files\Storage\Storage $storage
+	 */
+	protected $storage;
+
+	public $cache;
+	public $scanner;
+	public $watcher;
+	public $propagator;
+	public $updater;
+
+	/**
+	 * @param array $parameters
+	 */
+	public function __construct($parameters) {
+		$this->storage = $parameters['storage'];
+	}
+
+	/**
+	 * @return \OC\Files\Storage\Storage
+	 */
+	public function getWrapperStorage() {
+		return $this->storage;
+	}
+
+	/**
+	 * Get the identifier for the storage,
+	 * the returned id should be the same for every storage object that is created with the same parameters
+	 * and two storage objects with the same id should refer to two storages that display the same files.
+	 *
+	 * @return string
+	 */
+	public function getId() {
+		return $this->getWrapperStorage()->getId();
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.mkdir.php
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function mkdir($path) {
+		return $this->getWrapperStorage()->mkdir($path);
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.rmdir.php
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function rmdir($path) {
+		return $this->getWrapperStorage()->rmdir($path);
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.opendir.php
+	 *
+	 * @param string $path
+	 * @return resource|false
+	 */
+	public function opendir($path) {
+		return $this->getWrapperStorage()->opendir($path);
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.is_dir.php
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function is_dir($path) {
+		return $this->getWrapperStorage()->is_dir($path);
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.is_file.php
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function is_file($path) {
+		return $this->getWrapperStorage()->is_file($path);
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.stat.php
+	 * only the following keys are required in the result: size and mtime
+	 *
+	 * @param string $path
+	 * @return array|bool
+	 */
+	public function stat($path) {
+		return $this->getWrapperStorage()->stat($path);
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.filetype.php
+	 *
+	 * @param string $path
+	 * @return string|bool
+	 */
+	public function filetype($path) {
+		return $this->getWrapperStorage()->filetype($path);
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.filesize.php
+	 * The result for filesize when called on a folder is required to be 0
+	 */
+	public function filesize($path): false|int|float {
+		return $this->getWrapperStorage()->filesize($path);
+	}
+
+	/**
+	 * check if a file can be created in $path
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function isCreatable($path) {
+		return $this->getWrapperStorage()->isCreatable($path);
+	}
+
+	/**
+	 * check if a file can be read
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function isReadable($path) {
+		return $this->getWrapperStorage()->isReadable($path);
+	}
+
+	/**
+	 * check if a file can be written to
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function isUpdatable($path) {
+		return $this->getWrapperStorage()->isUpdatable($path);
+	}
+
+	/**
+	 * check if a file can be deleted
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function isDeletable($path) {
+		return $this->getWrapperStorage()->isDeletable($path);
+	}
+
+	/**
+	 * check if a file can be shared
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function isSharable($path) {
+		return $this->getWrapperStorage()->isSharable($path);
+	}
+
+	/**
+	 * get the full permissions of a path.
+	 * Should return a combination of the PERMISSION_ constants defined in lib/public/constants.php
+	 *
+	 * @param string $path
+	 * @return int
+	 */
+	public function getPermissions($path) {
+		return $this->getWrapperStorage()->getPermissions($path);
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.file_exists.php
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function file_exists($path) {
+		return $this->getWrapperStorage()->file_exists($path);
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.filemtime.php
+	 *
+	 * @param string $path
+	 * @return int|bool
+	 */
+	public function filemtime($path) {
+		return $this->getWrapperStorage()->filemtime($path);
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.file_get_contents.php
+	 *
+	 * @param string $path
+	 * @return string|false
+	 */
+	public function file_get_contents($path) {
+		return $this->getWrapperStorage()->file_get_contents($path);
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.file_put_contents.php
+	 *
+	 * @param string $path
+	 * @param mixed $data
+	 * @return int|float|false
+	 */
+	public function file_put_contents($path, $data) {
+		return $this->getWrapperStorage()->file_put_contents($path, $data);
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.unlink.php
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function unlink($path) {
+		return $this->getWrapperStorage()->unlink($path);
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.rename.php
+	 *
+	 * @param string $source
+	 * @param string $target
+	 * @return bool
+	 */
+	public function rename($source, $target) {
+		return $this->getWrapperStorage()->rename($source, $target);
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.copy.php
+	 *
+	 * @param string $source
+	 * @param string $target
+	 * @return bool
+	 */
+	public function copy($source, $target) {
+		return $this->getWrapperStorage()->copy($source, $target);
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.fopen.php
+	 *
+	 * @param string $path
+	 * @param string $mode
+	 * @return resource|bool
+	 */
+	public function fopen($path, $mode) {
+		return $this->getWrapperStorage()->fopen($path, $mode);
+	}
+
+	/**
+	 * get the mimetype for a file or folder
+	 * The mimetype for a folder is required to be "httpd/unix-directory"
+	 *
+	 * @param string $path
+	 * @return string|bool
+	 */
+	public function getMimeType($path) {
+		return $this->getWrapperStorage()->getMimeType($path);
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.hash.php
+	 *
+	 * @param string $type
+	 * @param string $path
+	 * @param bool $raw
+	 * @return string|bool
+	 */
+	public function hash($type, $path, $raw = false) {
+		return $this->getWrapperStorage()->hash($type, $path, $raw);
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.free_space.php
+	 *
+	 * @param string $path
+	 * @return int|float|bool
+	 */
+	public function free_space($path) {
+		return $this->getWrapperStorage()->free_space($path);
+	}
+
+	/**
+	 * search for occurrences of $query in file names
+	 *
+	 * @param string $query
+	 * @return array|bool
+	 */
+	public function search($query) {
+		return $this->getWrapperStorage()->search($query);
+	}
+
+	/**
+	 * see https://www.php.net/manual/en/function.touch.php
+	 * If the backend does not support the operation, false should be returned
+	 *
+	 * @param string $path
+	 * @param int $mtime
+	 * @return bool
+	 */
+	public function touch($path, $mtime = null) {
+		return $this->getWrapperStorage()->touch($path, $mtime);
+	}
+
+	/**
+	 * get the path to a local version of the file.
+	 * The local version of the file can be temporary and doesn't have to be persistent across requests
+	 *
+	 * @param string $path
+	 * @return string|false
+	 */
+	public function getLocalFile($path) {
+		return $this->getWrapperStorage()->getLocalFile($path);
+	}
+
+	/**
+	 * check if a file or folder has been updated since $time
+	 *
+	 * @param string $path
+	 * @param int $time
+	 * @return bool
+	 *
+	 * hasUpdated for folders should return at least true if a file inside the folder is add, removed or renamed.
+	 * returning true for other changes in the folder is optional
+	 */
+	public function hasUpdated($path, $time) {
+		return $this->getWrapperStorage()->hasUpdated($path, $time);
+	}
+
+	/**
+	 * get a cache instance for the storage
+	 *
+	 * @param string $path
+	 * @param \OC\Files\Storage\Storage|null (optional) the storage to pass to the cache
+	 * @return \OC\Files\Cache\Cache
+	 */
+	public function getCache($path = '', $storage = null) {
+		if (!$storage) {
+			$storage = $this;
+		}
+		return $this->getWrapperStorage()->getCache($path, $storage);
+	}
+
+	/**
+	 * get a scanner instance for the storage
+	 *
+	 * @param string $path
+	 * @param \OC\Files\Storage\Storage (optional) the storage to pass to the scanner
+	 * @return \OC\Files\Cache\Scanner
+	 */
+	public function getScanner($path = '', $storage = null) {
+		if (!$storage) {
+			$storage = $this;
+		}
+		return $this->getWrapperStorage()->getScanner($path, $storage);
+	}
+
+
+	/**
+	 * get the user id of the owner of a file or folder
+	 *
+	 * @param string $path
+	 * @return string
+	 */
+	public function getOwner($path) {
+		return $this->getWrapperStorage()->getOwner($path);
+	}
+
+	/**
+	 * get a watcher instance for the cache
+	 *
+	 * @param string $path
+	 * @param \OC\Files\Storage\Storage (optional) the storage to pass to the watcher
+	 * @return \OC\Files\Cache\Watcher
+	 */
+	public function getWatcher($path = '', $storage = null) {
+		if (!$storage) {
+			$storage = $this;
+		}
+		return $this->getWrapperStorage()->getWatcher($path, $storage);
+	}
+
+	public function getPropagator($storage = null) {
+		if (!$storage) {
+			$storage = $this;
+		}
+		return $this->getWrapperStorage()->getPropagator($storage);
+	}
+
+	public function getUpdater($storage = null) {
+		if (!$storage) {
+			$storage = $this;
+		}
+		return $this->getWrapperStorage()->getUpdater($storage);
+	}
+
+	/**
+	 * @return \OC\Files\Cache\Storage
+	 */
+	public function getStorageCache() {
+		return $this->getWrapperStorage()->getStorageCache();
+	}
+
+	/**
+	 * get the ETag for a file or folder
+	 *
+	 * @param string $path
+	 * @return string|false
+	 */
+	public function getETag($path) {
+		return $this->getWrapperStorage()->getETag($path);
+	}
+
+	/**
+	 * Returns true
+	 *
+	 * @return true
+	 */
+	public function test() {
+		return $this->getWrapperStorage()->test();
+	}
+
+	/**
+	 * Returns the wrapped storage's value for isLocal()
+	 *
+	 * @return bool wrapped storage's isLocal() value
+	 */
+	public function isLocal() {
+		return $this->getWrapperStorage()->isLocal();
+	}
+
+	/**
+	 * Check if the storage is an instance of $class or is a wrapper for a storage that is an instance of $class
+	 *
+	 * @param class-string<IStorage> $class
+	 * @return bool
+	 */
+	public function instanceOfStorage($class) {
+		if (ltrim($class, '\\') === 'OC\Files\Storage\Shared') {
+			// FIXME Temporary fix to keep existing checks working
+			$class = '\OCA\Files_Sharing\SharedStorage';
+		}
+		return is_a($this, $class) or $this->getWrapperStorage()->instanceOfStorage($class);
+	}
+
+	/**
+	 * @psalm-template T of IStorage
+	 * @psalm-param class-string<T> $class
+	 * @psalm-return T|null
+	 */
+	public function getInstanceOfStorage(string $class) {
+		$storage = $this;
+		while ($storage instanceof Wrapper) {
+			if ($storage instanceof $class) {
+				break;
+			}
+			$storage = $storage->getWrapperStorage();
+		}
+		if (!($storage instanceof $class)) {
+			return null;
+		}
+		return $storage;
+	}
+
+	/**
+	 * Pass any methods custom to specific storage implementations to the wrapped storage
+	 *
+	 * @param string $method
+	 * @param array $args
+	 * @return mixed
+	 */
+	public function __call($method, $args) {
+		return call_user_func_array([$this->getWrapperStorage(), $method], $args);
+	}
+
+	/**
+	 * A custom storage implementation can return an url for direct download of a give file.
+	 *
+	 * For now the returned array can hold the parameter url - in future more attributes might follow.
+	 *
+	 * @param string $path
+	 * @return array|bool
+	 */
+	public function getDirectDownload($path) {
+		return $this->getWrapperStorage()->getDirectDownload($path);
+	}
+
+	/**
+	 * Get availability of the storage
+	 *
+	 * @return array [ available, last_checked ]
+	 */
+	public function getAvailability() {
+		return $this->getWrapperStorage()->getAvailability();
+	}
+
+	/**
+	 * Set availability of the storage
+	 *
+	 * @param bool $isAvailable
+	 */
+	public function setAvailability($isAvailable) {
+		$this->getWrapperStorage()->setAvailability($isAvailable);
+	}
+
+	/**
+	 * @param string $path the path of the target folder
+	 * @param string $fileName the name of the file itself
+	 * @return void
+	 * @throws InvalidPathException
+	 */
+	public function verifyPath($path, $fileName) {
+		$this->getWrapperStorage()->verifyPath($path, $fileName);
+	}
+
+	/**
+	 * @param IStorage $sourceStorage
+	 * @param string $sourceInternalPath
+	 * @param string $targetInternalPath
+	 * @return bool
+	 */
+	public function copyFromStorage(IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath) {
+		if ($sourceStorage === $this) {
+			return $this->copy($sourceInternalPath, $targetInternalPath);
+		}
+
+		return $this->getWrapperStorage()->copyFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath);
+	}
+
+	/**
+	 * @param IStorage $sourceStorage
+	 * @param string $sourceInternalPath
+	 * @param string $targetInternalPath
+	 * @return bool
+	 */
+	public function moveFromStorage(IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath) {
+		if ($sourceStorage === $this) {
+			return $this->rename($sourceInternalPath, $targetInternalPath);
+		}
+
+		return $this->getWrapperStorage()->moveFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath);
+	}
+
+	public function getMetaData($path) {
+		return $this->getWrapperStorage()->getMetaData($path);
+	}
+
+	/**
+	 * @param string $path
+	 * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
+	 * @param \OCP\Lock\ILockingProvider $provider
+	 * @throws \OCP\Lock\LockedException
+	 */
+	public function acquireLock($path, $type, ILockingProvider $provider) {
+		if ($this->getWrapperStorage()->instanceOfStorage('\OCP\Files\Storage\ILockingStorage')) {
+			$this->getWrapperStorage()->acquireLock($path, $type, $provider);
+		}
+	}
+
+	/**
+	 * @param string $path
+	 * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
+	 * @param \OCP\Lock\ILockingProvider $provider
+	 */
+	public function releaseLock($path, $type, ILockingProvider $provider) {
+		if ($this->getWrapperStorage()->instanceOfStorage('\OCP\Files\Storage\ILockingStorage')) {
+			$this->getWrapperStorage()->releaseLock($path, $type, $provider);
+		}
+	}
+
+	/**
+	 * @param string $path
+	 * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
+	 * @param \OCP\Lock\ILockingProvider $provider
+	 */
+	public function changeLock($path, $type, ILockingProvider $provider) {
+		if ($this->getWrapperStorage()->instanceOfStorage('\OCP\Files\Storage\ILockingStorage')) {
+			$this->getWrapperStorage()->changeLock($path, $type, $provider);
+		}
+	}
+
+	/**
+	 * @return bool
+	 */
+	public function needsPartFile() {
+		return $this->getWrapperStorage()->needsPartFile();
+	}
+
+	public function writeStream(string $path, $stream, int $size = null): int {
+		$storage = $this->getWrapperStorage();
+		if ($storage->instanceOfStorage(IWriteStreamStorage::class)) {
+			/** @var IWriteStreamStorage $storage */
+			return $storage->writeStream($path, $stream, $size);
+		} else {
+			$target = $this->fopen($path, 'w');
+			[$count, $result] = \OC_Helper::streamCopy($stream, $target);
+			fclose($stream);
+			fclose($target);
+			return $count;
+		}
+	}
+
+	public function getDirectoryContent($directory): \Traversable {
+		return $this->getWrapperStorage()->getDirectoryContent($directory);
+	}
+}