nextcloud / server

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

Indentation +265 added lines, -265 removed lines

@@ -18,269 +18,269 @@
  * Throws a StorageNotAvailableException for storages with known failures
  */
 class Availability extends Wrapper {
-	public const RECHECK_TTL_SEC = 600; // 10 minutes
-
-	/** @var IConfig */
-	protected $config;
-	protected ?bool $available = null;
-
-	public function __construct(array $parameters) {
-		$this->config = $parameters['config'] ?? \OCP\Server::get(IConfig::class);
-		parent::__construct($parameters);
-	}
-
-	public static function shouldRecheck($availability): bool {
-		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
-	 */
-	private function updateAvailability(): bool {
-		// 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;
-	}
-
-	private function isAvailable(): bool {
-		if (is_null($this->available)) {
-			$availability = $this->getAvailability();
-			if (self::shouldRecheck($availability)) {
-				return $this->updateAvailability();
-			}
-			$this->available = $availability['available'];
-		}
-		return $this->available;
-	}
-
-	/**
-	 * @throws StorageNotAvailableException
-	 */
-	private function checkAvailability(): void {
-		if (!$this->isAvailable()) {
-			throw new StorageNotAvailableException();
-		}
-	}
-
-	/**
-	 * Handles availability checks and delegates method calls dynamically
-	 */
-	private function handleAvailability(string $method, mixed ...$args): mixed {
-		$this->checkAvailability();
-		try {
-			return call_user_func_array([parent::class, $method], $args);
-		} catch (StorageNotAvailableException $e) {
-			$this->setUnavailable($e);
-			return false;
-		}
-	}
-
-	public function mkdir(string $path): bool {
-		return $this->handleAvailability('mkdir', $path);
-	}
-
-	public function rmdir(string $path): bool {
-		return $this->handleAvailability('rmdir', $path);
-	}
-
-	public function opendir(string $path) {
-		return $this->handleAvailability('opendir', $path);
-	}
-
-	public function is_dir(string $path): bool {
-		return $this->handleAvailability('is_dir', $path);
-	}
-
-	public function is_file(string $path): bool {
-		return $this->handleAvailability('is_file', $path);
-	}
-
-	public function stat(string $path): array|false {
-		return $this->handleAvailability('stat', $path);
-	}
-
-	public function filetype(string $path): string|false {
-		return $this->handleAvailability('filetype', $path);
-	}
-
-	public function filesize(string $path): int|float|false {
-		return $this->handleAvailability('filesize', $path);
-	}
-
-	public function isCreatable(string $path): bool {
-		return $this->handleAvailability('isCreatable', $path);
-	}
-
-	public function isReadable(string $path): bool {
-		return $this->handleAvailability('isReadable', $path);
-	}
-
-	public function isUpdatable(string $path): bool {
-		return $this->handleAvailability('isUpdatable', $path);
-	}
-
-	public function isDeletable(string $path): bool {
-		return $this->handleAvailability('isDeletable', $path);
-	}
-
-	public function isSharable(string $path): bool {
-		return $this->handleAvailability('isSharable', $path);
-	}
-
-	public function getPermissions(string $path): int {
-		return $this->handleAvailability('getPermissions', $path);
-	}
-
-	public function file_exists(string $path): bool {
-		if ($path === '') {
-			return true;
-		}
-		return $this->handleAvailability('file_exists', $path);
-	}
-
-	public function filemtime(string $path): int|false {
-		return $this->handleAvailability('filemtime', $path);
-	}
-
-	public function file_get_contents(string $path): string|false {
-		return $this->handleAvailability('file_get_contents', $path);
-	}
-
-	public function file_put_contents(string $path, mixed $data): int|float|false {
-		return $this->handleAvailability('file_put_contents', $path, $data);
-	}
-
-	public function unlink(string $path): bool {
-		return $this->handleAvailability('unlink', $path);
-	}
-
-	public function rename(string $source, string $target): bool {
-		return $this->handleAvailability('rename', $source, $target);
-	}
-
-	public function copy(string $source, string $target): bool {
-		return $this->handleAvailability('copy', $source, $target);
-	}
-
-	public function fopen(string $path, string $mode) {
-		return $this->handleAvailability('fopen', $path, $mode);
-	}
-
-	public function getMimeType(string $path): string|false {
-		return $this->handleAvailability('getMimeType', $path);
-	}
-
-	public function hash(string $type, string $path, bool $raw = false): string|false {
-		return $this->handleAvailability('hash', $type, $path, $raw);
-	}
-
-	public function free_space(string $path): int|float|false {
-		return $this->handleAvailability('free_space', $path);
-	}
-
-	public function touch(string $path, ?int $mtime = null): bool {
-		return $this->handleAvailability('touch', $path, $mtime);
-	}
-
-	public function getLocalFile(string $path): string|false {
-		return $this->handleAvailability('getLocalFile', $path);
-	}
-
-	public function hasUpdated(string $path, int $time): bool {
-		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;
-		}
-	}
-
-	public function getOwner(string $path): string|false {
-		try {
-			return parent::getOwner($path);
-		} catch (StorageNotAvailableException $e) {
-			$this->setUnavailable($e);
-			return false;
-		}
-	}
-
-	public function getETag(string $path): string|false {
-		return $this->handleAvailability('getETag', $path);
-	}
-
-	public function getDirectDownload(string $path): array|false {
-		return $this->handleAvailability('getDirectDownload', $path);
-	}
-
-	public function getDirectDownloadById(string $fileId): array|false {
-		return $this->handleAvailability('getDirectDownloadById', $fileId);
-	}
-
-	public function copyFromStorage(IStorage $sourceStorage, string $sourceInternalPath, string $targetInternalPath): bool {
-		return $this->handleAvailability('copyFromStorage', $sourceStorage, $sourceInternalPath, $targetInternalPath);
-	}
-
-	public function moveFromStorage(IStorage $sourceStorage, string $sourceInternalPath, string $targetInternalPath): bool {
-		return $this->handleAvailability('moveFromStorage', $sourceStorage, $sourceInternalPath, $targetInternalPath);
-	}
-
-	public function getMetaData(string $path): ?array {
-		$this->checkAvailability();
-		try {
-			return parent::getMetaData($path);
-		} catch (StorageNotAvailableException $e) {
-			$this->setUnavailable($e);
-			return null;
-		}
-	}
-
-	/**
-	 * @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->available = false;
-		$this->getStorageCache()->setAvailability(false, $delay);
-		if ($e !== null) {
-			throw $e;
-		}
-	}
-
-
-
-	public function getDirectoryContent(string $directory): \Traversable {
-		$this->checkAvailability();
-		try {
-			return parent::getDirectoryContent($directory);
-		} catch (StorageNotAvailableException $e) {
-			$this->setUnavailable($e);
-			return new \EmptyIterator();
-		}
-	}
+    public const RECHECK_TTL_SEC = 600; // 10 minutes
+
+    /** @var IConfig */
+    protected $config;
+    protected ?bool $available = null;
+
+    public function __construct(array $parameters) {
+        $this->config = $parameters['config'] ?? \OCP\Server::get(IConfig::class);
+        parent::__construct($parameters);
+    }
+
+    public static function shouldRecheck($availability): bool {
+        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
+     */
+    private function updateAvailability(): bool {
+        // 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;
+    }
+
+    private function isAvailable(): bool {
+        if (is_null($this->available)) {
+            $availability = $this->getAvailability();
+            if (self::shouldRecheck($availability)) {
+                return $this->updateAvailability();
+            }
+            $this->available = $availability['available'];
+        }
+        return $this->available;
+    }
+
+    /**
+     * @throws StorageNotAvailableException
+     */
+    private function checkAvailability(): void {
+        if (!$this->isAvailable()) {
+            throw new StorageNotAvailableException();
+        }
+    }
+
+    /**
+     * Handles availability checks and delegates method calls dynamically
+     */
+    private function handleAvailability(string $method, mixed ...$args): mixed {
+        $this->checkAvailability();
+        try {
+            return call_user_func_array([parent::class, $method], $args);
+        } catch (StorageNotAvailableException $e) {
+            $this->setUnavailable($e);
+            return false;
+        }
+    }
+
+    public function mkdir(string $path): bool {
+        return $this->handleAvailability('mkdir', $path);
+    }
+
+    public function rmdir(string $path): bool {
+        return $this->handleAvailability('rmdir', $path);
+    }
+
+    public function opendir(string $path) {
+        return $this->handleAvailability('opendir', $path);
+    }
+
+    public function is_dir(string $path): bool {
+        return $this->handleAvailability('is_dir', $path);
+    }
+
+    public function is_file(string $path): bool {
+        return $this->handleAvailability('is_file', $path);
+    }
+
+    public function stat(string $path): array|false {
+        return $this->handleAvailability('stat', $path);
+    }
+
+    public function filetype(string $path): string|false {
+        return $this->handleAvailability('filetype', $path);
+    }
+
+    public function filesize(string $path): int|float|false {
+        return $this->handleAvailability('filesize', $path);
+    }
+
+    public function isCreatable(string $path): bool {
+        return $this->handleAvailability('isCreatable', $path);
+    }
+
+    public function isReadable(string $path): bool {
+        return $this->handleAvailability('isReadable', $path);
+    }
+
+    public function isUpdatable(string $path): bool {
+        return $this->handleAvailability('isUpdatable', $path);
+    }
+
+    public function isDeletable(string $path): bool {
+        return $this->handleAvailability('isDeletable', $path);
+    }
+
+    public function isSharable(string $path): bool {
+        return $this->handleAvailability('isSharable', $path);
+    }
+
+    public function getPermissions(string $path): int {
+        return $this->handleAvailability('getPermissions', $path);
+    }
+
+    public function file_exists(string $path): bool {
+        if ($path === '') {
+            return true;
+        }
+        return $this->handleAvailability('file_exists', $path);
+    }
+
+    public function filemtime(string $path): int|false {
+        return $this->handleAvailability('filemtime', $path);
+    }
+
+    public function file_get_contents(string $path): string|false {
+        return $this->handleAvailability('file_get_contents', $path);
+    }
+
+    public function file_put_contents(string $path, mixed $data): int|float|false {
+        return $this->handleAvailability('file_put_contents', $path, $data);
+    }
+
+    public function unlink(string $path): bool {
+        return $this->handleAvailability('unlink', $path);
+    }
+
+    public function rename(string $source, string $target): bool {
+        return $this->handleAvailability('rename', $source, $target);
+    }
+
+    public function copy(string $source, string $target): bool {
+        return $this->handleAvailability('copy', $source, $target);
+    }
+
+    public function fopen(string $path, string $mode) {
+        return $this->handleAvailability('fopen', $path, $mode);
+    }
+
+    public function getMimeType(string $path): string|false {
+        return $this->handleAvailability('getMimeType', $path);
+    }
+
+    public function hash(string $type, string $path, bool $raw = false): string|false {
+        return $this->handleAvailability('hash', $type, $path, $raw);
+    }
+
+    public function free_space(string $path): int|float|false {
+        return $this->handleAvailability('free_space', $path);
+    }
+
+    public function touch(string $path, ?int $mtime = null): bool {
+        return $this->handleAvailability('touch', $path, $mtime);
+    }
+
+    public function getLocalFile(string $path): string|false {
+        return $this->handleAvailability('getLocalFile', $path);
+    }
+
+    public function hasUpdated(string $path, int $time): bool {
+        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;
+        }
+    }
+
+    public function getOwner(string $path): string|false {
+        try {
+            return parent::getOwner($path);
+        } catch (StorageNotAvailableException $e) {
+            $this->setUnavailable($e);
+            return false;
+        }
+    }
+
+    public function getETag(string $path): string|false {
+        return $this->handleAvailability('getETag', $path);
+    }
+
+    public function getDirectDownload(string $path): array|false {
+        return $this->handleAvailability('getDirectDownload', $path);
+    }
+
+    public function getDirectDownloadById(string $fileId): array|false {
+        return $this->handleAvailability('getDirectDownloadById', $fileId);
+    }
+
+    public function copyFromStorage(IStorage $sourceStorage, string $sourceInternalPath, string $targetInternalPath): bool {
+        return $this->handleAvailability('copyFromStorage', $sourceStorage, $sourceInternalPath, $targetInternalPath);
+    }
+
+    public function moveFromStorage(IStorage $sourceStorage, string $sourceInternalPath, string $targetInternalPath): bool {
+        return $this->handleAvailability('moveFromStorage', $sourceStorage, $sourceInternalPath, $targetInternalPath);
+    }
+
+    public function getMetaData(string $path): ?array {
+        $this->checkAvailability();
+        try {
+            return parent::getMetaData($path);
+        } catch (StorageNotAvailableException $e) {
+            $this->setUnavailable($e);
+            return null;
+        }
+    }
+
+    /**
+     * @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->available = false;
+        $this->getStorageCache()->setAvailability(false, $delay);
+        if ($e !== null) {
+            throw $e;
+        }
+    }
+
+
+
+    public function getDirectoryContent(string $directory): \Traversable {
+        $this->checkAvailability();
+        try {
+            return parent::getDirectoryContent($directory);
+        } catch (StorageNotAvailableException $e) {
+            $this->setUnavailable($e);
+            return new \EmptyIterator();
+        }
+    }
 }

lib/private/Files/Storage/FailedStorage.php

Indentation +159 added lines, -159 removed lines

@@ -16,180 +16,180 @@
  * Storage placeholder to represent a missing precondition, storage unavailable
  */
 class FailedStorage extends Common {
-	/** @var \Exception */
-	protected $e;
-
-	/**
-	 * @param array $parameters ['exception' => \Exception]
-	 */
-	public function __construct(array $parameters) {
-		$this->e = $parameters['exception'];
-		if (!$this->e) {
-			throw new \InvalidArgumentException('Missing "exception" argument in FailedStorage constructor');
-		}
-	}
-
-	public function getId(): string {
-		// we can't return anything sane here
-		return 'failedstorage';
-	}
-
-	public function mkdir(string $path): never {
-		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
-	}
-
-	public function rmdir(string $path): never {
-		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
-	}
-
-	public function opendir(string $path): never {
-		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
-	}
-
-	public function is_dir(string $path): never {
-		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
-	}
-
-	public function is_file(string $path): never {
-		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
-	}
-
-	public function stat(string $path): never {
-		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
-	}
-
-	public function filetype(string $path): never {
-		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
-	}
-
-	public function filesize(string $path): never {
-		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
-	}
-
-	public function isCreatable(string $path): never {
-		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
-	}
-
-	public function isReadable(string $path): never {
-		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
-	}
-
-	public function isUpdatable(string $path): never {
-		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
-	}
-
-	public function isDeletable(string $path): never {
-		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
-	}
-
-	public function isSharable(string $path): never {
-		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
-	}
-
-	public function getPermissions(string $path): never {
-		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
-	}
-
-	public function file_exists(string $path): never {
-		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
-	}
-
-	public function filemtime(string $path): never {
-		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
-	}
-
-	public function file_get_contents(string $path): never {
-		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
-	}
-
-	public function file_put_contents(string $path, mixed $data): never {
-		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
-	}
-
-	public function unlink(string $path): never {
-		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
-	}
-
-	public function rename(string $source, string $target): never {
-		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
-	}
-
-	public function copy(string $source, string $target): never {
-		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
-	}
-
-	public function fopen(string $path, string $mode): never {
-		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
-	}
-
-	public function getMimeType(string $path): never {
-		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
-	}
+    /** @var \Exception */
+    protected $e;
+
+    /**
+     * @param array $parameters ['exception' => \Exception]
+     */
+    public function __construct(array $parameters) {
+        $this->e = $parameters['exception'];
+        if (!$this->e) {
+            throw new \InvalidArgumentException('Missing "exception" argument in FailedStorage constructor');
+        }
+    }
+
+    public function getId(): string {
+        // we can't return anything sane here
+        return 'failedstorage';
+    }
+
+    public function mkdir(string $path): never {
+        throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+    }
+
+    public function rmdir(string $path): never {
+        throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+    }
+
+    public function opendir(string $path): never {
+        throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+    }
+
+    public function is_dir(string $path): never {
+        throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+    }
+
+    public function is_file(string $path): never {
+        throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+    }
+
+    public function stat(string $path): never {
+        throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+    }
+
+    public function filetype(string $path): never {
+        throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+    }
+
+    public function filesize(string $path): never {
+        throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+    }
+
+    public function isCreatable(string $path): never {
+        throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+    }
+
+    public function isReadable(string $path): never {
+        throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+    }
+
+    public function isUpdatable(string $path): never {
+        throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+    }
+
+    public function isDeletable(string $path): never {
+        throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+    }
+
+    public function isSharable(string $path): never {
+        throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+    }
+
+    public function getPermissions(string $path): never {
+        throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+    }
+
+    public function file_exists(string $path): never {
+        throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+    }
+
+    public function filemtime(string $path): never {
+        throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+    }
+
+    public function file_get_contents(string $path): never {
+        throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+    }
+
+    public function file_put_contents(string $path, mixed $data): never {
+        throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+    }
+
+    public function unlink(string $path): never {
+        throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+    }
+
+    public function rename(string $source, string $target): never {
+        throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+    }
+
+    public function copy(string $source, string $target): never {
+        throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+    }
+
+    public function fopen(string $path, string $mode): never {
+        throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+    }
+
+    public function getMimeType(string $path): never {
+        throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+    }
 
-	public function hash(string $type, string $path, bool $raw = false): never {
-		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
-	}
+    public function hash(string $type, string $path, bool $raw = false): never {
+        throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+    }
 
-	public function free_space(string $path): never {
-		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
-	}
+    public function free_space(string $path): never {
+        throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+    }
 
-	public function touch(string $path, ?int $mtime = null): never {
-		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
-	}
+    public function touch(string $path, ?int $mtime = null): never {
+        throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+    }
 
-	public function getLocalFile(string $path): never {
-		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
-	}
+    public function getLocalFile(string $path): never {
+        throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+    }
 
-	public function hasUpdated(string $path, int $time): never {
-		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
-	}
+    public function hasUpdated(string $path, int $time): never {
+        throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+    }
 
-	public function getETag(string $path): never {
-		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
-	}
+    public function getETag(string $path): never {
+        throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+    }
 
-	public function getDirectDownload(string $path): never {
-		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
-	}
+    public function getDirectDownload(string $path): never {
+        throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+    }
 
-	public function getDirectDownloadById(string $fileId): never {
-		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
-	}
+    public function getDirectDownloadById(string $fileId): never {
+        throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+    }
 
-	public function verifyPath(string $path, string $fileName): void {
-	}
+    public function verifyPath(string $path, string $fileName): void {
+    }
 
-	public function copyFromStorage(IStorage $sourceStorage, string $sourceInternalPath, string $targetInternalPath, bool $preserveMtime = false): never {
-		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
-	}
+    public function copyFromStorage(IStorage $sourceStorage, string $sourceInternalPath, string $targetInternalPath, bool $preserveMtime = false): never {
+        throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+    }
 
-	public function moveFromStorage(IStorage $sourceStorage, string $sourceInternalPath, string $targetInternalPath): never {
-		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
-	}
+    public function moveFromStorage(IStorage $sourceStorage, string $sourceInternalPath, string $targetInternalPath): never {
+        throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+    }
 
-	public function acquireLock(string $path, int $type, ILockingProvider $provider): never {
-		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
-	}
+    public function acquireLock(string $path, int $type, ILockingProvider $provider): never {
+        throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+    }
 
-	public function releaseLock(string $path, int $type, ILockingProvider $provider): never {
-		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
-	}
+    public function releaseLock(string $path, int $type, ILockingProvider $provider): never {
+        throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+    }
 
-	public function changeLock(string $path, int $type, ILockingProvider $provider): never {
-		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
-	}
+    public function changeLock(string $path, int $type, ILockingProvider $provider): never {
+        throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+    }
 
-	public function getAvailability(): never {
-		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
-	}
+    public function getAvailability(): never {
+        throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+    }
 
-	public function setAvailability(bool $isAvailable): never {
-		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
-	}
+    public function setAvailability(bool $isAvailable): never {
+        throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+    }
 
-	public function getCache(string $path = '', ?IStorage $storage = null): FailedCache {
-		return new FailedCache();
-	}
+    public function getCache(string $path = '', ?IStorage $storage = null): FailedCache {
+        return new FailedCache();
+    }
 }

lib/private/Files/Storage/Common.php

Indentation +715 added lines, -715 removed lines

@@ -53,719 +53,719 @@
  * in classes which extend it, e.g. $this->stat() .
  */
 abstract class Common implements Storage, ILockingStorage, IWriteStreamStorage, IConstructableStorage {
-	use LocalTempFileTrait;
-
-	protected ?Cache $cache = null;
-	protected ?Scanner $scanner = null;
-	protected ?Watcher $watcher = null;
-	protected ?Propagator $propagator = null;
-	protected $storageCache;
-	protected ?Updater $updater = null;
-
-	protected array $mountOptions = [];
-	protected $owner = null;
-
-	private ?bool $shouldLogLocks = null;
-	private ?LoggerInterface $logger = null;
-	private ?IFilenameValidator $filenameValidator = null;
-
-	public function __construct(array $parameters) {
-	}
-
-	protected function remove(string $path): bool {
-		if ($this->file_exists($path)) {
-			if ($this->is_dir($path)) {
-				return $this->rmdir($path);
-			} elseif ($this->is_file($path)) {
-				return $this->unlink($path);
-			}
-		}
-		return false;
-	}
-
-	public function is_dir(string $path): bool {
-		return $this->filetype($path) === 'dir';
-	}
-
-	public function is_file(string $path): bool {
-		return $this->filetype($path) === 'file';
-	}
-
-	public function filesize(string $path): int|float|false {
-		if ($this->is_dir($path)) {
-			return 0; //by definition
-		} else {
-			$stat = $this->stat($path);
-			return isset($stat['size']) ? $stat['size'] : 0;
-		}
-	}
-
-	public function isReadable(string $path): bool {
-		// at least check whether it exists
-		// subclasses might want to implement this more thoroughly
-		return $this->file_exists($path);
-	}
-
-	public function isUpdatable(string $path): bool {
-		// 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(string $path): bool {
-		if ($this->is_dir($path) && $this->isUpdatable($path)) {
-			return true;
-		}
-		return false;
-	}
-
-	public function isDeletable(string $path): bool {
-		if ($path === '' || $path === '/') {
-			return $this->isUpdatable($path);
-		}
-		$parent = dirname($path);
-		return $this->isUpdatable($parent) && $this->isUpdatable($path);
-	}
-
-	public function isSharable(string $path): bool {
-		return $this->isReadable($path);
-	}
-
-	public function getPermissions(string $path): int {
-		$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(string $path): int|false {
-		$stat = $this->stat($path);
-		if (isset($stat['mtime']) && $stat['mtime'] > 0) {
-			return $stat['mtime'];
-		} else {
-			return 0;
-		}
-	}
-
-	public function file_get_contents(string $path): string|false {
-		$handle = $this->fopen($path, 'r');
-		if (!$handle) {
-			return false;
-		}
-		$data = stream_get_contents($handle);
-		fclose($handle);
-		return $data;
-	}
-
-	public function file_put_contents(string $path, mixed $data): int|float|false {
-		$handle = $this->fopen($path, 'w');
-		if (!$handle) {
-			return false;
-		}
-		$this->removeCachedFile($path);
-		$count = fwrite($handle, $data);
-		fclose($handle);
-		return $count;
-	}
-
-	public function rename(string $source, string $target): bool {
-		$this->remove($target);
-
-		$this->removeCachedFile($source);
-		return $this->copy($source, $target) && $this->remove($source);
-	}
-
-	public function copy(string $source, string $target): bool {
-		if ($this->is_dir($source)) {
-			$this->remove($target);
-			$dir = $this->opendir($source);
-			$this->mkdir($target);
-			while (($file = readdir($dir)) !== false) {
-				if (!Filesystem::isIgnoredDir($file)) {
-					if (!$this->copy($source . '/' . $file, $target . '/' . $file)) {
-						closedir($dir);
-						return false;
-					}
-				}
-			}
-			closedir($dir);
-			return true;
-		} else {
-			$sourceStream = $this->fopen($source, 'r');
-			$targetStream = $this->fopen($target, 'w');
-			[, $result] = Files::streamCopy($sourceStream, $targetStream, true);
-			if (!$result) {
-				Server::get(LoggerInterface::class)->warning("Failed to write data while copying $source to $target");
-			}
-			$this->removeCachedFile($target);
-			return $result;
-		}
-	}
-
-	public function getMimeType(string $path): string|false {
-		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(string $type, string $path, bool $raw = false): string|false {
-		$fh = $this->fopen($path, 'rb');
-		if (!$fh) {
-			return false;
-		}
-		$ctx = hash_init($type);
-		hash_update_stream($ctx, $fh);
-		fclose($fh);
-		return hash_final($ctx, $raw);
-	}
-
-	public function getLocalFile(string $path): string|false {
-		return $this->getCachedFile($path);
-	}
-
-	private function addLocalFolder(string $path, string $target): void {
-		$dh = $this->opendir($path);
-		if (is_resource($dh)) {
-			while (($file = readdir($dh)) !== false) {
-				if (!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);
-					}
-				}
-			}
-		}
-	}
-
-	protected function searchInDir(string $query, string $dir = ''): array {
-		$files = [];
-		$dh = $this->opendir($dir);
-		if (is_resource($dh)) {
-			while (($item = readdir($dh)) !== false) {
-				if (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;
-	}
-
-	/**
-	 * @inheritDoc
-	 * 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
-	 * Nextcloud filesystem.
-	 */
-	public function hasUpdated(string $path, int $time): bool {
-		return $this->filemtime($path) > $time;
-	}
-
-	protected function getCacheDependencies(): CacheDependencies {
-		static $dependencies = null;
-		if (!$dependencies) {
-			$dependencies = Server::get(CacheDependencies::class);
-		}
-		return $dependencies;
-	}
-
-	public function getCache(string $path = '', ?IStorage $storage = null): ICache {
-		if (!$storage) {
-			$storage = $this;
-		}
-		/** @var self $storage */
-		if (!isset($storage->cache)) {
-			$storage->cache = new Cache($storage, $this->getCacheDependencies());
-		}
-		return $storage->cache;
-	}
-
-	public function getScanner(string $path = '', ?IStorage $storage = null): IScanner {
-		if (!$storage) {
-			$storage = $this;
-		}
-		if (!$storage->instanceOfStorage(self::class)) {
-			throw new \InvalidArgumentException('Storage is not of the correct class');
-		}
-		if (!isset($storage->scanner)) {
-			$storage->scanner = new Scanner($storage);
-		}
-		return $storage->scanner;
-	}
-
-	public function getWatcher(string $path = '', ?IStorage $storage = null): IWatcher {
-		if (!$storage) {
-			$storage = $this;
-		}
-		if (!isset($this->watcher)) {
-			$this->watcher = new Watcher($storage);
-			$globalPolicy = Server::get(IConfig::class)->getSystemValueInt('filesystem_check_changes', Watcher::CHECK_NEVER);
-			$this->watcher->setPolicy((int)$this->getMountOption('filesystem_check_changes', $globalPolicy));
-		}
-		return $this->watcher;
-	}
-
-	public function getPropagator(?IStorage $storage = null): IPropagator {
-		if (!$storage) {
-			$storage = $this;
-		}
-		if (!$storage->instanceOfStorage(self::class)) {
-			throw new \InvalidArgumentException('Storage is not of the correct class');
-		}
-		/** @var self $storage */
-		if (!isset($storage->propagator)) {
-			$config = Server::get(IConfig::class);
-			$storage->propagator = new Propagator($storage, \OC::$server->getDatabaseConnection(), ['appdata_' . $config->getSystemValueString('instanceid')]);
-		}
-		return $storage->propagator;
-	}
-
-	public function getUpdater(?IStorage $storage = null): IUpdater {
-		if (!$storage) {
-			$storage = $this;
-		}
-		if (!$storage->instanceOfStorage(self::class)) {
-			throw new \InvalidArgumentException('Storage is not of the correct class');
-		}
-		/** @var self $storage */
-		if (!isset($storage->updater)) {
-			$storage->updater = new Updater($storage);
-		}
-		return $storage->updater;
-	}
-
-	public function getStorageCache(?IStorage $storage = null): \OC\Files\Cache\Storage {
-		/** @var Cache $cache */
-		$cache = $this->getCache(storage: $storage);
-		return $cache->getStorageCache();
-	}
-
-	public function getOwner(string $path): string|false {
-		if ($this->owner === null) {
-			$this->owner = \OC_User::getUser();
-		}
-
-		return $this->owner;
-	}
-
-	public function getETag(string $path): string|false {
-		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(string $path): string {
-		if (strlen($path) == 0 || $path[0] != '/') {
-			$path = '/' . $path;
-		}
-
-		$output = [];
-		foreach (explode('/', $path) as $chunk) {
-			if ($chunk == '..') {
-				array_pop($output);
-			} elseif ($chunk == '.') {
-			} else {
-				$output[] = $chunk;
-			}
-		}
-		return implode('/', $output);
-	}
-
-	/**
-	 * Test a storage for availability
-	 */
-	public function test(): bool {
-		try {
-			if ($this->stat('')) {
-				return true;
-			}
-			Server::get(LoggerInterface::class)->info('External storage not available: stat() failed');
-			return false;
-		} catch (\Exception $e) {
-			Server::get(LoggerInterface::class)->warning(
-				'External storage not available: ' . $e->getMessage(),
-				['exception' => $e]
-			);
-			return false;
-		}
-	}
-
-	public function free_space(string $path): int|float|false {
-		return \OCP\Files\FileInfo::SPACE_UNKNOWN;
-	}
-
-	public function isLocal(): bool {
-		// 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
-	 */
-	public function instanceOfStorage(string $class): bool {
-		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);
-	}
-
-	#[Override]
-	public function getDirectDownload(string $path): array|false {
-		return false;
-	}
-
-	#[Override]
-	public function getDirectDownloadById(string $fileId): array|false {
-		return false;
-	}
-
-	public function verifyPath(string $path, string $fileName): void {
-		$this->getFilenameValidator()
-			->validateFilename($fileName);
-
-		// verify also the path is valid
-		if ($path && $path !== '/' && $path !== '.') {
-			try {
-				$this->verifyPath(dirname($path), basename($path));
-			} catch (InvalidPathException $e) {
-				// Ignore invalid file type exceptions on directories
-				if ($e->getCode() !== FilenameValidator::INVALID_FILE_TYPE) {
-					$l = \OCP\Util::getL10N('lib');
-					throw new InvalidPathException($l->t('Invalid parent path'), previous: $e);
-				}
-			}
-		}
-	}
-
-	/**
-	 * Get the filename validator
-	 * (cached for performance)
-	 */
-	protected function getFilenameValidator(): IFilenameValidator {
-		if ($this->filenameValidator === null) {
-			$this->filenameValidator = Server::get(IFilenameValidator::class);
-		}
-		return $this->filenameValidator;
-	}
-
-	public function setMountOptions(array $options): void {
-		$this->mountOptions = $options;
-	}
-
-	public function getMountOption(string $name, mixed $default = null): mixed {
-		return $this->mountOptions[$name] ?? $default;
-	}
-
-	public function copyFromStorage(IStorage $sourceStorage, string $sourceInternalPath, string $targetInternalPath, bool $preserveMtime = false): bool {
-		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)) {
-				$result = true;
-				while ($result && ($file = readdir($dh)) !== false) {
-					if (!Filesystem::isIgnoredDir($file)) {
-						$result &= $this->copyFromStorage($sourceStorage, $sourceInternalPath . '/' . $file, $targetInternalPath . '/' . $file);
-					}
-				}
-			}
-		} else {
-			$source = $sourceStorage->fopen($sourceInternalPath, 'r');
-			$result = false;
-			if ($source) {
-				try {
-					$this->writeStream($targetInternalPath, $source);
-					$result = true;
-				} catch (\Exception $e) {
-					Server::get(LoggerInterface::class)->warning('Failed to copy stream to storage', ['exception' => $e]);
-				}
-			}
-
-			if ($result && $preserveMtime) {
-				$mtime = $sourceStorage->filemtime($sourceInternalPath);
-				$this->touch($targetInternalPath, is_int($mtime) ? $mtime : null);
-			}
-
-			if (!$result) {
-				// delete partially written target file
-				$this->unlink($targetInternalPath);
-				// delete cache entry that was created by fopen
-				$this->getCache()->remove($targetInternalPath);
-			}
-		}
-		return (bool)$result;
-	}
-
-	/**
-	 * Check if a storage is the same as the current one, including wrapped storages
-	 */
-	private function isSameStorage(IStorage $storage): bool {
-		while ($storage->instanceOfStorage(Wrapper::class)) {
-			/**
-			 * @var Wrapper $storage
-			 */
-			$storage = $storage->getWrapperStorage();
-		}
-
-		return $storage === $this;
-	}
-
-	public function moveFromStorage(IStorage $sourceStorage, string $sourceInternalPath, string $targetInternalPath): bool {
-		if (
-			!$sourceStorage->instanceOfStorage(Encryption::class)
-			&& $this->isSameStorage($sourceStorage)
-		) {
-			// resolve any jailed paths
-			while ($sourceStorage->instanceOfStorage(Jail::class)) {
-				/**
-				 * @var Jail $sourceStorage
-				 */
-				$sourceInternalPath = $sourceStorage->getUnjailedPath($sourceInternalPath);
-				$sourceStorage = $sourceStorage->getUnjailedStorage();
-			}
-
-			return $this->rename($sourceInternalPath, $targetInternalPath);
-		}
-
-		if (!$sourceStorage->isDeletable($sourceInternalPath)) {
-			return false;
-		}
-
-		$result = $this->copyFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath, true);
-		if ($result) {
-			if ($sourceStorage->instanceOfStorage(ObjectStoreStorage::class)) {
-				/** @var ObjectStoreStorage $sourceStorage */
-				$sourceStorage->setPreserveCacheOnDelete(true);
-			}
-			try {
-				if ($sourceStorage->is_dir($sourceInternalPath)) {
-					$result = $sourceStorage->rmdir($sourceInternalPath);
-				} else {
-					$result = $sourceStorage->unlink($sourceInternalPath);
-				}
-			} finally {
-				if ($sourceStorage->instanceOfStorage(ObjectStoreStorage::class)) {
-					/** @var ObjectStoreStorage $sourceStorage */
-					$sourceStorage->setPreserveCacheOnDelete(false);
-				}
-			}
-		}
-		return $result;
-	}
-
-	public function getMetaData(string $path): ?array {
-		if (Filesystem::isFileBlacklisted($path)) {
-			throw new ForbiddenException('Invalid path: ' . $path, false);
-		}
-
-		$permissions = $this->getPermissions($path);
-		if (!$permissions & \OCP\Constants::PERMISSION_READ) {
-			//can't read, nothing we can do
-			return null;
-		}
-
-		$data = [];
-		$data['mimetype'] = $this->getMimeType($path);
-		$data['mtime'] = $this->filemtime($path);
-		if ($data['mtime'] === false) {
-			$data['mtime'] = time();
-		}
-		if ($data['mimetype'] == 'httpd/unix-directory') {
-			$data['size'] = -1; //unknown
-		} else {
-			$data['size'] = $this->filesize($path);
-		}
-		$data['etag'] = $this->getETag($path);
-		$data['storage_mtime'] = $data['mtime'];
-		$data['permissions'] = $permissions;
-		$data['name'] = basename($path);
-
-		return $data;
-	}
-
-	public function acquireLock(string $path, int $type, ILockingProvider $provider): void {
-		$logger = $this->getLockLogger();
-		if ($logger) {
-			$typeString = ($type === ILockingProvider::LOCK_SHARED) ? 'shared' : 'exclusive';
-			$logger->info(
-				sprintf(
-					'acquire %s lock on "%s" on storage "%s"',
-					$typeString,
-					$path,
-					$this->getId()
-				),
-				[
-					'app' => 'locking',
-				]
-			);
-		}
-		try {
-			$provider->acquireLock('files/' . md5($this->getId() . '::' . trim($path, '/')), $type, $this->getId() . '::' . $path);
-		} catch (LockedException $e) {
-			$e = new LockedException($e->getPath(), $e, $e->getExistingLock(), $path);
-			if ($logger) {
-				$logger->info($e->getMessage(), ['exception' => $e]);
-			}
-			throw $e;
-		}
-	}
-
-	public function releaseLock(string $path, int $type, ILockingProvider $provider): void {
-		$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) {
-			$e = new LockedException($e->getPath(), $e, $e->getExistingLock(), $path);
-			if ($logger) {
-				$logger->info($e->getMessage(), ['exception' => $e]);
-			}
-			throw $e;
-		}
-	}
-
-	public function changeLock(string $path, int $type, ILockingProvider $provider): void {
-		$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) {
-			$e = new LockedException($e->getPath(), $e, $e->getExistingLock(), $path);
-			if ($logger) {
-				$logger->info($e->getMessage(), ['exception' => $e]);
-			}
-			throw $e;
-		}
-	}
-
-	private function getLockLogger(): ?LoggerInterface {
-		if (is_null($this->shouldLogLocks)) {
-			$this->shouldLogLocks = Server::get(IConfig::class)->getSystemValueBool('filelocking.debug', false);
-			$this->logger = $this->shouldLogLocks ? Server::get(LoggerInterface::class) : null;
-		}
-		return $this->logger;
-	}
-
-	/**
-	 * @return array{available: bool, last_checked: int}
-	 */
-	public function getAvailability(): array {
-		return $this->getStorageCache()->getAvailability();
-	}
-
-	public function setAvailability(bool $isAvailable): void {
-		$this->getStorageCache()->setAvailability($isAvailable);
-	}
-
-	public function setOwner(?string $user): void {
-		$this->owner = $user;
-	}
-
-	public function needsPartFile(): bool {
-		return true;
-	}
-
-	public function writeStream(string $path, $stream, ?int $size = null): int {
-		$target = $this->fopen($path, 'w');
-		if (!$target) {
-			throw new GenericFileException("Failed to open $path for writing");
-		}
-		try {
-			[$count, $result] = Files::streamCopy($stream, $target, true);
-			if (!$result) {
-				throw new GenericFileException('Failed to copy stream');
-			}
-		} finally {
-			fclose($target);
-			fclose($stream);
-		}
-		return $count;
-	}
-
-	public function getDirectoryContent(string $directory): \Traversable {
-		$dh = $this->opendir($directory);
-
-		if ($dh === false) {
-			throw new StorageNotAvailableException('Directory listing failed');
-		}
-
-		if (is_resource($dh)) {
-			$basePath = rtrim($directory, '/');
-			while (($file = readdir($dh)) !== false) {
-				if (!Filesystem::isIgnoredDir($file)) {
-					$childPath = $basePath . '/' . trim($file, '/');
-					$metadata = $this->getMetaData($childPath);
-					if ($metadata !== null) {
-						yield $metadata;
-					}
-				}
-			}
-		}
-	}
+    use LocalTempFileTrait;
+
+    protected ?Cache $cache = null;
+    protected ?Scanner $scanner = null;
+    protected ?Watcher $watcher = null;
+    protected ?Propagator $propagator = null;
+    protected $storageCache;
+    protected ?Updater $updater = null;
+
+    protected array $mountOptions = [];
+    protected $owner = null;
+
+    private ?bool $shouldLogLocks = null;
+    private ?LoggerInterface $logger = null;
+    private ?IFilenameValidator $filenameValidator = null;
+
+    public function __construct(array $parameters) {
+    }
+
+    protected function remove(string $path): bool {
+        if ($this->file_exists($path)) {
+            if ($this->is_dir($path)) {
+                return $this->rmdir($path);
+            } elseif ($this->is_file($path)) {
+                return $this->unlink($path);
+            }
+        }
+        return false;
+    }
+
+    public function is_dir(string $path): bool {
+        return $this->filetype($path) === 'dir';
+    }
+
+    public function is_file(string $path): bool {
+        return $this->filetype($path) === 'file';
+    }
+
+    public function filesize(string $path): int|float|false {
+        if ($this->is_dir($path)) {
+            return 0; //by definition
+        } else {
+            $stat = $this->stat($path);
+            return isset($stat['size']) ? $stat['size'] : 0;
+        }
+    }
+
+    public function isReadable(string $path): bool {
+        // at least check whether it exists
+        // subclasses might want to implement this more thoroughly
+        return $this->file_exists($path);
+    }
+
+    public function isUpdatable(string $path): bool {
+        // 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(string $path): bool {
+        if ($this->is_dir($path) && $this->isUpdatable($path)) {
+            return true;
+        }
+        return false;
+    }
+
+    public function isDeletable(string $path): bool {
+        if ($path === '' || $path === '/') {
+            return $this->isUpdatable($path);
+        }
+        $parent = dirname($path);
+        return $this->isUpdatable($parent) && $this->isUpdatable($path);
+    }
+
+    public function isSharable(string $path): bool {
+        return $this->isReadable($path);
+    }
+
+    public function getPermissions(string $path): int {
+        $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(string $path): int|false {
+        $stat = $this->stat($path);
+        if (isset($stat['mtime']) && $stat['mtime'] > 0) {
+            return $stat['mtime'];
+        } else {
+            return 0;
+        }
+    }
+
+    public function file_get_contents(string $path): string|false {
+        $handle = $this->fopen($path, 'r');
+        if (!$handle) {
+            return false;
+        }
+        $data = stream_get_contents($handle);
+        fclose($handle);
+        return $data;
+    }
+
+    public function file_put_contents(string $path, mixed $data): int|float|false {
+        $handle = $this->fopen($path, 'w');
+        if (!$handle) {
+            return false;
+        }
+        $this->removeCachedFile($path);
+        $count = fwrite($handle, $data);
+        fclose($handle);
+        return $count;
+    }
+
+    public function rename(string $source, string $target): bool {
+        $this->remove($target);
+
+        $this->removeCachedFile($source);
+        return $this->copy($source, $target) && $this->remove($source);
+    }
+
+    public function copy(string $source, string $target): bool {
+        if ($this->is_dir($source)) {
+            $this->remove($target);
+            $dir = $this->opendir($source);
+            $this->mkdir($target);
+            while (($file = readdir($dir)) !== false) {
+                if (!Filesystem::isIgnoredDir($file)) {
+                    if (!$this->copy($source . '/' . $file, $target . '/' . $file)) {
+                        closedir($dir);
+                        return false;
+                    }
+                }
+            }
+            closedir($dir);
+            return true;
+        } else {
+            $sourceStream = $this->fopen($source, 'r');
+            $targetStream = $this->fopen($target, 'w');
+            [, $result] = Files::streamCopy($sourceStream, $targetStream, true);
+            if (!$result) {
+                Server::get(LoggerInterface::class)->warning("Failed to write data while copying $source to $target");
+            }
+            $this->removeCachedFile($target);
+            return $result;
+        }
+    }
+
+    public function getMimeType(string $path): string|false {
+        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(string $type, string $path, bool $raw = false): string|false {
+        $fh = $this->fopen($path, 'rb');
+        if (!$fh) {
+            return false;
+        }
+        $ctx = hash_init($type);
+        hash_update_stream($ctx, $fh);
+        fclose($fh);
+        return hash_final($ctx, $raw);
+    }
+
+    public function getLocalFile(string $path): string|false {
+        return $this->getCachedFile($path);
+    }
+
+    private function addLocalFolder(string $path, string $target): void {
+        $dh = $this->opendir($path);
+        if (is_resource($dh)) {
+            while (($file = readdir($dh)) !== false) {
+                if (!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);
+                    }
+                }
+            }
+        }
+    }
+
+    protected function searchInDir(string $query, string $dir = ''): array {
+        $files = [];
+        $dh = $this->opendir($dir);
+        if (is_resource($dh)) {
+            while (($item = readdir($dh)) !== false) {
+                if (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;
+    }
+
+    /**
+     * @inheritDoc
+     * 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
+     * Nextcloud filesystem.
+     */
+    public function hasUpdated(string $path, int $time): bool {
+        return $this->filemtime($path) > $time;
+    }
+
+    protected function getCacheDependencies(): CacheDependencies {
+        static $dependencies = null;
+        if (!$dependencies) {
+            $dependencies = Server::get(CacheDependencies::class);
+        }
+        return $dependencies;
+    }
+
+    public function getCache(string $path = '', ?IStorage $storage = null): ICache {
+        if (!$storage) {
+            $storage = $this;
+        }
+        /** @var self $storage */
+        if (!isset($storage->cache)) {
+            $storage->cache = new Cache($storage, $this->getCacheDependencies());
+        }
+        return $storage->cache;
+    }
+
+    public function getScanner(string $path = '', ?IStorage $storage = null): IScanner {
+        if (!$storage) {
+            $storage = $this;
+        }
+        if (!$storage->instanceOfStorage(self::class)) {
+            throw new \InvalidArgumentException('Storage is not of the correct class');
+        }
+        if (!isset($storage->scanner)) {
+            $storage->scanner = new Scanner($storage);
+        }
+        return $storage->scanner;
+    }
+
+    public function getWatcher(string $path = '', ?IStorage $storage = null): IWatcher {
+        if (!$storage) {
+            $storage = $this;
+        }
+        if (!isset($this->watcher)) {
+            $this->watcher = new Watcher($storage);
+            $globalPolicy = Server::get(IConfig::class)->getSystemValueInt('filesystem_check_changes', Watcher::CHECK_NEVER);
+            $this->watcher->setPolicy((int)$this->getMountOption('filesystem_check_changes', $globalPolicy));
+        }
+        return $this->watcher;
+    }
+
+    public function getPropagator(?IStorage $storage = null): IPropagator {
+        if (!$storage) {
+            $storage = $this;
+        }
+        if (!$storage->instanceOfStorage(self::class)) {
+            throw new \InvalidArgumentException('Storage is not of the correct class');
+        }
+        /** @var self $storage */
+        if (!isset($storage->propagator)) {
+            $config = Server::get(IConfig::class);
+            $storage->propagator = new Propagator($storage, \OC::$server->getDatabaseConnection(), ['appdata_' . $config->getSystemValueString('instanceid')]);
+        }
+        return $storage->propagator;
+    }
+
+    public function getUpdater(?IStorage $storage = null): IUpdater {
+        if (!$storage) {
+            $storage = $this;
+        }
+        if (!$storage->instanceOfStorage(self::class)) {
+            throw new \InvalidArgumentException('Storage is not of the correct class');
+        }
+        /** @var self $storage */
+        if (!isset($storage->updater)) {
+            $storage->updater = new Updater($storage);
+        }
+        return $storage->updater;
+    }
+
+    public function getStorageCache(?IStorage $storage = null): \OC\Files\Cache\Storage {
+        /** @var Cache $cache */
+        $cache = $this->getCache(storage: $storage);
+        return $cache->getStorageCache();
+    }
+
+    public function getOwner(string $path): string|false {
+        if ($this->owner === null) {
+            $this->owner = \OC_User::getUser();
+        }
+
+        return $this->owner;
+    }
+
+    public function getETag(string $path): string|false {
+        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(string $path): string {
+        if (strlen($path) == 0 || $path[0] != '/') {
+            $path = '/' . $path;
+        }
+
+        $output = [];
+        foreach (explode('/', $path) as $chunk) {
+            if ($chunk == '..') {
+                array_pop($output);
+            } elseif ($chunk == '.') {
+            } else {
+                $output[] = $chunk;
+            }
+        }
+        return implode('/', $output);
+    }
+
+    /**
+     * Test a storage for availability
+     */
+    public function test(): bool {
+        try {
+            if ($this->stat('')) {
+                return true;
+            }
+            Server::get(LoggerInterface::class)->info('External storage not available: stat() failed');
+            return false;
+        } catch (\Exception $e) {
+            Server::get(LoggerInterface::class)->warning(
+                'External storage not available: ' . $e->getMessage(),
+                ['exception' => $e]
+            );
+            return false;
+        }
+    }
+
+    public function free_space(string $path): int|float|false {
+        return \OCP\Files\FileInfo::SPACE_UNKNOWN;
+    }
+
+    public function isLocal(): bool {
+        // 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
+     */
+    public function instanceOfStorage(string $class): bool {
+        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);
+    }
+
+    #[Override]
+    public function getDirectDownload(string $path): array|false {
+        return false;
+    }
+
+    #[Override]
+    public function getDirectDownloadById(string $fileId): array|false {
+        return false;
+    }
+
+    public function verifyPath(string $path, string $fileName): void {
+        $this->getFilenameValidator()
+            ->validateFilename($fileName);
+
+        // verify also the path is valid
+        if ($path && $path !== '/' && $path !== '.') {
+            try {
+                $this->verifyPath(dirname($path), basename($path));
+            } catch (InvalidPathException $e) {
+                // Ignore invalid file type exceptions on directories
+                if ($e->getCode() !== FilenameValidator::INVALID_FILE_TYPE) {
+                    $l = \OCP\Util::getL10N('lib');
+                    throw new InvalidPathException($l->t('Invalid parent path'), previous: $e);
+                }
+            }
+        }
+    }
+
+    /**
+     * Get the filename validator
+     * (cached for performance)
+     */
+    protected function getFilenameValidator(): IFilenameValidator {
+        if ($this->filenameValidator === null) {
+            $this->filenameValidator = Server::get(IFilenameValidator::class);
+        }
+        return $this->filenameValidator;
+    }
+
+    public function setMountOptions(array $options): void {
+        $this->mountOptions = $options;
+    }
+
+    public function getMountOption(string $name, mixed $default = null): mixed {
+        return $this->mountOptions[$name] ?? $default;
+    }
+
+    public function copyFromStorage(IStorage $sourceStorage, string $sourceInternalPath, string $targetInternalPath, bool $preserveMtime = false): bool {
+        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)) {
+                $result = true;
+                while ($result && ($file = readdir($dh)) !== false) {
+                    if (!Filesystem::isIgnoredDir($file)) {
+                        $result &= $this->copyFromStorage($sourceStorage, $sourceInternalPath . '/' . $file, $targetInternalPath . '/' . $file);
+                    }
+                }
+            }
+        } else {
+            $source = $sourceStorage->fopen($sourceInternalPath, 'r');
+            $result = false;
+            if ($source) {
+                try {
+                    $this->writeStream($targetInternalPath, $source);
+                    $result = true;
+                } catch (\Exception $e) {
+                    Server::get(LoggerInterface::class)->warning('Failed to copy stream to storage', ['exception' => $e]);
+                }
+            }
+
+            if ($result && $preserveMtime) {
+                $mtime = $sourceStorage->filemtime($sourceInternalPath);
+                $this->touch($targetInternalPath, is_int($mtime) ? $mtime : null);
+            }
+
+            if (!$result) {
+                // delete partially written target file
+                $this->unlink($targetInternalPath);
+                // delete cache entry that was created by fopen
+                $this->getCache()->remove($targetInternalPath);
+            }
+        }
+        return (bool)$result;
+    }
+
+    /**
+     * Check if a storage is the same as the current one, including wrapped storages
+     */
+    private function isSameStorage(IStorage $storage): bool {
+        while ($storage->instanceOfStorage(Wrapper::class)) {
+            /**
+             * @var Wrapper $storage
+             */
+            $storage = $storage->getWrapperStorage();
+        }
+
+        return $storage === $this;
+    }
+
+    public function moveFromStorage(IStorage $sourceStorage, string $sourceInternalPath, string $targetInternalPath): bool {
+        if (
+            !$sourceStorage->instanceOfStorage(Encryption::class)
+            && $this->isSameStorage($sourceStorage)
+        ) {
+            // resolve any jailed paths
+            while ($sourceStorage->instanceOfStorage(Jail::class)) {
+                /**
+                 * @var Jail $sourceStorage
+                 */
+                $sourceInternalPath = $sourceStorage->getUnjailedPath($sourceInternalPath);
+                $sourceStorage = $sourceStorage->getUnjailedStorage();
+            }
+
+            return $this->rename($sourceInternalPath, $targetInternalPath);
+        }
+
+        if (!$sourceStorage->isDeletable($sourceInternalPath)) {
+            return false;
+        }
+
+        $result = $this->copyFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath, true);
+        if ($result) {
+            if ($sourceStorage->instanceOfStorage(ObjectStoreStorage::class)) {
+                /** @var ObjectStoreStorage $sourceStorage */
+                $sourceStorage->setPreserveCacheOnDelete(true);
+            }
+            try {
+                if ($sourceStorage->is_dir($sourceInternalPath)) {
+                    $result = $sourceStorage->rmdir($sourceInternalPath);
+                } else {
+                    $result = $sourceStorage->unlink($sourceInternalPath);
+                }
+            } finally {
+                if ($sourceStorage->instanceOfStorage(ObjectStoreStorage::class)) {
+                    /** @var ObjectStoreStorage $sourceStorage */
+                    $sourceStorage->setPreserveCacheOnDelete(false);
+                }
+            }
+        }
+        return $result;
+    }
+
+    public function getMetaData(string $path): ?array {
+        if (Filesystem::isFileBlacklisted($path)) {
+            throw new ForbiddenException('Invalid path: ' . $path, false);
+        }
+
+        $permissions = $this->getPermissions($path);
+        if (!$permissions & \OCP\Constants::PERMISSION_READ) {
+            //can't read, nothing we can do
+            return null;
+        }
+
+        $data = [];
+        $data['mimetype'] = $this->getMimeType($path);
+        $data['mtime'] = $this->filemtime($path);
+        if ($data['mtime'] === false) {
+            $data['mtime'] = time();
+        }
+        if ($data['mimetype'] == 'httpd/unix-directory') {
+            $data['size'] = -1; //unknown
+        } else {
+            $data['size'] = $this->filesize($path);
+        }
+        $data['etag'] = $this->getETag($path);
+        $data['storage_mtime'] = $data['mtime'];
+        $data['permissions'] = $permissions;
+        $data['name'] = basename($path);
+
+        return $data;
+    }
+
+    public function acquireLock(string $path, int $type, ILockingProvider $provider): void {
+        $logger = $this->getLockLogger();
+        if ($logger) {
+            $typeString = ($type === ILockingProvider::LOCK_SHARED) ? 'shared' : 'exclusive';
+            $logger->info(
+                sprintf(
+                    'acquire %s lock on "%s" on storage "%s"',
+                    $typeString,
+                    $path,
+                    $this->getId()
+                ),
+                [
+                    'app' => 'locking',
+                ]
+            );
+        }
+        try {
+            $provider->acquireLock('files/' . md5($this->getId() . '::' . trim($path, '/')), $type, $this->getId() . '::' . $path);
+        } catch (LockedException $e) {
+            $e = new LockedException($e->getPath(), $e, $e->getExistingLock(), $path);
+            if ($logger) {
+                $logger->info($e->getMessage(), ['exception' => $e]);
+            }
+            throw $e;
+        }
+    }
+
+    public function releaseLock(string $path, int $type, ILockingProvider $provider): void {
+        $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) {
+            $e = new LockedException($e->getPath(), $e, $e->getExistingLock(), $path);
+            if ($logger) {
+                $logger->info($e->getMessage(), ['exception' => $e]);
+            }
+            throw $e;
+        }
+    }
+
+    public function changeLock(string $path, int $type, ILockingProvider $provider): void {
+        $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) {
+            $e = new LockedException($e->getPath(), $e, $e->getExistingLock(), $path);
+            if ($logger) {
+                $logger->info($e->getMessage(), ['exception' => $e]);
+            }
+            throw $e;
+        }
+    }
+
+    private function getLockLogger(): ?LoggerInterface {
+        if (is_null($this->shouldLogLocks)) {
+            $this->shouldLogLocks = Server::get(IConfig::class)->getSystemValueBool('filelocking.debug', false);
+            $this->logger = $this->shouldLogLocks ? Server::get(LoggerInterface::class) : null;
+        }
+        return $this->logger;
+    }
+
+    /**
+     * @return array{available: bool, last_checked: int}
+     */
+    public function getAvailability(): array {
+        return $this->getStorageCache()->getAvailability();
+    }
+
+    public function setAvailability(bool $isAvailable): void {
+        $this->getStorageCache()->setAvailability($isAvailable);
+    }
+
+    public function setOwner(?string $user): void {
+        $this->owner = $user;
+    }
+
+    public function needsPartFile(): bool {
+        return true;
+    }
+
+    public function writeStream(string $path, $stream, ?int $size = null): int {
+        $target = $this->fopen($path, 'w');
+        if (!$target) {
+            throw new GenericFileException("Failed to open $path for writing");
+        }
+        try {
+            [$count, $result] = Files::streamCopy($stream, $target, true);
+            if (!$result) {
+                throw new GenericFileException('Failed to copy stream');
+            }
+        } finally {
+            fclose($target);
+            fclose($stream);
+        }
+        return $count;
+    }
+
+    public function getDirectoryContent(string $directory): \Traversable {
+        $dh = $this->opendir($directory);
+
+        if ($dh === false) {
+            throw new StorageNotAvailableException('Directory listing failed');
+        }
+
+        if (is_resource($dh)) {
+            $basePath = rtrim($directory, '/');
+            while (($file = readdir($dh)) !== false) {
+                if (!Filesystem::isIgnoredDir($file)) {
+                    $childPath = $basePath . '/' . trim($file, '/');
+                    $metadata = $this->getMetaData($childPath);
+                    if ($metadata !== null) {
+                        yield $metadata;
+                    }
+                }
+            }
+        }
+    }
 }

apps/files_sharing/lib/SharedStorage.php

Indentation +523 added lines, -523 removed lines

@@ -47,527 +47,527 @@
  * Convert target path to source path and pass the function call to the correct storage provider
  */
 class SharedStorage extends Jail implements LegacyISharedStorage, ISharedStorage, IDisableEncryptionStorage {
-	/** @var IShare */
-	private $superShare;
-
-	/** @var IShare[] */
-	private $groupedShares;
-
-	/**
-	 * @var View
-	 */
-	private $ownerView;
-
-	private $initialized = false;
-
-	/**
-	 * @var ICacheEntry
-	 */
-	private $sourceRootInfo;
-
-	/** @var string */
-	private $user;
-
-	private LoggerInterface $logger;
-
-	/** @var IStorage */
-	private $nonMaskedStorage;
-
-	private array $mountOptions = [];
-
-	/** @var boolean */
-	private $sharingDisabledForUser;
-
-	/** @var ?Folder $ownerUserFolder */
-	private $ownerUserFolder = null;
-
-	private string $sourcePath = '';
-
-	private static int $initDepth = 0;
-
-	/**
-	 * @psalm-suppress NonInvariantDocblockPropertyType
-	 * @var ?Storage $storage
-	 */
-	protected $storage;
-
-	public function __construct(array $parameters) {
-		$this->ownerView = $parameters['ownerView'];
-		$this->logger = Server::get(LoggerInterface::class);
-
-		$this->superShare = $parameters['superShare'];
-		$this->groupedShares = $parameters['groupedShares'];
-
-		$this->user = $parameters['user'];
-		if (isset($parameters['sharingDisabledForUser'])) {
-			$this->sharingDisabledForUser = $parameters['sharingDisabledForUser'];
-		} else {
-			$this->sharingDisabledForUser = false;
-		}
-
-		parent::__construct([
-			'storage' => null,
-			'root' => null,
-		]);
-	}
-
-	/**
-	 * @return ICacheEntry
-	 */
-	private function getSourceRootInfo() {
-		if (is_null($this->sourceRootInfo)) {
-			if (is_null($this->superShare->getNodeCacheEntry())) {
-				$this->init();
-				$this->sourceRootInfo = $this->nonMaskedStorage->getCache()->get($this->rootPath);
-			} else {
-				$this->sourceRootInfo = $this->superShare->getNodeCacheEntry();
-			}
-		}
-		return $this->sourceRootInfo;
-	}
-
-	/**
-	 * @psalm-assert Storage $this->storage
-	 */
-	private function init() {
-		if ($this->initialized) {
-			if (!$this->storage) {
-				// marked as initialized but no storage set
-				// this is probably because some code path has caused recursion during the share setup
-				// we setup a "failed storage" so `getWrapperStorage` doesn't return null.
-				// If the share setup completes after this the "failed storage" will be overwritten by the correct one
-				$ex = new \Exception('Possible share setup recursion detected for share ' . $this->superShare->getId());
-				$this->logger->warning($ex->getMessage(), ['exception' => $ex, 'app' => 'files_sharing']);
-				$this->storage = new FailedStorage(['exception' => $ex]);
-				$this->cache = new FailedCache();
-				$this->rootPath = '';
-			}
-			return;
-		}
-
-		$this->initialized = true;
-		self::$initDepth++;
-
-		try {
-			if (self::$initDepth > 10) {
-				throw new \Exception('Maximum share depth reached');
-			}
-
-			/** @var IRootFolder $rootFolder */
-			$rootFolder = Server::get(IRootFolder::class);
-			$this->ownerUserFolder = $rootFolder->getUserFolder($this->superShare->getShareOwner());
-			$sourceId = $this->superShare->getNodeId();
-			$ownerNodes = $this->ownerUserFolder->getById($sourceId);
-
-			if (count($ownerNodes) === 0) {
-				$this->storage = new FailedStorage(['exception' => new NotFoundException("File by id $sourceId not found")]);
-				$this->cache = new FailedCache();
-				$this->rootPath = '';
-			} else {
-				foreach ($ownerNodes as $ownerNode) {
-					$nonMaskedStorage = $ownerNode->getStorage();
-
-					// check if potential source node would lead to a recursive share setup
-					if ($nonMaskedStorage instanceof Wrapper && $nonMaskedStorage->isWrapperOf($this)) {
-						continue;
-					}
-					$this->nonMaskedStorage = $nonMaskedStorage;
-					$this->sourcePath = $ownerNode->getPath();
-					$this->rootPath = $ownerNode->getInternalPath();
-					$this->cache = null;
-					break;
-				}
-				if (!$this->nonMaskedStorage) {
-					// all potential source nodes would have been recursive
-					throw new \Exception('recursive share detected');
-				}
-				$this->storage = new PermissionsMask([
-					'storage' => $this->nonMaskedStorage,
-					'mask' => $this->superShare->getPermissions(),
-				]);
-			}
-		} catch (NotFoundException $e) {
-			// original file not accessible or deleted, set FailedStorage
-			$this->storage = new FailedStorage(['exception' => $e]);
-			$this->cache = new FailedCache();
-			$this->rootPath = '';
-		} catch (NoUserException $e) {
-			// sharer user deleted, set FailedStorage
-			$this->storage = new FailedStorage(['exception' => $e]);
-			$this->cache = new FailedCache();
-			$this->rootPath = '';
-		} catch (\Exception $e) {
-			$this->storage = new FailedStorage(['exception' => $e]);
-			$this->cache = new FailedCache();
-			$this->rootPath = '';
-			$this->logger->error($e->getMessage(), ['exception' => $e]);
-		}
-
-		if (!$this->nonMaskedStorage) {
-			$this->nonMaskedStorage = $this->storage;
-		}
-		self::$initDepth--;
-	}
-
-	public function instanceOfStorage(string $class): bool {
-		if ($class === '\OC\Files\Storage\Common' || $class == Common::class) {
-			return true;
-		}
-		if (in_array($class, [
-			'\OC\Files\Storage\Home',
-			'\OC\Files\ObjectStore\HomeObjectStoreStorage',
-			'\OCP\Files\IHomeStorage',
-			Home::class,
-			HomeObjectStoreStorage::class,
-			IHomeStorage::class
-		])) {
-			return false;
-		}
-		return parent::instanceOfStorage($class);
-	}
-
-	/**
-	 * @return string
-	 */
-	public function getShareId() {
-		return $this->superShare->getId();
-	}
-
-	private function isValid(): bool {
-		return $this->getSourceRootInfo() && ($this->getSourceRootInfo()->getPermissions() & Constants::PERMISSION_SHARE) === Constants::PERMISSION_SHARE;
-	}
-
-	public function getId(): string {
-		return 'shared::' . $this->getMountPoint();
-	}
-
-	public function getPermissions(string $path = ''): int {
-		if (!$this->isValid()) {
-			return 0;
-		}
-		$permissions = parent::getPermissions($path) & $this->superShare->getPermissions();
-
-		// part files and the mount point always have delete permissions
-		if ($path === '' || pathinfo($path, PATHINFO_EXTENSION) === 'part') {
-			$permissions |= Constants::PERMISSION_DELETE;
-		}
-
-		if ($this->sharingDisabledForUser) {
-			$permissions &= ~Constants::PERMISSION_SHARE;
-		}
-
-		return $permissions;
-	}
-
-	public function isCreatable(string $path): bool {
-		return (bool)($this->getPermissions($path) & Constants::PERMISSION_CREATE);
-	}
-
-	public function isReadable(string $path): bool {
-		if (!$this->isValid()) {
-			return false;
-		}
-		if (!$this->file_exists($path)) {
-			return false;
-		}
-		/** @var IStorage $storage */
-		/** @var string $internalPath */
-		[$storage, $internalPath] = $this->resolvePath($path);
-		return $storage->isReadable($internalPath);
-	}
-
-	public function isUpdatable(string $path): bool {
-		return (bool)($this->getPermissions($path) & Constants::PERMISSION_UPDATE);
-	}
-
-	public function isDeletable(string $path): bool {
-		return (bool)($this->getPermissions($path) & Constants::PERMISSION_DELETE);
-	}
-
-	public function isSharable(string $path): bool {
-		if (Util::isSharingDisabledForUser() || !Share::isResharingAllowed()) {
-			return false;
-		}
-		return (bool)($this->getPermissions($path) & Constants::PERMISSION_SHARE);
-	}
-
-	public function fopen(string $path, string $mode) {
-		$source = $this->getUnjailedPath($path);
-		switch ($mode) {
-			case 'r+':
-			case 'rb+':
-			case 'w+':
-			case 'wb+':
-			case 'x+':
-			case 'xb+':
-			case 'a+':
-			case 'ab+':
-			case 'w':
-			case 'wb':
-			case 'x':
-			case 'xb':
-			case 'a':
-			case 'ab':
-				$creatable = $this->isCreatable(dirname($path));
-				$updatable = $this->isUpdatable($path);
-				// if neither permissions given, no need to continue
-				if (!$creatable && !$updatable) {
-					if (pathinfo($path, PATHINFO_EXTENSION) === 'part') {
-						$updatable = $this->isUpdatable(dirname($path));
-					}
-
-					if (!$updatable) {
-						return false;
-					}
-				}
-
-				$exists = $this->file_exists($path);
-				// if a file exists, updatable permissions are required
-				if ($exists && !$updatable) {
-					return false;
-				}
-
-				// part file is allowed if !$creatable but the final file is $updatable
-				if (pathinfo($path, PATHINFO_EXTENSION) !== 'part') {
-					if (!$exists && !$creatable) {
-						return false;
-					}
-				}
-		}
-		$info = [
-			'target' => $this->getMountPoint() . '/' . $path,
-			'source' => $source,
-			'mode' => $mode,
-		];
-		Util::emitHook('\OC\Files\Storage\Shared', 'fopen', $info);
-		return $this->nonMaskedStorage->fopen($this->getUnjailedPath($path), $mode);
-	}
-
-	public function rename(string $source, string $target): bool {
-		$this->init();
-		$isPartFile = pathinfo($source, PATHINFO_EXTENSION) === 'part';
-		$targetExists = $this->file_exists($target);
-		$sameFolder = dirname($source) === dirname($target);
-
-		if ($targetExists || ($sameFolder && !$isPartFile)) {
-			if (!$this->isUpdatable('')) {
-				return false;
-			}
-		} else {
-			if (!$this->isCreatable('')) {
-				return false;
-			}
-		}
-
-		return $this->nonMaskedStorage->rename($this->getUnjailedPath($source), $this->getUnjailedPath($target));
-	}
-
-	/**
-	 * return mount point of share, relative to data/user/files
-	 *
-	 * @return string
-	 */
-	public function getMountPoint(): string {
-		return $this->superShare->getTarget();
-	}
-
-	public function setMountPoint(string $path): void {
-		$this->superShare->setTarget($path);
-
-		foreach ($this->groupedShares as $share) {
-			$share->setTarget($path);
-		}
-	}
-
-	/**
-	 * get the user who shared the file
-	 *
-	 * @return string
-	 */
-	public function getSharedFrom(): string {
-		return $this->superShare->getShareOwner();
-	}
-
-	public function getShare(): IShare {
-		return $this->superShare;
-	}
-
-	/**
-	 * return share type, can be "file" or "folder"
-	 *
-	 * @return string
-	 */
-	public function getItemType(): string {
-		return $this->superShare->getNodeType();
-	}
-
-	public function getCache(string $path = '', ?IStorage $storage = null): ICache {
-		if ($this->cache) {
-			return $this->cache;
-		}
-		if (!$storage) {
-			$storage = $this;
-		}
-		$sourceRoot = $this->getSourceRootInfo();
-		if ($this->storage instanceof FailedStorage) {
-			return new FailedCache();
-		}
-
-		$this->cache = new Cache(
-			$storage,
-			$sourceRoot,
-			Server::get(CacheDependencies::class),
-			$this->getShare()
-		);
-		return $this->cache;
-	}
-
-	public function getScanner(string $path = '', ?IStorage $storage = null): IScanner {
-		if (!$storage) {
-			$storage = $this;
-		}
-		return new Scanner($storage);
-	}
-
-	public function getOwner(string $path): string|false {
-		return $this->superShare->getShareOwner();
-	}
-
-	public function getWatcher(string $path = '', ?IStorage $storage = null): IWatcher {
-		if ($this->watcher) {
-			return $this->watcher;
-		}
-
-		// Get node information
-		$node = $this->getShare()->getNodeCacheEntry();
-		if ($node instanceof CacheEntry) {
-			$storageId = $node->getData()['storage_string_id'] ?? null;
-			// for shares from the home storage we can rely on the home storage to keep itself up to date
-			// for other storages we need use the proper watcher
-			if ($storageId !== null && !(str_starts_with($storageId, 'home::') || str_starts_with($storageId, 'object::user'))) {
-				$cache = $this->getCache();
-				$this->watcher = parent::getWatcher($path, $storage);
-				if ($cache instanceof Cache) {
-					$this->watcher->onUpdate($cache->markRootChanged(...));
-				}
-				return $this->watcher;
-			}
-		}
-
-		// cache updating is handled by the share source
-		$this->watcher = new NullWatcher();
-		return $this->watcher;
-	}
-
-	/**
-	 * unshare complete storage, also the grouped shares
-	 *
-	 * @return bool
-	 */
-	public function unshareStorage(): bool {
-		foreach ($this->groupedShares as $share) {
-			Server::get(\OCP\Share\IManager::class)->deleteFromSelf($share, $this->user);
-		}
-		return true;
-	}
-
-	public function acquireLock(string $path, int $type, ILockingProvider $provider): void {
-		/** @var ILockingStorage $targetStorage */
-		[$targetStorage, $targetInternalPath] = $this->resolvePath($path);
-		$targetStorage->acquireLock($targetInternalPath, $type, $provider);
-		// lock the parent folders of the owner when locking the share as recipient
-		if ($path === '') {
-			$sourcePath = $this->ownerUserFolder->getRelativePath($this->sourcePath);
-			$this->ownerView->lockFile(dirname($sourcePath), ILockingProvider::LOCK_SHARED, true);
-		}
-	}
-
-	public function releaseLock(string $path, int $type, ILockingProvider $provider): void {
-		/** @var ILockingStorage $targetStorage */
-		[$targetStorage, $targetInternalPath] = $this->resolvePath($path);
-		$targetStorage->releaseLock($targetInternalPath, $type, $provider);
-		// unlock the parent folders of the owner when unlocking the share as recipient
-		if ($path === '') {
-			$sourcePath = $this->ownerUserFolder->getRelativePath($this->sourcePath);
-			$this->ownerView->unlockFile(dirname($sourcePath), ILockingProvider::LOCK_SHARED, true);
-		}
-	}
-
-	public function changeLock(string $path, int $type, ILockingProvider $provider): void {
-		/** @var ILockingStorage $targetStorage */
-		[$targetStorage, $targetInternalPath] = $this->resolvePath($path);
-		$targetStorage->changeLock($targetInternalPath, $type, $provider);
-	}
-
-	public function getAvailability(): array {
-		// shares do not participate in availability logic
-		return [
-			'available' => true,
-			'last_checked' => 0,
-		];
-	}
-
-	public function setAvailability(bool $isAvailable): void {
-		// shares do not participate in availability logic
-	}
-
-	public function getSourceStorage() {
-		$this->init();
-		return $this->nonMaskedStorage;
-	}
-
-	public function getWrapperStorage(): Storage {
-		$this->init();
-
-		/**
-		 * @psalm-suppress DocblockTypeContradiction
-		 */
-		if (!$this->storage) {
-			$message = 'no storage set after init for share ' . $this->getShareId();
-			$this->logger->error($message);
-			$this->storage = new FailedStorage(['exception' => new \Exception($message)]);
-		}
-
-		return $this->storage;
-	}
-
-	public function file_get_contents(string $path): string|false {
-		$info = [
-			'target' => $this->getMountPoint() . '/' . $path,
-			'source' => $this->getUnjailedPath($path),
-		];
-		Util::emitHook('\OC\Files\Storage\Shared', 'file_get_contents', $info);
-		return parent::file_get_contents($path);
-	}
-
-	public function file_put_contents(string $path, mixed $data): int|float|false {
-		$info = [
-			'target' => $this->getMountPoint() . '/' . $path,
-			'source' => $this->getUnjailedPath($path),
-		];
-		Util::emitHook('\OC\Files\Storage\Shared', 'file_put_contents', $info);
-		return parent::file_put_contents($path, $data);
-	}
-
-	public function setMountOptions(array $options): void {
-		/* Note: This value is never read */
-		$this->mountOptions = $options;
-	}
-
-	public function getUnjailedPath(string $path): string {
-		$this->init();
-		return parent::getUnjailedPath($path);
-	}
-
-	#[Override]
-	public function getDirectDownload(string $path): array|false {
-		// disable direct download for shares
-		return false;
-	}
-
-	#[Override]
-	public function getDirectDownloadById(string $fileId): array|false {
-		// disable direct download for shares
-		return false;
-	}
+    /** @var IShare */
+    private $superShare;
+
+    /** @var IShare[] */
+    private $groupedShares;
+
+    /**
+     * @var View
+     */
+    private $ownerView;
+
+    private $initialized = false;
+
+    /**
+     * @var ICacheEntry
+     */
+    private $sourceRootInfo;
+
+    /** @var string */
+    private $user;
+
+    private LoggerInterface $logger;
+
+    /** @var IStorage */
+    private $nonMaskedStorage;
+
+    private array $mountOptions = [];
+
+    /** @var boolean */
+    private $sharingDisabledForUser;
+
+    /** @var ?Folder $ownerUserFolder */
+    private $ownerUserFolder = null;
+
+    private string $sourcePath = '';
+
+    private static int $initDepth = 0;
+
+    /**
+     * @psalm-suppress NonInvariantDocblockPropertyType
+     * @var ?Storage $storage
+     */
+    protected $storage;
+
+    public function __construct(array $parameters) {
+        $this->ownerView = $parameters['ownerView'];
+        $this->logger = Server::get(LoggerInterface::class);
+
+        $this->superShare = $parameters['superShare'];
+        $this->groupedShares = $parameters['groupedShares'];
+
+        $this->user = $parameters['user'];
+        if (isset($parameters['sharingDisabledForUser'])) {
+            $this->sharingDisabledForUser = $parameters['sharingDisabledForUser'];
+        } else {
+            $this->sharingDisabledForUser = false;
+        }
+
+        parent::__construct([
+            'storage' => null,
+            'root' => null,
+        ]);
+    }
+
+    /**
+     * @return ICacheEntry
+     */
+    private function getSourceRootInfo() {
+        if (is_null($this->sourceRootInfo)) {
+            if (is_null($this->superShare->getNodeCacheEntry())) {
+                $this->init();
+                $this->sourceRootInfo = $this->nonMaskedStorage->getCache()->get($this->rootPath);
+            } else {
+                $this->sourceRootInfo = $this->superShare->getNodeCacheEntry();
+            }
+        }
+        return $this->sourceRootInfo;
+    }
+
+    /**
+     * @psalm-assert Storage $this->storage
+     */
+    private function init() {
+        if ($this->initialized) {
+            if (!$this->storage) {
+                // marked as initialized but no storage set
+                // this is probably because some code path has caused recursion during the share setup
+                // we setup a "failed storage" so `getWrapperStorage` doesn't return null.
+                // If the share setup completes after this the "failed storage" will be overwritten by the correct one
+                $ex = new \Exception('Possible share setup recursion detected for share ' . $this->superShare->getId());
+                $this->logger->warning($ex->getMessage(), ['exception' => $ex, 'app' => 'files_sharing']);
+                $this->storage = new FailedStorage(['exception' => $ex]);
+                $this->cache = new FailedCache();
+                $this->rootPath = '';
+            }
+            return;
+        }
+
+        $this->initialized = true;
+        self::$initDepth++;
+
+        try {
+            if (self::$initDepth > 10) {
+                throw new \Exception('Maximum share depth reached');
+            }
+
+            /** @var IRootFolder $rootFolder */
+            $rootFolder = Server::get(IRootFolder::class);
+            $this->ownerUserFolder = $rootFolder->getUserFolder($this->superShare->getShareOwner());
+            $sourceId = $this->superShare->getNodeId();
+            $ownerNodes = $this->ownerUserFolder->getById($sourceId);
+
+            if (count($ownerNodes) === 0) {
+                $this->storage = new FailedStorage(['exception' => new NotFoundException("File by id $sourceId not found")]);
+                $this->cache = new FailedCache();
+                $this->rootPath = '';
+            } else {
+                foreach ($ownerNodes as $ownerNode) {
+                    $nonMaskedStorage = $ownerNode->getStorage();
+
+                    // check if potential source node would lead to a recursive share setup
+                    if ($nonMaskedStorage instanceof Wrapper && $nonMaskedStorage->isWrapperOf($this)) {
+                        continue;
+                    }
+                    $this->nonMaskedStorage = $nonMaskedStorage;
+                    $this->sourcePath = $ownerNode->getPath();
+                    $this->rootPath = $ownerNode->getInternalPath();
+                    $this->cache = null;
+                    break;
+                }
+                if (!$this->nonMaskedStorage) {
+                    // all potential source nodes would have been recursive
+                    throw new \Exception('recursive share detected');
+                }
+                $this->storage = new PermissionsMask([
+                    'storage' => $this->nonMaskedStorage,
+                    'mask' => $this->superShare->getPermissions(),
+                ]);
+            }
+        } catch (NotFoundException $e) {
+            // original file not accessible or deleted, set FailedStorage
+            $this->storage = new FailedStorage(['exception' => $e]);
+            $this->cache = new FailedCache();
+            $this->rootPath = '';
+        } catch (NoUserException $e) {
+            // sharer user deleted, set FailedStorage
+            $this->storage = new FailedStorage(['exception' => $e]);
+            $this->cache = new FailedCache();
+            $this->rootPath = '';
+        } catch (\Exception $e) {
+            $this->storage = new FailedStorage(['exception' => $e]);
+            $this->cache = new FailedCache();
+            $this->rootPath = '';
+            $this->logger->error($e->getMessage(), ['exception' => $e]);
+        }
+
+        if (!$this->nonMaskedStorage) {
+            $this->nonMaskedStorage = $this->storage;
+        }
+        self::$initDepth--;
+    }
+
+    public function instanceOfStorage(string $class): bool {
+        if ($class === '\OC\Files\Storage\Common' || $class == Common::class) {
+            return true;
+        }
+        if (in_array($class, [
+            '\OC\Files\Storage\Home',
+            '\OC\Files\ObjectStore\HomeObjectStoreStorage',
+            '\OCP\Files\IHomeStorage',
+            Home::class,
+            HomeObjectStoreStorage::class,
+            IHomeStorage::class
+        ])) {
+            return false;
+        }
+        return parent::instanceOfStorage($class);
+    }
+
+    /**
+     * @return string
+     */
+    public function getShareId() {
+        return $this->superShare->getId();
+    }
+
+    private function isValid(): bool {
+        return $this->getSourceRootInfo() && ($this->getSourceRootInfo()->getPermissions() & Constants::PERMISSION_SHARE) === Constants::PERMISSION_SHARE;
+    }
+
+    public function getId(): string {
+        return 'shared::' . $this->getMountPoint();
+    }
+
+    public function getPermissions(string $path = ''): int {
+        if (!$this->isValid()) {
+            return 0;
+        }
+        $permissions = parent::getPermissions($path) & $this->superShare->getPermissions();
+
+        // part files and the mount point always have delete permissions
+        if ($path === '' || pathinfo($path, PATHINFO_EXTENSION) === 'part') {
+            $permissions |= Constants::PERMISSION_DELETE;
+        }
+
+        if ($this->sharingDisabledForUser) {
+            $permissions &= ~Constants::PERMISSION_SHARE;
+        }
+
+        return $permissions;
+    }
+
+    public function isCreatable(string $path): bool {
+        return (bool)($this->getPermissions($path) & Constants::PERMISSION_CREATE);
+    }
+
+    public function isReadable(string $path): bool {
+        if (!$this->isValid()) {
+            return false;
+        }
+        if (!$this->file_exists($path)) {
+            return false;
+        }
+        /** @var IStorage $storage */
+        /** @var string $internalPath */
+        [$storage, $internalPath] = $this->resolvePath($path);
+        return $storage->isReadable($internalPath);
+    }
+
+    public function isUpdatable(string $path): bool {
+        return (bool)($this->getPermissions($path) & Constants::PERMISSION_UPDATE);
+    }
+
+    public function isDeletable(string $path): bool {
+        return (bool)($this->getPermissions($path) & Constants::PERMISSION_DELETE);
+    }
+
+    public function isSharable(string $path): bool {
+        if (Util::isSharingDisabledForUser() || !Share::isResharingAllowed()) {
+            return false;
+        }
+        return (bool)($this->getPermissions($path) & Constants::PERMISSION_SHARE);
+    }
+
+    public function fopen(string $path, string $mode) {
+        $source = $this->getUnjailedPath($path);
+        switch ($mode) {
+            case 'r+':
+            case 'rb+':
+            case 'w+':
+            case 'wb+':
+            case 'x+':
+            case 'xb+':
+            case 'a+':
+            case 'ab+':
+            case 'w':
+            case 'wb':
+            case 'x':
+            case 'xb':
+            case 'a':
+            case 'ab':
+                $creatable = $this->isCreatable(dirname($path));
+                $updatable = $this->isUpdatable($path);
+                // if neither permissions given, no need to continue
+                if (!$creatable && !$updatable) {
+                    if (pathinfo($path, PATHINFO_EXTENSION) === 'part') {
+                        $updatable = $this->isUpdatable(dirname($path));
+                    }
+
+                    if (!$updatable) {
+                        return false;
+                    }
+                }
+
+                $exists = $this->file_exists($path);
+                // if a file exists, updatable permissions are required
+                if ($exists && !$updatable) {
+                    return false;
+                }
+
+                // part file is allowed if !$creatable but the final file is $updatable
+                if (pathinfo($path, PATHINFO_EXTENSION) !== 'part') {
+                    if (!$exists && !$creatable) {
+                        return false;
+                    }
+                }
+        }
+        $info = [
+            'target' => $this->getMountPoint() . '/' . $path,
+            'source' => $source,
+            'mode' => $mode,
+        ];
+        Util::emitHook('\OC\Files\Storage\Shared', 'fopen', $info);
+        return $this->nonMaskedStorage->fopen($this->getUnjailedPath($path), $mode);
+    }
+
+    public function rename(string $source, string $target): bool {
+        $this->init();
+        $isPartFile = pathinfo($source, PATHINFO_EXTENSION) === 'part';
+        $targetExists = $this->file_exists($target);
+        $sameFolder = dirname($source) === dirname($target);
+
+        if ($targetExists || ($sameFolder && !$isPartFile)) {
+            if (!$this->isUpdatable('')) {
+                return false;
+            }
+        } else {
+            if (!$this->isCreatable('')) {
+                return false;
+            }
+        }
+
+        return $this->nonMaskedStorage->rename($this->getUnjailedPath($source), $this->getUnjailedPath($target));
+    }
+
+    /**
+     * return mount point of share, relative to data/user/files
+     *
+     * @return string
+     */
+    public function getMountPoint(): string {
+        return $this->superShare->getTarget();
+    }
+
+    public function setMountPoint(string $path): void {
+        $this->superShare->setTarget($path);
+
+        foreach ($this->groupedShares as $share) {
+            $share->setTarget($path);
+        }
+    }
+
+    /**
+     * get the user who shared the file
+     *
+     * @return string
+     */
+    public function getSharedFrom(): string {
+        return $this->superShare->getShareOwner();
+    }
+
+    public function getShare(): IShare {
+        return $this->superShare;
+    }
+
+    /**
+     * return share type, can be "file" or "folder"
+     *
+     * @return string
+     */
+    public function getItemType(): string {
+        return $this->superShare->getNodeType();
+    }
+
+    public function getCache(string $path = '', ?IStorage $storage = null): ICache {
+        if ($this->cache) {
+            return $this->cache;
+        }
+        if (!$storage) {
+            $storage = $this;
+        }
+        $sourceRoot = $this->getSourceRootInfo();
+        if ($this->storage instanceof FailedStorage) {
+            return new FailedCache();
+        }
+
+        $this->cache = new Cache(
+            $storage,
+            $sourceRoot,
+            Server::get(CacheDependencies::class),
+            $this->getShare()
+        );
+        return $this->cache;
+    }
+
+    public function getScanner(string $path = '', ?IStorage $storage = null): IScanner {
+        if (!$storage) {
+            $storage = $this;
+        }
+        return new Scanner($storage);
+    }
+
+    public function getOwner(string $path): string|false {
+        return $this->superShare->getShareOwner();
+    }
+
+    public function getWatcher(string $path = '', ?IStorage $storage = null): IWatcher {
+        if ($this->watcher) {
+            return $this->watcher;
+        }
+
+        // Get node information
+        $node = $this->getShare()->getNodeCacheEntry();
+        if ($node instanceof CacheEntry) {
+            $storageId = $node->getData()['storage_string_id'] ?? null;
+            // for shares from the home storage we can rely on the home storage to keep itself up to date
+            // for other storages we need use the proper watcher
+            if ($storageId !== null && !(str_starts_with($storageId, 'home::') || str_starts_with($storageId, 'object::user'))) {
+                $cache = $this->getCache();
+                $this->watcher = parent::getWatcher($path, $storage);
+                if ($cache instanceof Cache) {
+                    $this->watcher->onUpdate($cache->markRootChanged(...));
+                }
+                return $this->watcher;
+            }
+        }
+
+        // cache updating is handled by the share source
+        $this->watcher = new NullWatcher();
+        return $this->watcher;
+    }
+
+    /**
+     * unshare complete storage, also the grouped shares
+     *
+     * @return bool
+     */
+    public function unshareStorage(): bool {
+        foreach ($this->groupedShares as $share) {
+            Server::get(\OCP\Share\IManager::class)->deleteFromSelf($share, $this->user);
+        }
+        return true;
+    }
+
+    public function acquireLock(string $path, int $type, ILockingProvider $provider): void {
+        /** @var ILockingStorage $targetStorage */
+        [$targetStorage, $targetInternalPath] = $this->resolvePath($path);
+        $targetStorage->acquireLock($targetInternalPath, $type, $provider);
+        // lock the parent folders of the owner when locking the share as recipient
+        if ($path === '') {
+            $sourcePath = $this->ownerUserFolder->getRelativePath($this->sourcePath);
+            $this->ownerView->lockFile(dirname($sourcePath), ILockingProvider::LOCK_SHARED, true);
+        }
+    }
+
+    public function releaseLock(string $path, int $type, ILockingProvider $provider): void {
+        /** @var ILockingStorage $targetStorage */
+        [$targetStorage, $targetInternalPath] = $this->resolvePath($path);
+        $targetStorage->releaseLock($targetInternalPath, $type, $provider);
+        // unlock the parent folders of the owner when unlocking the share as recipient
+        if ($path === '') {
+            $sourcePath = $this->ownerUserFolder->getRelativePath($this->sourcePath);
+            $this->ownerView->unlockFile(dirname($sourcePath), ILockingProvider::LOCK_SHARED, true);
+        }
+    }
+
+    public function changeLock(string $path, int $type, ILockingProvider $provider): void {
+        /** @var ILockingStorage $targetStorage */
+        [$targetStorage, $targetInternalPath] = $this->resolvePath($path);
+        $targetStorage->changeLock($targetInternalPath, $type, $provider);
+    }
+
+    public function getAvailability(): array {
+        // shares do not participate in availability logic
+        return [
+            'available' => true,
+            'last_checked' => 0,
+        ];
+    }
+
+    public function setAvailability(bool $isAvailable): void {
+        // shares do not participate in availability logic
+    }
+
+    public function getSourceStorage() {
+        $this->init();
+        return $this->nonMaskedStorage;
+    }
+
+    public function getWrapperStorage(): Storage {
+        $this->init();
+
+        /**
+         * @psalm-suppress DocblockTypeContradiction
+         */
+        if (!$this->storage) {
+            $message = 'no storage set after init for share ' . $this->getShareId();
+            $this->logger->error($message);
+            $this->storage = new FailedStorage(['exception' => new \Exception($message)]);
+        }
+
+        return $this->storage;
+    }
+
+    public function file_get_contents(string $path): string|false {
+        $info = [
+            'target' => $this->getMountPoint() . '/' . $path,
+            'source' => $this->getUnjailedPath($path),
+        ];
+        Util::emitHook('\OC\Files\Storage\Shared', 'file_get_contents', $info);
+        return parent::file_get_contents($path);
+    }
+
+    public function file_put_contents(string $path, mixed $data): int|float|false {
+        $info = [
+            'target' => $this->getMountPoint() . '/' . $path,
+            'source' => $this->getUnjailedPath($path),
+        ];
+        Util::emitHook('\OC\Files\Storage\Shared', 'file_put_contents', $info);
+        return parent::file_put_contents($path, $data);
+    }
+
+    public function setMountOptions(array $options): void {
+        /* Note: This value is never read */
+        $this->mountOptions = $options;
+    }
+
+    public function getUnjailedPath(string $path): string {
+        $this->init();
+        return parent::getUnjailedPath($path);
+    }
+
+    #[Override]
+    public function getDirectDownload(string $path): array|false {
+        // disable direct download for shares
+        return false;
+    }
+
+    #[Override]
+    public function getDirectDownloadById(string $fileId): array|false {
+        // disable direct download for shares
+        return false;
+    }
 }

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

Indentation +587 added lines, -587 removed lines

@@ -50,591 +50,591 @@
 use Sabre\DAV\IFile;
 
 class File extends Node implements IFile {
-	protected IRequest $request;
-	protected IL10N $l10n;
-
-	/**
-	 * Sets up the node, expects a full path name
-	 *
-	 * @param View $view
-	 * @param FileInfo $info
-	 * @param ?\OCP\Share\IManager $shareManager
-	 * @param ?IRequest $request
-	 * @param ?IL10N $l10n
-	 */
-	public function __construct(View $view, FileInfo $info, ?IManager $shareManager = null, ?IRequest $request = null, ?IL10N $l10n = null) {
-		parent::__construct($view, $info, $shareManager);
-
-		if ($l10n) {
-			$this->l10n = $l10n;
-		} else {
-			// Querying IL10N directly results in a dependency loop
-			/** @var IL10NFactory $l10nFactory */
-			$l10nFactory = Server::get(IL10NFactory::class);
-			$this->l10n = $l10nFactory->get(Application::APP_ID);
-		}
-
-		if (isset($request)) {
-			$this->request = $request;
-		} else {
-			$this->request = Server::get(IRequest::class);
-		}
-	}
-
-	/**
-	 * Updates the data
-	 *
-	 * The data argument is a readable stream resource.
-	 *
-	 * After a successful put operation, you may choose to return an ETag. The
-	 * etag must always be surrounded by double-quotes. These quotes must
-	 * appear in the actual string you're returning.
-	 *
-	 * Clients may use the ETag from a PUT request to later on make sure that
-	 * when they update the file, the contents haven't changed in the mean
-	 * time.
-	 *
-	 * If you don't plan to store the file byte-by-byte, and you return a
-	 * different object on a subsequent GET you are strongly recommended to not
-	 * return an ETag, and just return null.
-	 *
-	 * @param resource|string $data
-	 *
-	 * @throws Forbidden
-	 * @throws UnsupportedMediaType
-	 * @throws BadRequest
-	 * @throws Exception
-	 * @throws EntityTooLarge
-	 * @throws ServiceUnavailable
-	 * @throws FileLocked
-	 * @return string|null
-	 */
-	public function put($data) {
-		try {
-			$exists = $this->fileView->file_exists($this->path);
-			if ($exists && !$this->info->isUpdateable()) {
-				throw new Forbidden();
-			}
-		} catch (StorageNotAvailableException $e) {
-			throw new ServiceUnavailable($this->l10n->t('File is not updatable: %1$s', [$e->getMessage()]));
-		}
-
-		// verify path of the target
-		$this->verifyPath();
-
-		[$partStorage] = $this->fileView->resolvePath($this->path);
-		if ($partStorage === null) {
-			throw new ServiceUnavailable($this->l10n->t('Failed to get storage for file'));
-		}
-		$needsPartFile = $partStorage->needsPartFile() && (strlen($this->path) > 1);
-
-		$view = Filesystem::getView();
-
-		if ($needsPartFile) {
-			$transferId = \rand();
-			// mark file as partial while uploading (ignored by the scanner)
-			$partFilePath = $this->getPartFileBasePath($this->path) . '.ocTransferId' . $transferId . '.part';
-
-			if (!$view->isCreatable($partFilePath) && $view->isUpdatable($this->path)) {
-				$needsPartFile = false;
-			}
-		}
-		if (!$needsPartFile) {
-			// upload file directly as the final path
-			$partFilePath = $this->path;
-
-			if ($view && !$this->emitPreHooks($exists)) {
-				throw new Exception($this->l10n->t('Could not write to final file, canceled by hook'));
-			}
-		}
-
-		// the part file and target file might be on a different storage in case of a single file storage (e.g. single file share)
-		[$partStorage, $internalPartPath] = $this->fileView->resolvePath($partFilePath);
-		[$storage, $internalPath] = $this->fileView->resolvePath($this->path);
-		if ($partStorage === null || $storage === null) {
-			throw new ServiceUnavailable($this->l10n->t('Failed to get storage for file'));
-		}
-		try {
-			if (!$needsPartFile) {
-				try {
-					$this->changeLock(ILockingProvider::LOCK_EXCLUSIVE);
-				} catch (LockedException $e) {
-					// during very large uploads, the shared lock we got at the start might have been expired
-					// meaning that the above lock can fail not just only because somebody else got a shared lock
-					// or because there is no existing shared lock to make exclusive
-					//
-					// Thus we try to get a new exclusive lock, if the original lock failed because of a different shared
-					// lock this will still fail, if our original shared lock expired the new lock will be successful and
-					// the entire operation will be safe
-
-					try {
-						$this->acquireLock(ILockingProvider::LOCK_EXCLUSIVE);
-					} catch (LockedException $ex) {
-						throw new FileLocked($e->getMessage(), $e->getCode(), $e);
-					}
-				}
-			}
-
-			if (!is_resource($data)) {
-				$tmpData = fopen('php://temp', 'r+');
-				if ($data !== null) {
-					fwrite($tmpData, $data);
-					rewind($tmpData);
-				}
-				$data = $tmpData;
-			}
-
-			if ($this->request->getHeader('X-HASH') !== '') {
-				$hash = $this->request->getHeader('X-HASH');
-				if ($hash === 'all' || $hash === 'md5') {
-					$data = HashWrapper::wrap($data, 'md5', function ($hash): void {
-						$this->header('X-Hash-MD5: ' . $hash);
-					});
-				}
-
-				if ($hash === 'all' || $hash === 'sha1') {
-					$data = HashWrapper::wrap($data, 'sha1', function ($hash): void {
-						$this->header('X-Hash-SHA1: ' . $hash);
-					});
-				}
-
-				if ($hash === 'all' || $hash === 'sha256') {
-					$data = HashWrapper::wrap($data, 'sha256', function ($hash): void {
-						$this->header('X-Hash-SHA256: ' . $hash);
-					});
-				}
-			}
-
-			$lengthHeader = $this->request->getHeader('content-length');
-			$expected = $lengthHeader !== '' ? (int)$lengthHeader : null;
-
-			if ($partStorage->instanceOfStorage(IWriteStreamStorage::class)) {
-				$isEOF = false;
-				$wrappedData = CallbackWrapper::wrap($data, null, null, null, null, function ($stream) use (&$isEOF): void {
-					$isEOF = feof($stream);
-				});
-
-				$result = is_resource($wrappedData);
-				if ($result) {
-					$count = -1;
-					try {
-						/** @var IWriteStreamStorage $partStorage */
-						$count = $partStorage->writeStream($internalPartPath, $wrappedData, $expected);
-					} catch (GenericFileException $e) {
-						$logger = Server::get(LoggerInterface::class);
-						$logger->error('Error while writing stream to storage: ' . $e->getMessage(), ['exception' => $e, 'app' => 'webdav']);
-						$result = $isEOF;
-						if (is_resource($wrappedData)) {
-							$result = feof($wrappedData);
-						}
-					}
-				}
-			} else {
-				$target = $partStorage->fopen($internalPartPath, 'wb');
-				if ($target === false) {
-					Server::get(LoggerInterface::class)->error('\OC\Files\Filesystem::fopen() failed', ['app' => 'webdav']);
-					// because we have no clue about the cause we can only throw back a 500/Internal Server Error
-					throw new Exception($this->l10n->t('Could not write file contents'));
-				}
-				[$count, $result] = Files::streamCopy($data, $target, true);
-				fclose($target);
-			}
-			if ($result === false && $expected !== null) {
-				throw new Exception(
-					$this->l10n->t(
-						'Error while copying file to target location (copied: %1$s, expected filesize: %2$s)',
-						[
-							$this->l10n->n('%n byte', '%n bytes', $count),
-							$this->l10n->n('%n byte', '%n bytes', $expected),
-						],
-					)
-				);
-			}
-
-			// if content length is sent by client:
-			// double check if the file was fully received
-			// compare expected and actual size
-			if ($expected !== null
-				&& $expected !== $count
-				&& $this->request->getMethod() === 'PUT'
-			) {
-				throw new BadRequest(
-					$this->l10n->t(
-						'Expected filesize of %1$s but read (from Nextcloud client) and wrote (to Nextcloud storage) %2$s. Could either be a network problem on the sending side or a problem writing to the storage on the server side.',
-						[
-							$this->l10n->n('%n byte', '%n bytes', $expected),
-							$this->l10n->n('%n byte', '%n bytes', $count),
-						],
-					)
-				);
-			}
-		} catch (\Exception $e) {
-			if ($e instanceof LockedException) {
-				Server::get(LoggerInterface::class)->debug($e->getMessage(), ['exception' => $e]);
-			} else {
-				Server::get(LoggerInterface::class)->error($e->getMessage(), ['exception' => $e]);
-			}
-
-			if ($needsPartFile) {
-				$partStorage->unlink($internalPartPath);
-			}
-			$this->convertToSabreException($e);
-		}
-
-		try {
-			if ($needsPartFile) {
-				if ($view && !$this->emitPreHooks($exists)) {
-					$partStorage->unlink($internalPartPath);
-					throw new Exception($this->l10n->t('Could not rename part file to final file, canceled by hook'));
-				}
-				try {
-					$this->changeLock(ILockingProvider::LOCK_EXCLUSIVE);
-				} catch (LockedException $e) {
-					// during very large uploads, the shared lock we got at the start might have been expired
-					// meaning that the above lock can fail not just only because somebody else got a shared lock
-					// or because there is no existing shared lock to make exclusive
-					//
-					// Thus we try to get a new exclusive lock, if the original lock failed because of a different shared
-					// lock this will still fail, if our original shared lock expired the new lock will be successful and
-					// the entire operation will be safe
-
-					try {
-						$this->acquireLock(ILockingProvider::LOCK_EXCLUSIVE);
-					} catch (LockedException $ex) {
-						if ($needsPartFile) {
-							$partStorage->unlink($internalPartPath);
-						}
-						throw new FileLocked($e->getMessage(), $e->getCode(), $e);
-					}
-				}
-
-				// rename to correct path
-				try {
-					$renameOkay = $storage->moveFromStorage($partStorage, $internalPartPath, $internalPath);
-					$fileExists = $storage->file_exists($internalPath);
-					if ($renameOkay === false || $fileExists === false) {
-						Server::get(LoggerInterface::class)->error('renaming part file to final file failed $renameOkay: ' . ($renameOkay ? 'true' : 'false') . ', $fileExists: ' . ($fileExists ? 'true' : 'false') . ')', ['app' => 'webdav']);
-						throw new Exception($this->l10n->t('Could not rename part file to final file'));
-					}
-				} catch (ForbiddenException $ex) {
-					if (!$ex->getRetry()) {
-						$partStorage->unlink($internalPartPath);
-					}
-					throw new DAVForbiddenException($ex->getMessage(), $ex->getRetry());
-				} catch (\Exception $e) {
-					$partStorage->unlink($internalPartPath);
-					$this->convertToSabreException($e);
-				}
-			}
-
-			// since we skipped the view we need to scan and emit the hooks ourselves
-			$storage->getUpdater()->update($internalPath);
-
-			try {
-				$this->changeLock(ILockingProvider::LOCK_SHARED);
-			} catch (LockedException $e) {
-				throw new FileLocked($e->getMessage(), $e->getCode(), $e);
-			}
-
-			// allow sync clients to send the mtime along in a header
-			$mtimeHeader = $this->request->getHeader('x-oc-mtime');
-			if ($mtimeHeader !== '') {
-				$mtime = $this->sanitizeMtime($mtimeHeader);
-				if ($this->fileView->touch($this->path, $mtime)) {
-					$this->header('X-OC-MTime: accepted');
-				}
-			}
-
-			$fileInfoUpdate = [
-				'upload_time' => time()
-			];
-
-			// allow sync clients to send the creation time along in a header
-			$ctimeHeader = $this->request->getHeader('x-oc-ctime');
-			if ($ctimeHeader) {
-				$ctime = $this->sanitizeMtime($ctimeHeader);
-				$fileInfoUpdate['creation_time'] = $ctime;
-				$this->header('X-OC-CTime: accepted');
-			}
-
-			$this->fileView->putFileInfo($this->path, $fileInfoUpdate);
-
-			if ($view) {
-				$this->emitPostHooks($exists);
-			}
-
-			$this->refreshInfo();
-
-			$checksumHeader = $this->request->getHeader('oc-checksum');
-			if ($checksumHeader) {
-				$checksum = trim($checksumHeader);
-				$this->setChecksum($checksum);
-			} elseif ($this->getChecksum() !== null && $this->getChecksum() !== '') {
-				$this->setChecksum('');
-			}
-		} catch (StorageNotAvailableException $e) {
-			throw new ServiceUnavailable($this->l10n->t('Failed to check file size: %1$s', [$e->getMessage()]), 0, $e);
-		}
-
-		return '"' . $this->info->getEtag() . '"';
-	}
-
-	private function getPartFileBasePath($path) {
-		$partFileInStorage = Server::get(IConfig::class)->getSystemValue('part_file_in_storage', true);
-		if ($partFileInStorage) {
-			$filename = basename($path);
-			// hash does not need to be secure but fast and semi unique
-			$hashedFilename = hash('xxh128', $filename);
-			return substr($path, 0, strlen($path) - strlen($filename)) . $hashedFilename;
-		} else {
-			// will place the .part file in the users root directory
-			// therefor we need to make the name (semi) unique - hash does not need to be secure but fast.
-			return hash('xxh128', $path);
-		}
-	}
-
-	private function emitPreHooks(bool $exists, ?string $path = null): bool {
-		if (is_null($path)) {
-			$path = $this->path;
-		}
-		$hookPath = Filesystem::getView()->getRelativePath($this->fileView->getAbsolutePath($path));
-		if ($hookPath === null) {
-			// We only trigger hooks from inside default view
-			return true;
-		}
-		$run = true;
-
-		if (!$exists) {
-			\OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_create, [
-				Filesystem::signal_param_path => $hookPath,
-				Filesystem::signal_param_run => &$run,
-			]);
-		} else {
-			\OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_update, [
-				Filesystem::signal_param_path => $hookPath,
-				Filesystem::signal_param_run => &$run,
-			]);
-		}
-		\OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_write, [
-			Filesystem::signal_param_path => $hookPath,
-			Filesystem::signal_param_run => &$run,
-		]);
-		return $run;
-	}
-
-	private function emitPostHooks(bool $exists, ?string $path = null): void {
-		if (is_null($path)) {
-			$path = $this->path;
-		}
-		$hookPath = Filesystem::getView()->getRelativePath($this->fileView->getAbsolutePath($path));
-		if ($hookPath === null) {
-			// We only trigger hooks from inside default view
-			return;
-		}
-		if (!$exists) {
-			\OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_post_create, [
-				Filesystem::signal_param_path => $hookPath
-			]);
-		} else {
-			\OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_post_update, [
-				Filesystem::signal_param_path => $hookPath
-			]);
-		}
-		\OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_post_write, [
-			Filesystem::signal_param_path => $hookPath
-		]);
-	}
-
-	/**
-	 * Returns the data
-	 *
-	 * @return resource
-	 * @throws Forbidden
-	 * @throws ServiceUnavailable
-	 */
-	public function get() {
-		//throw exception if encryption is disabled but files are still encrypted
-		try {
-			if (!$this->info->isReadable()) {
-				// do a if the file did not exist
-				throw new NotFound();
-			}
-			$path = ltrim($this->path, '/');
-			try {
-				$res = $this->fileView->fopen($path, 'rb');
-			} catch (\Exception $e) {
-				$this->convertToSabreException($e);
-			}
-
-			if ($res === false) {
-				if ($this->fileView->file_exists($path)) {
-					throw new ServiceUnavailable($this->l10n->t('Could not open file: %1$s, file does seem to exist', [$path]));
-				} else {
-					throw new ServiceUnavailable($this->l10n->t('Could not open file: %1$s, file doesn\'t seem to exist', [$path]));
-				}
-			}
-
-			// comparing current file size with the one in DB
-			// if different, fix DB and refresh cache.
-			if ($this->getSize() !== $this->fileView->filesize($this->getPath())) {
-				$logger = Server::get(LoggerInterface::class);
-				$logger->warning('fixing cached size of file id=' . $this->getId());
-
-				$this->getFileInfo()->getStorage()->getUpdater()->update($this->getFileInfo()->getInternalPath());
-				$this->refreshInfo();
-			}
-
-			return $res;
-		} catch (GenericEncryptionException $e) {
-			// returning 503 will allow retry of the operation at a later point in time
-			throw new ServiceUnavailable($this->l10n->t('Encryption not ready: %1$s', [$e->getMessage()]));
-		} catch (StorageNotAvailableException $e) {
-			throw new ServiceUnavailable($this->l10n->t('Failed to open file: %1$s', [$e->getMessage()]));
-		} catch (ForbiddenException $ex) {
-			throw new DAVForbiddenException($ex->getMessage(), $ex->getRetry());
-		} catch (LockedException $e) {
-			throw new FileLocked($e->getMessage(), $e->getCode(), $e);
-		}
-	}
-
-	/**
-	 * Delete the current file
-	 *
-	 * @throws Forbidden
-	 * @throws ServiceUnavailable
-	 */
-	public function delete() {
-		if (!$this->info->isDeletable()) {
-			throw new Forbidden();
-		}
-
-		try {
-			if (!$this->fileView->unlink($this->path)) {
-				// assume it wasn't possible to delete due to permissions
-				throw new Forbidden();
-			}
-		} catch (StorageNotAvailableException $e) {
-			throw new ServiceUnavailable($this->l10n->t('Failed to unlink: %1$s', [$e->getMessage()]));
-		} catch (ForbiddenException $ex) {
-			throw new DAVForbiddenException($ex->getMessage(), $ex->getRetry());
-		} catch (LockedException $e) {
-			throw new FileLocked($e->getMessage(), $e->getCode(), $e);
-		}
-	}
-
-	/**
-	 * Returns the mime-type for a file
-	 *
-	 * If null is returned, we'll assume application/octet-stream
-	 *
-	 * @return string
-	 */
-	public function getContentType() {
-		$mimeType = $this->info->getMimetype();
-
-		// PROPFIND needs to return the correct mime type, for consistency with the web UI
-		if ($this->request->getMethod() === 'PROPFIND') {
-			return $mimeType;
-		}
-		return Server::get(IMimeTypeDetector::class)->getSecureMimeType($mimeType);
-	}
-
-	/**
-	 * @throws NotFoundException
-	 * @throws NotPermittedException
-	 */
-	public function getDirectDownload(): array|false {
-		if (Server::get(IAppManager::class)->isEnabledForUser('encryption')) {
-			return false;
-		}
-		$node = $this->getNode();
-		$storage = $node->getStorage();
-		if (!$storage) {
-			return false;
-		}
-
-		if (!($node->getPermissions() & Constants::PERMISSION_READ)) {
-			return false;
-		}
-
-		return $storage->getDirectDownloadById((string)$node->getId());
-	}
-
-	/**
-	 * Convert the given exception to a SabreException instance
-	 *
-	 * @param \Exception $e
-	 *
-	 * @throws \Sabre\DAV\Exception
-	 */
-	private function convertToSabreException(\Exception $e) {
-		if ($e instanceof \Sabre\DAV\Exception) {
-			throw $e;
-		}
-		if ($e instanceof NotPermittedException) {
-			// a more general case - due to whatever reason the content could not be written
-			throw new Forbidden($e->getMessage(), 0, $e);
-		}
-		if ($e instanceof ForbiddenException) {
-			// the path for the file was forbidden
-			throw new DAVForbiddenException($e->getMessage(), $e->getRetry(), $e);
-		}
-		if ($e instanceof EntityTooLargeException) {
-			// the file is too big to be stored
-			throw new EntityTooLarge($e->getMessage(), 0, $e);
-		}
-		if ($e instanceof InvalidContentException) {
-			// the file content is not permitted
-			throw new UnsupportedMediaType($e->getMessage(), 0, $e);
-		}
-		if ($e instanceof InvalidPathException) {
-			// the path for the file was not valid
-			// TODO: find proper http status code for this case
-			throw new Forbidden($e->getMessage(), 0, $e);
-		}
-		if ($e instanceof LockedException || $e instanceof LockNotAcquiredException) {
-			// the file is currently being written to by another process
-			throw new FileLocked($e->getMessage(), $e->getCode(), $e);
-		}
-		if ($e instanceof GenericEncryptionException) {
-			// returning 503 will allow retry of the operation at a later point in time
-			throw new ServiceUnavailable($this->l10n->t('Encryption not ready: %1$s', [$e->getMessage()]), 0, $e);
-		}
-		if ($e instanceof StorageNotAvailableException) {
-			throw new ServiceUnavailable($this->l10n->t('Failed to write file contents: %1$s', [$e->getMessage()]), 0, $e);
-		}
-		if ($e instanceof NotFoundException) {
-			throw new NotFound($this->l10n->t('File not found: %1$s', [$e->getMessage()]), 0, $e);
-		}
-
-		throw new \Sabre\DAV\Exception($e->getMessage(), 0, $e);
-	}
-
-	/**
-	 * Get the checksum for this file
-	 *
-	 * @return string|null
-	 */
-	public function getChecksum() {
-		return $this->info->getChecksum();
-	}
-
-	public function setChecksum(string $checksum) {
-		$this->fileView->putFileInfo($this->path, ['checksum' => $checksum]);
-		$this->refreshInfo();
-	}
-
-	protected function header($string) {
-		if (!\OC::$CLI) {
-			\header($string);
-		}
-	}
-
-	public function hash(string $type) {
-		return $this->fileView->hash($type, $this->path);
-	}
-
-	public function getNode(): \OCP\Files\File {
-		return $this->node;
-	}
+    protected IRequest $request;
+    protected IL10N $l10n;
+
+    /**
+     * Sets up the node, expects a full path name
+     *
+     * @param View $view
+     * @param FileInfo $info
+     * @param ?\OCP\Share\IManager $shareManager
+     * @param ?IRequest $request
+     * @param ?IL10N $l10n
+     */
+    public function __construct(View $view, FileInfo $info, ?IManager $shareManager = null, ?IRequest $request = null, ?IL10N $l10n = null) {
+        parent::__construct($view, $info, $shareManager);
+
+        if ($l10n) {
+            $this->l10n = $l10n;
+        } else {
+            // Querying IL10N directly results in a dependency loop
+            /** @var IL10NFactory $l10nFactory */
+            $l10nFactory = Server::get(IL10NFactory::class);
+            $this->l10n = $l10nFactory->get(Application::APP_ID);
+        }
+
+        if (isset($request)) {
+            $this->request = $request;
+        } else {
+            $this->request = Server::get(IRequest::class);
+        }
+    }
+
+    /**
+     * Updates the data
+     *
+     * The data argument is a readable stream resource.
+     *
+     * After a successful put operation, you may choose to return an ETag. The
+     * etag must always be surrounded by double-quotes. These quotes must
+     * appear in the actual string you're returning.
+     *
+     * Clients may use the ETag from a PUT request to later on make sure that
+     * when they update the file, the contents haven't changed in the mean
+     * time.
+     *
+     * If you don't plan to store the file byte-by-byte, and you return a
+     * different object on a subsequent GET you are strongly recommended to not
+     * return an ETag, and just return null.
+     *
+     * @param resource|string $data
+     *
+     * @throws Forbidden
+     * @throws UnsupportedMediaType
+     * @throws BadRequest
+     * @throws Exception
+     * @throws EntityTooLarge
+     * @throws ServiceUnavailable
+     * @throws FileLocked
+     * @return string|null
+     */
+    public function put($data) {
+        try {
+            $exists = $this->fileView->file_exists($this->path);
+            if ($exists && !$this->info->isUpdateable()) {
+                throw new Forbidden();
+            }
+        } catch (StorageNotAvailableException $e) {
+            throw new ServiceUnavailable($this->l10n->t('File is not updatable: %1$s', [$e->getMessage()]));
+        }
+
+        // verify path of the target
+        $this->verifyPath();
+
+        [$partStorage] = $this->fileView->resolvePath($this->path);
+        if ($partStorage === null) {
+            throw new ServiceUnavailable($this->l10n->t('Failed to get storage for file'));
+        }
+        $needsPartFile = $partStorage->needsPartFile() && (strlen($this->path) > 1);
+
+        $view = Filesystem::getView();
+
+        if ($needsPartFile) {
+            $transferId = \rand();
+            // mark file as partial while uploading (ignored by the scanner)
+            $partFilePath = $this->getPartFileBasePath($this->path) . '.ocTransferId' . $transferId . '.part';
+
+            if (!$view->isCreatable($partFilePath) && $view->isUpdatable($this->path)) {
+                $needsPartFile = false;
+            }
+        }
+        if (!$needsPartFile) {
+            // upload file directly as the final path
+            $partFilePath = $this->path;
+
+            if ($view && !$this->emitPreHooks($exists)) {
+                throw new Exception($this->l10n->t('Could not write to final file, canceled by hook'));
+            }
+        }
+
+        // the part file and target file might be on a different storage in case of a single file storage (e.g. single file share)
+        [$partStorage, $internalPartPath] = $this->fileView->resolvePath($partFilePath);
+        [$storage, $internalPath] = $this->fileView->resolvePath($this->path);
+        if ($partStorage === null || $storage === null) {
+            throw new ServiceUnavailable($this->l10n->t('Failed to get storage for file'));
+        }
+        try {
+            if (!$needsPartFile) {
+                try {
+                    $this->changeLock(ILockingProvider::LOCK_EXCLUSIVE);
+                } catch (LockedException $e) {
+                    // during very large uploads, the shared lock we got at the start might have been expired
+                    // meaning that the above lock can fail not just only because somebody else got a shared lock
+                    // or because there is no existing shared lock to make exclusive
+                    //
+                    // Thus we try to get a new exclusive lock, if the original lock failed because of a different shared
+                    // lock this will still fail, if our original shared lock expired the new lock will be successful and
+                    // the entire operation will be safe
+
+                    try {
+                        $this->acquireLock(ILockingProvider::LOCK_EXCLUSIVE);
+                    } catch (LockedException $ex) {
+                        throw new FileLocked($e->getMessage(), $e->getCode(), $e);
+                    }
+                }
+            }
+
+            if (!is_resource($data)) {
+                $tmpData = fopen('php://temp', 'r+');
+                if ($data !== null) {
+                    fwrite($tmpData, $data);
+                    rewind($tmpData);
+                }
+                $data = $tmpData;
+            }
+
+            if ($this->request->getHeader('X-HASH') !== '') {
+                $hash = $this->request->getHeader('X-HASH');
+                if ($hash === 'all' || $hash === 'md5') {
+                    $data = HashWrapper::wrap($data, 'md5', function ($hash): void {
+                        $this->header('X-Hash-MD5: ' . $hash);
+                    });
+                }
+
+                if ($hash === 'all' || $hash === 'sha1') {
+                    $data = HashWrapper::wrap($data, 'sha1', function ($hash): void {
+                        $this->header('X-Hash-SHA1: ' . $hash);
+                    });
+                }
+
+                if ($hash === 'all' || $hash === 'sha256') {
+                    $data = HashWrapper::wrap($data, 'sha256', function ($hash): void {
+                        $this->header('X-Hash-SHA256: ' . $hash);
+                    });
+                }
+            }
+
+            $lengthHeader = $this->request->getHeader('content-length');
+            $expected = $lengthHeader !== '' ? (int)$lengthHeader : null;
+
+            if ($partStorage->instanceOfStorage(IWriteStreamStorage::class)) {
+                $isEOF = false;
+                $wrappedData = CallbackWrapper::wrap($data, null, null, null, null, function ($stream) use (&$isEOF): void {
+                    $isEOF = feof($stream);
+                });
+
+                $result = is_resource($wrappedData);
+                if ($result) {
+                    $count = -1;
+                    try {
+                        /** @var IWriteStreamStorage $partStorage */
+                        $count = $partStorage->writeStream($internalPartPath, $wrappedData, $expected);
+                    } catch (GenericFileException $e) {
+                        $logger = Server::get(LoggerInterface::class);
+                        $logger->error('Error while writing stream to storage: ' . $e->getMessage(), ['exception' => $e, 'app' => 'webdav']);
+                        $result = $isEOF;
+                        if (is_resource($wrappedData)) {
+                            $result = feof($wrappedData);
+                        }
+                    }
+                }
+            } else {
+                $target = $partStorage->fopen($internalPartPath, 'wb');
+                if ($target === false) {
+                    Server::get(LoggerInterface::class)->error('\OC\Files\Filesystem::fopen() failed', ['app' => 'webdav']);
+                    // because we have no clue about the cause we can only throw back a 500/Internal Server Error
+                    throw new Exception($this->l10n->t('Could not write file contents'));
+                }
+                [$count, $result] = Files::streamCopy($data, $target, true);
+                fclose($target);
+            }
+            if ($result === false && $expected !== null) {
+                throw new Exception(
+                    $this->l10n->t(
+                        'Error while copying file to target location (copied: %1$s, expected filesize: %2$s)',
+                        [
+                            $this->l10n->n('%n byte', '%n bytes', $count),
+                            $this->l10n->n('%n byte', '%n bytes', $expected),
+                        ],
+                    )
+                );
+            }
+
+            // if content length is sent by client:
+            // double check if the file was fully received
+            // compare expected and actual size
+            if ($expected !== null
+                && $expected !== $count
+                && $this->request->getMethod() === 'PUT'
+            ) {
+                throw new BadRequest(
+                    $this->l10n->t(
+                        'Expected filesize of %1$s but read (from Nextcloud client) and wrote (to Nextcloud storage) %2$s. Could either be a network problem on the sending side or a problem writing to the storage on the server side.',
+                        [
+                            $this->l10n->n('%n byte', '%n bytes', $expected),
+                            $this->l10n->n('%n byte', '%n bytes', $count),
+                        ],
+                    )
+                );
+            }
+        } catch (\Exception $e) {
+            if ($e instanceof LockedException) {
+                Server::get(LoggerInterface::class)->debug($e->getMessage(), ['exception' => $e]);
+            } else {
+                Server::get(LoggerInterface::class)->error($e->getMessage(), ['exception' => $e]);
+            }
+
+            if ($needsPartFile) {
+                $partStorage->unlink($internalPartPath);
+            }
+            $this->convertToSabreException($e);
+        }
+
+        try {
+            if ($needsPartFile) {
+                if ($view && !$this->emitPreHooks($exists)) {
+                    $partStorage->unlink($internalPartPath);
+                    throw new Exception($this->l10n->t('Could not rename part file to final file, canceled by hook'));
+                }
+                try {
+                    $this->changeLock(ILockingProvider::LOCK_EXCLUSIVE);
+                } catch (LockedException $e) {
+                    // during very large uploads, the shared lock we got at the start might have been expired
+                    // meaning that the above lock can fail not just only because somebody else got a shared lock
+                    // or because there is no existing shared lock to make exclusive
+                    //
+                    // Thus we try to get a new exclusive lock, if the original lock failed because of a different shared
+                    // lock this will still fail, if our original shared lock expired the new lock will be successful and
+                    // the entire operation will be safe
+
+                    try {
+                        $this->acquireLock(ILockingProvider::LOCK_EXCLUSIVE);
+                    } catch (LockedException $ex) {
+                        if ($needsPartFile) {
+                            $partStorage->unlink($internalPartPath);
+                        }
+                        throw new FileLocked($e->getMessage(), $e->getCode(), $e);
+                    }
+                }
+
+                // rename to correct path
+                try {
+                    $renameOkay = $storage->moveFromStorage($partStorage, $internalPartPath, $internalPath);
+                    $fileExists = $storage->file_exists($internalPath);
+                    if ($renameOkay === false || $fileExists === false) {
+                        Server::get(LoggerInterface::class)->error('renaming part file to final file failed $renameOkay: ' . ($renameOkay ? 'true' : 'false') . ', $fileExists: ' . ($fileExists ? 'true' : 'false') . ')', ['app' => 'webdav']);
+                        throw new Exception($this->l10n->t('Could not rename part file to final file'));
+                    }
+                } catch (ForbiddenException $ex) {
+                    if (!$ex->getRetry()) {
+                        $partStorage->unlink($internalPartPath);
+                    }
+                    throw new DAVForbiddenException($ex->getMessage(), $ex->getRetry());
+                } catch (\Exception $e) {
+                    $partStorage->unlink($internalPartPath);
+                    $this->convertToSabreException($e);
+                }
+            }
+
+            // since we skipped the view we need to scan and emit the hooks ourselves
+            $storage->getUpdater()->update($internalPath);
+
+            try {
+                $this->changeLock(ILockingProvider::LOCK_SHARED);
+            } catch (LockedException $e) {
+                throw new FileLocked($e->getMessage(), $e->getCode(), $e);
+            }
+
+            // allow sync clients to send the mtime along in a header
+            $mtimeHeader = $this->request->getHeader('x-oc-mtime');
+            if ($mtimeHeader !== '') {
+                $mtime = $this->sanitizeMtime($mtimeHeader);
+                if ($this->fileView->touch($this->path, $mtime)) {
+                    $this->header('X-OC-MTime: accepted');
+                }
+            }
+
+            $fileInfoUpdate = [
+                'upload_time' => time()
+            ];
+
+            // allow sync clients to send the creation time along in a header
+            $ctimeHeader = $this->request->getHeader('x-oc-ctime');
+            if ($ctimeHeader) {
+                $ctime = $this->sanitizeMtime($ctimeHeader);
+                $fileInfoUpdate['creation_time'] = $ctime;
+                $this->header('X-OC-CTime: accepted');
+            }
+
+            $this->fileView->putFileInfo($this->path, $fileInfoUpdate);
+
+            if ($view) {
+                $this->emitPostHooks($exists);
+            }
+
+            $this->refreshInfo();
+
+            $checksumHeader = $this->request->getHeader('oc-checksum');
+            if ($checksumHeader) {
+                $checksum = trim($checksumHeader);
+                $this->setChecksum($checksum);
+            } elseif ($this->getChecksum() !== null && $this->getChecksum() !== '') {
+                $this->setChecksum('');
+            }
+        } catch (StorageNotAvailableException $e) {
+            throw new ServiceUnavailable($this->l10n->t('Failed to check file size: %1$s', [$e->getMessage()]), 0, $e);
+        }
+
+        return '"' . $this->info->getEtag() . '"';
+    }
+
+    private function getPartFileBasePath($path) {
+        $partFileInStorage = Server::get(IConfig::class)->getSystemValue('part_file_in_storage', true);
+        if ($partFileInStorage) {
+            $filename = basename($path);
+            // hash does not need to be secure but fast and semi unique
+            $hashedFilename = hash('xxh128', $filename);
+            return substr($path, 0, strlen($path) - strlen($filename)) . $hashedFilename;
+        } else {
+            // will place the .part file in the users root directory
+            // therefor we need to make the name (semi) unique - hash does not need to be secure but fast.
+            return hash('xxh128', $path);
+        }
+    }
+
+    private function emitPreHooks(bool $exists, ?string $path = null): bool {
+        if (is_null($path)) {
+            $path = $this->path;
+        }
+        $hookPath = Filesystem::getView()->getRelativePath($this->fileView->getAbsolutePath($path));
+        if ($hookPath === null) {
+            // We only trigger hooks from inside default view
+            return true;
+        }
+        $run = true;
+
+        if (!$exists) {
+            \OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_create, [
+                Filesystem::signal_param_path => $hookPath,
+                Filesystem::signal_param_run => &$run,
+            ]);
+        } else {
+            \OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_update, [
+                Filesystem::signal_param_path => $hookPath,
+                Filesystem::signal_param_run => &$run,
+            ]);
+        }
+        \OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_write, [
+            Filesystem::signal_param_path => $hookPath,
+            Filesystem::signal_param_run => &$run,
+        ]);
+        return $run;
+    }
+
+    private function emitPostHooks(bool $exists, ?string $path = null): void {
+        if (is_null($path)) {
+            $path = $this->path;
+        }
+        $hookPath = Filesystem::getView()->getRelativePath($this->fileView->getAbsolutePath($path));
+        if ($hookPath === null) {
+            // We only trigger hooks from inside default view
+            return;
+        }
+        if (!$exists) {
+            \OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_post_create, [
+                Filesystem::signal_param_path => $hookPath
+            ]);
+        } else {
+            \OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_post_update, [
+                Filesystem::signal_param_path => $hookPath
+            ]);
+        }
+        \OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_post_write, [
+            Filesystem::signal_param_path => $hookPath
+        ]);
+    }
+
+    /**
+     * Returns the data
+     *
+     * @return resource
+     * @throws Forbidden
+     * @throws ServiceUnavailable
+     */
+    public function get() {
+        //throw exception if encryption is disabled but files are still encrypted
+        try {
+            if (!$this->info->isReadable()) {
+                // do a if the file did not exist
+                throw new NotFound();
+            }
+            $path = ltrim($this->path, '/');
+            try {
+                $res = $this->fileView->fopen($path, 'rb');
+            } catch (\Exception $e) {
+                $this->convertToSabreException($e);
+            }
+
+            if ($res === false) {
+                if ($this->fileView->file_exists($path)) {
+                    throw new ServiceUnavailable($this->l10n->t('Could not open file: %1$s, file does seem to exist', [$path]));
+                } else {
+                    throw new ServiceUnavailable($this->l10n->t('Could not open file: %1$s, file doesn\'t seem to exist', [$path]));
+                }
+            }
+
+            // comparing current file size with the one in DB
+            // if different, fix DB and refresh cache.
+            if ($this->getSize() !== $this->fileView->filesize($this->getPath())) {
+                $logger = Server::get(LoggerInterface::class);
+                $logger->warning('fixing cached size of file id=' . $this->getId());
+
+                $this->getFileInfo()->getStorage()->getUpdater()->update($this->getFileInfo()->getInternalPath());
+                $this->refreshInfo();
+            }
+
+            return $res;
+        } catch (GenericEncryptionException $e) {
+            // returning 503 will allow retry of the operation at a later point in time
+            throw new ServiceUnavailable($this->l10n->t('Encryption not ready: %1$s', [$e->getMessage()]));
+        } catch (StorageNotAvailableException $e) {
+            throw new ServiceUnavailable($this->l10n->t('Failed to open file: %1$s', [$e->getMessage()]));
+        } catch (ForbiddenException $ex) {
+            throw new DAVForbiddenException($ex->getMessage(), $ex->getRetry());
+        } catch (LockedException $e) {
+            throw new FileLocked($e->getMessage(), $e->getCode(), $e);
+        }
+    }
+
+    /**
+     * Delete the current file
+     *
+     * @throws Forbidden
+     * @throws ServiceUnavailable
+     */
+    public function delete() {
+        if (!$this->info->isDeletable()) {
+            throw new Forbidden();
+        }
+
+        try {
+            if (!$this->fileView->unlink($this->path)) {
+                // assume it wasn't possible to delete due to permissions
+                throw new Forbidden();
+            }
+        } catch (StorageNotAvailableException $e) {
+            throw new ServiceUnavailable($this->l10n->t('Failed to unlink: %1$s', [$e->getMessage()]));
+        } catch (ForbiddenException $ex) {
+            throw new DAVForbiddenException($ex->getMessage(), $ex->getRetry());
+        } catch (LockedException $e) {
+            throw new FileLocked($e->getMessage(), $e->getCode(), $e);
+        }
+    }
+
+    /**
+     * Returns the mime-type for a file
+     *
+     * If null is returned, we'll assume application/octet-stream
+     *
+     * @return string
+     */
+    public function getContentType() {
+        $mimeType = $this->info->getMimetype();
+
+        // PROPFIND needs to return the correct mime type, for consistency with the web UI
+        if ($this->request->getMethod() === 'PROPFIND') {
+            return $mimeType;
+        }
+        return Server::get(IMimeTypeDetector::class)->getSecureMimeType($mimeType);
+    }
+
+    /**
+     * @throws NotFoundException
+     * @throws NotPermittedException
+     */
+    public function getDirectDownload(): array|false {
+        if (Server::get(IAppManager::class)->isEnabledForUser('encryption')) {
+            return false;
+        }
+        $node = $this->getNode();
+        $storage = $node->getStorage();
+        if (!$storage) {
+            return false;
+        }
+
+        if (!($node->getPermissions() & Constants::PERMISSION_READ)) {
+            return false;
+        }
+
+        return $storage->getDirectDownloadById((string)$node->getId());
+    }
+
+    /**
+     * Convert the given exception to a SabreException instance
+     *
+     * @param \Exception $e
+     *
+     * @throws \Sabre\DAV\Exception
+     */
+    private function convertToSabreException(\Exception $e) {
+        if ($e instanceof \Sabre\DAV\Exception) {
+            throw $e;
+        }
+        if ($e instanceof NotPermittedException) {
+            // a more general case - due to whatever reason the content could not be written
+            throw new Forbidden($e->getMessage(), 0, $e);
+        }
+        if ($e instanceof ForbiddenException) {
+            // the path for the file was forbidden
+            throw new DAVForbiddenException($e->getMessage(), $e->getRetry(), $e);
+        }
+        if ($e instanceof EntityTooLargeException) {
+            // the file is too big to be stored
+            throw new EntityTooLarge($e->getMessage(), 0, $e);
+        }
+        if ($e instanceof InvalidContentException) {
+            // the file content is not permitted
+            throw new UnsupportedMediaType($e->getMessage(), 0, $e);
+        }
+        if ($e instanceof InvalidPathException) {
+            // the path for the file was not valid
+            // TODO: find proper http status code for this case
+            throw new Forbidden($e->getMessage(), 0, $e);
+        }
+        if ($e instanceof LockedException || $e instanceof LockNotAcquiredException) {
+            // the file is currently being written to by another process
+            throw new FileLocked($e->getMessage(), $e->getCode(), $e);
+        }
+        if ($e instanceof GenericEncryptionException) {
+            // returning 503 will allow retry of the operation at a later point in time
+            throw new ServiceUnavailable($this->l10n->t('Encryption not ready: %1$s', [$e->getMessage()]), 0, $e);
+        }
+        if ($e instanceof StorageNotAvailableException) {
+            throw new ServiceUnavailable($this->l10n->t('Failed to write file contents: %1$s', [$e->getMessage()]), 0, $e);
+        }
+        if ($e instanceof NotFoundException) {
+            throw new NotFound($this->l10n->t('File not found: %1$s', [$e->getMessage()]), 0, $e);
+        }
+
+        throw new \Sabre\DAV\Exception($e->getMessage(), 0, $e);
+    }
+
+    /**
+     * Get the checksum for this file
+     *
+     * @return string|null
+     */
+    public function getChecksum() {
+        return $this->info->getChecksum();
+    }
+
+    public function setChecksum(string $checksum) {
+        $this->fileView->putFileInfo($this->path, ['checksum' => $checksum]);
+        $this->refreshInfo();
+    }
+
+    protected function header($string) {
+        if (!\OC::$CLI) {
+            \header($string);
+        }
+    }
+
+    public function hash(string $type) {
+        return $this->fileView->hash($type, $this->path);
+    }
+
+    public function getNode(): \OCP\Files\File {
+        return $this->node;
+    }
 }

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

Indentation +711 added lines, -711 removed lines

@@ -40,715 +40,715 @@
 use Sabre\HTTP\ResponseInterface;
 
 class FilesPlugin extends ServerPlugin {
-	// namespace
-	public const NS_OWNCLOUD = 'http://owncloud.org/ns';
-	public const NS_NEXTCLOUD = 'http://nextcloud.org/ns';
-	public const FILEID_PROPERTYNAME = '{http://owncloud.org/ns}id';
-	public const INTERNAL_FILEID_PROPERTYNAME = '{http://owncloud.org/ns}fileid';
-	public const PERMISSIONS_PROPERTYNAME = '{http://owncloud.org/ns}permissions';
-	public const SHARE_PERMISSIONS_PROPERTYNAME = '{http://open-collaboration-services.org/ns}share-permissions';
-	public const OCM_SHARE_PERMISSIONS_PROPERTYNAME = '{http://open-cloud-mesh.org/ns}share-permissions';
-	public const SHARE_ATTRIBUTES_PROPERTYNAME = '{http://nextcloud.org/ns}share-attributes';
-	public const DOWNLOADURL_PROPERTYNAME = '{http://owncloud.org/ns}downloadURL';
-	public const DOWNLOADURL_EXPIRATION_PROPERTYNAME = '{http://nextcloud.org/ns}download-url-expiration';
-	public const SIZE_PROPERTYNAME = '{http://owncloud.org/ns}size';
-	public const GETETAG_PROPERTYNAME = '{DAV:}getetag';
-	public const LASTMODIFIED_PROPERTYNAME = '{DAV:}lastmodified';
-	public const CREATIONDATE_PROPERTYNAME = '{DAV:}creationdate';
-	public const DISPLAYNAME_PROPERTYNAME = '{DAV:}displayname';
-	public const OWNER_ID_PROPERTYNAME = '{http://owncloud.org/ns}owner-id';
-	public const OWNER_DISPLAY_NAME_PROPERTYNAME = '{http://owncloud.org/ns}owner-display-name';
-	public const CHECKSUMS_PROPERTYNAME = '{http://owncloud.org/ns}checksums';
-	public const DATA_FINGERPRINT_PROPERTYNAME = '{http://owncloud.org/ns}data-fingerprint';
-	public const HAS_PREVIEW_PROPERTYNAME = '{http://nextcloud.org/ns}has-preview';
-	public const MOUNT_TYPE_PROPERTYNAME = '{http://nextcloud.org/ns}mount-type';
-	public const MOUNT_ROOT_PROPERTYNAME = '{http://nextcloud.org/ns}is-mount-root';
-	public const IS_FEDERATED_PROPERTYNAME = '{http://nextcloud.org/ns}is-federated';
-	public const METADATA_ETAG_PROPERTYNAME = '{http://nextcloud.org/ns}metadata_etag';
-	public const UPLOAD_TIME_PROPERTYNAME = '{http://nextcloud.org/ns}upload_time';
-	public const CREATION_TIME_PROPERTYNAME = '{http://nextcloud.org/ns}creation_time';
-	public const SHARE_NOTE = '{http://nextcloud.org/ns}note';
-	public const SHARE_HIDE_DOWNLOAD_PROPERTYNAME = '{http://nextcloud.org/ns}hide-download';
-	public const SUBFOLDER_COUNT_PROPERTYNAME = '{http://nextcloud.org/ns}contained-folder-count';
-	public const SUBFILE_COUNT_PROPERTYNAME = '{http://nextcloud.org/ns}contained-file-count';
-	public const FILE_METADATA_PREFIX = '{http://nextcloud.org/ns}metadata-';
-	public const HIDDEN_PROPERTYNAME = '{http://nextcloud.org/ns}hidden';
-
-	/** Reference to main server object */
-	private ?Server $server = null;
-
-	/**
-	 * @param Tree $tree
-	 * @param IConfig $config
-	 * @param IRequest $request
-	 * @param IPreview $previewManager
-	 * @param IUserSession $userSession
-	 * @param bool $isPublic Whether this is public WebDAV. If true, some returned information will be stripped off.
-	 * @param bool $downloadAttachment
-	 * @return void
-	 */
-	public function __construct(
-		private Tree $tree,
-		private IConfig $config,
-		private IRequest $request,
-		private IPreview $previewManager,
-		private IUserSession $userSession,
-		private IFilenameValidator $validator,
-		private IAccountManager $accountManager,
-		private bool $isPublic = false,
-		private bool $downloadAttachment = true,
-	) {
-	}
-
-	/**
-	 * This initializes the plugin.
-	 *
-	 * This function is called by \Sabre\DAV\Server, after
-	 * addPlugin is called.
-	 *
-	 * This method should set up the required event subscriptions.
-	 *
-	 * @return void
-	 */
-	public function initialize(Server $server) {
-		$server->xml->namespaceMap[self::NS_OWNCLOUD] = 'oc';
-		$server->xml->namespaceMap[self::NS_NEXTCLOUD] = 'nc';
-		$server->protectedProperties[] = self::FILEID_PROPERTYNAME;
-		$server->protectedProperties[] = self::INTERNAL_FILEID_PROPERTYNAME;
-		$server->protectedProperties[] = self::PERMISSIONS_PROPERTYNAME;
-		$server->protectedProperties[] = self::SHARE_PERMISSIONS_PROPERTYNAME;
-		$server->protectedProperties[] = self::OCM_SHARE_PERMISSIONS_PROPERTYNAME;
-		$server->protectedProperties[] = self::SHARE_ATTRIBUTES_PROPERTYNAME;
-		$server->protectedProperties[] = self::SIZE_PROPERTYNAME;
-		$server->protectedProperties[] = self::DOWNLOADURL_PROPERTYNAME;
-		$server->protectedProperties[] = self::DOWNLOADURL_EXPIRATION_PROPERTYNAME;
-		$server->protectedProperties[] = self::OWNER_ID_PROPERTYNAME;
-		$server->protectedProperties[] = self::OWNER_DISPLAY_NAME_PROPERTYNAME;
-		$server->protectedProperties[] = self::CHECKSUMS_PROPERTYNAME;
-		$server->protectedProperties[] = self::DATA_FINGERPRINT_PROPERTYNAME;
-		$server->protectedProperties[] = self::HAS_PREVIEW_PROPERTYNAME;
-		$server->protectedProperties[] = self::MOUNT_TYPE_PROPERTYNAME;
-		$server->protectedProperties[] = self::IS_FEDERATED_PROPERTYNAME;
-		$server->protectedProperties[] = self::SHARE_NOTE;
-
-		// normally these cannot be changed (RFC4918), but we want them modifiable through PROPPATCH
-		$allowedProperties = ['{DAV:}getetag'];
-		$server->protectedProperties = array_diff($server->protectedProperties, $allowedProperties);
-
-		$this->server = $server;
-		$this->server->on('propFind', [$this, 'handleGetProperties']);
-		$this->server->on('propPatch', [$this, 'handleUpdateProperties']);
-		$this->server->on('afterBind', [$this, 'sendFileIdHeader']);
-		$this->server->on('afterWriteContent', [$this, 'sendFileIdHeader']);
-		$this->server->on('afterMethod:GET', [$this,'httpGet']);
-		$this->server->on('afterMethod:GET', [$this, 'handleDownloadToken']);
-		$this->server->on('afterResponse', function ($request, ResponseInterface $response): void {
-			$body = $response->getBody();
-			if (is_resource($body)) {
-				fclose($body);
-			}
-		});
-		$this->server->on('beforeMove', [$this, 'checkMove']);
-		$this->server->on('beforeCopy', [$this, 'checkCopy']);
-	}
-
-	/**
-	 * Plugin that checks if a copy can actually be performed.
-	 *
-	 * @param string $source source path
-	 * @param string $target target path
-	 * @throws NotFound If the source does not exist
-	 * @throws InvalidPath If the target is invalid
-	 */
-	public function checkCopy($source, $target): void {
-		$sourceNode = $this->tree->getNodeForPath($source);
-		if (!$sourceNode instanceof Node) {
-			return;
-		}
-
-		// Ensure source exists
-		$sourceNodeFileInfo = $sourceNode->getFileInfo();
-		if ($sourceNodeFileInfo === null) {
-			throw new NotFound($source . ' does not exist');
-		}
-		// Ensure the target name is valid
-		try {
-			[$targetPath, $targetName] = \Sabre\Uri\split($target);
-			$this->validator->validateFilename($targetName);
-		} catch (InvalidPathException $e) {
-			throw new InvalidPath($e->getMessage(), false);
-		}
-		// Ensure the target path is valid
-		$segments = array_slice(explode('/', $targetPath), 2);
-		foreach ($segments as $segment) {
-			if ($this->validator->isFilenameValid($segment) === false) {
-				$l = \OCP\Server::get(IFactory::class)->get('dav');
-				throw new InvalidPath($l->t('Invalid target path'));
-			}
-		}
-	}
-
-	/**
-	 * Plugin that checks if a move can actually be performed.
-	 *
-	 * @param string $source source path
-	 * @param string $target target path
-	 * @throws Forbidden If the source is not deletable
-	 * @throws NotFound If the source does not exist
-	 * @throws InvalidPath If the target name is invalid
-	 */
-	public function checkMove(string $source, string $target): void {
-		$sourceNode = $this->tree->getNodeForPath($source);
-		if (!$sourceNode instanceof Node) {
-			return;
-		}
-
-		// First check copyable (move only needs additional delete permission)
-		$this->checkCopy($source, $target);
-
-		// The source needs to be deletable for moving
-		$sourceNodeFileInfo = $sourceNode->getFileInfo();
-		if (!$sourceNodeFileInfo->isDeletable()) {
-			throw new Forbidden($source . ' cannot be deleted');
-		}
-
-		// The source is not allowed to be the parent of the target
-		if (str_starts_with($source, $target . '/')) {
-			throw new Forbidden($source . ' cannot be moved to it\'s parent');
-		}
-	}
-
-	/**
-	 * This sets a cookie to be able to recognize the start of the download
-	 * the content must not be longer than 32 characters and must only contain
-	 * alphanumeric characters
-	 *
-	 * @param RequestInterface $request
-	 * @param ResponseInterface $response
-	 */
-	public function handleDownloadToken(RequestInterface $request, ResponseInterface $response) {
-		$queryParams = $request->getQueryParameters();
-
-		/**
-		 * this sets a cookie to be able to recognize the start of the download
-		 * the content must not be longer than 32 characters and must only contain
-		 * alphanumeric characters
-		 */
-		if (isset($queryParams['downloadStartSecret'])) {
-			$token = $queryParams['downloadStartSecret'];
-			if (!isset($token[32])
-				&& preg_match('!^[a-zA-Z0-9]+$!', $token) === 1) {
-				// FIXME: use $response->setHeader() instead
-				setcookie('ocDownloadStarted', $token, time() + 20, '/');
-			}
-		}
-	}
-
-	/**
-	 * Add headers to file download
-	 *
-	 * @param RequestInterface $request
-	 * @param ResponseInterface $response
-	 */
-	public function httpGet(RequestInterface $request, ResponseInterface $response) {
-		// Only handle valid files
-		$node = $this->tree->getNodeForPath($request->getPath());
-		if (!($node instanceof IFile)) {
-			return;
-		}
-
-		// adds a 'Content-Disposition: attachment' header in case no disposition
-		// header has been set before
-		if ($this->downloadAttachment
-			&& $response->getHeader('Content-Disposition') === null) {
-			$filename = $node->getName();
-			if ($this->request->isUserAgent(
-				[
-					Request::USER_AGENT_IE,
-					Request::USER_AGENT_ANDROID_MOBILE_CHROME,
-					Request::USER_AGENT_FREEBOX,
-				])) {
-				$response->addHeader('Content-Disposition', 'attachment; filename="' . rawurlencode($filename) . '"');
-			} else {
-				$response->addHeader('Content-Disposition', 'attachment; filename*=UTF-8\'\'' . rawurlencode($filename)
-													 . '; filename="' . rawurlencode($filename) . '"');
-			}
-		}
-
-		if ($node instanceof File) {
-			//Add OC-Checksum header
-			$checksum = $node->getChecksum();
-			if ($checksum !== null && $checksum !== '') {
-				$response->addHeader('OC-Checksum', $checksum);
-			}
-		}
-		$response->addHeader('X-Accel-Buffering', 'no');
-	}
-
-	/**
-	 * Adds all ownCloud-specific properties
-	 *
-	 * @param PropFind $propFind
-	 * @param \Sabre\DAV\INode $node
-	 * @return void
-	 */
-	public function handleGetProperties(PropFind $propFind, \Sabre\DAV\INode $node) {
-		$httpRequest = $this->server->httpRequest;
-
-		if ($node instanceof Node) {
-			/**
-			 * This was disabled, because it made dir listing throw an exception,
-			 * so users were unable to navigate into folders where one subitem
-			 * is blocked by the files_accesscontrol app, see:
-			 * https://github.com/nextcloud/files_accesscontrol/issues/65
-			 * if (!$node->getFileInfo()->isReadable()) {
-			 *     // avoid detecting files through this means
-			 *     throw new NotFound();
-			 * }
-			 */
-
-			$propFind->handle(self::FILEID_PROPERTYNAME, function () use ($node) {
-				return $node->getFileId();
-			});
-
-			$propFind->handle(self::INTERNAL_FILEID_PROPERTYNAME, function () use ($node) {
-				return $node->getInternalFileId();
-			});
-
-			$propFind->handle(self::PERMISSIONS_PROPERTYNAME, function () use ($node) {
-				$perms = $node->getDavPermissions();
-				if ($this->isPublic) {
-					// remove mount information
-					$perms = str_replace(['S', 'M'], '', $perms);
-				}
-				return $perms;
-			});
-
-			$propFind->handle(self::SHARE_PERMISSIONS_PROPERTYNAME, function () use ($node, $httpRequest) {
-				$user = $this->userSession->getUser();
-				if ($user === null) {
-					return null;
-				}
-				return $node->getSharePermissions(
-					$user->getUID()
-				);
-			});
-
-			$propFind->handle(self::OCM_SHARE_PERMISSIONS_PROPERTYNAME, function () use ($node, $httpRequest): ?string {
-				$user = $this->userSession->getUser();
-				if ($user === null) {
-					return null;
-				}
-				$ncPermissions = $node->getSharePermissions(
-					$user->getUID()
-				);
-				$ocmPermissions = $this->ncPermissions2ocmPermissions($ncPermissions);
-				return json_encode($ocmPermissions, JSON_THROW_ON_ERROR);
-			});
-
-			$propFind->handle(self::SHARE_ATTRIBUTES_PROPERTYNAME, function () use ($node, $httpRequest) {
-				return json_encode($node->getShareAttributes(), JSON_THROW_ON_ERROR);
-			});
-
-			$propFind->handle(self::GETETAG_PROPERTYNAME, function () use ($node): string {
-				return $node->getETag();
-			});
-
-			$propFind->handle(self::OWNER_ID_PROPERTYNAME, function () use ($node): ?string {
-				$owner = $node->getOwner();
-				if (!$owner) {
-					return null;
-				} else {
-					return $owner->getUID();
-				}
-			});
-			$propFind->handle(self::OWNER_DISPLAY_NAME_PROPERTYNAME, function () use ($node): ?string {
-				$owner = $node->getOwner();
-				if (!$owner) {
-					return null;
-				}
-
-				// Get current user to see if we're in a public share or not
-				$user = $this->userSession->getUser();
-
-				// If the user is logged in, we can return the display name
-				if ($user !== null) {
-					return $owner->getDisplayName();
-				}
-
-				// Check if the user published their display name
-				try {
-					$ownerAccount = $this->accountManager->getAccount($owner);
-				} catch (NoUserException) {
-					// do not lock process if owner is not local
-					return null;
-				}
-
-				$ownerNameProperty = $ownerAccount->getProperty(IAccountManager::PROPERTY_DISPLAYNAME);
-
-				// Since we are not logged in, we need to have at least the published scope
-				if ($ownerNameProperty->getScope() === IAccountManager::SCOPE_PUBLISHED) {
-					return $owner->getDisplayName();
-				}
-
-				return null;
-			});
-
-			$propFind->handle(self::HAS_PREVIEW_PROPERTYNAME, function () use ($node) {
-				return json_encode($this->previewManager->isAvailable($node->getFileInfo()), JSON_THROW_ON_ERROR);
-			});
-			$propFind->handle(self::SIZE_PROPERTYNAME, function () use ($node): int|float {
-				return $node->getSize();
-			});
-			$propFind->handle(self::MOUNT_TYPE_PROPERTYNAME, function () use ($node) {
-				return $node->getFileInfo()->getMountPoint()->getMountType();
-			});
-
-			/**
-			 * This is a special property which is used to determine if a node
-			 * is a mount root or not, e.g. a shared folder.
-			 * If so, then the node can only be unshared and not deleted.
-			 * @see https://github.com/nextcloud/server/blob/cc75294eb6b16b916a342e69998935f89222619d/lib/private/Files/View.php#L696-L698
-			 */
-			$propFind->handle(self::MOUNT_ROOT_PROPERTYNAME, function () use ($node) {
-				return $node->getNode()->getInternalPath() === '' ? 'true' : 'false';
-			});
-
-			$propFind->handle(self::SHARE_NOTE, function () use ($node): ?string {
-				$user = $this->userSession->getUser();
-				return $node->getNoteFromShare(
-					$user?->getUID()
-				);
-			});
-
-			$propFind->handle(self::SHARE_HIDE_DOWNLOAD_PROPERTYNAME, function () use ($node) {
-				$storage = $node->getNode()->getStorage();
-				if ($storage->instanceOfStorage(ISharedStorage::class)) {
-					/** @var ISharedStorage $storage */
-					return match($storage->getShare()->getHideDownload()) {
-						true => 'true',
-						false => 'false',
-					};
-				} else {
-					return null;
-				}
-			});
-
-			$propFind->handle(self::DATA_FINGERPRINT_PROPERTYNAME, function () {
-				return $this->config->getSystemValue('data-fingerprint', '');
-			});
-			$propFind->handle(self::CREATIONDATE_PROPERTYNAME, function () use ($node) {
-				return (new \DateTimeImmutable())
-					->setTimestamp($node->getFileInfo()->getCreationTime())
-					->format(\DateTimeInterface::ATOM);
-			});
-			$propFind->handle(self::CREATION_TIME_PROPERTYNAME, function () use ($node) {
-				return $node->getFileInfo()->getCreationTime();
-			});
-
-			foreach ($node->getFileInfo()->getMetadata() as $metadataKey => $metadataValue) {
-				$propFind->handle(self::FILE_METADATA_PREFIX . $metadataKey, $metadataValue);
-			}
-
-			$propFind->handle(self::HIDDEN_PROPERTYNAME, function () use ($node) {
-				$isLivePhoto = isset($node->getFileInfo()->getMetadata()['files-live-photo']);
-				$isMovFile = $node->getFileInfo()->getMimetype() === 'video/quicktime';
-				return ($isLivePhoto && $isMovFile) ? 'true' : 'false';
-			});
-
-			/**
-			 * Return file/folder name as displayname. The primary reason to
-			 * implement it this way is to avoid costly fallback to
-			 * CustomPropertiesBackend (esp. visible when querying all files
-			 * in a folder).
-			 */
-			$propFind->handle(self::DISPLAYNAME_PROPERTYNAME, function () use ($node) {
-				return $node->getName();
-			});
-
-			$propFind->handle(self::IS_FEDERATED_PROPERTYNAME, function () use ($node) {
-				return $node->getFileInfo()->getMountPoint()
-					instanceof SharingExternalMount;
-			});
-		}
-
-		if ($node instanceof File) {
-			$requestProperties = $propFind->getRequestedProperties();
-
-			if (in_array(self::DOWNLOADURL_PROPERTYNAME, $requestProperties, true)
-				|| in_array(self::DOWNLOADURL_EXPIRATION_PROPERTYNAME, $requestProperties, true)) {
-				try {
-					$directDownloadUrl = $node->getDirectDownload();
-				} catch (StorageNotAvailableException|ForbiddenException) {
-					$directDownloadUrl = null;
-				}
-
-				$propFind->handle(self::DOWNLOADURL_PROPERTYNAME, function () use ($node, $directDownloadUrl) {
-					if ($directDownloadUrl && isset($directDownloadUrl['url'])) {
-						return $directDownloadUrl['url'];
-					}
-					return false;
-				});
-
-				$propFind->handle(self::DOWNLOADURL_EXPIRATION_PROPERTYNAME, function () use ($node, $directDownloadUrl) {
-					if ($directDownloadUrl && isset($directDownloadUrl['expiration'])) {
-						return $directDownloadUrl['expiration'];
-					}
-					return false;
-				});
-			}
-
-			$propFind->handle(self::CHECKSUMS_PROPERTYNAME, function () use ($node) {
-				$checksum = $node->getChecksum();
-				if ($checksum === null || $checksum === '') {
-					return null;
-				}
-
-				return new ChecksumList($checksum);
-			});
-
-			$propFind->handle(self::UPLOAD_TIME_PROPERTYNAME, function () use ($node) {
-				return $node->getFileInfo()->getUploadTime();
-			});
-		}
-
-		if ($node instanceof Directory) {
-			$propFind->handle(self::SIZE_PROPERTYNAME, function () use ($node) {
-				return $node->getSize();
-			});
-
-			$requestProperties = $propFind->getRequestedProperties();
-
-			if (in_array(self::SUBFILE_COUNT_PROPERTYNAME, $requestProperties, true)
-				|| in_array(self::SUBFOLDER_COUNT_PROPERTYNAME, $requestProperties, true)) {
-				$nbFiles = 0;
-				$nbFolders = 0;
-				foreach ($node->getChildren() as $child) {
-					if ($child instanceof File) {
-						$nbFiles++;
-					} elseif ($child instanceof Directory) {
-						$nbFolders++;
-					}
-				}
-
-				$propFind->handle(self::SUBFILE_COUNT_PROPERTYNAME, $nbFiles);
-				$propFind->handle(self::SUBFOLDER_COUNT_PROPERTYNAME, $nbFolders);
-			}
-		}
-	}
-
-	/**
-	 * translate Nextcloud permissions to OCM Permissions
-	 *
-	 * @param $ncPermissions
-	 * @return array
-	 */
-	protected function ncPermissions2ocmPermissions($ncPermissions) {
-		$ocmPermissions = [];
-
-		if ($ncPermissions & Constants::PERMISSION_SHARE) {
-			$ocmPermissions[] = 'share';
-		}
-
-		if ($ncPermissions & Constants::PERMISSION_READ) {
-			$ocmPermissions[] = 'read';
-		}
-
-		if (($ncPermissions & Constants::PERMISSION_CREATE)
-			|| ($ncPermissions & Constants::PERMISSION_UPDATE)) {
-			$ocmPermissions[] = 'write';
-		}
-
-		return $ocmPermissions;
-	}
-
-	/**
-	 * Update ownCloud-specific properties
-	 *
-	 * @param string $path
-	 * @param PropPatch $propPatch
-	 *
-	 * @return void
-	 */
-	public function handleUpdateProperties($path, PropPatch $propPatch) {
-		$node = $this->tree->getNodeForPath($path);
-		if (!($node instanceof Node)) {
-			return;
-		}
-
-		$propPatch->handle(self::LASTMODIFIED_PROPERTYNAME, function ($time) use ($node) {
-			if (empty($time)) {
-				return false;
-			}
-			$node->touch($time);
-			return true;
-		});
-		$propPatch->handle(self::GETETAG_PROPERTYNAME, function ($etag) use ($node) {
-			if (empty($etag)) {
-				return false;
-			}
-			return $node->setEtag($etag) !== -1;
-		});
-		$propPatch->handle(self::CREATIONDATE_PROPERTYNAME, function ($time) use ($node) {
-			if (empty($time)) {
-				return false;
-			}
-			$dateTime = new \DateTimeImmutable($time);
-			$node->setCreationTime($dateTime->getTimestamp());
-			return true;
-		});
-		$propPatch->handle(self::CREATION_TIME_PROPERTYNAME, function ($time) use ($node) {
-			if (empty($time)) {
-				return false;
-			}
-			$node->setCreationTime((int)$time);
-			return true;
-		});
-
-		$this->handleUpdatePropertiesMetadata($propPatch, $node);
-
-		/**
-		 * Disable modification of the displayname property for files and
-		 * folders via PROPPATCH. See PROPFIND for more information.
-		 */
-		$propPatch->handle(self::DISPLAYNAME_PROPERTYNAME, function ($displayName) {
-			return 403;
-		});
-	}
-
-
-	/**
-	 * handle the update of metadata from PROPPATCH requests
-	 *
-	 * @param PropPatch $propPatch
-	 * @param Node $node
-	 *
-	 * @throws FilesMetadataException
-	 */
-	private function handleUpdatePropertiesMetadata(PropPatch $propPatch, Node $node): void {
-		$userId = $this->userSession->getUser()?->getUID();
-		if ($userId === null) {
-			return;
-		}
-
-		$accessRight = $this->getMetadataFileAccessRight($node, $userId);
-		$filesMetadataManager = $this->initFilesMetadataManager();
-		$knownMetadata = $filesMetadataManager->getKnownMetadata();
-
-		foreach ($propPatch->getRemainingMutations() as $mutation) {
-			if (!str_starts_with($mutation, self::FILE_METADATA_PREFIX)) {
-				continue;
-			}
-
-			$propPatch->handle(
-				$mutation,
-				function (mixed $value) use ($accessRight, $knownMetadata, $node, $mutation, $filesMetadataManager): bool {
-					/** @var FilesMetadata $metadata */
-					$metadata = $filesMetadataManager->getMetadata((int)$node->getFileId(), true);
-					$metadata->setStorageId($node->getNode()->getStorage()->getCache()->getNumericStorageId());
-					$metadataKey = substr($mutation, strlen(self::FILE_METADATA_PREFIX));
-
-					// confirm metadata key is editable via PROPPATCH
-					if ($knownMetadata->getEditPermission($metadataKey) < $accessRight) {
-						throw new FilesMetadataException('you do not have enough rights to update \'' . $metadataKey . '\' on this node');
-					}
-
-					if ($value === null) {
-						$metadata->unset($metadataKey);
-						$filesMetadataManager->saveMetadata($metadata);
-						return true;
-					}
-
-					// If the metadata is unknown, it defaults to string.
-					try {
-						$type = $knownMetadata->getType($metadataKey);
-					} catch (FilesMetadataNotFoundException) {
-						$type = IMetadataValueWrapper::TYPE_STRING;
-					}
-
-					switch ($type) {
-						case IMetadataValueWrapper::TYPE_STRING:
-							$metadata->setString($metadataKey, $value, $knownMetadata->isIndex($metadataKey));
-							break;
-						case IMetadataValueWrapper::TYPE_INT:
-							$metadata->setInt($metadataKey, $value, $knownMetadata->isIndex($metadataKey));
-							break;
-						case IMetadataValueWrapper::TYPE_FLOAT:
-							$metadata->setFloat($metadataKey, $value);
-							break;
-						case IMetadataValueWrapper::TYPE_BOOL:
-							$metadata->setBool($metadataKey, $value, $knownMetadata->isIndex($metadataKey));
-							break;
-						case IMetadataValueWrapper::TYPE_ARRAY:
-							$metadata->setArray($metadataKey, $value);
-							break;
-						case IMetadataValueWrapper::TYPE_STRING_LIST:
-							$metadata->setStringList($metadataKey, $value, $knownMetadata->isIndex($metadataKey));
-							break;
-						case IMetadataValueWrapper::TYPE_INT_LIST:
-							$metadata->setIntList($metadataKey, $value, $knownMetadata->isIndex($metadataKey));
-							break;
-					}
-
-					$filesMetadataManager->saveMetadata($metadata);
-
-					return true;
-				}
-			);
-		}
-	}
-
-	/**
-	 * init default internal metadata
-	 *
-	 * @return IFilesMetadataManager
-	 */
-	private function initFilesMetadataManager(): IFilesMetadataManager {
-		/** @var IFilesMetadataManager $manager */
-		$manager = \OCP\Server::get(IFilesMetadataManager::class);
-		$manager->initMetadata('files-live-photo', IMetadataValueWrapper::TYPE_STRING, false, IMetadataValueWrapper::EDIT_REQ_WRITE_PERMISSION);
-
-		return $manager;
-	}
-
-	/**
-	 * based on owner and shares, returns the bottom limit to update related metadata
-	 *
-	 * @param Node $node
-	 * @param string $userId
-	 *
-	 * @return int
-	 */
-	private function getMetadataFileAccessRight(Node $node, string $userId): int {
-		if ($node->getOwner()?->getUID() === $userId) {
-			return IMetadataValueWrapper::EDIT_REQ_OWNERSHIP;
-		} else {
-			$filePermissions = $node->getSharePermissions($userId);
-			if ($filePermissions & Constants::PERMISSION_UPDATE) {
-				return IMetadataValueWrapper::EDIT_REQ_WRITE_PERMISSION;
-			}
-		}
-
-		return IMetadataValueWrapper::EDIT_REQ_READ_PERMISSION;
-	}
-
-	/**
-	 * @param string $filePath
-	 * @param ?\Sabre\DAV\INode $node
-	 * @return void
-	 * @throws \Sabre\DAV\Exception\BadRequest
-	 */
-	public function sendFileIdHeader($filePath, ?\Sabre\DAV\INode $node = null) {
-		// we get the node for the given $filePath here because in case of afterCreateFile $node is the parent folder
-		try {
-			$node = $this->server->tree->getNodeForPath($filePath);
-			if ($node instanceof Node) {
-				$fileId = $node->getFileId();
-				if (!is_null($fileId)) {
-					$this->server->httpResponse->setHeader('OC-FileId', $fileId);
-				}
-			}
-		} catch (NotFound) {
-		}
-	}
+    // namespace
+    public const NS_OWNCLOUD = 'http://owncloud.org/ns';
+    public const NS_NEXTCLOUD = 'http://nextcloud.org/ns';
+    public const FILEID_PROPERTYNAME = '{http://owncloud.org/ns}id';
+    public const INTERNAL_FILEID_PROPERTYNAME = '{http://owncloud.org/ns}fileid';
+    public const PERMISSIONS_PROPERTYNAME = '{http://owncloud.org/ns}permissions';
+    public const SHARE_PERMISSIONS_PROPERTYNAME = '{http://open-collaboration-services.org/ns}share-permissions';
+    public const OCM_SHARE_PERMISSIONS_PROPERTYNAME = '{http://open-cloud-mesh.org/ns}share-permissions';
+    public const SHARE_ATTRIBUTES_PROPERTYNAME = '{http://nextcloud.org/ns}share-attributes';
+    public const DOWNLOADURL_PROPERTYNAME = '{http://owncloud.org/ns}downloadURL';
+    public const DOWNLOADURL_EXPIRATION_PROPERTYNAME = '{http://nextcloud.org/ns}download-url-expiration';
+    public const SIZE_PROPERTYNAME = '{http://owncloud.org/ns}size';
+    public const GETETAG_PROPERTYNAME = '{DAV:}getetag';
+    public const LASTMODIFIED_PROPERTYNAME = '{DAV:}lastmodified';
+    public const CREATIONDATE_PROPERTYNAME = '{DAV:}creationdate';
+    public const DISPLAYNAME_PROPERTYNAME = '{DAV:}displayname';
+    public const OWNER_ID_PROPERTYNAME = '{http://owncloud.org/ns}owner-id';
+    public const OWNER_DISPLAY_NAME_PROPERTYNAME = '{http://owncloud.org/ns}owner-display-name';
+    public const CHECKSUMS_PROPERTYNAME = '{http://owncloud.org/ns}checksums';
+    public const DATA_FINGERPRINT_PROPERTYNAME = '{http://owncloud.org/ns}data-fingerprint';
+    public const HAS_PREVIEW_PROPERTYNAME = '{http://nextcloud.org/ns}has-preview';
+    public const MOUNT_TYPE_PROPERTYNAME = '{http://nextcloud.org/ns}mount-type';
+    public const MOUNT_ROOT_PROPERTYNAME = '{http://nextcloud.org/ns}is-mount-root';
+    public const IS_FEDERATED_PROPERTYNAME = '{http://nextcloud.org/ns}is-federated';
+    public const METADATA_ETAG_PROPERTYNAME = '{http://nextcloud.org/ns}metadata_etag';
+    public const UPLOAD_TIME_PROPERTYNAME = '{http://nextcloud.org/ns}upload_time';
+    public const CREATION_TIME_PROPERTYNAME = '{http://nextcloud.org/ns}creation_time';
+    public const SHARE_NOTE = '{http://nextcloud.org/ns}note';
+    public const SHARE_HIDE_DOWNLOAD_PROPERTYNAME = '{http://nextcloud.org/ns}hide-download';
+    public const SUBFOLDER_COUNT_PROPERTYNAME = '{http://nextcloud.org/ns}contained-folder-count';
+    public const SUBFILE_COUNT_PROPERTYNAME = '{http://nextcloud.org/ns}contained-file-count';
+    public const FILE_METADATA_PREFIX = '{http://nextcloud.org/ns}metadata-';
+    public const HIDDEN_PROPERTYNAME = '{http://nextcloud.org/ns}hidden';
+
+    /** Reference to main server object */
+    private ?Server $server = null;
+
+    /**
+     * @param Tree $tree
+     * @param IConfig $config
+     * @param IRequest $request
+     * @param IPreview $previewManager
+     * @param IUserSession $userSession
+     * @param bool $isPublic Whether this is public WebDAV. If true, some returned information will be stripped off.
+     * @param bool $downloadAttachment
+     * @return void
+     */
+    public function __construct(
+        private Tree $tree,
+        private IConfig $config,
+        private IRequest $request,
+        private IPreview $previewManager,
+        private IUserSession $userSession,
+        private IFilenameValidator $validator,
+        private IAccountManager $accountManager,
+        private bool $isPublic = false,
+        private bool $downloadAttachment = true,
+    ) {
+    }
+
+    /**
+     * This initializes the plugin.
+     *
+     * This function is called by \Sabre\DAV\Server, after
+     * addPlugin is called.
+     *
+     * This method should set up the required event subscriptions.
+     *
+     * @return void
+     */
+    public function initialize(Server $server) {
+        $server->xml->namespaceMap[self::NS_OWNCLOUD] = 'oc';
+        $server->xml->namespaceMap[self::NS_NEXTCLOUD] = 'nc';
+        $server->protectedProperties[] = self::FILEID_PROPERTYNAME;
+        $server->protectedProperties[] = self::INTERNAL_FILEID_PROPERTYNAME;
+        $server->protectedProperties[] = self::PERMISSIONS_PROPERTYNAME;
+        $server->protectedProperties[] = self::SHARE_PERMISSIONS_PROPERTYNAME;
+        $server->protectedProperties[] = self::OCM_SHARE_PERMISSIONS_PROPERTYNAME;
+        $server->protectedProperties[] = self::SHARE_ATTRIBUTES_PROPERTYNAME;
+        $server->protectedProperties[] = self::SIZE_PROPERTYNAME;
+        $server->protectedProperties[] = self::DOWNLOADURL_PROPERTYNAME;
+        $server->protectedProperties[] = self::DOWNLOADURL_EXPIRATION_PROPERTYNAME;
+        $server->protectedProperties[] = self::OWNER_ID_PROPERTYNAME;
+        $server->protectedProperties[] = self::OWNER_DISPLAY_NAME_PROPERTYNAME;
+        $server->protectedProperties[] = self::CHECKSUMS_PROPERTYNAME;
+        $server->protectedProperties[] = self::DATA_FINGERPRINT_PROPERTYNAME;
+        $server->protectedProperties[] = self::HAS_PREVIEW_PROPERTYNAME;
+        $server->protectedProperties[] = self::MOUNT_TYPE_PROPERTYNAME;
+        $server->protectedProperties[] = self::IS_FEDERATED_PROPERTYNAME;
+        $server->protectedProperties[] = self::SHARE_NOTE;
+
+        // normally these cannot be changed (RFC4918), but we want them modifiable through PROPPATCH
+        $allowedProperties = ['{DAV:}getetag'];
+        $server->protectedProperties = array_diff($server->protectedProperties, $allowedProperties);
+
+        $this->server = $server;
+        $this->server->on('propFind', [$this, 'handleGetProperties']);
+        $this->server->on('propPatch', [$this, 'handleUpdateProperties']);
+        $this->server->on('afterBind', [$this, 'sendFileIdHeader']);
+        $this->server->on('afterWriteContent', [$this, 'sendFileIdHeader']);
+        $this->server->on('afterMethod:GET', [$this,'httpGet']);
+        $this->server->on('afterMethod:GET', [$this, 'handleDownloadToken']);
+        $this->server->on('afterResponse', function ($request, ResponseInterface $response): void {
+            $body = $response->getBody();
+            if (is_resource($body)) {
+                fclose($body);
+            }
+        });
+        $this->server->on('beforeMove', [$this, 'checkMove']);
+        $this->server->on('beforeCopy', [$this, 'checkCopy']);
+    }
+
+    /**
+     * Plugin that checks if a copy can actually be performed.
+     *
+     * @param string $source source path
+     * @param string $target target path
+     * @throws NotFound If the source does not exist
+     * @throws InvalidPath If the target is invalid
+     */
+    public function checkCopy($source, $target): void {
+        $sourceNode = $this->tree->getNodeForPath($source);
+        if (!$sourceNode instanceof Node) {
+            return;
+        }
+
+        // Ensure source exists
+        $sourceNodeFileInfo = $sourceNode->getFileInfo();
+        if ($sourceNodeFileInfo === null) {
+            throw new NotFound($source . ' does not exist');
+        }
+        // Ensure the target name is valid
+        try {
+            [$targetPath, $targetName] = \Sabre\Uri\split($target);
+            $this->validator->validateFilename($targetName);
+        } catch (InvalidPathException $e) {
+            throw new InvalidPath($e->getMessage(), false);
+        }
+        // Ensure the target path is valid
+        $segments = array_slice(explode('/', $targetPath), 2);
+        foreach ($segments as $segment) {
+            if ($this->validator->isFilenameValid($segment) === false) {
+                $l = \OCP\Server::get(IFactory::class)->get('dav');
+                throw new InvalidPath($l->t('Invalid target path'));
+            }
+        }
+    }
+
+    /**
+     * Plugin that checks if a move can actually be performed.
+     *
+     * @param string $source source path
+     * @param string $target target path
+     * @throws Forbidden If the source is not deletable
+     * @throws NotFound If the source does not exist
+     * @throws InvalidPath If the target name is invalid
+     */
+    public function checkMove(string $source, string $target): void {
+        $sourceNode = $this->tree->getNodeForPath($source);
+        if (!$sourceNode instanceof Node) {
+            return;
+        }
+
+        // First check copyable (move only needs additional delete permission)
+        $this->checkCopy($source, $target);
+
+        // The source needs to be deletable for moving
+        $sourceNodeFileInfo = $sourceNode->getFileInfo();
+        if (!$sourceNodeFileInfo->isDeletable()) {
+            throw new Forbidden($source . ' cannot be deleted');
+        }
+
+        // The source is not allowed to be the parent of the target
+        if (str_starts_with($source, $target . '/')) {
+            throw new Forbidden($source . ' cannot be moved to it\'s parent');
+        }
+    }
+
+    /**
+     * This sets a cookie to be able to recognize the start of the download
+     * the content must not be longer than 32 characters and must only contain
+     * alphanumeric characters
+     *
+     * @param RequestInterface $request
+     * @param ResponseInterface $response
+     */
+    public function handleDownloadToken(RequestInterface $request, ResponseInterface $response) {
+        $queryParams = $request->getQueryParameters();
+
+        /**
+         * this sets a cookie to be able to recognize the start of the download
+         * the content must not be longer than 32 characters and must only contain
+         * alphanumeric characters
+         */
+        if (isset($queryParams['downloadStartSecret'])) {
+            $token = $queryParams['downloadStartSecret'];
+            if (!isset($token[32])
+                && preg_match('!^[a-zA-Z0-9]+$!', $token) === 1) {
+                // FIXME: use $response->setHeader() instead
+                setcookie('ocDownloadStarted', $token, time() + 20, '/');
+            }
+        }
+    }
+
+    /**
+     * Add headers to file download
+     *
+     * @param RequestInterface $request
+     * @param ResponseInterface $response
+     */
+    public function httpGet(RequestInterface $request, ResponseInterface $response) {
+        // Only handle valid files
+        $node = $this->tree->getNodeForPath($request->getPath());
+        if (!($node instanceof IFile)) {
+            return;
+        }
+
+        // adds a 'Content-Disposition: attachment' header in case no disposition
+        // header has been set before
+        if ($this->downloadAttachment
+            && $response->getHeader('Content-Disposition') === null) {
+            $filename = $node->getName();
+            if ($this->request->isUserAgent(
+                [
+                    Request::USER_AGENT_IE,
+                    Request::USER_AGENT_ANDROID_MOBILE_CHROME,
+                    Request::USER_AGENT_FREEBOX,
+                ])) {
+                $response->addHeader('Content-Disposition', 'attachment; filename="' . rawurlencode($filename) . '"');
+            } else {
+                $response->addHeader('Content-Disposition', 'attachment; filename*=UTF-8\'\'' . rawurlencode($filename)
+                                                        . '; filename="' . rawurlencode($filename) . '"');
+            }
+        }
+
+        if ($node instanceof File) {
+            //Add OC-Checksum header
+            $checksum = $node->getChecksum();
+            if ($checksum !== null && $checksum !== '') {
+                $response->addHeader('OC-Checksum', $checksum);
+            }
+        }
+        $response->addHeader('X-Accel-Buffering', 'no');
+    }
+
+    /**
+     * Adds all ownCloud-specific properties
+     *
+     * @param PropFind $propFind
+     * @param \Sabre\DAV\INode $node
+     * @return void
+     */
+    public function handleGetProperties(PropFind $propFind, \Sabre\DAV\INode $node) {
+        $httpRequest = $this->server->httpRequest;
+
+        if ($node instanceof Node) {
+            /**
+             * This was disabled, because it made dir listing throw an exception,
+             * so users were unable to navigate into folders where one subitem
+             * is blocked by the files_accesscontrol app, see:
+             * https://github.com/nextcloud/files_accesscontrol/issues/65
+             * if (!$node->getFileInfo()->isReadable()) {
+             *     // avoid detecting files through this means
+             *     throw new NotFound();
+             * }
+             */
+
+            $propFind->handle(self::FILEID_PROPERTYNAME, function () use ($node) {
+                return $node->getFileId();
+            });
+
+            $propFind->handle(self::INTERNAL_FILEID_PROPERTYNAME, function () use ($node) {
+                return $node->getInternalFileId();
+            });
+
+            $propFind->handle(self::PERMISSIONS_PROPERTYNAME, function () use ($node) {
+                $perms = $node->getDavPermissions();
+                if ($this->isPublic) {
+                    // remove mount information
+                    $perms = str_replace(['S', 'M'], '', $perms);
+                }
+                return $perms;
+            });
+
+            $propFind->handle(self::SHARE_PERMISSIONS_PROPERTYNAME, function () use ($node, $httpRequest) {
+                $user = $this->userSession->getUser();
+                if ($user === null) {
+                    return null;
+                }
+                return $node->getSharePermissions(
+                    $user->getUID()
+                );
+            });
+
+            $propFind->handle(self::OCM_SHARE_PERMISSIONS_PROPERTYNAME, function () use ($node, $httpRequest): ?string {
+                $user = $this->userSession->getUser();
+                if ($user === null) {
+                    return null;
+                }
+                $ncPermissions = $node->getSharePermissions(
+                    $user->getUID()
+                );
+                $ocmPermissions = $this->ncPermissions2ocmPermissions($ncPermissions);
+                return json_encode($ocmPermissions, JSON_THROW_ON_ERROR);
+            });
+
+            $propFind->handle(self::SHARE_ATTRIBUTES_PROPERTYNAME, function () use ($node, $httpRequest) {
+                return json_encode($node->getShareAttributes(), JSON_THROW_ON_ERROR);
+            });
+
+            $propFind->handle(self::GETETAG_PROPERTYNAME, function () use ($node): string {
+                return $node->getETag();
+            });
+
+            $propFind->handle(self::OWNER_ID_PROPERTYNAME, function () use ($node): ?string {
+                $owner = $node->getOwner();
+                if (!$owner) {
+                    return null;
+                } else {
+                    return $owner->getUID();
+                }
+            });
+            $propFind->handle(self::OWNER_DISPLAY_NAME_PROPERTYNAME, function () use ($node): ?string {
+                $owner = $node->getOwner();
+                if (!$owner) {
+                    return null;
+                }
+
+                // Get current user to see if we're in a public share or not
+                $user = $this->userSession->getUser();
+
+                // If the user is logged in, we can return the display name
+                if ($user !== null) {
+                    return $owner->getDisplayName();
+                }
+
+                // Check if the user published their display name
+                try {
+                    $ownerAccount = $this->accountManager->getAccount($owner);
+                } catch (NoUserException) {
+                    // do not lock process if owner is not local
+                    return null;
+                }
+
+                $ownerNameProperty = $ownerAccount->getProperty(IAccountManager::PROPERTY_DISPLAYNAME);
+
+                // Since we are not logged in, we need to have at least the published scope
+                if ($ownerNameProperty->getScope() === IAccountManager::SCOPE_PUBLISHED) {
+                    return $owner->getDisplayName();
+                }
+
+                return null;
+            });
+
+            $propFind->handle(self::HAS_PREVIEW_PROPERTYNAME, function () use ($node) {
+                return json_encode($this->previewManager->isAvailable($node->getFileInfo()), JSON_THROW_ON_ERROR);
+            });
+            $propFind->handle(self::SIZE_PROPERTYNAME, function () use ($node): int|float {
+                return $node->getSize();
+            });
+            $propFind->handle(self::MOUNT_TYPE_PROPERTYNAME, function () use ($node) {
+                return $node->getFileInfo()->getMountPoint()->getMountType();
+            });
+
+            /**
+             * This is a special property which is used to determine if a node
+             * is a mount root or not, e.g. a shared folder.
+             * If so, then the node can only be unshared and not deleted.
+             * @see https://github.com/nextcloud/server/blob/cc75294eb6b16b916a342e69998935f89222619d/lib/private/Files/View.php#L696-L698
+             */
+            $propFind->handle(self::MOUNT_ROOT_PROPERTYNAME, function () use ($node) {
+                return $node->getNode()->getInternalPath() === '' ? 'true' : 'false';
+            });
+
+            $propFind->handle(self::SHARE_NOTE, function () use ($node): ?string {
+                $user = $this->userSession->getUser();
+                return $node->getNoteFromShare(
+                    $user?->getUID()
+                );
+            });
+
+            $propFind->handle(self::SHARE_HIDE_DOWNLOAD_PROPERTYNAME, function () use ($node) {
+                $storage = $node->getNode()->getStorage();
+                if ($storage->instanceOfStorage(ISharedStorage::class)) {
+                    /** @var ISharedStorage $storage */
+                    return match($storage->getShare()->getHideDownload()) {
+                        true => 'true',
+                        false => 'false',
+                    };
+                } else {
+                    return null;
+                }
+            });
+
+            $propFind->handle(self::DATA_FINGERPRINT_PROPERTYNAME, function () {
+                return $this->config->getSystemValue('data-fingerprint', '');
+            });
+            $propFind->handle(self::CREATIONDATE_PROPERTYNAME, function () use ($node) {
+                return (new \DateTimeImmutable())
+                    ->setTimestamp($node->getFileInfo()->getCreationTime())
+                    ->format(\DateTimeInterface::ATOM);
+            });
+            $propFind->handle(self::CREATION_TIME_PROPERTYNAME, function () use ($node) {
+                return $node->getFileInfo()->getCreationTime();
+            });
+
+            foreach ($node->getFileInfo()->getMetadata() as $metadataKey => $metadataValue) {
+                $propFind->handle(self::FILE_METADATA_PREFIX . $metadataKey, $metadataValue);
+            }
+
+            $propFind->handle(self::HIDDEN_PROPERTYNAME, function () use ($node) {
+                $isLivePhoto = isset($node->getFileInfo()->getMetadata()['files-live-photo']);
+                $isMovFile = $node->getFileInfo()->getMimetype() === 'video/quicktime';
+                return ($isLivePhoto && $isMovFile) ? 'true' : 'false';
+            });
+
+            /**
+             * Return file/folder name as displayname. The primary reason to
+             * implement it this way is to avoid costly fallback to
+             * CustomPropertiesBackend (esp. visible when querying all files
+             * in a folder).
+             */
+            $propFind->handle(self::DISPLAYNAME_PROPERTYNAME, function () use ($node) {
+                return $node->getName();
+            });
+
+            $propFind->handle(self::IS_FEDERATED_PROPERTYNAME, function () use ($node) {
+                return $node->getFileInfo()->getMountPoint()
+                    instanceof SharingExternalMount;
+            });
+        }
+
+        if ($node instanceof File) {
+            $requestProperties = $propFind->getRequestedProperties();
+
+            if (in_array(self::DOWNLOADURL_PROPERTYNAME, $requestProperties, true)
+                || in_array(self::DOWNLOADURL_EXPIRATION_PROPERTYNAME, $requestProperties, true)) {
+                try {
+                    $directDownloadUrl = $node->getDirectDownload();
+                } catch (StorageNotAvailableException|ForbiddenException) {
+                    $directDownloadUrl = null;
+                }
+
+                $propFind->handle(self::DOWNLOADURL_PROPERTYNAME, function () use ($node, $directDownloadUrl) {
+                    if ($directDownloadUrl && isset($directDownloadUrl['url'])) {
+                        return $directDownloadUrl['url'];
+                    }
+                    return false;
+                });
+
+                $propFind->handle(self::DOWNLOADURL_EXPIRATION_PROPERTYNAME, function () use ($node, $directDownloadUrl) {
+                    if ($directDownloadUrl && isset($directDownloadUrl['expiration'])) {
+                        return $directDownloadUrl['expiration'];
+                    }
+                    return false;
+                });
+            }
+
+            $propFind->handle(self::CHECKSUMS_PROPERTYNAME, function () use ($node) {
+                $checksum = $node->getChecksum();
+                if ($checksum === null || $checksum === '') {
+                    return null;
+                }
+
+                return new ChecksumList($checksum);
+            });
+
+            $propFind->handle(self::UPLOAD_TIME_PROPERTYNAME, function () use ($node) {
+                return $node->getFileInfo()->getUploadTime();
+            });
+        }
+
+        if ($node instanceof Directory) {
+            $propFind->handle(self::SIZE_PROPERTYNAME, function () use ($node) {
+                return $node->getSize();
+            });
+
+            $requestProperties = $propFind->getRequestedProperties();
+
+            if (in_array(self::SUBFILE_COUNT_PROPERTYNAME, $requestProperties, true)
+                || in_array(self::SUBFOLDER_COUNT_PROPERTYNAME, $requestProperties, true)) {
+                $nbFiles = 0;
+                $nbFolders = 0;
+                foreach ($node->getChildren() as $child) {
+                    if ($child instanceof File) {
+                        $nbFiles++;
+                    } elseif ($child instanceof Directory) {
+                        $nbFolders++;
+                    }
+                }
+
+                $propFind->handle(self::SUBFILE_COUNT_PROPERTYNAME, $nbFiles);
+                $propFind->handle(self::SUBFOLDER_COUNT_PROPERTYNAME, $nbFolders);
+            }
+        }
+    }
+
+    /**
+     * translate Nextcloud permissions to OCM Permissions
+     *
+     * @param $ncPermissions
+     * @return array
+     */
+    protected function ncPermissions2ocmPermissions($ncPermissions) {
+        $ocmPermissions = [];
+
+        if ($ncPermissions & Constants::PERMISSION_SHARE) {
+            $ocmPermissions[] = 'share';
+        }
+
+        if ($ncPermissions & Constants::PERMISSION_READ) {
+            $ocmPermissions[] = 'read';
+        }
+
+        if (($ncPermissions & Constants::PERMISSION_CREATE)
+            || ($ncPermissions & Constants::PERMISSION_UPDATE)) {
+            $ocmPermissions[] = 'write';
+        }
+
+        return $ocmPermissions;
+    }
+
+    /**
+     * Update ownCloud-specific properties
+     *
+     * @param string $path
+     * @param PropPatch $propPatch
+     *
+     * @return void
+     */
+    public function handleUpdateProperties($path, PropPatch $propPatch) {
+        $node = $this->tree->getNodeForPath($path);
+        if (!($node instanceof Node)) {
+            return;
+        }
+
+        $propPatch->handle(self::LASTMODIFIED_PROPERTYNAME, function ($time) use ($node) {
+            if (empty($time)) {
+                return false;
+            }
+            $node->touch($time);
+            return true;
+        });
+        $propPatch->handle(self::GETETAG_PROPERTYNAME, function ($etag) use ($node) {
+            if (empty($etag)) {
+                return false;
+            }
+            return $node->setEtag($etag) !== -1;
+        });
+        $propPatch->handle(self::CREATIONDATE_PROPERTYNAME, function ($time) use ($node) {
+            if (empty($time)) {
+                return false;
+            }
+            $dateTime = new \DateTimeImmutable($time);
+            $node->setCreationTime($dateTime->getTimestamp());
+            return true;
+        });
+        $propPatch->handle(self::CREATION_TIME_PROPERTYNAME, function ($time) use ($node) {
+            if (empty($time)) {
+                return false;
+            }
+            $node->setCreationTime((int)$time);
+            return true;
+        });
+
+        $this->handleUpdatePropertiesMetadata($propPatch, $node);
+
+        /**
+         * Disable modification of the displayname property for files and
+         * folders via PROPPATCH. See PROPFIND for more information.
+         */
+        $propPatch->handle(self::DISPLAYNAME_PROPERTYNAME, function ($displayName) {
+            return 403;
+        });
+    }
+
+
+    /**
+     * handle the update of metadata from PROPPATCH requests
+     *
+     * @param PropPatch $propPatch
+     * @param Node $node
+     *
+     * @throws FilesMetadataException
+     */
+    private function handleUpdatePropertiesMetadata(PropPatch $propPatch, Node $node): void {
+        $userId = $this->userSession->getUser()?->getUID();
+        if ($userId === null) {
+            return;
+        }
+
+        $accessRight = $this->getMetadataFileAccessRight($node, $userId);
+        $filesMetadataManager = $this->initFilesMetadataManager();
+        $knownMetadata = $filesMetadataManager->getKnownMetadata();
+
+        foreach ($propPatch->getRemainingMutations() as $mutation) {
+            if (!str_starts_with($mutation, self::FILE_METADATA_PREFIX)) {
+                continue;
+            }
+
+            $propPatch->handle(
+                $mutation,
+                function (mixed $value) use ($accessRight, $knownMetadata, $node, $mutation, $filesMetadataManager): bool {
+                    /** @var FilesMetadata $metadata */
+                    $metadata = $filesMetadataManager->getMetadata((int)$node->getFileId(), true);
+                    $metadata->setStorageId($node->getNode()->getStorage()->getCache()->getNumericStorageId());
+                    $metadataKey = substr($mutation, strlen(self::FILE_METADATA_PREFIX));
+
+                    // confirm metadata key is editable via PROPPATCH
+                    if ($knownMetadata->getEditPermission($metadataKey) < $accessRight) {
+                        throw new FilesMetadataException('you do not have enough rights to update \'' . $metadataKey . '\' on this node');
+                    }
+
+                    if ($value === null) {
+                        $metadata->unset($metadataKey);
+                        $filesMetadataManager->saveMetadata($metadata);
+                        return true;
+                    }
+
+                    // If the metadata is unknown, it defaults to string.
+                    try {
+                        $type = $knownMetadata->getType($metadataKey);
+                    } catch (FilesMetadataNotFoundException) {
+                        $type = IMetadataValueWrapper::TYPE_STRING;
+                    }
+
+                    switch ($type) {
+                        case IMetadataValueWrapper::TYPE_STRING:
+                            $metadata->setString($metadataKey, $value, $knownMetadata->isIndex($metadataKey));
+                            break;
+                        case IMetadataValueWrapper::TYPE_INT:
+                            $metadata->setInt($metadataKey, $value, $knownMetadata->isIndex($metadataKey));
+                            break;
+                        case IMetadataValueWrapper::TYPE_FLOAT:
+                            $metadata->setFloat($metadataKey, $value);
+                            break;
+                        case IMetadataValueWrapper::TYPE_BOOL:
+                            $metadata->setBool($metadataKey, $value, $knownMetadata->isIndex($metadataKey));
+                            break;
+                        case IMetadataValueWrapper::TYPE_ARRAY:
+                            $metadata->setArray($metadataKey, $value);
+                            break;
+                        case IMetadataValueWrapper::TYPE_STRING_LIST:
+                            $metadata->setStringList($metadataKey, $value, $knownMetadata->isIndex($metadataKey));
+                            break;
+                        case IMetadataValueWrapper::TYPE_INT_LIST:
+                            $metadata->setIntList($metadataKey, $value, $knownMetadata->isIndex($metadataKey));
+                            break;
+                    }
+
+                    $filesMetadataManager->saveMetadata($metadata);
+
+                    return true;
+                }
+            );
+        }
+    }
+
+    /**
+     * init default internal metadata
+     *
+     * @return IFilesMetadataManager
+     */
+    private function initFilesMetadataManager(): IFilesMetadataManager {
+        /** @var IFilesMetadataManager $manager */
+        $manager = \OCP\Server::get(IFilesMetadataManager::class);
+        $manager->initMetadata('files-live-photo', IMetadataValueWrapper::TYPE_STRING, false, IMetadataValueWrapper::EDIT_REQ_WRITE_PERMISSION);
+
+        return $manager;
+    }
+
+    /**
+     * based on owner and shares, returns the bottom limit to update related metadata
+     *
+     * @param Node $node
+     * @param string $userId
+     *
+     * @return int
+     */
+    private function getMetadataFileAccessRight(Node $node, string $userId): int {
+        if ($node->getOwner()?->getUID() === $userId) {
+            return IMetadataValueWrapper::EDIT_REQ_OWNERSHIP;
+        } else {
+            $filePermissions = $node->getSharePermissions($userId);
+            if ($filePermissions & Constants::PERMISSION_UPDATE) {
+                return IMetadataValueWrapper::EDIT_REQ_WRITE_PERMISSION;
+            }
+        }
+
+        return IMetadataValueWrapper::EDIT_REQ_READ_PERMISSION;
+    }
+
+    /**
+     * @param string $filePath
+     * @param ?\Sabre\DAV\INode $node
+     * @return void
+     * @throws \Sabre\DAV\Exception\BadRequest
+     */
+    public function sendFileIdHeader($filePath, ?\Sabre\DAV\INode $node = null) {
+        // we get the node for the given $filePath here because in case of afterCreateFile $node is the parent folder
+        try {
+            $node = $this->server->tree->getNodeForPath($filePath);
+            if ($node instanceof Node) {
+                $fileId = $node->getFileId();
+                if (!is_null($fileId)) {
+                    $this->server->httpResponse->setHeader('OC-FileId', $fileId);
+                }
+            }
+        } catch (NotFound) {
+        }
+    }
 }

tests/lib/Files/ObjectStore/FailWriteObjectStore.php

Indentation +33 added lines, -33 removed lines

@@ -11,37 +11,37 @@
 use OCP\Files\ObjectStore\IObjectStore;
 
 class FailWriteObjectStore implements IObjectStore {
-	public function __construct(
-		private IObjectStore $objectStore,
-	) {
-	}
-
-	public function getStorageId() {
-		return $this->objectStore->getStorageId();
-	}
-
-	public function readObject($urn) {
-		return $this->objectStore->readObject($urn);
-	}
-
-	public function writeObject($urn, $stream, ?string $mimetype = null) {
-		// emulate a failed write that didn't throw an error
-		return true;
-	}
-
-	public function deleteObject($urn) {
-		$this->objectStore->deleteObject($urn);
-	}
-
-	public function objectExists($urn) {
-		return $this->objectStore->objectExists($urn);
-	}
-
-	public function copyObject($from, $to) {
-		$this->objectStore->copyObject($from, $to);
-	}
-
-	public function preSignedUrl(string $urn, \DateTimeInterface $expiration): ?string {
-		return null;
-	}
+    public function __construct(
+        private IObjectStore $objectStore,
+    ) {
+    }
+
+    public function getStorageId() {
+        return $this->objectStore->getStorageId();
+    }
+
+    public function readObject($urn) {
+        return $this->objectStore->readObject($urn);
+    }
+
+    public function writeObject($urn, $stream, ?string $mimetype = null) {
+        // emulate a failed write that didn't throw an error
+        return true;
+    }
+
+    public function deleteObject($urn) {
+        $this->objectStore->deleteObject($urn);
+    }
+
+    public function objectExists($urn) {
+        return $this->objectStore->objectExists($urn);
+    }
+
+    public function copyObject($from, $to) {
+        $this->objectStore->copyObject($from, $to);
+    }
+
+    public function preSignedUrl(string $urn, \DateTimeInterface $expiration): ?string {
+        return null;
+    }
 }

tests/lib/Files/ObjectStore/FailDeleteObjectStore.php

Indentation +32 added lines, -32 removed lines

@@ -11,36 +11,36 @@
 use OCP\Files\ObjectStore\IObjectStore;
 
 class FailDeleteObjectStore implements IObjectStore {
-	public function __construct(
-		private IObjectStore $objectStore,
-	) {
-	}
-
-	public function getStorageId() {
-		return $this->objectStore->getStorageId();
-	}
-
-	public function readObject($urn) {
-		return $this->objectStore->readObject($urn);
-	}
-
-	public function writeObject($urn, $stream, ?string $mimetype = null) {
-		return $this->objectStore->writeObject($urn, $stream, $mimetype);
-	}
-
-	public function deleteObject($urn) {
-		throw new \Exception();
-	}
-
-	public function objectExists($urn) {
-		return $this->objectStore->objectExists($urn);
-	}
-
-	public function copyObject($from, $to) {
-		$this->objectStore->copyObject($from, $to);
-	}
-
-	public function preSignedUrl(string $urn, \DateTimeInterface $expiration): ?string {
-		return null;
-	}
+    public function __construct(
+        private IObjectStore $objectStore,
+    ) {
+    }
+
+    public function getStorageId() {
+        return $this->objectStore->getStorageId();
+    }
+
+    public function readObject($urn) {
+        return $this->objectStore->readObject($urn);
+    }
+
+    public function writeObject($urn, $stream, ?string $mimetype = null) {
+        return $this->objectStore->writeObject($urn, $stream, $mimetype);
+    }
+
+    public function deleteObject($urn) {
+        throw new \Exception();
+    }
+
+    public function objectExists($urn) {
+        return $this->objectStore->objectExists($urn);
+    }
+
+    public function copyObject($from, $to) {
+        $this->objectStore->copyObject($from, $to);
+    }
+
+    public function preSignedUrl(string $urn, \DateTimeInterface $expiration): ?string {
+        return null;
+    }
 }

tests/lib/Files/Mount/ObjectHomeMountProviderTest.php

Indentation +245 added lines, -245 removed lines

@@ -16,260 +16,260 @@
 use OCP\IUser;
 
 class ObjectHomeMountProviderTest extends \Test\TestCase {
-	/** @var ObjectHomeMountProvider */
-	protected $provider;
-
-	/** @var IConfig|\PHPUnit\Framework\MockObject\MockObject */
-	protected $config;
-
-	/** @var IUser|\PHPUnit\Framework\MockObject\MockObject */
-	protected $user;
-
-	/** @var IStorageFactory|\PHPUnit\Framework\MockObject\MockObject */
-	protected $loader;
-
-	protected function setUp(): void {
-		parent::setUp();
-
-		$this->config = $this->createMock(IConfig::class);
-		$this->user = $this->createMock(IUser::class);
-		$this->loader = $this->createMock(IStorageFactory::class);
-
-		$objectStoreConfig = new PrimaryObjectStoreConfig($this->config, $this->createMock(IAppManager::class));
-		$this->provider = new ObjectHomeMountProvider($objectStoreConfig);
-	}
-
-	public function testSingleBucket(): void {
-		$this->config->method('getSystemValue')
-			->willReturnCallback(function ($key, $default) {
-				if ($key === 'objectstore') {
-					return [
-						'class' => 'Test\Files\Mount\FakeObjectStore',
-						'arguments' => [
-							'foo' => 'bar'
-						],
-					];
-				} else {
-					return $default;
-				}
-			});
-
-		$mount = $this->provider->getHomeMountForUser($this->user, $this->loader);
-		$arguments = $this->invokePrivate($mount, 'arguments');
-
-		$objectStore = $arguments['objectstore'];
-		$this->assertInstanceOf(FakeObjectStore::class, $objectStore);
-		$this->assertEquals(['foo' => 'bar', 'multibucket' => false], $objectStore->getArguments());
-	}
-
-	public function testMultiBucket(): void {
-		$this->config->method('getSystemValue')
-			->willReturnCallback(function ($key, $default) {
-				if ($key === 'objectstore_multibucket') {
-					return [
-						'class' => 'Test\Files\Mount\FakeObjectStore',
-						'arguments' => [
-							'foo' => 'bar'
-						],
-					];
-				} else {
-					return $default;
-				}
-			});
-
-		$this->user->method('getUID')
-			->willReturn('uid');
-		$this->loader->expects($this->never())->method($this->anything());
-
-		$this->config->method('getUserValue')
-			->willReturn(null);
-
-		$this->config
-			->method('setUserValue')
-			->with(
-				$this->equalTo('uid'),
-				$this->equalTo('homeobjectstore'),
-				$this->equalTo('bucket'),
-				$this->equalTo('49'),
-				$this->equalTo(null)
-			);
-
-		$mount = $this->provider->getHomeMountForUser($this->user, $this->loader);
-		$arguments = $this->invokePrivate($mount, 'arguments');
-
-		$objectStore = $arguments['objectstore'];
-		$this->assertInstanceOf(FakeObjectStore::class, $objectStore);
-		$this->assertEquals(['foo' => 'bar', 'bucket' => 49, 'multibucket' => true], $objectStore->getArguments());
-	}
-
-	public function testMultiBucketWithPrefix(): void {
-		$this->config->method('getSystemValue')
-			->willReturnCallback(function ($key, $default) {
-				if ($key === 'objectstore_multibucket') {
-					return [
-						'class' => 'Test\Files\Mount\FakeObjectStore',
-						'arguments' => [
-							'foo' => 'bar',
-							'bucket' => 'myBucketPrefix',
-						],
-					];
-				} else {
-					return $default;
-				}
-			});
-
-		$this->user->method('getUID')
-			->willReturn('uid');
-		$this->loader->expects($this->never())->method($this->anything());
-
-		$this->config
-			->method('getUserValue')
-			->willReturn(null);
-
-		$this->config->expects($this->once())
-			->method('setUserValue')
-			->with(
-				$this->equalTo('uid'),
-				$this->equalTo('homeobjectstore'),
-				$this->equalTo('bucket'),
-				$this->equalTo('myBucketPrefix49'),
-				$this->equalTo(null)
-			);
-
-		$mount = $this->provider->getHomeMountForUser($this->user, $this->loader);
-		$arguments = $this->invokePrivate($mount, 'arguments');
-
-		$objectStore = $arguments['objectstore'];
-		$this->assertInstanceOf(FakeObjectStore::class, $objectStore);
-		$this->assertEquals(['foo' => 'bar', 'bucket' => 'myBucketPrefix49', 'multibucket' => true], $objectStore->getArguments());
-	}
-
-	public function testMultiBucketBucketAlreadySet(): void {
-		$this->config->method('getSystemValue')
-			->willReturnCallback(function ($key, $default) {
-				if ($key === 'objectstore_multibucket') {
-					return [
-						'class' => 'Test\Files\Mount\FakeObjectStore',
-						'arguments' => [
-							'foo' => 'bar',
-							'bucket' => 'myBucketPrefix',
-						],
-					];
-				} else {
-					return $default;
-				}
-			});
-
-		$this->user->method('getUID')
-			->willReturn('uid');
-		$this->loader->expects($this->never())->method($this->anything());
-
-		$this->config
-			->method('getUserValue')
-			->willReturnCallback(function ($uid, $app, $key, $default) {
-				if ($uid === 'uid' && $app === 'homeobjectstore' && $key === 'bucket') {
-					return 'awesomeBucket1';
-				} else {
-					return $default;
-				}
-			});
-
-		$this->config->expects($this->never())
-			->method('setUserValue');
-
-		$mount = $this->provider->getHomeMountForUser($this->user, $this->loader);
-		$arguments = $this->invokePrivate($mount, 'arguments');
-
-		$objectStore = $arguments['objectstore'];
-		$this->assertInstanceOf(FakeObjectStore::class, $objectStore);
-		$this->assertEquals(['foo' => 'bar', 'bucket' => 'awesomeBucket1', 'multibucket' => true], $objectStore->getArguments());
-	}
-
-	public function testMultiBucketConfigFirst(): void {
-		$this->config->method('getSystemValue')
-			->willReturnCallback(function ($key, $default) {
-				if ($key === 'objectstore_multibucket') {
-					return [
-						'class' => 'Test\Files\Mount\FakeObjectStore',
-						'arguments' => [
-							'foo' => 'bar',
-							'bucket' => 'myBucketPrefix',
-						],
-					];
-				} else {
-					return $default;
-				}
-			});
-
-		$this->user->method('getUID')
-			->willReturn('uid');
-		$this->loader->expects($this->never())->method($this->anything());
-
-		$mount = $this->provider->getHomeMountForUser($this->user, $this->loader);
-		$this->assertInstanceOf('OC\Files\Mount\MountPoint', $mount);
-	}
-
-	public function testMultiBucketConfigFirstFallBackSingle(): void {
-		$this->config
-			->method('getSystemValue')->willReturnMap([
-				['objectstore_multibucket', null, null],
-				['objectstore', null, [
-					'class' => 'Test\Files\Mount\FakeObjectStore',
-					'arguments' => [
-						'foo' => 'bar',
-						'bucket' => 'myBucketPrefix',
-					],
-				]],
-			]);
-
-		$this->user->method('getUID')
-			->willReturn('uid');
-		$this->loader->expects($this->never())->method($this->anything());
-
-		$mount = $this->provider->getHomeMountForUser($this->user, $this->loader);
-		$this->assertInstanceOf('OC\Files\Mount\MountPoint', $mount);
-	}
-
-	public function testNoObjectStore(): void {
-		$this->config->method('getSystemValue')
-			->willReturnCallback(function ($key, $default) {
-				return $default;
-			});
-
-		$mount = $this->provider->getHomeMountForUser($this->user, $this->loader);
-		$this->assertNull($mount);
-	}
+    /** @var ObjectHomeMountProvider */
+    protected $provider;
+
+    /** @var IConfig|\PHPUnit\Framework\MockObject\MockObject */
+    protected $config;
+
+    /** @var IUser|\PHPUnit\Framework\MockObject\MockObject */
+    protected $user;
+
+    /** @var IStorageFactory|\PHPUnit\Framework\MockObject\MockObject */
+    protected $loader;
+
+    protected function setUp(): void {
+        parent::setUp();
+
+        $this->config = $this->createMock(IConfig::class);
+        $this->user = $this->createMock(IUser::class);
+        $this->loader = $this->createMock(IStorageFactory::class);
+
+        $objectStoreConfig = new PrimaryObjectStoreConfig($this->config, $this->createMock(IAppManager::class));
+        $this->provider = new ObjectHomeMountProvider($objectStoreConfig);
+    }
+
+    public function testSingleBucket(): void {
+        $this->config->method('getSystemValue')
+            ->willReturnCallback(function ($key, $default) {
+                if ($key === 'objectstore') {
+                    return [
+                        'class' => 'Test\Files\Mount\FakeObjectStore',
+                        'arguments' => [
+                            'foo' => 'bar'
+                        ],
+                    ];
+                } else {
+                    return $default;
+                }
+            });
+
+        $mount = $this->provider->getHomeMountForUser($this->user, $this->loader);
+        $arguments = $this->invokePrivate($mount, 'arguments');
+
+        $objectStore = $arguments['objectstore'];
+        $this->assertInstanceOf(FakeObjectStore::class, $objectStore);
+        $this->assertEquals(['foo' => 'bar', 'multibucket' => false], $objectStore->getArguments());
+    }
+
+    public function testMultiBucket(): void {
+        $this->config->method('getSystemValue')
+            ->willReturnCallback(function ($key, $default) {
+                if ($key === 'objectstore_multibucket') {
+                    return [
+                        'class' => 'Test\Files\Mount\FakeObjectStore',
+                        'arguments' => [
+                            'foo' => 'bar'
+                        ],
+                    ];
+                } else {
+                    return $default;
+                }
+            });
+
+        $this->user->method('getUID')
+            ->willReturn('uid');
+        $this->loader->expects($this->never())->method($this->anything());
+
+        $this->config->method('getUserValue')
+            ->willReturn(null);
+
+        $this->config
+            ->method('setUserValue')
+            ->with(
+                $this->equalTo('uid'),
+                $this->equalTo('homeobjectstore'),
+                $this->equalTo('bucket'),
+                $this->equalTo('49'),
+                $this->equalTo(null)
+            );
+
+        $mount = $this->provider->getHomeMountForUser($this->user, $this->loader);
+        $arguments = $this->invokePrivate($mount, 'arguments');
+
+        $objectStore = $arguments['objectstore'];
+        $this->assertInstanceOf(FakeObjectStore::class, $objectStore);
+        $this->assertEquals(['foo' => 'bar', 'bucket' => 49, 'multibucket' => true], $objectStore->getArguments());
+    }
+
+    public function testMultiBucketWithPrefix(): void {
+        $this->config->method('getSystemValue')
+            ->willReturnCallback(function ($key, $default) {
+                if ($key === 'objectstore_multibucket') {
+                    return [
+                        'class' => 'Test\Files\Mount\FakeObjectStore',
+                        'arguments' => [
+                            'foo' => 'bar',
+                            'bucket' => 'myBucketPrefix',
+                        ],
+                    ];
+                } else {
+                    return $default;
+                }
+            });
+
+        $this->user->method('getUID')
+            ->willReturn('uid');
+        $this->loader->expects($this->never())->method($this->anything());
+
+        $this->config
+            ->method('getUserValue')
+            ->willReturn(null);
+
+        $this->config->expects($this->once())
+            ->method('setUserValue')
+            ->with(
+                $this->equalTo('uid'),
+                $this->equalTo('homeobjectstore'),
+                $this->equalTo('bucket'),
+                $this->equalTo('myBucketPrefix49'),
+                $this->equalTo(null)
+            );
+
+        $mount = $this->provider->getHomeMountForUser($this->user, $this->loader);
+        $arguments = $this->invokePrivate($mount, 'arguments');
+
+        $objectStore = $arguments['objectstore'];
+        $this->assertInstanceOf(FakeObjectStore::class, $objectStore);
+        $this->assertEquals(['foo' => 'bar', 'bucket' => 'myBucketPrefix49', 'multibucket' => true], $objectStore->getArguments());
+    }
+
+    public function testMultiBucketBucketAlreadySet(): void {
+        $this->config->method('getSystemValue')
+            ->willReturnCallback(function ($key, $default) {
+                if ($key === 'objectstore_multibucket') {
+                    return [
+                        'class' => 'Test\Files\Mount\FakeObjectStore',
+                        'arguments' => [
+                            'foo' => 'bar',
+                            'bucket' => 'myBucketPrefix',
+                        ],
+                    ];
+                } else {
+                    return $default;
+                }
+            });
+
+        $this->user->method('getUID')
+            ->willReturn('uid');
+        $this->loader->expects($this->never())->method($this->anything());
+
+        $this->config
+            ->method('getUserValue')
+            ->willReturnCallback(function ($uid, $app, $key, $default) {
+                if ($uid === 'uid' && $app === 'homeobjectstore' && $key === 'bucket') {
+                    return 'awesomeBucket1';
+                } else {
+                    return $default;
+                }
+            });
+
+        $this->config->expects($this->never())
+            ->method('setUserValue');
+
+        $mount = $this->provider->getHomeMountForUser($this->user, $this->loader);
+        $arguments = $this->invokePrivate($mount, 'arguments');
+
+        $objectStore = $arguments['objectstore'];
+        $this->assertInstanceOf(FakeObjectStore::class, $objectStore);
+        $this->assertEquals(['foo' => 'bar', 'bucket' => 'awesomeBucket1', 'multibucket' => true], $objectStore->getArguments());
+    }
+
+    public function testMultiBucketConfigFirst(): void {
+        $this->config->method('getSystemValue')
+            ->willReturnCallback(function ($key, $default) {
+                if ($key === 'objectstore_multibucket') {
+                    return [
+                        'class' => 'Test\Files\Mount\FakeObjectStore',
+                        'arguments' => [
+                            'foo' => 'bar',
+                            'bucket' => 'myBucketPrefix',
+                        ],
+                    ];
+                } else {
+                    return $default;
+                }
+            });
+
+        $this->user->method('getUID')
+            ->willReturn('uid');
+        $this->loader->expects($this->never())->method($this->anything());
+
+        $mount = $this->provider->getHomeMountForUser($this->user, $this->loader);
+        $this->assertInstanceOf('OC\Files\Mount\MountPoint', $mount);
+    }
+
+    public function testMultiBucketConfigFirstFallBackSingle(): void {
+        $this->config
+            ->method('getSystemValue')->willReturnMap([
+                ['objectstore_multibucket', null, null],
+                ['objectstore', null, [
+                    'class' => 'Test\Files\Mount\FakeObjectStore',
+                    'arguments' => [
+                        'foo' => 'bar',
+                        'bucket' => 'myBucketPrefix',
+                    ],
+                ]],
+            ]);
+
+        $this->user->method('getUID')
+            ->willReturn('uid');
+        $this->loader->expects($this->never())->method($this->anything());
+
+        $mount = $this->provider->getHomeMountForUser($this->user, $this->loader);
+        $this->assertInstanceOf('OC\Files\Mount\MountPoint', $mount);
+    }
+
+    public function testNoObjectStore(): void {
+        $this->config->method('getSystemValue')
+            ->willReturnCallback(function ($key, $default) {
+                return $default;
+            });
+
+        $mount = $this->provider->getHomeMountForUser($this->user, $this->loader);
+        $this->assertNull($mount);
+    }
 }
 
 class FakeObjectStore implements IObjectStore {
-	public function __construct(
-		private array $arguments,
-	) {
-	}
+    public function __construct(
+        private array $arguments,
+    ) {
+    }
 
-	public function getArguments() {
-		return $this->arguments;
-	}
+    public function getArguments() {
+        return $this->arguments;
+    }
 
-	public function getStorageId() {
-	}
+    public function getStorageId() {
+    }
 
-	public function readObject($urn) {
-	}
+    public function readObject($urn) {
+    }
 
-	public function writeObject($urn, $stream, ?string $mimetype = null) {
-	}
+    public function writeObject($urn, $stream, ?string $mimetype = null) {
+    }
 
-	public function deleteObject($urn) {
-	}
+    public function deleteObject($urn) {
+    }
 
-	public function objectExists($urn) {
-	}
+    public function objectExists($urn) {
+    }
 
-	public function copyObject($from, $to) {
-	}
+    public function copyObject($from, $to) {
+    }
 
-	public function preSignedUrl(string $urn, \DateTimeInterface $expiration): ?string {
-		return null;
-	}
+    public function preSignedUrl(string $urn, \DateTimeInterface $expiration): ?string {
+        return null;
+    }
 }