nextcloud / server

lib/private/IntegrityCheck/Checker.php

Indentation +550 added lines, -550 removed lines

@@ -57,554 +57,554 @@
  * @package OC\IntegrityCheck
  */
 class Checker {
-	public const CACHE_KEY = 'oc.integritycheck.checker';
-	/** @var EnvironmentHelper */
-	private $environmentHelper;
-	/** @var AppLocator */
-	private $appLocator;
-	/** @var FileAccessHelper */
-	private $fileAccessHelper;
-	/** @var IConfig|null */
-	private $config;
-	/** @var ICache */
-	private $cache;
-	/** @var IAppManager|null */
-	private $appManager;
-	/** @var IMimeTypeDetector */
-	private $mimeTypeDetector;
-
-	/**
-	 * @param EnvironmentHelper $environmentHelper
-	 * @param FileAccessHelper $fileAccessHelper
-	 * @param AppLocator $appLocator
-	 * @param IConfig|null $config
-	 * @param ICacheFactory $cacheFactory
-	 * @param IAppManager|null $appManager
-	 * @param IMimeTypeDetector $mimeTypeDetector
-	 */
-	public function __construct(EnvironmentHelper $environmentHelper,
-								FileAccessHelper $fileAccessHelper,
-								AppLocator $appLocator,
-								?IConfig $config,
-								ICacheFactory $cacheFactory,
-								?IAppManager $appManager,
-								IMimeTypeDetector $mimeTypeDetector) {
-		$this->environmentHelper = $environmentHelper;
-		$this->fileAccessHelper = $fileAccessHelper;
-		$this->appLocator = $appLocator;
-		$this->config = $config;
-		$this->cache = $cacheFactory->createDistributed(self::CACHE_KEY);
-		$this->appManager = $appManager;
-		$this->mimeTypeDetector = $mimeTypeDetector;
-	}
-
-	/**
-	 * Whether code signing is enforced or not.
-	 *
-	 * @return bool
-	 */
-	public function isCodeCheckEnforced(): bool {
-		$notSignedChannels = [ '', 'git'];
-		if (\in_array($this->environmentHelper->getChannel(), $notSignedChannels, true)) {
-			return false;
-		}
-
-		/**
-		 * This config option is undocumented and supposed to be so, it's only
-		 * applicable for very specific scenarios and we should not advertise it
-		 * too prominent. So please do not add it to config.sample.php.
-		 */
-		$isIntegrityCheckDisabled = false;
-		if ($this->config !== null) {
-			$isIntegrityCheckDisabled = $this->config->getSystemValueBool('integrity.check.disabled', false);
-		}
-		if ($isIntegrityCheckDisabled) {
-			return false;
-		}
-
-		return true;
-	}
-
-	/**
-	 * Enumerates all files belonging to the folder. Sensible defaults are excluded.
-	 *
-	 * @param string $folderToIterate
-	 * @param string $root
-	 * @return \RecursiveIteratorIterator
-	 * @throws \Exception
-	 */
-	private function getFolderIterator(string $folderToIterate, string $root = ''): \RecursiveIteratorIterator {
-		$dirItr = new \RecursiveDirectoryIterator(
-			$folderToIterate,
-			\RecursiveDirectoryIterator::SKIP_DOTS
-		);
-		if ($root === '') {
-			$root = \OC::$SERVERROOT;
-		}
-		$root = rtrim($root, '/');
-
-		$excludeGenericFilesIterator = new ExcludeFileByNameFilterIterator($dirItr);
-		$excludeFoldersIterator = new ExcludeFoldersByPathFilterIterator($excludeGenericFilesIterator, $root);
-
-		return new \RecursiveIteratorIterator(
-			$excludeFoldersIterator,
-			\RecursiveIteratorIterator::SELF_FIRST
-		);
-	}
-
-	/**
-	 * Returns an array of ['filename' => 'SHA512-hash-of-file'] for all files found
-	 * in the iterator.
-	 *
-	 * @param \RecursiveIteratorIterator $iterator
-	 * @param string $path
-	 * @return array Array of hashes.
-	 */
-	private function generateHashes(\RecursiveIteratorIterator $iterator,
-									string $path): array {
-		$hashes = [];
-
-		$baseDirectoryLength = \strlen($path);
-		foreach ($iterator as $filename => $data) {
-			/** @var \DirectoryIterator $data */
-			if ($data->isDir()) {
-				continue;
-			}
-
-			$relativeFileName = substr($filename, $baseDirectoryLength);
-			$relativeFileName = ltrim($relativeFileName, '/');
-
-			// Exclude signature.json files in the appinfo and root folder
-			if ($relativeFileName === 'appinfo/signature.json') {
-				continue;
-			}
-			// Exclude signature.json files in the appinfo and core folder
-			if ($relativeFileName === 'core/signature.json') {
-				continue;
-			}
-
-			// The .htaccess file in the root folder of ownCloud can contain
-			// custom content after the installation due to the fact that dynamic
-			// content is written into it at installation time as well. This
-			// includes for example the 404 and 403 instructions.
-			// Thus we ignore everything below the first occurrence of
-			// "#### DO NOT CHANGE ANYTHING ABOVE THIS LINE ####" and have the
-			// hash generated based on this.
-			if ($filename === $this->environmentHelper->getServerRoot() . '/.htaccess') {
-				$fileContent = file_get_contents($filename);
-				$explodedArray = explode('#### DO NOT CHANGE ANYTHING ABOVE THIS LINE ####', $fileContent);
-				if (\count($explodedArray) === 2) {
-					$hashes[$relativeFileName] = hash('sha512', $explodedArray[0]);
-					continue;
-				}
-			}
-			if ($filename === $this->environmentHelper->getServerRoot() . '/core/js/mimetypelist.js') {
-				$oldMimetypeList = new GenerateMimetypeFileBuilder();
-				$newFile = $oldMimetypeList->generateFile($this->mimeTypeDetector->getAllAliases());
-				$oldFile = $this->fileAccessHelper->file_get_contents($filename);
-				if ($newFile === $oldFile) {
-					$hashes[$relativeFileName] = hash('sha512', $oldMimetypeList->generateFile($this->mimeTypeDetector->getOnlyDefaultAliases()));
-					continue;
-				}
-			}
-
-			$hashes[$relativeFileName] = hash_file('sha512', $filename);
-		}
-
-		return $hashes;
-	}
-
-	/**
-	 * Creates the signature data
-	 *
-	 * @param array $hashes
-	 * @param X509 $certificate
-	 * @param RSA $privateKey
-	 * @return array
-	 */
-	private function createSignatureData(array $hashes,
-										 X509 $certificate,
-										 RSA $privateKey): array {
-		ksort($hashes);
-
-		$privateKey->setSignatureMode(RSA::SIGNATURE_PSS);
-		$privateKey->setMGFHash('sha512');
-		// See https://tools.ietf.org/html/rfc3447#page-38
-		$privateKey->setSaltLength(0);
-		$signature = $privateKey->sign(json_encode($hashes));
-
-		return [
-			'hashes' => $hashes,
-			'signature' => base64_encode($signature),
-			'certificate' => $certificate->saveX509($certificate->currentCert),
-		];
-	}
-
-	/**
-	 * Write the signature of the app in the specified folder
-	 *
-	 * @param string $path
-	 * @param X509 $certificate
-	 * @param RSA $privateKey
-	 * @throws \Exception
-	 */
-	public function writeAppSignature($path,
-									  X509 $certificate,
-									  RSA $privateKey) {
-		$appInfoDir = $path . '/appinfo';
-		try {
-			$this->fileAccessHelper->assertDirectoryExists($appInfoDir);
-
-			$iterator = $this->getFolderIterator($path);
-			$hashes = $this->generateHashes($iterator, $path);
-			$signature = $this->createSignatureData($hashes, $certificate, $privateKey);
-			$this->fileAccessHelper->file_put_contents(
-				$appInfoDir . '/signature.json',
-				json_encode($signature, JSON_PRETTY_PRINT)
-			);
-		} catch (\Exception $e) {
-			if (!$this->fileAccessHelper->is_writable($appInfoDir)) {
-				throw new \Exception($appInfoDir . ' is not writable');
-			}
-			throw $e;
-		}
-	}
-
-	/**
-	 * Write the signature of core
-	 *
-	 * @param X509 $certificate
-	 * @param RSA $rsa
-	 * @param string $path
-	 * @throws \Exception
-	 */
-	public function writeCoreSignature(X509 $certificate,
-									   RSA $rsa,
-									   $path) {
-		$coreDir = $path . '/core';
-		try {
-			$this->fileAccessHelper->assertDirectoryExists($coreDir);
-			$iterator = $this->getFolderIterator($path, $path);
-			$hashes = $this->generateHashes($iterator, $path);
-			$signatureData = $this->createSignatureData($hashes, $certificate, $rsa);
-			$this->fileAccessHelper->file_put_contents(
-				$coreDir . '/signature.json',
-				json_encode($signatureData, JSON_PRETTY_PRINT)
-			);
-		} catch (\Exception $e) {
-			if (!$this->fileAccessHelper->is_writable($coreDir)) {
-				throw new \Exception($coreDir . ' is not writable');
-			}
-			throw $e;
-		}
-	}
-
-	/**
-	 * Split the certificate file in individual certs
-	 *
-	 * @param string $cert
-	 * @return string[]
-	 */
-	private function splitCerts(string $cert): array {
-		preg_match_all('([\-]{3,}[\S\ ]+?[\-]{3,}[\S\s]+?[\-]{3,}[\S\ ]+?[\-]{3,})', $cert, $matches);
-
-		return $matches[0];
-	}
-
-	/**
-	 * Verifies the signature for the specified path.
-	 *
-	 * @param string $signaturePath
-	 * @param string $basePath
-	 * @param string $certificateCN
-	 * @param bool $forceVerify
-	 * @return array
-	 * @throws InvalidSignatureException
-	 * @throws \Exception
-	 */
-	private function verify(string $signaturePath, string $basePath, string $certificateCN, bool $forceVerify = false): array {
-		if (!$forceVerify && !$this->isCodeCheckEnforced()) {
-			return [];
-		}
-
-		$content = $this->fileAccessHelper->file_get_contents($signaturePath);
-		$signatureData = null;
-
-		if (\is_string($content)) {
-			$signatureData = json_decode($content, true);
-		}
-		if (!\is_array($signatureData)) {
-			throw new InvalidSignatureException('Signature data not found.');
-		}
-
-		$expectedHashes = $signatureData['hashes'];
-		ksort($expectedHashes);
-		$signature = base64_decode($signatureData['signature']);
-		$certificate = $signatureData['certificate'];
-
-		// Check if certificate is signed by Nextcloud Root Authority
-		$x509 = new \phpseclib\File\X509();
-		$rootCertificatePublicKey = $this->fileAccessHelper->file_get_contents($this->environmentHelper->getServerRoot().'/resources/codesigning/root.crt');
-
-		$rootCerts = $this->splitCerts($rootCertificatePublicKey);
-		foreach ($rootCerts as $rootCert) {
-			$x509->loadCA($rootCert);
-		}
-		$x509->loadX509($certificate);
-		if (!$x509->validateSignature()) {
-			throw new InvalidSignatureException('Certificate is not valid.');
-		}
-		// Verify if certificate has proper CN. "core" CN is always trusted.
-		if ($x509->getDN(X509::DN_OPENSSL)['CN'] !== $certificateCN && $x509->getDN(X509::DN_OPENSSL)['CN'] !== 'core') {
-			throw new InvalidSignatureException(
-				sprintf('Certificate is not valid for required scope. (Requested: %s, current: CN=%s)', $certificateCN, $x509->getDN(true)['CN'])
-			);
-		}
-
-		// Check if the signature of the files is valid
-		$rsa = new \phpseclib\Crypt\RSA();
-		$rsa->loadKey($x509->currentCert['tbsCertificate']['subjectPublicKeyInfo']['subjectPublicKey']);
-		$rsa->setSignatureMode(RSA::SIGNATURE_PSS);
-		$rsa->setMGFHash('sha512');
-		// See https://tools.ietf.org/html/rfc3447#page-38
-		$rsa->setSaltLength(0);
-		if (!$rsa->verify(json_encode($expectedHashes), $signature)) {
-			throw new InvalidSignatureException('Signature could not get verified.');
-		}
-
-		// Fixes for the updater as shipped with ownCloud 9.0.x: The updater is
-		// replaced after the code integrity check is performed.
-		//
-		// Due to this reason we exclude the whole updater/ folder from the code
-		// integrity check.
-		if ($basePath === $this->environmentHelper->getServerRoot()) {
-			foreach ($expectedHashes as $fileName => $hash) {
-				if (str_starts_with($fileName, 'updater/')) {
-					unset($expectedHashes[$fileName]);
-				}
-			}
-		}
-
-		// Compare the list of files which are not identical
-		$currentInstanceHashes = $this->generateHashes($this->getFolderIterator($basePath), $basePath);
-		$differencesA = array_diff($expectedHashes, $currentInstanceHashes);
-		$differencesB = array_diff($currentInstanceHashes, $expectedHashes);
-		$differences = array_unique(array_merge($differencesA, $differencesB));
-		$differenceArray = [];
-		foreach ($differences as $filename => $hash) {
-			// Check if file should not exist in the new signature table
-			if (!array_key_exists($filename, $expectedHashes)) {
-				$differenceArray['EXTRA_FILE'][$filename]['expected'] = '';
-				$differenceArray['EXTRA_FILE'][$filename]['current'] = $hash;
-				continue;
-			}
-
-			// Check if file is missing
-			if (!array_key_exists($filename, $currentInstanceHashes)) {
-				$differenceArray['FILE_MISSING'][$filename]['expected'] = $expectedHashes[$filename];
-				$differenceArray['FILE_MISSING'][$filename]['current'] = '';
-				continue;
-			}
-
-			// Check if hash does mismatch
-			if ($expectedHashes[$filename] !== $currentInstanceHashes[$filename]) {
-				$differenceArray['INVALID_HASH'][$filename]['expected'] = $expectedHashes[$filename];
-				$differenceArray['INVALID_HASH'][$filename]['current'] = $currentInstanceHashes[$filename];
-				continue;
-			}
-
-			// Should never happen.
-			throw new \Exception('Invalid behaviour in file hash comparison experienced. Please report this error to the developers.');
-		}
-
-		return $differenceArray;
-	}
-
-	/**
-	 * Whether the code integrity check has passed successful or not
-	 *
-	 * @return bool
-	 */
-	public function hasPassedCheck(): bool {
-		$results = $this->getResults();
-		if (empty($results)) {
-			return true;
-		}
-
-		return false;
-	}
-
-	/**
-	 * @return array
-	 */
-	public function getResults(): array {
-		$cachedResults = $this->cache->get(self::CACHE_KEY);
-		if (!\is_null($cachedResults) and $cachedResults !== false) {
-			return json_decode($cachedResults, true);
-		}
-
-		if ($this->config !== null) {
-			return json_decode($this->config->getAppValue('core', self::CACHE_KEY, '{}'), true);
-		}
-		return [];
-	}
-
-	/**
-	 * Stores the results in the app config as well as cache
-	 *
-	 * @param string $scope
-	 * @param array $result
-	 */
-	private function storeResults(string $scope, array $result) {
-		$resultArray = $this->getResults();
-		unset($resultArray[$scope]);
-		if (!empty($result)) {
-			$resultArray[$scope] = $result;
-		}
-		if ($this->config !== null) {
-			$this->config->setAppValue('core', self::CACHE_KEY, json_encode($resultArray));
-		}
-		$this->cache->set(self::CACHE_KEY, json_encode($resultArray));
-	}
-
-	/**
-	 *
-	 * Clean previous results for a proper rescanning. Otherwise
-	 */
-	private function cleanResults() {
-		$this->config->deleteAppValue('core', self::CACHE_KEY);
-		$this->cache->remove(self::CACHE_KEY);
-	}
-
-	/**
-	 * Verify the signature of $appId. Returns an array with the following content:
-	 * [
-	 * 	'FILE_MISSING' =>
-	 * 	[
-	 * 		'filename' => [
-	 * 			'expected' => 'expectedSHA512',
-	 * 			'current' => 'currentSHA512',
-	 * 		],
-	 * 	],
-	 * 	'EXTRA_FILE' =>
-	 * 	[
-	 * 		'filename' => [
-	 * 			'expected' => 'expectedSHA512',
-	 * 			'current' => 'currentSHA512',
-	 * 		],
-	 * 	],
-	 * 	'INVALID_HASH' =>
-	 * 	[
-	 * 		'filename' => [
-	 * 			'expected' => 'expectedSHA512',
-	 * 			'current' => 'currentSHA512',
-	 * 		],
-	 * 	],
-	 * ]
-	 *
-	 * Array may be empty in case no problems have been found.
-	 *
-	 * @param string $appId
-	 * @param string $path Optional path. If none is given it will be guessed.
-	 * @param bool $forceVerify
-	 * @return array
-	 */
-	public function verifyAppSignature(string $appId, string $path = '', bool $forceVerify = false): array {
-		try {
-			if ($path === '') {
-				$path = $this->appLocator->getAppPath($appId);
-			}
-			$result = $this->verify(
-				$path . '/appinfo/signature.json',
-				$path,
-				$appId,
-				$forceVerify
-			);
-		} catch (\Exception $e) {
-			$result = [
-				'EXCEPTION' => [
-					'class' => \get_class($e),
-					'message' => $e->getMessage(),
-				],
-			];
-		}
-		$this->storeResults($appId, $result);
-
-		return $result;
-	}
-
-	/**
-	 * Verify the signature of core. Returns an array with the following content:
-	 * [
-	 * 	'FILE_MISSING' =>
-	 * 	[
-	 * 		'filename' => [
-	 * 			'expected' => 'expectedSHA512',
-	 * 			'current' => 'currentSHA512',
-	 * 		],
-	 * 	],
-	 * 	'EXTRA_FILE' =>
-	 * 	[
-	 * 		'filename' => [
-	 * 			'expected' => 'expectedSHA512',
-	 * 			'current' => 'currentSHA512',
-	 * 		],
-	 * 	],
-	 * 	'INVALID_HASH' =>
-	 * 	[
-	 * 		'filename' => [
-	 * 			'expected' => 'expectedSHA512',
-	 * 			'current' => 'currentSHA512',
-	 * 		],
-	 * 	],
-	 * ]
-	 *
-	 * Array may be empty in case no problems have been found.
-	 *
-	 * @return array
-	 */
-	public function verifyCoreSignature(): array {
-		try {
-			$result = $this->verify(
-				$this->environmentHelper->getServerRoot() . '/core/signature.json',
-				$this->environmentHelper->getServerRoot(),
-				'core'
-			);
-		} catch (\Exception $e) {
-			$result = [
-				'EXCEPTION' => [
-					'class' => \get_class($e),
-					'message' => $e->getMessage(),
-				],
-			];
-		}
-		$this->storeResults('core', $result);
-
-		return $result;
-	}
-
-	/**
-	 * Verify the core code of the instance as well as all applicable applications
-	 * and store the results.
-	 */
-	public function runInstanceVerification() {
-		$this->cleanResults();
-		$this->verifyCoreSignature();
-		$appIds = $this->appLocator->getAllApps();
-		foreach ($appIds as $appId) {
-			// If an application is shipped a valid signature is required
-			$isShipped = $this->appManager->isShipped($appId);
-			$appNeedsToBeChecked = false;
-			if ($isShipped) {
-				$appNeedsToBeChecked = true;
-			} elseif ($this->fileAccessHelper->file_exists($this->appLocator->getAppPath($appId) . '/appinfo/signature.json')) {
-				// Otherwise only if the application explicitly ships a signature.json file
-				$appNeedsToBeChecked = true;
-			}
-
-			if ($appNeedsToBeChecked) {
-				$this->verifyAppSignature($appId);
-			}
-		}
-	}
+    public const CACHE_KEY = 'oc.integritycheck.checker';
+    /** @var EnvironmentHelper */
+    private $environmentHelper;
+    /** @var AppLocator */
+    private $appLocator;
+    /** @var FileAccessHelper */
+    private $fileAccessHelper;
+    /** @var IConfig|null */
+    private $config;
+    /** @var ICache */
+    private $cache;
+    /** @var IAppManager|null */
+    private $appManager;
+    /** @var IMimeTypeDetector */
+    private $mimeTypeDetector;
+
+    /**
+     * @param EnvironmentHelper $environmentHelper
+     * @param FileAccessHelper $fileAccessHelper
+     * @param AppLocator $appLocator
+     * @param IConfig|null $config
+     * @param ICacheFactory $cacheFactory
+     * @param IAppManager|null $appManager
+     * @param IMimeTypeDetector $mimeTypeDetector
+     */
+    public function __construct(EnvironmentHelper $environmentHelper,
+                                FileAccessHelper $fileAccessHelper,
+                                AppLocator $appLocator,
+                                ?IConfig $config,
+                                ICacheFactory $cacheFactory,
+                                ?IAppManager $appManager,
+                                IMimeTypeDetector $mimeTypeDetector) {
+        $this->environmentHelper = $environmentHelper;
+        $this->fileAccessHelper = $fileAccessHelper;
+        $this->appLocator = $appLocator;
+        $this->config = $config;
+        $this->cache = $cacheFactory->createDistributed(self::CACHE_KEY);
+        $this->appManager = $appManager;
+        $this->mimeTypeDetector = $mimeTypeDetector;
+    }
+
+    /**
+     * Whether code signing is enforced or not.
+     *
+     * @return bool
+     */
+    public function isCodeCheckEnforced(): bool {
+        $notSignedChannels = [ '', 'git'];
+        if (\in_array($this->environmentHelper->getChannel(), $notSignedChannels, true)) {
+            return false;
+        }
+
+        /**
+         * This config option is undocumented and supposed to be so, it's only
+         * applicable for very specific scenarios and we should not advertise it
+         * too prominent. So please do not add it to config.sample.php.
+         */
+        $isIntegrityCheckDisabled = false;
+        if ($this->config !== null) {
+            $isIntegrityCheckDisabled = $this->config->getSystemValueBool('integrity.check.disabled', false);
+        }
+        if ($isIntegrityCheckDisabled) {
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * Enumerates all files belonging to the folder. Sensible defaults are excluded.
+     *
+     * @param string $folderToIterate
+     * @param string $root
+     * @return \RecursiveIteratorIterator
+     * @throws \Exception
+     */
+    private function getFolderIterator(string $folderToIterate, string $root = ''): \RecursiveIteratorIterator {
+        $dirItr = new \RecursiveDirectoryIterator(
+            $folderToIterate,
+            \RecursiveDirectoryIterator::SKIP_DOTS
+        );
+        if ($root === '') {
+            $root = \OC::$SERVERROOT;
+        }
+        $root = rtrim($root, '/');
+
+        $excludeGenericFilesIterator = new ExcludeFileByNameFilterIterator($dirItr);
+        $excludeFoldersIterator = new ExcludeFoldersByPathFilterIterator($excludeGenericFilesIterator, $root);
+
+        return new \RecursiveIteratorIterator(
+            $excludeFoldersIterator,
+            \RecursiveIteratorIterator::SELF_FIRST
+        );
+    }
+
+    /**
+     * Returns an array of ['filename' => 'SHA512-hash-of-file'] for all files found
+     * in the iterator.
+     *
+     * @param \RecursiveIteratorIterator $iterator
+     * @param string $path
+     * @return array Array of hashes.
+     */
+    private function generateHashes(\RecursiveIteratorIterator $iterator,
+                                    string $path): array {
+        $hashes = [];
+
+        $baseDirectoryLength = \strlen($path);
+        foreach ($iterator as $filename => $data) {
+            /** @var \DirectoryIterator $data */
+            if ($data->isDir()) {
+                continue;
+            }
+
+            $relativeFileName = substr($filename, $baseDirectoryLength);
+            $relativeFileName = ltrim($relativeFileName, '/');
+
+            // Exclude signature.json files in the appinfo and root folder
+            if ($relativeFileName === 'appinfo/signature.json') {
+                continue;
+            }
+            // Exclude signature.json files in the appinfo and core folder
+            if ($relativeFileName === 'core/signature.json') {
+                continue;
+            }
+
+            // The .htaccess file in the root folder of ownCloud can contain
+            // custom content after the installation due to the fact that dynamic
+            // content is written into it at installation time as well. This
+            // includes for example the 404 and 403 instructions.
+            // Thus we ignore everything below the first occurrence of
+            // "#### DO NOT CHANGE ANYTHING ABOVE THIS LINE ####" and have the
+            // hash generated based on this.
+            if ($filename === $this->environmentHelper->getServerRoot() . '/.htaccess') {
+                $fileContent = file_get_contents($filename);
+                $explodedArray = explode('#### DO NOT CHANGE ANYTHING ABOVE THIS LINE ####', $fileContent);
+                if (\count($explodedArray) === 2) {
+                    $hashes[$relativeFileName] = hash('sha512', $explodedArray[0]);
+                    continue;
+                }
+            }
+            if ($filename === $this->environmentHelper->getServerRoot() . '/core/js/mimetypelist.js') {
+                $oldMimetypeList = new GenerateMimetypeFileBuilder();
+                $newFile = $oldMimetypeList->generateFile($this->mimeTypeDetector->getAllAliases());
+                $oldFile = $this->fileAccessHelper->file_get_contents($filename);
+                if ($newFile === $oldFile) {
+                    $hashes[$relativeFileName] = hash('sha512', $oldMimetypeList->generateFile($this->mimeTypeDetector->getOnlyDefaultAliases()));
+                    continue;
+                }
+            }
+
+            $hashes[$relativeFileName] = hash_file('sha512', $filename);
+        }
+
+        return $hashes;
+    }
+
+    /**
+     * Creates the signature data
+     *
+     * @param array $hashes
+     * @param X509 $certificate
+     * @param RSA $privateKey
+     * @return array
+     */
+    private function createSignatureData(array $hashes,
+                                            X509 $certificate,
+                                            RSA $privateKey): array {
+        ksort($hashes);
+
+        $privateKey->setSignatureMode(RSA::SIGNATURE_PSS);
+        $privateKey->setMGFHash('sha512');
+        // See https://tools.ietf.org/html/rfc3447#page-38
+        $privateKey->setSaltLength(0);
+        $signature = $privateKey->sign(json_encode($hashes));
+
+        return [
+            'hashes' => $hashes,
+            'signature' => base64_encode($signature),
+            'certificate' => $certificate->saveX509($certificate->currentCert),
+        ];
+    }
+
+    /**
+     * Write the signature of the app in the specified folder
+     *
+     * @param string $path
+     * @param X509 $certificate
+     * @param RSA $privateKey
+     * @throws \Exception
+     */
+    public function writeAppSignature($path,
+                                        X509 $certificate,
+                                        RSA $privateKey) {
+        $appInfoDir = $path . '/appinfo';
+        try {
+            $this->fileAccessHelper->assertDirectoryExists($appInfoDir);
+
+            $iterator = $this->getFolderIterator($path);
+            $hashes = $this->generateHashes($iterator, $path);
+            $signature = $this->createSignatureData($hashes, $certificate, $privateKey);
+            $this->fileAccessHelper->file_put_contents(
+                $appInfoDir . '/signature.json',
+                json_encode($signature, JSON_PRETTY_PRINT)
+            );
+        } catch (\Exception $e) {
+            if (!$this->fileAccessHelper->is_writable($appInfoDir)) {
+                throw new \Exception($appInfoDir . ' is not writable');
+            }
+            throw $e;
+        }
+    }
+
+    /**
+     * Write the signature of core
+     *
+     * @param X509 $certificate
+     * @param RSA $rsa
+     * @param string $path
+     * @throws \Exception
+     */
+    public function writeCoreSignature(X509 $certificate,
+                                        RSA $rsa,
+                                        $path) {
+        $coreDir = $path . '/core';
+        try {
+            $this->fileAccessHelper->assertDirectoryExists($coreDir);
+            $iterator = $this->getFolderIterator($path, $path);
+            $hashes = $this->generateHashes($iterator, $path);
+            $signatureData = $this->createSignatureData($hashes, $certificate, $rsa);
+            $this->fileAccessHelper->file_put_contents(
+                $coreDir . '/signature.json',
+                json_encode($signatureData, JSON_PRETTY_PRINT)
+            );
+        } catch (\Exception $e) {
+            if (!$this->fileAccessHelper->is_writable($coreDir)) {
+                throw new \Exception($coreDir . ' is not writable');
+            }
+            throw $e;
+        }
+    }
+
+    /**
+     * Split the certificate file in individual certs
+     *
+     * @param string $cert
+     * @return string[]
+     */
+    private function splitCerts(string $cert): array {
+        preg_match_all('([\-]{3,}[\S\ ]+?[\-]{3,}[\S\s]+?[\-]{3,}[\S\ ]+?[\-]{3,})', $cert, $matches);
+
+        return $matches[0];
+    }
+
+    /**
+     * Verifies the signature for the specified path.
+     *
+     * @param string $signaturePath
+     * @param string $basePath
+     * @param string $certificateCN
+     * @param bool $forceVerify
+     * @return array
+     * @throws InvalidSignatureException
+     * @throws \Exception
+     */
+    private function verify(string $signaturePath, string $basePath, string $certificateCN, bool $forceVerify = false): array {
+        if (!$forceVerify && !$this->isCodeCheckEnforced()) {
+            return [];
+        }
+
+        $content = $this->fileAccessHelper->file_get_contents($signaturePath);
+        $signatureData = null;
+
+        if (\is_string($content)) {
+            $signatureData = json_decode($content, true);
+        }
+        if (!\is_array($signatureData)) {
+            throw new InvalidSignatureException('Signature data not found.');
+        }
+
+        $expectedHashes = $signatureData['hashes'];
+        ksort($expectedHashes);
+        $signature = base64_decode($signatureData['signature']);
+        $certificate = $signatureData['certificate'];
+
+        // Check if certificate is signed by Nextcloud Root Authority
+        $x509 = new \phpseclib\File\X509();
+        $rootCertificatePublicKey = $this->fileAccessHelper->file_get_contents($this->environmentHelper->getServerRoot().'/resources/codesigning/root.crt');
+
+        $rootCerts = $this->splitCerts($rootCertificatePublicKey);
+        foreach ($rootCerts as $rootCert) {
+            $x509->loadCA($rootCert);
+        }
+        $x509->loadX509($certificate);
+        if (!$x509->validateSignature()) {
+            throw new InvalidSignatureException('Certificate is not valid.');
+        }
+        // Verify if certificate has proper CN. "core" CN is always trusted.
+        if ($x509->getDN(X509::DN_OPENSSL)['CN'] !== $certificateCN && $x509->getDN(X509::DN_OPENSSL)['CN'] !== 'core') {
+            throw new InvalidSignatureException(
+                sprintf('Certificate is not valid for required scope. (Requested: %s, current: CN=%s)', $certificateCN, $x509->getDN(true)['CN'])
+            );
+        }
+
+        // Check if the signature of the files is valid
+        $rsa = new \phpseclib\Crypt\RSA();
+        $rsa->loadKey($x509->currentCert['tbsCertificate']['subjectPublicKeyInfo']['subjectPublicKey']);
+        $rsa->setSignatureMode(RSA::SIGNATURE_PSS);
+        $rsa->setMGFHash('sha512');
+        // See https://tools.ietf.org/html/rfc3447#page-38
+        $rsa->setSaltLength(0);
+        if (!$rsa->verify(json_encode($expectedHashes), $signature)) {
+            throw new InvalidSignatureException('Signature could not get verified.');
+        }
+
+        // Fixes for the updater as shipped with ownCloud 9.0.x: The updater is
+        // replaced after the code integrity check is performed.
+        //
+        // Due to this reason we exclude the whole updater/ folder from the code
+        // integrity check.
+        if ($basePath === $this->environmentHelper->getServerRoot()) {
+            foreach ($expectedHashes as $fileName => $hash) {
+                if (str_starts_with($fileName, 'updater/')) {
+                    unset($expectedHashes[$fileName]);
+                }
+            }
+        }
+
+        // Compare the list of files which are not identical
+        $currentInstanceHashes = $this->generateHashes($this->getFolderIterator($basePath), $basePath);
+        $differencesA = array_diff($expectedHashes, $currentInstanceHashes);
+        $differencesB = array_diff($currentInstanceHashes, $expectedHashes);
+        $differences = array_unique(array_merge($differencesA, $differencesB));
+        $differenceArray = [];
+        foreach ($differences as $filename => $hash) {
+            // Check if file should not exist in the new signature table
+            if (!array_key_exists($filename, $expectedHashes)) {
+                $differenceArray['EXTRA_FILE'][$filename]['expected'] = '';
+                $differenceArray['EXTRA_FILE'][$filename]['current'] = $hash;
+                continue;
+            }
+
+            // Check if file is missing
+            if (!array_key_exists($filename, $currentInstanceHashes)) {
+                $differenceArray['FILE_MISSING'][$filename]['expected'] = $expectedHashes[$filename];
+                $differenceArray['FILE_MISSING'][$filename]['current'] = '';
+                continue;
+            }
+
+            // Check if hash does mismatch
+            if ($expectedHashes[$filename] !== $currentInstanceHashes[$filename]) {
+                $differenceArray['INVALID_HASH'][$filename]['expected'] = $expectedHashes[$filename];
+                $differenceArray['INVALID_HASH'][$filename]['current'] = $currentInstanceHashes[$filename];
+                continue;
+            }
+
+            // Should never happen.
+            throw new \Exception('Invalid behaviour in file hash comparison experienced. Please report this error to the developers.');
+        }
+
+        return $differenceArray;
+    }
+
+    /**
+     * Whether the code integrity check has passed successful or not
+     *
+     * @return bool
+     */
+    public function hasPassedCheck(): bool {
+        $results = $this->getResults();
+        if (empty($results)) {
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * @return array
+     */
+    public function getResults(): array {
+        $cachedResults = $this->cache->get(self::CACHE_KEY);
+        if (!\is_null($cachedResults) and $cachedResults !== false) {
+            return json_decode($cachedResults, true);
+        }
+
+        if ($this->config !== null) {
+            return json_decode($this->config->getAppValue('core', self::CACHE_KEY, '{}'), true);
+        }
+        return [];
+    }
+
+    /**
+     * Stores the results in the app config as well as cache
+     *
+     * @param string $scope
+     * @param array $result
+     */
+    private function storeResults(string $scope, array $result) {
+        $resultArray = $this->getResults();
+        unset($resultArray[$scope]);
+        if (!empty($result)) {
+            $resultArray[$scope] = $result;
+        }
+        if ($this->config !== null) {
+            $this->config->setAppValue('core', self::CACHE_KEY, json_encode($resultArray));
+        }
+        $this->cache->set(self::CACHE_KEY, json_encode($resultArray));
+    }
+
+    /**
+     *
+     * Clean previous results for a proper rescanning. Otherwise
+     */
+    private function cleanResults() {
+        $this->config->deleteAppValue('core', self::CACHE_KEY);
+        $this->cache->remove(self::CACHE_KEY);
+    }
+
+    /**
+     * Verify the signature of $appId. Returns an array with the following content:
+     * [
+     * 	'FILE_MISSING' =>
+     * 	[
+     * 		'filename' => [
+     * 			'expected' => 'expectedSHA512',
+     * 			'current' => 'currentSHA512',
+     * 		],
+     * 	],
+     * 	'EXTRA_FILE' =>
+     * 	[
+     * 		'filename' => [
+     * 			'expected' => 'expectedSHA512',
+     * 			'current' => 'currentSHA512',
+     * 		],
+     * 	],
+     * 	'INVALID_HASH' =>
+     * 	[
+     * 		'filename' => [
+     * 			'expected' => 'expectedSHA512',
+     * 			'current' => 'currentSHA512',
+     * 		],
+     * 	],
+     * ]
+     *
+     * Array may be empty in case no problems have been found.
+     *
+     * @param string $appId
+     * @param string $path Optional path. If none is given it will be guessed.
+     * @param bool $forceVerify
+     * @return array
+     */
+    public function verifyAppSignature(string $appId, string $path = '', bool $forceVerify = false): array {
+        try {
+            if ($path === '') {
+                $path = $this->appLocator->getAppPath($appId);
+            }
+            $result = $this->verify(
+                $path . '/appinfo/signature.json',
+                $path,
+                $appId,
+                $forceVerify
+            );
+        } catch (\Exception $e) {
+            $result = [
+                'EXCEPTION' => [
+                    'class' => \get_class($e),
+                    'message' => $e->getMessage(),
+                ],
+            ];
+        }
+        $this->storeResults($appId, $result);
+
+        return $result;
+    }
+
+    /**
+     * Verify the signature of core. Returns an array with the following content:
+     * [
+     * 	'FILE_MISSING' =>
+     * 	[
+     * 		'filename' => [
+     * 			'expected' => 'expectedSHA512',
+     * 			'current' => 'currentSHA512',
+     * 		],
+     * 	],
+     * 	'EXTRA_FILE' =>
+     * 	[
+     * 		'filename' => [
+     * 			'expected' => 'expectedSHA512',
+     * 			'current' => 'currentSHA512',
+     * 		],
+     * 	],
+     * 	'INVALID_HASH' =>
+     * 	[
+     * 		'filename' => [
+     * 			'expected' => 'expectedSHA512',
+     * 			'current' => 'currentSHA512',
+     * 		],
+     * 	],
+     * ]
+     *
+     * Array may be empty in case no problems have been found.
+     *
+     * @return array
+     */
+    public function verifyCoreSignature(): array {
+        try {
+            $result = $this->verify(
+                $this->environmentHelper->getServerRoot() . '/core/signature.json',
+                $this->environmentHelper->getServerRoot(),
+                'core'
+            );
+        } catch (\Exception $e) {
+            $result = [
+                'EXCEPTION' => [
+                    'class' => \get_class($e),
+                    'message' => $e->getMessage(),
+                ],
+            ];
+        }
+        $this->storeResults('core', $result);
+
+        return $result;
+    }
+
+    /**
+     * Verify the core code of the instance as well as all applicable applications
+     * and store the results.
+     */
+    public function runInstanceVerification() {
+        $this->cleanResults();
+        $this->verifyCoreSignature();
+        $appIds = $this->appLocator->getAllApps();
+        foreach ($appIds as $appId) {
+            // If an application is shipped a valid signature is required
+            $isShipped = $this->appManager->isShipped($appId);
+            $appNeedsToBeChecked = false;
+            if ($isShipped) {
+                $appNeedsToBeChecked = true;
+            } elseif ($this->fileAccessHelper->file_exists($this->appLocator->getAppPath($appId) . '/appinfo/signature.json')) {
+                // Otherwise only if the application explicitly ships a signature.json file
+                $appNeedsToBeChecked = true;
+            }
+
+            if ($appNeedsToBeChecked) {
+                $this->verifyAppSignature($appId);
+            }
+        }
+    }
 }

lib/private/Files/SetupManager.php

Indentation +541 added lines, -541 removed lines

@@ -63,547 +63,547 @@
 use Psr\Log\LoggerInterface;
 
 class SetupManager {
-	private bool $rootSetup = false;
-	private IEventLogger $eventLogger;
-	private MountProviderCollection $mountProviderCollection;
-	private IMountManager $mountManager;
-	private IUserManager $userManager;
-	// List of users for which at least one mount is setup
-	private array $setupUsers = [];
-	// List of users for which all mounts are setup
-	private array $setupUsersComplete = [];
-	/** @var array<string, string[]> */
-	private array $setupUserMountProviders = [];
-	private IEventDispatcher $eventDispatcher;
-	private IUserMountCache $userMountCache;
-	private ILockdownManager $lockdownManager;
-	private IUserSession $userSession;
-	private ICache $cache;
-	private LoggerInterface $logger;
-	private IConfig $config;
-	private bool $listeningForProviders;
-	private array $fullSetupRequired = [];
-	private bool $setupBuiltinWrappersDone = false;
-
-	public function __construct(
-		IEventLogger $eventLogger,
-		MountProviderCollection $mountProviderCollection,
-		IMountManager $mountManager,
-		IUserManager $userManager,
-		IEventDispatcher $eventDispatcher,
-		IUserMountCache $userMountCache,
-		ILockdownManager $lockdownManager,
-		IUserSession $userSession,
-		ICacheFactory $cacheFactory,
-		LoggerInterface $logger,
-		IConfig $config
-	) {
-		$this->eventLogger = $eventLogger;
-		$this->mountProviderCollection = $mountProviderCollection;
-		$this->mountManager = $mountManager;
-		$this->userManager = $userManager;
-		$this->eventDispatcher = $eventDispatcher;
-		$this->userMountCache = $userMountCache;
-		$this->lockdownManager = $lockdownManager;
-		$this->logger = $logger;
-		$this->userSession = $userSession;
-		$this->cache = $cacheFactory->createDistributed('setupmanager::');
-		$this->listeningForProviders = false;
-		$this->config = $config;
-
-		$this->setupListeners();
-	}
-
-	private function isSetupStarted(IUser $user): bool {
-		return in_array($user->getUID(), $this->setupUsers, true);
-	}
-
-	public function isSetupComplete(IUser $user): bool {
-		return in_array($user->getUID(), $this->setupUsersComplete, true);
-	}
-
-	private function setupBuiltinWrappers() {
-		if ($this->setupBuiltinWrappersDone) {
-			return;
-		}
-		$this->setupBuiltinWrappersDone = true;
-
-		// load all filesystem apps before, so no setup-hook gets lost
-		OC_App::loadApps(['filesystem']);
-		$prevLogging = Filesystem::logWarningWhenAddingStorageWrapper(false);
-
-		Filesystem::addStorageWrapper('mount_options', function ($mountPoint, IStorage $storage, IMountPoint $mount) {
-			if ($storage->instanceOfStorage(Common::class)) {
-				$storage->setMountOptions($mount->getOptions());
-			}
-			return $storage;
-		});
-
-		Filesystem::addStorageWrapper('enable_sharing', function ($mountPoint, IStorage $storage, IMountPoint $mount) {
-			if (!$mount->getOption('enable_sharing', true)) {
-				return new PermissionsMask([
-					'storage' => $storage,
-					'mask' => Constants::PERMISSION_ALL - Constants::PERMISSION_SHARE,
-				]);
-			}
-			return $storage;
-		});
-
-		// install storage availability wrapper, before most other wrappers
-		Filesystem::addStorageWrapper('oc_availability', function ($mountPoint, IStorage $storage) {
-			if (!$storage->instanceOfStorage('\OCA\Files_Sharing\SharedStorage') && !$storage->isLocal()) {
-				return new Availability(['storage' => $storage]);
-			}
-			return $storage;
-		});
-
-		Filesystem::addStorageWrapper('oc_encoding', function ($mountPoint, IStorage $storage, IMountPoint $mount) {
-			if ($mount->getOption('encoding_compatibility', false) && !$storage->instanceOfStorage('\OCA\Files_Sharing\SharedStorage')) {
-				return new Encoding(['storage' => $storage]);
-			}
-			return $storage;
-		});
-
-		Filesystem::addStorageWrapper('oc_quota', function ($mountPoint, $storage) {
-			// set up quota for home storages, even for other users
-			// which can happen when using sharing
-
-			/**
-			 * @var Storage $storage
-			 */
-			if ($storage->instanceOfStorage(HomeObjectStoreStorage::class) || $storage->instanceOfStorage(Home::class)) {
-				if (is_object($storage->getUser())) {
-					$user = $storage->getUser();
-					return new Quota(['storage' => $storage, 'quotaCallback' => function () use ($user) {
-						return OC_Util::getUserQuota($user);
-					}, 'root' => 'files']);
-				}
-			}
-
-			return $storage;
-		});
-
-		Filesystem::addStorageWrapper('readonly', function ($mountPoint, IStorage $storage, IMountPoint $mount) {
-			/*
+    private bool $rootSetup = false;
+    private IEventLogger $eventLogger;
+    private MountProviderCollection $mountProviderCollection;
+    private IMountManager $mountManager;
+    private IUserManager $userManager;
+    // List of users for which at least one mount is setup
+    private array $setupUsers = [];
+    // List of users for which all mounts are setup
+    private array $setupUsersComplete = [];
+    /** @var array<string, string[]> */
+    private array $setupUserMountProviders = [];
+    private IEventDispatcher $eventDispatcher;
+    private IUserMountCache $userMountCache;
+    private ILockdownManager $lockdownManager;
+    private IUserSession $userSession;
+    private ICache $cache;
+    private LoggerInterface $logger;
+    private IConfig $config;
+    private bool $listeningForProviders;
+    private array $fullSetupRequired = [];
+    private bool $setupBuiltinWrappersDone = false;
+
+    public function __construct(
+        IEventLogger $eventLogger,
+        MountProviderCollection $mountProviderCollection,
+        IMountManager $mountManager,
+        IUserManager $userManager,
+        IEventDispatcher $eventDispatcher,
+        IUserMountCache $userMountCache,
+        ILockdownManager $lockdownManager,
+        IUserSession $userSession,
+        ICacheFactory $cacheFactory,
+        LoggerInterface $logger,
+        IConfig $config
+    ) {
+        $this->eventLogger = $eventLogger;
+        $this->mountProviderCollection = $mountProviderCollection;
+        $this->mountManager = $mountManager;
+        $this->userManager = $userManager;
+        $this->eventDispatcher = $eventDispatcher;
+        $this->userMountCache = $userMountCache;
+        $this->lockdownManager = $lockdownManager;
+        $this->logger = $logger;
+        $this->userSession = $userSession;
+        $this->cache = $cacheFactory->createDistributed('setupmanager::');
+        $this->listeningForProviders = false;
+        $this->config = $config;
+
+        $this->setupListeners();
+    }
+
+    private function isSetupStarted(IUser $user): bool {
+        return in_array($user->getUID(), $this->setupUsers, true);
+    }
+
+    public function isSetupComplete(IUser $user): bool {
+        return in_array($user->getUID(), $this->setupUsersComplete, true);
+    }
+
+    private function setupBuiltinWrappers() {
+        if ($this->setupBuiltinWrappersDone) {
+            return;
+        }
+        $this->setupBuiltinWrappersDone = true;
+
+        // load all filesystem apps before, so no setup-hook gets lost
+        OC_App::loadApps(['filesystem']);
+        $prevLogging = Filesystem::logWarningWhenAddingStorageWrapper(false);
+
+        Filesystem::addStorageWrapper('mount_options', function ($mountPoint, IStorage $storage, IMountPoint $mount) {
+            if ($storage->instanceOfStorage(Common::class)) {
+                $storage->setMountOptions($mount->getOptions());
+            }
+            return $storage;
+        });
+
+        Filesystem::addStorageWrapper('enable_sharing', function ($mountPoint, IStorage $storage, IMountPoint $mount) {
+            if (!$mount->getOption('enable_sharing', true)) {
+                return new PermissionsMask([
+                    'storage' => $storage,
+                    'mask' => Constants::PERMISSION_ALL - Constants::PERMISSION_SHARE,
+                ]);
+            }
+            return $storage;
+        });
+
+        // install storage availability wrapper, before most other wrappers
+        Filesystem::addStorageWrapper('oc_availability', function ($mountPoint, IStorage $storage) {
+            if (!$storage->instanceOfStorage('\OCA\Files_Sharing\SharedStorage') && !$storage->isLocal()) {
+                return new Availability(['storage' => $storage]);
+            }
+            return $storage;
+        });
+
+        Filesystem::addStorageWrapper('oc_encoding', function ($mountPoint, IStorage $storage, IMountPoint $mount) {
+            if ($mount->getOption('encoding_compatibility', false) && !$storage->instanceOfStorage('\OCA\Files_Sharing\SharedStorage')) {
+                return new Encoding(['storage' => $storage]);
+            }
+            return $storage;
+        });
+
+        Filesystem::addStorageWrapper('oc_quota', function ($mountPoint, $storage) {
+            // set up quota for home storages, even for other users
+            // which can happen when using sharing
+
+            /**
+             * @var Storage $storage
+             */
+            if ($storage->instanceOfStorage(HomeObjectStoreStorage::class) || $storage->instanceOfStorage(Home::class)) {
+                if (is_object($storage->getUser())) {
+                    $user = $storage->getUser();
+                    return new Quota(['storage' => $storage, 'quotaCallback' => function () use ($user) {
+                        return OC_Util::getUserQuota($user);
+                    }, 'root' => 'files']);
+                }
+            }
+
+            return $storage;
+        });
+
+        Filesystem::addStorageWrapper('readonly', function ($mountPoint, IStorage $storage, IMountPoint $mount) {
+            /*
 			 * Do not allow any operations that modify the storage
 			 */
-			if ($mount->getOption('readonly', false)) {
-				return new PermissionsMask([
-					'storage' => $storage,
-					'mask' => Constants::PERMISSION_ALL & ~(
-						Constants::PERMISSION_UPDATE |
-						Constants::PERMISSION_CREATE |
-						Constants::PERMISSION_DELETE
-					),
-				]);
-			}
-			return $storage;
-		});
-
-		Filesystem::logWarningWhenAddingStorageWrapper($prevLogging);
-	}
-
-	/**
-	 * Setup the full filesystem for the specified user
-	 */
-	public function setupForUser(IUser $user): void {
-		if ($this->isSetupComplete($user)) {
-			return;
-		}
-		$this->setupUsersComplete[] = $user->getUID();
-
-		$this->eventLogger->start('fs:setup:user:full', 'Setup full filesystem for user');
-
-		if (!isset($this->setupUserMountProviders[$user->getUID()])) {
-			$this->setupUserMountProviders[$user->getUID()] = [];
-		}
-
-		$previouslySetupProviders = $this->setupUserMountProviders[$user->getUID()];
-
-		$this->setupForUserWith($user, function () use ($user) {
-			$this->mountProviderCollection->addMountForUser($user, $this->mountManager, function (
-				IMountProvider $provider
-			) use ($user) {
-				return !in_array(get_class($provider), $this->setupUserMountProviders[$user->getUID()]);
-			});
-		});
-		$this->afterUserFullySetup($user, $previouslySetupProviders);
-		$this->eventLogger->end('fs:setup:user:full');
-	}
-
-	/**
-	 * part of the user setup that is run only once per user
-	 */
-	private function oneTimeUserSetup(IUser $user) {
-		if ($this->isSetupStarted($user)) {
-			return;
-		}
-		$this->setupUsers[] = $user->getUID();
-
-		$this->setupRoot();
-
-		$this->eventLogger->start('fs:setup:user:onetime', 'Onetime filesystem for user');
-
-		$this->setupBuiltinWrappers();
-
-		$prevLogging = Filesystem::logWarningWhenAddingStorageWrapper(false);
-
-		OC_Hook::emit('OC_Filesystem', 'preSetup', ['user' => $user->getUID()]);
-
-		Filesystem::logWarningWhenAddingStorageWrapper($prevLogging);
-
-		$userDir = '/' . $user->getUID() . '/files';
-
-		Filesystem::initInternal($userDir);
-
-		if ($this->lockdownManager->canAccessFilesystem()) {
-			$this->eventLogger->start('fs:setup:user:home', 'Setup home filesystem for user');
-			// home mounts are handled separate since we need to ensure this is mounted before we call the other mount providers
-			$homeMount = $this->mountProviderCollection->getHomeMountForUser($user);
-			$this->mountManager->addMount($homeMount);
-
-			if ($homeMount->getStorageRootId() === -1) {
-				$this->eventLogger->start('fs:setup:user:home:scan', 'Scan home filesystem for user');
-				$homeMount->getStorage()->mkdir('');
-				$homeMount->getStorage()->getScanner()->scan('');
-				$this->eventLogger->end('fs:setup:user:home:scan');
-			}
-			$this->eventLogger->end('fs:setup:user:home');
-		} else {
-			$this->mountManager->addMount(new MountPoint(
-				new NullStorage([]),
-				'/' . $user->getUID()
-			));
-			$this->mountManager->addMount(new MountPoint(
-				new NullStorage([]),
-				'/' . $user->getUID() . '/files'
-			));
-			$this->setupUsersComplete[] = $user->getUID();
-		}
-
-		$this->listenForNewMountProviders();
-
-		$this->eventLogger->end('fs:setup:user:onetime');
-	}
-
-	/**
-	 * Final housekeeping after a user has been fully setup
-	 */
-	private function afterUserFullySetup(IUser $user, array $previouslySetupProviders): void {
-		$this->eventLogger->start('fs:setup:user:full:post', 'Housekeeping after user is setup');
-		$userRoot = '/' . $user->getUID() . '/';
-		$mounts = $this->mountManager->getAll();
-		$mounts = array_filter($mounts, function (IMountPoint $mount) use ($userRoot) {
-			return str_starts_with($mount->getMountPoint(), $userRoot);
-		});
-		$allProviders = array_map(function (IMountProvider $provider) {
-			return get_class($provider);
-		}, $this->mountProviderCollection->getProviders());
-		$newProviders = array_diff($allProviders, $previouslySetupProviders);
-		$mounts = array_filter($mounts, function (IMountPoint $mount) use ($previouslySetupProviders) {
-			return !in_array($mount->getMountProvider(), $previouslySetupProviders);
-		});
-		$this->userMountCache->registerMounts($user, $mounts, $newProviders);
-
-		$cacheDuration = $this->config->getSystemValueInt('fs_mount_cache_duration', 5 * 60);
-		if ($cacheDuration > 0) {
-			$this->cache->set($user->getUID(), true, $cacheDuration);
-			$this->fullSetupRequired[$user->getUID()] = false;
-		}
-		$this->eventLogger->end('fs:setup:user:full:post');
-	}
-
-	/**
-	 * @param IUser $user
-	 * @param IMountPoint $mounts
-	 * @return void
-	 * @throws \OCP\HintException
-	 * @throws \OC\ServerNotAvailableException
-	 */
-	private function setupForUserWith(IUser $user, callable $mountCallback): void {
-		$this->oneTimeUserSetup($user);
-
-		if ($this->lockdownManager->canAccessFilesystem()) {
-			$mountCallback();
-		}
-		$this->eventLogger->start('fs:setup:user:post-init-mountpoint', 'post_initMountPoints legacy hook');
-		\OC_Hook::emit('OC_Filesystem', 'post_initMountPoints', ['user' => $user->getUID()]);
-		$this->eventLogger->end('fs:setup:user:post-init-mountpoint');
-
-		$userDir = '/' . $user->getUID() . '/files';
-		$this->eventLogger->start('fs:setup:user:setup-hook', 'setup legacy hook');
-		OC_Hook::emit('OC_Filesystem', 'setup', ['user' => $user->getUID(), 'user_dir' => $userDir]);
-		$this->eventLogger->end('fs:setup:user:setup-hook');
-	}
-
-	/**
-	 * Set up the root filesystem
-	 */
-	public function setupRoot(): void {
-		//setting up the filesystem twice can only lead to trouble
-		if ($this->rootSetup) {
-			return;
-		}
-		$this->rootSetup = true;
-
-		$this->eventLogger->start('fs:setup:root', 'Setup root filesystem');
-
-		$this->setupBuiltinWrappers();
-
-		$rootMounts = $this->mountProviderCollection->getRootMounts();
-		foreach ($rootMounts as $rootMountProvider) {
-			$this->mountManager->addMount($rootMountProvider);
-		}
-
-		$this->eventLogger->end('fs:setup:root');
-	}
-
-	/**
-	 * Get the user to setup for a path or `null` if the root needs to be setup
-	 *
-	 * @param string $path
-	 * @return IUser|null
-	 */
-	private function getUserForPath(string $path) {
-		if (str_starts_with($path, '/__groupfolders')) {
-			return null;
-		} elseif (substr_count($path, '/') < 2) {
-			if ($user = $this->userSession->getUser()) {
-				return $user;
-			} else {
-				return null;
-			}
-		} elseif (str_starts_with($path, '/appdata_' . \OC_Util::getInstanceId()) || str_starts_with($path, '/files_external/')) {
-			return null;
-		} else {
-			[, $userId] = explode('/', $path);
-		}
-
-		return $this->userManager->get($userId);
-	}
-
-	/**
-	 * Set up the filesystem for the specified path
-	 */
-	public function setupForPath(string $path, bool $includeChildren = false): void {
-		$user = $this->getUserForPath($path);
-		if (!$user) {
-			$this->setupRoot();
-			return;
-		}
-
-		if ($this->isSetupComplete($user)) {
-			return;
-		}
-
-		if ($this->fullSetupRequired($user)) {
-			$this->setupForUser($user);
-			return;
-		}
-
-		// for the user's home folder, and includes children we need everything always
-		if (rtrim($path) === "/" . $user->getUID() . "/files" && $includeChildren) {
-			$this->setupForUser($user);
-			return;
-		}
-
-		if (!isset($this->setupUserMountProviders[$user->getUID()])) {
-			$this->setupUserMountProviders[$user->getUID()] = [];
-		}
-		$setupProviders = &$this->setupUserMountProviders[$user->getUID()];
-		$currentProviders = [];
-
-		try {
-			$cachedMount = $this->userMountCache->getMountForPath($user, $path);
-		} catch (NotFoundException $e) {
-			$this->setupForUser($user);
-			return;
-		}
-
-		$this->oneTimeUserSetup($user);
-
-		$this->eventLogger->start('fs:setup:user:path', "Setup $path filesystem for user");
-		$this->eventLogger->start('fs:setup:user:path:find', "Find mountpoint for $path");
-
-		$mounts = [];
-		if (!in_array($cachedMount->getMountProvider(), $setupProviders)) {
-			$currentProviders[] = $cachedMount->getMountProvider();
-			if ($cachedMount->getMountProvider()) {
-				$setupProviders[] = $cachedMount->getMountProvider();
-				$mounts = $this->mountProviderCollection->getUserMountsForProviderClasses($user, [$cachedMount->getMountProvider()]);
-			} else {
-				$this->logger->debug("mount at " . $cachedMount->getMountPoint() . " has no provider set, performing full setup");
-				$this->eventLogger->end('fs:setup:user:path:find');
-				$this->setupForUser($user);
-				$this->eventLogger->end('fs:setup:user:path');
-				return;
-			}
-		}
-
-		if ($includeChildren) {
-			$subCachedMounts = $this->userMountCache->getMountsInPath($user, $path);
-			$this->eventLogger->end('fs:setup:user:path:find');
-
-			$needsFullSetup = array_reduce($subCachedMounts, function (bool $needsFullSetup, ICachedMountInfo $cachedMountInfo) {
-				return $needsFullSetup || $cachedMountInfo->getMountProvider() === '';
-			}, false);
-
-			if ($needsFullSetup) {
-				$this->logger->debug("mount has no provider set, performing full setup");
-				$this->setupForUser($user);
-				$this->eventLogger->end('fs:setup:user:path');
-				return;
-			} else {
-				foreach ($subCachedMounts as $cachedMount) {
-					if (!in_array($cachedMount->getMountProvider(), $setupProviders)) {
-						$currentProviders[] = $cachedMount->getMountProvider();
-						$setupProviders[] = $cachedMount->getMountProvider();
-						$mounts = array_merge($mounts, $this->mountProviderCollection->getUserMountsForProviderClasses($user, [$cachedMount->getMountProvider()]));
-					}
-				}
-			}
-		} else {
-			$this->eventLogger->end('fs:setup:user:path:find');
-		}
-
-		if (count($mounts)) {
-			$this->userMountCache->registerMounts($user, $mounts, $currentProviders);
-			$this->setupForUserWith($user, function () use ($mounts) {
-				array_walk($mounts, [$this->mountManager, 'addMount']);
-			});
-		} elseif (!$this->isSetupStarted($user)) {
-			$this->oneTimeUserSetup($user);
-		}
-		$this->eventLogger->end('fs:setup:user:path');
-	}
-
-	private function fullSetupRequired(IUser $user): bool {
-		// we perform a "cached" setup only after having done the full setup recently
-		// this is also used to trigger a full setup after handling events that are likely
-		// to change the available mounts
-		if (!isset($this->fullSetupRequired[$user->getUID()])) {
-			$this->fullSetupRequired[$user->getUID()] = !$this->cache->get($user->getUID());
-		}
-		return $this->fullSetupRequired[$user->getUID()];
-	}
-
-	/**
-	 * @param string $path
-	 * @param string[] $providers
-	 */
-	public function setupForProvider(string $path, array $providers): void {
-		$user = $this->getUserForPath($path);
-		if (!$user) {
-			$this->setupRoot();
-			return;
-		}
-
-		if ($this->isSetupComplete($user)) {
-			return;
-		}
-
-		if ($this->fullSetupRequired($user)) {
-			$this->setupForUser($user);
-			return;
-		}
-
-		$this->eventLogger->start('fs:setup:user:providers', "Setup filesystem for " . implode(', ', $providers));
-
-		$this->oneTimeUserSetup($user);
-
-		// home providers are always used
-		$providers = array_filter($providers, function (string $provider) {
-			return !is_subclass_of($provider, IHomeMountProvider::class);
-		});
-
-		if (in_array('', $providers)) {
-			$this->setupForUser($user);
-			return;
-		}
-		$setupProviders = $this->setupUserMountProviders[$user->getUID()] ?? [];
-
-		$providers = array_diff($providers, $setupProviders);
-		if (count($providers) === 0) {
-			if (!$this->isSetupStarted($user)) {
-				$this->oneTimeUserSetup($user);
-			}
-			$this->eventLogger->end('fs:setup:user:providers');
-			return;
-		} else {
-			$this->setupUserMountProviders[$user->getUID()] = array_merge($setupProviders, $providers);
-			$mounts = $this->mountProviderCollection->getUserMountsForProviderClasses($user, $providers);
-		}
-
-		$this->userMountCache->registerMounts($user, $mounts, $providers);
-		$this->setupForUserWith($user, function () use ($mounts) {
-			array_walk($mounts, [$this->mountManager, 'addMount']);
-		});
-		$this->eventLogger->end('fs:setup:user:providers');
-	}
-
-	public function tearDown() {
-		$this->setupUsers = [];
-		$this->setupUsersComplete = [];
-		$this->setupUserMountProviders = [];
-		$this->fullSetupRequired = [];
-		$this->rootSetup = false;
-		$this->mountManager->clear();
-		$this->eventDispatcher->dispatchTyped(new FilesystemTornDownEvent());
-	}
-
-	/**
-	 * Get mounts from mount providers that are registered after setup
-	 */
-	private function listenForNewMountProviders() {
-		if (!$this->listeningForProviders) {
-			$this->listeningForProviders = true;
-			$this->mountProviderCollection->listen('\OC\Files\Config', 'registerMountProvider', function (
-				IMountProvider $provider
-			) {
-				foreach ($this->setupUsers as $userId) {
-					$user = $this->userManager->get($userId);
-					if ($user) {
-						$mounts = $provider->getMountsForUser($user, Filesystem::getLoader());
-						array_walk($mounts, [$this->mountManager, 'addMount']);
-					}
-				}
-			});
-		}
-	}
-
-	private function setupListeners() {
-		// note that this event handling is intentionally pessimistic
-		// clearing the cache to often is better than not enough
-
-		$this->eventDispatcher->addListener(UserAddedEvent::class, function (UserAddedEvent $event) {
-			$this->cache->remove($event->getUser()->getUID());
-		});
-		$this->eventDispatcher->addListener(UserRemovedEvent::class, function (UserRemovedEvent $event) {
-			$this->cache->remove($event->getUser()->getUID());
-		});
-		$this->eventDispatcher->addListener(ShareCreatedEvent::class, function (ShareCreatedEvent $event) {
-			$this->cache->remove($event->getShare()->getSharedWith());
-		});
-		$this->eventDispatcher->addListener(InvalidateMountCacheEvent::class, function (InvalidateMountCacheEvent $event
-		) {
-			if ($user = $event->getUser()) {
-				$this->cache->remove($user->getUID());
-			} else {
-				$this->cache->clear();
-			}
-		});
-
-		$genericEvents = [
-			'OCA\Circles\Events\CreatingCircleEvent',
-			'OCA\Circles\Events\DestroyingCircleEvent',
-			'OCA\Circles\Events\AddingCircleMemberEvent',
-			'OCA\Circles\Events\RemovingCircleMemberEvent',
-		];
-
-		foreach ($genericEvents as $genericEvent) {
-			$this->eventDispatcher->addListener($genericEvent, function ($event) {
-				$this->cache->clear();
-			});
-		}
-	}
+            if ($mount->getOption('readonly', false)) {
+                return new PermissionsMask([
+                    'storage' => $storage,
+                    'mask' => Constants::PERMISSION_ALL & ~(
+                        Constants::PERMISSION_UPDATE |
+                        Constants::PERMISSION_CREATE |
+                        Constants::PERMISSION_DELETE
+                    ),
+                ]);
+            }
+            return $storage;
+        });
+
+        Filesystem::logWarningWhenAddingStorageWrapper($prevLogging);
+    }
+
+    /**
+     * Setup the full filesystem for the specified user
+     */
+    public function setupForUser(IUser $user): void {
+        if ($this->isSetupComplete($user)) {
+            return;
+        }
+        $this->setupUsersComplete[] = $user->getUID();
+
+        $this->eventLogger->start('fs:setup:user:full', 'Setup full filesystem for user');
+
+        if (!isset($this->setupUserMountProviders[$user->getUID()])) {
+            $this->setupUserMountProviders[$user->getUID()] = [];
+        }
+
+        $previouslySetupProviders = $this->setupUserMountProviders[$user->getUID()];
+
+        $this->setupForUserWith($user, function () use ($user) {
+            $this->mountProviderCollection->addMountForUser($user, $this->mountManager, function (
+                IMountProvider $provider
+            ) use ($user) {
+                return !in_array(get_class($provider), $this->setupUserMountProviders[$user->getUID()]);
+            });
+        });
+        $this->afterUserFullySetup($user, $previouslySetupProviders);
+        $this->eventLogger->end('fs:setup:user:full');
+    }
+
+    /**
+     * part of the user setup that is run only once per user
+     */
+    private function oneTimeUserSetup(IUser $user) {
+        if ($this->isSetupStarted($user)) {
+            return;
+        }
+        $this->setupUsers[] = $user->getUID();
+
+        $this->setupRoot();
+
+        $this->eventLogger->start('fs:setup:user:onetime', 'Onetime filesystem for user');
+
+        $this->setupBuiltinWrappers();
+
+        $prevLogging = Filesystem::logWarningWhenAddingStorageWrapper(false);
+
+        OC_Hook::emit('OC_Filesystem', 'preSetup', ['user' => $user->getUID()]);
+
+        Filesystem::logWarningWhenAddingStorageWrapper($prevLogging);
+
+        $userDir = '/' . $user->getUID() . '/files';
+
+        Filesystem::initInternal($userDir);
+
+        if ($this->lockdownManager->canAccessFilesystem()) {
+            $this->eventLogger->start('fs:setup:user:home', 'Setup home filesystem for user');
+            // home mounts are handled separate since we need to ensure this is mounted before we call the other mount providers
+            $homeMount = $this->mountProviderCollection->getHomeMountForUser($user);
+            $this->mountManager->addMount($homeMount);
+
+            if ($homeMount->getStorageRootId() === -1) {
+                $this->eventLogger->start('fs:setup:user:home:scan', 'Scan home filesystem for user');
+                $homeMount->getStorage()->mkdir('');
+                $homeMount->getStorage()->getScanner()->scan('');
+                $this->eventLogger->end('fs:setup:user:home:scan');
+            }
+            $this->eventLogger->end('fs:setup:user:home');
+        } else {
+            $this->mountManager->addMount(new MountPoint(
+                new NullStorage([]),
+                '/' . $user->getUID()
+            ));
+            $this->mountManager->addMount(new MountPoint(
+                new NullStorage([]),
+                '/' . $user->getUID() . '/files'
+            ));
+            $this->setupUsersComplete[] = $user->getUID();
+        }
+
+        $this->listenForNewMountProviders();
+
+        $this->eventLogger->end('fs:setup:user:onetime');
+    }
+
+    /**
+     * Final housekeeping after a user has been fully setup
+     */
+    private function afterUserFullySetup(IUser $user, array $previouslySetupProviders): void {
+        $this->eventLogger->start('fs:setup:user:full:post', 'Housekeeping after user is setup');
+        $userRoot = '/' . $user->getUID() . '/';
+        $mounts = $this->mountManager->getAll();
+        $mounts = array_filter($mounts, function (IMountPoint $mount) use ($userRoot) {
+            return str_starts_with($mount->getMountPoint(), $userRoot);
+        });
+        $allProviders = array_map(function (IMountProvider $provider) {
+            return get_class($provider);
+        }, $this->mountProviderCollection->getProviders());
+        $newProviders = array_diff($allProviders, $previouslySetupProviders);
+        $mounts = array_filter($mounts, function (IMountPoint $mount) use ($previouslySetupProviders) {
+            return !in_array($mount->getMountProvider(), $previouslySetupProviders);
+        });
+        $this->userMountCache->registerMounts($user, $mounts, $newProviders);
+
+        $cacheDuration = $this->config->getSystemValueInt('fs_mount_cache_duration', 5 * 60);
+        if ($cacheDuration > 0) {
+            $this->cache->set($user->getUID(), true, $cacheDuration);
+            $this->fullSetupRequired[$user->getUID()] = false;
+        }
+        $this->eventLogger->end('fs:setup:user:full:post');
+    }
+
+    /**
+     * @param IUser $user
+     * @param IMountPoint $mounts
+     * @return void
+     * @throws \OCP\HintException
+     * @throws \OC\ServerNotAvailableException
+     */
+    private function setupForUserWith(IUser $user, callable $mountCallback): void {
+        $this->oneTimeUserSetup($user);
+
+        if ($this->lockdownManager->canAccessFilesystem()) {
+            $mountCallback();
+        }
+        $this->eventLogger->start('fs:setup:user:post-init-mountpoint', 'post_initMountPoints legacy hook');
+        \OC_Hook::emit('OC_Filesystem', 'post_initMountPoints', ['user' => $user->getUID()]);
+        $this->eventLogger->end('fs:setup:user:post-init-mountpoint');
+
+        $userDir = '/' . $user->getUID() . '/files';
+        $this->eventLogger->start('fs:setup:user:setup-hook', 'setup legacy hook');
+        OC_Hook::emit('OC_Filesystem', 'setup', ['user' => $user->getUID(), 'user_dir' => $userDir]);
+        $this->eventLogger->end('fs:setup:user:setup-hook');
+    }
+
+    /**
+     * Set up the root filesystem
+     */
+    public function setupRoot(): void {
+        //setting up the filesystem twice can only lead to trouble
+        if ($this->rootSetup) {
+            return;
+        }
+        $this->rootSetup = true;
+
+        $this->eventLogger->start('fs:setup:root', 'Setup root filesystem');
+
+        $this->setupBuiltinWrappers();
+
+        $rootMounts = $this->mountProviderCollection->getRootMounts();
+        foreach ($rootMounts as $rootMountProvider) {
+            $this->mountManager->addMount($rootMountProvider);
+        }
+
+        $this->eventLogger->end('fs:setup:root');
+    }
+
+    /**
+     * Get the user to setup for a path or `null` if the root needs to be setup
+     *
+     * @param string $path
+     * @return IUser|null
+     */
+    private function getUserForPath(string $path) {
+        if (str_starts_with($path, '/__groupfolders')) {
+            return null;
+        } elseif (substr_count($path, '/') < 2) {
+            if ($user = $this->userSession->getUser()) {
+                return $user;
+            } else {
+                return null;
+            }
+        } elseif (str_starts_with($path, '/appdata_' . \OC_Util::getInstanceId()) || str_starts_with($path, '/files_external/')) {
+            return null;
+        } else {
+            [, $userId] = explode('/', $path);
+        }
+
+        return $this->userManager->get($userId);
+    }
+
+    /**
+     * Set up the filesystem for the specified path
+     */
+    public function setupForPath(string $path, bool $includeChildren = false): void {
+        $user = $this->getUserForPath($path);
+        if (!$user) {
+            $this->setupRoot();
+            return;
+        }
+
+        if ($this->isSetupComplete($user)) {
+            return;
+        }
+
+        if ($this->fullSetupRequired($user)) {
+            $this->setupForUser($user);
+            return;
+        }
+
+        // for the user's home folder, and includes children we need everything always
+        if (rtrim($path) === "/" . $user->getUID() . "/files" && $includeChildren) {
+            $this->setupForUser($user);
+            return;
+        }
+
+        if (!isset($this->setupUserMountProviders[$user->getUID()])) {
+            $this->setupUserMountProviders[$user->getUID()] = [];
+        }
+        $setupProviders = &$this->setupUserMountProviders[$user->getUID()];
+        $currentProviders = [];
+
+        try {
+            $cachedMount = $this->userMountCache->getMountForPath($user, $path);
+        } catch (NotFoundException $e) {
+            $this->setupForUser($user);
+            return;
+        }
+
+        $this->oneTimeUserSetup($user);
+
+        $this->eventLogger->start('fs:setup:user:path', "Setup $path filesystem for user");
+        $this->eventLogger->start('fs:setup:user:path:find', "Find mountpoint for $path");
+
+        $mounts = [];
+        if (!in_array($cachedMount->getMountProvider(), $setupProviders)) {
+            $currentProviders[] = $cachedMount->getMountProvider();
+            if ($cachedMount->getMountProvider()) {
+                $setupProviders[] = $cachedMount->getMountProvider();
+                $mounts = $this->mountProviderCollection->getUserMountsForProviderClasses($user, [$cachedMount->getMountProvider()]);
+            } else {
+                $this->logger->debug("mount at " . $cachedMount->getMountPoint() . " has no provider set, performing full setup");
+                $this->eventLogger->end('fs:setup:user:path:find');
+                $this->setupForUser($user);
+                $this->eventLogger->end('fs:setup:user:path');
+                return;
+            }
+        }
+
+        if ($includeChildren) {
+            $subCachedMounts = $this->userMountCache->getMountsInPath($user, $path);
+            $this->eventLogger->end('fs:setup:user:path:find');
+
+            $needsFullSetup = array_reduce($subCachedMounts, function (bool $needsFullSetup, ICachedMountInfo $cachedMountInfo) {
+                return $needsFullSetup || $cachedMountInfo->getMountProvider() === '';
+            }, false);
+
+            if ($needsFullSetup) {
+                $this->logger->debug("mount has no provider set, performing full setup");
+                $this->setupForUser($user);
+                $this->eventLogger->end('fs:setup:user:path');
+                return;
+            } else {
+                foreach ($subCachedMounts as $cachedMount) {
+                    if (!in_array($cachedMount->getMountProvider(), $setupProviders)) {
+                        $currentProviders[] = $cachedMount->getMountProvider();
+                        $setupProviders[] = $cachedMount->getMountProvider();
+                        $mounts = array_merge($mounts, $this->mountProviderCollection->getUserMountsForProviderClasses($user, [$cachedMount->getMountProvider()]));
+                    }
+                }
+            }
+        } else {
+            $this->eventLogger->end('fs:setup:user:path:find');
+        }
+
+        if (count($mounts)) {
+            $this->userMountCache->registerMounts($user, $mounts, $currentProviders);
+            $this->setupForUserWith($user, function () use ($mounts) {
+                array_walk($mounts, [$this->mountManager, 'addMount']);
+            });
+        } elseif (!$this->isSetupStarted($user)) {
+            $this->oneTimeUserSetup($user);
+        }
+        $this->eventLogger->end('fs:setup:user:path');
+    }
+
+    private function fullSetupRequired(IUser $user): bool {
+        // we perform a "cached" setup only after having done the full setup recently
+        // this is also used to trigger a full setup after handling events that are likely
+        // to change the available mounts
+        if (!isset($this->fullSetupRequired[$user->getUID()])) {
+            $this->fullSetupRequired[$user->getUID()] = !$this->cache->get($user->getUID());
+        }
+        return $this->fullSetupRequired[$user->getUID()];
+    }
+
+    /**
+     * @param string $path
+     * @param string[] $providers
+     */
+    public function setupForProvider(string $path, array $providers): void {
+        $user = $this->getUserForPath($path);
+        if (!$user) {
+            $this->setupRoot();
+            return;
+        }
+
+        if ($this->isSetupComplete($user)) {
+            return;
+        }
+
+        if ($this->fullSetupRequired($user)) {
+            $this->setupForUser($user);
+            return;
+        }
+
+        $this->eventLogger->start('fs:setup:user:providers', "Setup filesystem for " . implode(', ', $providers));
+
+        $this->oneTimeUserSetup($user);
+
+        // home providers are always used
+        $providers = array_filter($providers, function (string $provider) {
+            return !is_subclass_of($provider, IHomeMountProvider::class);
+        });
+
+        if (in_array('', $providers)) {
+            $this->setupForUser($user);
+            return;
+        }
+        $setupProviders = $this->setupUserMountProviders[$user->getUID()] ?? [];
+
+        $providers = array_diff($providers, $setupProviders);
+        if (count($providers) === 0) {
+            if (!$this->isSetupStarted($user)) {
+                $this->oneTimeUserSetup($user);
+            }
+            $this->eventLogger->end('fs:setup:user:providers');
+            return;
+        } else {
+            $this->setupUserMountProviders[$user->getUID()] = array_merge($setupProviders, $providers);
+            $mounts = $this->mountProviderCollection->getUserMountsForProviderClasses($user, $providers);
+        }
+
+        $this->userMountCache->registerMounts($user, $mounts, $providers);
+        $this->setupForUserWith($user, function () use ($mounts) {
+            array_walk($mounts, [$this->mountManager, 'addMount']);
+        });
+        $this->eventLogger->end('fs:setup:user:providers');
+    }
+
+    public function tearDown() {
+        $this->setupUsers = [];
+        $this->setupUsersComplete = [];
+        $this->setupUserMountProviders = [];
+        $this->fullSetupRequired = [];
+        $this->rootSetup = false;
+        $this->mountManager->clear();
+        $this->eventDispatcher->dispatchTyped(new FilesystemTornDownEvent());
+    }
+
+    /**
+     * Get mounts from mount providers that are registered after setup
+     */
+    private function listenForNewMountProviders() {
+        if (!$this->listeningForProviders) {
+            $this->listeningForProviders = true;
+            $this->mountProviderCollection->listen('\OC\Files\Config', 'registerMountProvider', function (
+                IMountProvider $provider
+            ) {
+                foreach ($this->setupUsers as $userId) {
+                    $user = $this->userManager->get($userId);
+                    if ($user) {
+                        $mounts = $provider->getMountsForUser($user, Filesystem::getLoader());
+                        array_walk($mounts, [$this->mountManager, 'addMount']);
+                    }
+                }
+            });
+        }
+    }
+
+    private function setupListeners() {
+        // note that this event handling is intentionally pessimistic
+        // clearing the cache to often is better than not enough
+
+        $this->eventDispatcher->addListener(UserAddedEvent::class, function (UserAddedEvent $event) {
+            $this->cache->remove($event->getUser()->getUID());
+        });
+        $this->eventDispatcher->addListener(UserRemovedEvent::class, function (UserRemovedEvent $event) {
+            $this->cache->remove($event->getUser()->getUID());
+        });
+        $this->eventDispatcher->addListener(ShareCreatedEvent::class, function (ShareCreatedEvent $event) {
+            $this->cache->remove($event->getShare()->getSharedWith());
+        });
+        $this->eventDispatcher->addListener(InvalidateMountCacheEvent::class, function (InvalidateMountCacheEvent $event
+        ) {
+            if ($user = $event->getUser()) {
+                $this->cache->remove($user->getUID());
+            } else {
+                $this->cache->clear();
+            }
+        });
+
+        $genericEvents = [
+            'OCA\Circles\Events\CreatingCircleEvent',
+            'OCA\Circles\Events\DestroyingCircleEvent',
+            'OCA\Circles\Events\AddingCircleMemberEvent',
+            'OCA\Circles\Events\RemovingCircleMemberEvent',
+        ];
+
+        foreach ($genericEvents as $genericEvent) {
+            $this->eventDispatcher->addListener($genericEvent, function ($event) {
+                $this->cache->clear();
+            });
+        }
+    }
 }

Spacing +31 added lines, -31 removed lines

@@ -132,14 +132,14 @@ 
 		OC_App::loadApps(['filesystem']);
 		$prevLogging = Filesystem::logWarningWhenAddingStorageWrapper(false);
 
-		Filesystem::addStorageWrapper('mount_options', function ($mountPoint, IStorage $storage, IMountPoint $mount) {
+		Filesystem::addStorageWrapper('mount_options', function($mountPoint, IStorage $storage, IMountPoint $mount) {
 			if ($storage->instanceOfStorage(Common::class)) {
 				$storage->setMountOptions($mount->getOptions());
 			}
 			return $storage;
 		});
 
-		Filesystem::addStorageWrapper('enable_sharing', function ($mountPoint, IStorage $storage, IMountPoint $mount) {
+		Filesystem::addStorageWrapper('enable_sharing', function($mountPoint, IStorage $storage, IMountPoint $mount) {
 			if (!$mount->getOption('enable_sharing', true)) {
 				return new PermissionsMask([
 					'storage' => $storage,
@@ -150,21 +150,21 @@ 
 		});
 
 		// install storage availability wrapper, before most other wrappers
-		Filesystem::addStorageWrapper('oc_availability', function ($mountPoint, IStorage $storage) {
+		Filesystem::addStorageWrapper('oc_availability', function($mountPoint, IStorage $storage) {
 			if (!$storage->instanceOfStorage('\OCA\Files_Sharing\SharedStorage') && !$storage->isLocal()) {
 				return new Availability(['storage' => $storage]);
 			}
 			return $storage;
 		});
 
-		Filesystem::addStorageWrapper('oc_encoding', function ($mountPoint, IStorage $storage, IMountPoint $mount) {
+		Filesystem::addStorageWrapper('oc_encoding', function($mountPoint, IStorage $storage, IMountPoint $mount) {
 			if ($mount->getOption('encoding_compatibility', false) && !$storage->instanceOfStorage('\OCA\Files_Sharing\SharedStorage')) {
 				return new Encoding(['storage' => $storage]);
 			}
 			return $storage;
 		});
 
-		Filesystem::addStorageWrapper('oc_quota', function ($mountPoint, $storage) {
+		Filesystem::addStorageWrapper('oc_quota', function($mountPoint, $storage) {
 			// set up quota for home storages, even for other users
 			// which can happen when using sharing
 
@@ -174,7 +174,7 @@ 
 			if ($storage->instanceOfStorage(HomeObjectStoreStorage::class) || $storage->instanceOfStorage(Home::class)) {
 				if (is_object($storage->getUser())) {
 					$user = $storage->getUser();
-					return new Quota(['storage' => $storage, 'quotaCallback' => function () use ($user) {
+					return new Quota(['storage' => $storage, 'quotaCallback' => function() use ($user) {
 						return OC_Util::getUserQuota($user);
 					}, 'root' => 'files']);
 				}
@@ -183,7 +183,7 @@ 
 			return $storage;
 		});
 
-		Filesystem::addStorageWrapper('readonly', function ($mountPoint, IStorage $storage, IMountPoint $mount) {
+		Filesystem::addStorageWrapper('readonly', function($mountPoint, IStorage $storage, IMountPoint $mount) {
 			/*
 			 * Do not allow any operations that modify the storage
 			 */
@@ -220,8 +220,8 @@ 
 
 		$previouslySetupProviders = $this->setupUserMountProviders[$user->getUID()];
 
-		$this->setupForUserWith($user, function () use ($user) {
-			$this->mountProviderCollection->addMountForUser($user, $this->mountManager, function (
+		$this->setupForUserWith($user, function() use ($user) {
+			$this->mountProviderCollection->addMountForUser($user, $this->mountManager, function(
 				IMountProvider $provider
 			) use ($user) {
 				return !in_array(get_class($provider), $this->setupUserMountProviders[$user->getUID()]);
@@ -252,7 +252,7 @@ 
 
 		Filesystem::logWarningWhenAddingStorageWrapper($prevLogging);
 
-		$userDir = '/' . $user->getUID() . '/files';
+		$userDir = '/'.$user->getUID().'/files';
 
 		Filesystem::initInternal($userDir);
 
@@ -272,11 +272,11 @@ 
 		} else {
 			$this->mountManager->addMount(new MountPoint(
 				new NullStorage([]),
-				'/' . $user->getUID()
+				'/'.$user->getUID()
 			));
 			$this->mountManager->addMount(new MountPoint(
 				new NullStorage([]),
-				'/' . $user->getUID() . '/files'
+				'/'.$user->getUID().'/files'
 			));
 			$this->setupUsersComplete[] = $user->getUID();
 		}
@@ -291,16 +291,16 @@ 
 	 */
 	private function afterUserFullySetup(IUser $user, array $previouslySetupProviders): void {
 		$this->eventLogger->start('fs:setup:user:full:post', 'Housekeeping after user is setup');
-		$userRoot = '/' . $user->getUID() . '/';
+		$userRoot = '/'.$user->getUID().'/';
 		$mounts = $this->mountManager->getAll();
-		$mounts = array_filter($mounts, function (IMountPoint $mount) use ($userRoot) {
+		$mounts = array_filter($mounts, function(IMountPoint $mount) use ($userRoot) {
 			return str_starts_with($mount->getMountPoint(), $userRoot);
 		});
-		$allProviders = array_map(function (IMountProvider $provider) {
+		$allProviders = array_map(function(IMountProvider $provider) {
 			return get_class($provider);
 		}, $this->mountProviderCollection->getProviders());
 		$newProviders = array_diff($allProviders, $previouslySetupProviders);
-		$mounts = array_filter($mounts, function (IMountPoint $mount) use ($previouslySetupProviders) {
+		$mounts = array_filter($mounts, function(IMountPoint $mount) use ($previouslySetupProviders) {
 			return !in_array($mount->getMountProvider(), $previouslySetupProviders);
 		});
 		$this->userMountCache->registerMounts($user, $mounts, $newProviders);
@@ -330,7 +330,7 @@ 
 		\OC_Hook::emit('OC_Filesystem', 'post_initMountPoints', ['user' => $user->getUID()]);
 		$this->eventLogger->end('fs:setup:user:post-init-mountpoint');
 
-		$userDir = '/' . $user->getUID() . '/files';
+		$userDir = '/'.$user->getUID().'/files';
 		$this->eventLogger->start('fs:setup:user:setup-hook', 'setup legacy hook');
 		OC_Hook::emit('OC_Filesystem', 'setup', ['user' => $user->getUID(), 'user_dir' => $userDir]);
 		$this->eventLogger->end('fs:setup:user:setup-hook');
@@ -373,7 +373,7 @@ 
 			} else {
 				return null;
 			}
-		} elseif (str_starts_with($path, '/appdata_' . \OC_Util::getInstanceId()) || str_starts_with($path, '/files_external/')) {
+		} elseif (str_starts_with($path, '/appdata_'.\OC_Util::getInstanceId()) || str_starts_with($path, '/files_external/')) {
 			return null;
 		} else {
 			[, $userId] = explode('/', $path);
@@ -402,7 +402,7 @@ 
 		}
 
 		// for the user's home folder, and includes children we need everything always
-		if (rtrim($path) === "/" . $user->getUID() . "/files" && $includeChildren) {
+		if (rtrim($path) === "/".$user->getUID()."/files" && $includeChildren) {
 			$this->setupForUser($user);
 			return;
 		}
@@ -432,7 +432,7 @@ 
 				$setupProviders[] = $cachedMount->getMountProvider();
 				$mounts = $this->mountProviderCollection->getUserMountsForProviderClasses($user, [$cachedMount->getMountProvider()]);
 			} else {
-				$this->logger->debug("mount at " . $cachedMount->getMountPoint() . " has no provider set, performing full setup");
+				$this->logger->debug("mount at ".$cachedMount->getMountPoint()." has no provider set, performing full setup");
 				$this->eventLogger->end('fs:setup:user:path:find');
 				$this->setupForUser($user);
 				$this->eventLogger->end('fs:setup:user:path');
@@ -444,7 +444,7 @@ 
 			$subCachedMounts = $this->userMountCache->getMountsInPath($user, $path);
 			$this->eventLogger->end('fs:setup:user:path:find');
 
-			$needsFullSetup = array_reduce($subCachedMounts, function (bool $needsFullSetup, ICachedMountInfo $cachedMountInfo) {
+			$needsFullSetup = array_reduce($subCachedMounts, function(bool $needsFullSetup, ICachedMountInfo $cachedMountInfo) {
 				return $needsFullSetup || $cachedMountInfo->getMountProvider() === '';
 			}, false);
 
@@ -468,7 +468,7 @@ 
 
 		if (count($mounts)) {
 			$this->userMountCache->registerMounts($user, $mounts, $currentProviders);
-			$this->setupForUserWith($user, function () use ($mounts) {
+			$this->setupForUserWith($user, function() use ($mounts) {
 				array_walk($mounts, [$this->mountManager, 'addMount']);
 			});
 		} elseif (!$this->isSetupStarted($user)) {
@@ -507,12 +507,12 @@ 
 			return;
 		}
 
-		$this->eventLogger->start('fs:setup:user:providers', "Setup filesystem for " . implode(', ', $providers));
+		$this->eventLogger->start('fs:setup:user:providers', "Setup filesystem for ".implode(', ', $providers));
 
 		$this->oneTimeUserSetup($user);
 
 		// home providers are always used
-		$providers = array_filter($providers, function (string $provider) {
+		$providers = array_filter($providers, function(string $provider) {
 			return !is_subclass_of($provider, IHomeMountProvider::class);
 		});
 
@@ -535,7 +535,7 @@ 
 		}
 
 		$this->userMountCache->registerMounts($user, $mounts, $providers);
-		$this->setupForUserWith($user, function () use ($mounts) {
+		$this->setupForUserWith($user, function() use ($mounts) {
 			array_walk($mounts, [$this->mountManager, 'addMount']);
 		});
 		$this->eventLogger->end('fs:setup:user:providers');
@@ -557,7 +557,7 @@ 
 	private function listenForNewMountProviders() {
 		if (!$this->listeningForProviders) {
 			$this->listeningForProviders = true;
-			$this->mountProviderCollection->listen('\OC\Files\Config', 'registerMountProvider', function (
+			$this->mountProviderCollection->listen('\OC\Files\Config', 'registerMountProvider', function(
 				IMountProvider $provider
 			) {
 				foreach ($this->setupUsers as $userId) {
@@ -575,16 +575,16 @@ 
 		// note that this event handling is intentionally pessimistic
 		// clearing the cache to often is better than not enough
 
-		$this->eventDispatcher->addListener(UserAddedEvent::class, function (UserAddedEvent $event) {
+		$this->eventDispatcher->addListener(UserAddedEvent::class, function(UserAddedEvent $event) {
 			$this->cache->remove($event->getUser()->getUID());
 		});
-		$this->eventDispatcher->addListener(UserRemovedEvent::class, function (UserRemovedEvent $event) {
+		$this->eventDispatcher->addListener(UserRemovedEvent::class, function(UserRemovedEvent $event) {
 			$this->cache->remove($event->getUser()->getUID());
 		});
-		$this->eventDispatcher->addListener(ShareCreatedEvent::class, function (ShareCreatedEvent $event) {
+		$this->eventDispatcher->addListener(ShareCreatedEvent::class, function(ShareCreatedEvent $event) {
 			$this->cache->remove($event->getShare()->getSharedWith());
 		});
-		$this->eventDispatcher->addListener(InvalidateMountCacheEvent::class, function (InvalidateMountCacheEvent $event
+		$this->eventDispatcher->addListener(InvalidateMountCacheEvent::class, function(InvalidateMountCacheEvent $event
 		) {
 			if ($user = $event->getUser()) {
 				$this->cache->remove($user->getUID());
@@ -601,7 +601,7 @@ 
 		];
 
 		foreach ($genericEvents as $genericEvent) {
-			$this->eventDispatcher->addListener($genericEvent, function ($event) {
+			$this->eventDispatcher->addListener($genericEvent, function($event) {
 				$this->cache->clear();
 			});
 		}

lib/private/Files/Config/UserMountCache.php

Indentation +444 added lines, -444 removed lines

@@ -46,448 +46,448 @@
  * Cache mounts points per user in the cache so we can easily look them up
  */
 class UserMountCache implements IUserMountCache {
-	private IDBConnection $connection;
-	private IUserManager $userManager;
-
-	/**
-	 * Cached mount info.
-	 * @var CappedMemoryCache<ICachedMountInfo[]>
-	 **/
-	private CappedMemoryCache $mountsForUsers;
-	private LoggerInterface $logger;
-	/** @var CappedMemoryCache<array> */
-	private CappedMemoryCache $cacheInfoCache;
-	private IEventLogger $eventLogger;
-
-	/**
-	 * UserMountCache constructor.
-	 */
-	public function __construct(
-		IDBConnection $connection,
-		IUserManager $userManager,
-		LoggerInterface $logger,
-		IEventLogger $eventLogger
-	) {
-		$this->connection = $connection;
-		$this->userManager = $userManager;
-		$this->logger = $logger;
-		$this->eventLogger = $eventLogger;
-		$this->cacheInfoCache = new CappedMemoryCache();
-		$this->mountsForUsers = new CappedMemoryCache();
-	}
-
-	public function registerMounts(IUser $user, array $mounts, array $mountProviderClasses = null) {
-		$this->eventLogger->start('fs:setup:user:register', 'Registering mounts for user');
-		// filter out non-proper storages coming from unit tests
-		$mounts = array_filter($mounts, function (IMountPoint $mount) {
-			return $mount instanceof SharedMount || ($mount->getStorage() && $mount->getStorage()->getCache());
-		});
-		/** @var ICachedMountInfo[] $newMounts */
-		$newMounts = array_map(function (IMountPoint $mount) use ($user) {
-			// filter out any storages which aren't scanned yet since we aren't interested in files from those storages (yet)
-			if ($mount->getStorageRootId() === -1) {
-				return null;
-			} else {
-				return new LazyStorageMountInfo($user, $mount);
-			}
-		}, $mounts);
-		$newMounts = array_values(array_filter($newMounts));
-		$newMountKeys = array_map(function (ICachedMountInfo $mount) {
-			return $mount->getRootId() . '::' . $mount->getMountPoint();
-		}, $newMounts);
-		$newMounts = array_combine($newMountKeys, $newMounts);
-
-		$cachedMounts = $this->getMountsForUser($user);
-		if (is_array($mountProviderClasses)) {
-			$cachedMounts = array_filter($cachedMounts, function (ICachedMountInfo $mountInfo) use ($mountProviderClasses, $newMounts) {
-				// for existing mounts that didn't have a mount provider set
-				// we still want the ones that map to new mounts
-				$mountKey = $mountInfo->getRootId() . '::' . $mountInfo->getMountPoint();
-				if ($mountInfo->getMountProvider() === '' && isset($newMounts[$mountKey])) {
-					return true;
-				}
-				return in_array($mountInfo->getMountProvider(), $mountProviderClasses);
-			});
-		}
-		$cachedRootKeys = array_map(function (ICachedMountInfo $mount) {
-			return $mount->getRootId() . '::' . $mount->getMountPoint();
-		}, $cachedMounts);
-		$cachedMounts = array_combine($cachedRootKeys, $cachedMounts);
-
-		$addedMounts = [];
-		$removedMounts = [];
-
-		foreach ($newMounts as $mountKey => $newMount) {
-			if (!isset($cachedMounts[$mountKey])) {
-				$addedMounts[] = $newMount;
-			}
-		}
-
-		foreach ($cachedMounts as $mountKey => $cachedMount) {
-			if (!isset($newMounts[$mountKey])) {
-				$removedMounts[] = $cachedMount;
-			}
-		}
-
-		$changedMounts = $this->findChangedMounts($newMounts, $cachedMounts);
-
-		$this->connection->beginTransaction();
-		try {
-			foreach ($addedMounts as $mount) {
-				$this->addToCache($mount);
-				/** @psalm-suppress InvalidArgument */
-				$this->mountsForUsers[$user->getUID()][] = $mount;
-			}
-			foreach ($removedMounts as $mount) {
-				$this->removeFromCache($mount);
-				$index = array_search($mount, $this->mountsForUsers[$user->getUID()]);
-				unset($this->mountsForUsers[$user->getUID()][$index]);
-			}
-			foreach ($changedMounts as $mount) {
-				$this->updateCachedMount($mount);
-			}
-			$this->connection->commit();
-		} catch (\Throwable $e) {
-			$this->connection->rollBack();
-			throw $e;
-		}
-		$this->eventLogger->end('fs:setup:user:register');
-	}
-
-	/**
-	 * @param ICachedMountInfo[] $newMounts
-	 * @param ICachedMountInfo[] $cachedMounts
-	 * @return ICachedMountInfo[]
-	 */
-	private function findChangedMounts(array $newMounts, array $cachedMounts) {
-		$new = [];
-		foreach ($newMounts as $mount) {
-			$new[$mount->getRootId() . '::' . $mount->getMountPoint()] = $mount;
-		}
-		$changed = [];
-		foreach ($cachedMounts as $cachedMount) {
-			$key = $cachedMount->getRootId() . '::' . $cachedMount->getMountPoint();
-			if (isset($new[$key])) {
-				$newMount = $new[$key];
-				if (
-					$newMount->getMountPoint() !== $cachedMount->getMountPoint() ||
-					$newMount->getStorageId() !== $cachedMount->getStorageId() ||
-					$newMount->getMountId() !== $cachedMount->getMountId() ||
-					$newMount->getMountProvider() !== $cachedMount->getMountProvider()
-				) {
-					$changed[] = $newMount;
-				}
-			}
-		}
-		return $changed;
-	}
-
-	private function addToCache(ICachedMountInfo $mount) {
-		if ($mount->getStorageId() !== -1) {
-			$this->connection->insertIfNotExist('*PREFIX*mounts', [
-				'storage_id' => $mount->getStorageId(),
-				'root_id' => $mount->getRootId(),
-				'user_id' => $mount->getUser()->getUID(),
-				'mount_point' => $mount->getMountPoint(),
-				'mount_id' => $mount->getMountId(),
-				'mount_provider_class' => $mount->getMountProvider(),
-			], ['root_id', 'user_id', 'mount_point']);
-		} else {
-			// in some cases this is legitimate, like orphaned shares
-			$this->logger->debug('Could not get storage info for mount at ' . $mount->getMountPoint());
-		}
-	}
-
-	private function updateCachedMount(ICachedMountInfo $mount) {
-		$builder = $this->connection->getQueryBuilder();
-
-		$query = $builder->update('mounts')
-			->set('storage_id', $builder->createNamedParameter($mount->getStorageId()))
-			->set('mount_point', $builder->createNamedParameter($mount->getMountPoint()))
-			->set('mount_id', $builder->createNamedParameter($mount->getMountId(), IQueryBuilder::PARAM_INT))
-			->set('mount_provider_class', $builder->createNamedParameter($mount->getMountProvider()))
-			->where($builder->expr()->eq('user_id', $builder->createNamedParameter($mount->getUser()->getUID())))
-			->andWhere($builder->expr()->eq('root_id', $builder->createNamedParameter($mount->getRootId(), IQueryBuilder::PARAM_INT)));
-
-		$query->execute();
-	}
-
-	private function removeFromCache(ICachedMountInfo $mount) {
-		$builder = $this->connection->getQueryBuilder();
-
-		$query = $builder->delete('mounts')
-			->where($builder->expr()->eq('user_id', $builder->createNamedParameter($mount->getUser()->getUID())))
-			->andWhere($builder->expr()->eq('root_id', $builder->createNamedParameter($mount->getRootId(), IQueryBuilder::PARAM_INT)))
-			->andWhere($builder->expr()->eq('mount_point', $builder->createNamedParameter($mount->getMountPoint())));
-		$query->execute();
-	}
-
-	private function dbRowToMountInfo(array $row) {
-		$user = $this->userManager->get($row['user_id']);
-		if (is_null($user)) {
-			return null;
-		}
-		$mount_id = $row['mount_id'];
-		if (!is_null($mount_id)) {
-			$mount_id = (int)$mount_id;
-		}
-		return new CachedMountInfo(
-			$user,
-			(int)$row['storage_id'],
-			(int)$row['root_id'],
-			$row['mount_point'],
-			$row['mount_provider_class'] ?? '',
-			$mount_id,
-			isset($row['path']) ? $row['path'] : '',
-		);
-	}
-
-	/**
-	 * @param IUser $user
-	 * @return ICachedMountInfo[]
-	 */
-	public function getMountsForUser(IUser $user) {
-		if (!isset($this->mountsForUsers[$user->getUID()])) {
-			$builder = $this->connection->getQueryBuilder();
-			$query = $builder->select('storage_id', 'root_id', 'user_id', 'mount_point', 'mount_id', 'f.path', 'mount_provider_class')
-				->from('mounts', 'm')
-				->innerJoin('m', 'filecache', 'f', $builder->expr()->eq('m.root_id', 'f.fileid'))
-				->where($builder->expr()->eq('user_id', $builder->createPositionalParameter($user->getUID())));
-
-			$result = $query->execute();
-			$rows = $result->fetchAll();
-			$result->closeCursor();
-
-			$this->mountsForUsers[$user->getUID()] = array_filter(array_map([$this, 'dbRowToMountInfo'], $rows));
-		}
-		return $this->mountsForUsers[$user->getUID()];
-	}
-
-	/**
-	 * @param int $numericStorageId
-	 * @param string|null $user limit the results to a single user
-	 * @return CachedMountInfo[]
-	 */
-	public function getMountsForStorageId($numericStorageId, $user = null) {
-		$builder = $this->connection->getQueryBuilder();
-		$query = $builder->select('storage_id', 'root_id', 'user_id', 'mount_point', 'mount_id', 'f.path', 'mount_provider_class')
-			->from('mounts', 'm')
-			->innerJoin('m', 'filecache', 'f', $builder->expr()->eq('m.root_id', 'f.fileid'))
-			->where($builder->expr()->eq('storage_id', $builder->createPositionalParameter($numericStorageId, IQueryBuilder::PARAM_INT)));
-
-		if ($user) {
-			$query->andWhere($builder->expr()->eq('user_id', $builder->createPositionalParameter($user)));
-		}
-
-		$result = $query->execute();
-		$rows = $result->fetchAll();
-		$result->closeCursor();
-
-		return array_filter(array_map([$this, 'dbRowToMountInfo'], $rows));
-	}
-
-	/**
-	 * @param int $rootFileId
-	 * @return CachedMountInfo[]
-	 */
-	public function getMountsForRootId($rootFileId) {
-		$builder = $this->connection->getQueryBuilder();
-		$query = $builder->select('storage_id', 'root_id', 'user_id', 'mount_point', 'mount_id', 'f.path', 'mount_provider_class')
-			->from('mounts', 'm')
-			->innerJoin('m', 'filecache', 'f', $builder->expr()->eq('m.root_id', 'f.fileid'))
-			->where($builder->expr()->eq('root_id', $builder->createPositionalParameter($rootFileId, IQueryBuilder::PARAM_INT)));
-
-		$result = $query->execute();
-		$rows = $result->fetchAll();
-		$result->closeCursor();
-
-		return array_filter(array_map([$this, 'dbRowToMountInfo'], $rows));
-	}
-
-	/**
-	 * @param $fileId
-	 * @return array{int, string, int}
-	 * @throws \OCP\Files\NotFoundException
-	 */
-	private function getCacheInfoFromFileId($fileId): array {
-		if (!isset($this->cacheInfoCache[$fileId])) {
-			$builder = $this->connection->getQueryBuilder();
-			$query = $builder->select('storage', 'path', 'mimetype')
-				->from('filecache')
-				->where($builder->expr()->eq('fileid', $builder->createNamedParameter($fileId, IQueryBuilder::PARAM_INT)));
-
-			$result = $query->execute();
-			$row = $result->fetch();
-			$result->closeCursor();
-
-			if (is_array($row)) {
-				$this->cacheInfoCache[$fileId] = [
-					(int)$row['storage'],
-					(string)$row['path'],
-					(int)$row['mimetype']
-				];
-			} else {
-				throw new NotFoundException('File with id "' . $fileId . '" not found');
-			}
-		}
-		return $this->cacheInfoCache[$fileId];
-	}
-
-	/**
-	 * @param int $fileId
-	 * @param string|null $user optionally restrict the results to a single user
-	 * @return ICachedMountFileInfo[]
-	 * @since 9.0.0
-	 */
-	public function getMountsForFileId($fileId, $user = null) {
-		try {
-			[$storageId, $internalPath] = $this->getCacheInfoFromFileId($fileId);
-		} catch (NotFoundException $e) {
-			return [];
-		}
-		$builder = $this->connection->getQueryBuilder();
-		$query = $builder->select('storage_id', 'root_id', 'user_id', 'mount_point', 'mount_id', 'f.path', 'mount_provider_class')
-			->from('mounts', 'm')
-			->innerJoin('m', 'filecache', 'f', $builder->expr()->eq('m.root_id', 'f.fileid'))
-			->where($builder->expr()->eq('storage_id', $builder->createPositionalParameter($storageId, IQueryBuilder::PARAM_INT)));
-
-		if ($user) {
-			$query->andWhere($builder->expr()->eq('user_id', $builder->createPositionalParameter($user)));
-		}
-
-		$result = $query->execute();
-		$rows = $result->fetchAll();
-		$result->closeCursor();
-		// filter mounts that are from the same storage but a different directory
-		$filteredMounts = array_filter($rows, function (array $row) use ($internalPath, $fileId) {
-			if ($fileId === (int)$row['root_id']) {
-				return true;
-			}
-			$internalMountPath = $row['path'] ?? '';
-
-			return $internalMountPath === '' || substr($internalPath, 0, strlen($internalMountPath) + 1) === $internalMountPath . '/';
-		});
-
-		$filteredMounts = array_filter(array_map([$this, 'dbRowToMountInfo'], $filteredMounts));
-		return array_map(function (ICachedMountInfo $mount) use ($internalPath) {
-			return new CachedMountFileInfo(
-				$mount->getUser(),
-				$mount->getStorageId(),
-				$mount->getRootId(),
-				$mount->getMountPoint(),
-				$mount->getMountId(),
-				$mount->getMountProvider(),
-				$mount->getRootInternalPath(),
-				$internalPath
-			);
-		}, $filteredMounts);
-	}
-
-	/**
-	 * Remove all cached mounts for a user
-	 *
-	 * @param IUser $user
-	 */
-	public function removeUserMounts(IUser $user) {
-		$builder = $this->connection->getQueryBuilder();
-
-		$query = $builder->delete('mounts')
-			->where($builder->expr()->eq('user_id', $builder->createNamedParameter($user->getUID())));
-		$query->execute();
-	}
-
-	public function removeUserStorageMount($storageId, $userId) {
-		$builder = $this->connection->getQueryBuilder();
-
-		$query = $builder->delete('mounts')
-			->where($builder->expr()->eq('user_id', $builder->createNamedParameter($userId)))
-			->andWhere($builder->expr()->eq('storage_id', $builder->createNamedParameter($storageId, IQueryBuilder::PARAM_INT)));
-		$query->execute();
-	}
-
-	public function remoteStorageMounts($storageId) {
-		$builder = $this->connection->getQueryBuilder();
-
-		$query = $builder->delete('mounts')
-			->where($builder->expr()->eq('storage_id', $builder->createNamedParameter($storageId, IQueryBuilder::PARAM_INT)));
-		$query->execute();
-	}
-
-	/**
-	 * @param array $users
-	 * @return array
-	 */
-	public function getUsedSpaceForUsers(array $users) {
-		$builder = $this->connection->getQueryBuilder();
-
-		$slash = $builder->createNamedParameter('/');
-
-		$mountPoint = $builder->func()->concat(
-			$builder->func()->concat($slash, 'user_id'),
-			$slash
-		);
-
-		$userIds = array_map(function (IUser $user) {
-			return $user->getUID();
-		}, $users);
-
-		$query = $builder->select('m.user_id', 'f.size')
-			->from('mounts', 'm')
-			->innerJoin('m', 'filecache', 'f',
-				$builder->expr()->andX(
-					$builder->expr()->eq('m.storage_id', 'f.storage'),
-					$builder->expr()->eq('f.path_hash', $builder->createNamedParameter(md5('files')))
-				))
-			->where($builder->expr()->eq('m.mount_point', $mountPoint))
-			->andWhere($builder->expr()->in('m.user_id', $builder->createNamedParameter($userIds, IQueryBuilder::PARAM_STR_ARRAY)));
-
-		$result = $query->execute();
-
-		$results = [];
-		while ($row = $result->fetch()) {
-			$results[$row['user_id']] = $row['size'];
-		}
-		$result->closeCursor();
-		return $results;
-	}
-
-	public function clear(): void {
-		$this->cacheInfoCache = new CappedMemoryCache();
-		$this->mountsForUsers = new CappedMemoryCache();
-	}
-
-	public function getMountForPath(IUser $user, string $path): ICachedMountInfo {
-		$mounts = $this->getMountsForUser($user);
-		$mountPoints = array_map(function (ICachedMountInfo $mount) {
-			return $mount->getMountPoint();
-		}, $mounts);
-		$mounts = array_combine($mountPoints, $mounts);
-
-		$current = $path;
-		// walk up the directory tree until we find a path that has a mountpoint set
-		// the loop will return if a mountpoint is found or break if none are found
-		while (true) {
-			$mountPoint = $current . '/';
-			if (isset($mounts[$mountPoint])) {
-				return $mounts[$mountPoint];
-			} elseif ($current === '') {
-				break;
-			}
-
-			$current = dirname($current);
-			if ($current === '.' || $current === '/') {
-				$current = '';
-			}
-		}
-
-		throw new NotFoundException("No cached mount for path " . $path);
-	}
-
-	public function getMountsInPath(IUser $user, string $path): array {
-		$path = rtrim($path, '/') . '/';
-		$mounts = $this->getMountsForUser($user);
-		return array_filter($mounts, function (ICachedMountInfo $mount) use ($path) {
-			return $mount->getMountPoint() !== $path && str_starts_with($mount->getMountPoint(), $path);
-		});
-	}
+    private IDBConnection $connection;
+    private IUserManager $userManager;
+
+    /**
+     * Cached mount info.
+     * @var CappedMemoryCache<ICachedMountInfo[]>
+     **/
+    private CappedMemoryCache $mountsForUsers;
+    private LoggerInterface $logger;
+    /** @var CappedMemoryCache<array> */
+    private CappedMemoryCache $cacheInfoCache;
+    private IEventLogger $eventLogger;
+
+    /**
+     * UserMountCache constructor.
+     */
+    public function __construct(
+        IDBConnection $connection,
+        IUserManager $userManager,
+        LoggerInterface $logger,
+        IEventLogger $eventLogger
+    ) {
+        $this->connection = $connection;
+        $this->userManager = $userManager;
+        $this->logger = $logger;
+        $this->eventLogger = $eventLogger;
+        $this->cacheInfoCache = new CappedMemoryCache();
+        $this->mountsForUsers = new CappedMemoryCache();
+    }
+
+    public function registerMounts(IUser $user, array $mounts, array $mountProviderClasses = null) {
+        $this->eventLogger->start('fs:setup:user:register', 'Registering mounts for user');
+        // filter out non-proper storages coming from unit tests
+        $mounts = array_filter($mounts, function (IMountPoint $mount) {
+            return $mount instanceof SharedMount || ($mount->getStorage() && $mount->getStorage()->getCache());
+        });
+        /** @var ICachedMountInfo[] $newMounts */
+        $newMounts = array_map(function (IMountPoint $mount) use ($user) {
+            // filter out any storages which aren't scanned yet since we aren't interested in files from those storages (yet)
+            if ($mount->getStorageRootId() === -1) {
+                return null;
+            } else {
+                return new LazyStorageMountInfo($user, $mount);
+            }
+        }, $mounts);
+        $newMounts = array_values(array_filter($newMounts));
+        $newMountKeys = array_map(function (ICachedMountInfo $mount) {
+            return $mount->getRootId() . '::' . $mount->getMountPoint();
+        }, $newMounts);
+        $newMounts = array_combine($newMountKeys, $newMounts);
+
+        $cachedMounts = $this->getMountsForUser($user);
+        if (is_array($mountProviderClasses)) {
+            $cachedMounts = array_filter($cachedMounts, function (ICachedMountInfo $mountInfo) use ($mountProviderClasses, $newMounts) {
+                // for existing mounts that didn't have a mount provider set
+                // we still want the ones that map to new mounts
+                $mountKey = $mountInfo->getRootId() . '::' . $mountInfo->getMountPoint();
+                if ($mountInfo->getMountProvider() === '' && isset($newMounts[$mountKey])) {
+                    return true;
+                }
+                return in_array($mountInfo->getMountProvider(), $mountProviderClasses);
+            });
+        }
+        $cachedRootKeys = array_map(function (ICachedMountInfo $mount) {
+            return $mount->getRootId() . '::' . $mount->getMountPoint();
+        }, $cachedMounts);
+        $cachedMounts = array_combine($cachedRootKeys, $cachedMounts);
+
+        $addedMounts = [];
+        $removedMounts = [];
+
+        foreach ($newMounts as $mountKey => $newMount) {
+            if (!isset($cachedMounts[$mountKey])) {
+                $addedMounts[] = $newMount;
+            }
+        }
+
+        foreach ($cachedMounts as $mountKey => $cachedMount) {
+            if (!isset($newMounts[$mountKey])) {
+                $removedMounts[] = $cachedMount;
+            }
+        }
+
+        $changedMounts = $this->findChangedMounts($newMounts, $cachedMounts);
+
+        $this->connection->beginTransaction();
+        try {
+            foreach ($addedMounts as $mount) {
+                $this->addToCache($mount);
+                /** @psalm-suppress InvalidArgument */
+                $this->mountsForUsers[$user->getUID()][] = $mount;
+            }
+            foreach ($removedMounts as $mount) {
+                $this->removeFromCache($mount);
+                $index = array_search($mount, $this->mountsForUsers[$user->getUID()]);
+                unset($this->mountsForUsers[$user->getUID()][$index]);
+            }
+            foreach ($changedMounts as $mount) {
+                $this->updateCachedMount($mount);
+            }
+            $this->connection->commit();
+        } catch (\Throwable $e) {
+            $this->connection->rollBack();
+            throw $e;
+        }
+        $this->eventLogger->end('fs:setup:user:register');
+    }
+
+    /**
+     * @param ICachedMountInfo[] $newMounts
+     * @param ICachedMountInfo[] $cachedMounts
+     * @return ICachedMountInfo[]
+     */
+    private function findChangedMounts(array $newMounts, array $cachedMounts) {
+        $new = [];
+        foreach ($newMounts as $mount) {
+            $new[$mount->getRootId() . '::' . $mount->getMountPoint()] = $mount;
+        }
+        $changed = [];
+        foreach ($cachedMounts as $cachedMount) {
+            $key = $cachedMount->getRootId() . '::' . $cachedMount->getMountPoint();
+            if (isset($new[$key])) {
+                $newMount = $new[$key];
+                if (
+                    $newMount->getMountPoint() !== $cachedMount->getMountPoint() ||
+                    $newMount->getStorageId() !== $cachedMount->getStorageId() ||
+                    $newMount->getMountId() !== $cachedMount->getMountId() ||
+                    $newMount->getMountProvider() !== $cachedMount->getMountProvider()
+                ) {
+                    $changed[] = $newMount;
+                }
+            }
+        }
+        return $changed;
+    }
+
+    private function addToCache(ICachedMountInfo $mount) {
+        if ($mount->getStorageId() !== -1) {
+            $this->connection->insertIfNotExist('*PREFIX*mounts', [
+                'storage_id' => $mount->getStorageId(),
+                'root_id' => $mount->getRootId(),
+                'user_id' => $mount->getUser()->getUID(),
+                'mount_point' => $mount->getMountPoint(),
+                'mount_id' => $mount->getMountId(),
+                'mount_provider_class' => $mount->getMountProvider(),
+            ], ['root_id', 'user_id', 'mount_point']);
+        } else {
+            // in some cases this is legitimate, like orphaned shares
+            $this->logger->debug('Could not get storage info for mount at ' . $mount->getMountPoint());
+        }
+    }
+
+    private function updateCachedMount(ICachedMountInfo $mount) {
+        $builder = $this->connection->getQueryBuilder();
+
+        $query = $builder->update('mounts')
+            ->set('storage_id', $builder->createNamedParameter($mount->getStorageId()))
+            ->set('mount_point', $builder->createNamedParameter($mount->getMountPoint()))
+            ->set('mount_id', $builder->createNamedParameter($mount->getMountId(), IQueryBuilder::PARAM_INT))
+            ->set('mount_provider_class', $builder->createNamedParameter($mount->getMountProvider()))
+            ->where($builder->expr()->eq('user_id', $builder->createNamedParameter($mount->getUser()->getUID())))
+            ->andWhere($builder->expr()->eq('root_id', $builder->createNamedParameter($mount->getRootId(), IQueryBuilder::PARAM_INT)));
+
+        $query->execute();
+    }
+
+    private function removeFromCache(ICachedMountInfo $mount) {
+        $builder = $this->connection->getQueryBuilder();
+
+        $query = $builder->delete('mounts')
+            ->where($builder->expr()->eq('user_id', $builder->createNamedParameter($mount->getUser()->getUID())))
+            ->andWhere($builder->expr()->eq('root_id', $builder->createNamedParameter($mount->getRootId(), IQueryBuilder::PARAM_INT)))
+            ->andWhere($builder->expr()->eq('mount_point', $builder->createNamedParameter($mount->getMountPoint())));
+        $query->execute();
+    }
+
+    private function dbRowToMountInfo(array $row) {
+        $user = $this->userManager->get($row['user_id']);
+        if (is_null($user)) {
+            return null;
+        }
+        $mount_id = $row['mount_id'];
+        if (!is_null($mount_id)) {
+            $mount_id = (int)$mount_id;
+        }
+        return new CachedMountInfo(
+            $user,
+            (int)$row['storage_id'],
+            (int)$row['root_id'],
+            $row['mount_point'],
+            $row['mount_provider_class'] ?? '',
+            $mount_id,
+            isset($row['path']) ? $row['path'] : '',
+        );
+    }
+
+    /**
+     * @param IUser $user
+     * @return ICachedMountInfo[]
+     */
+    public function getMountsForUser(IUser $user) {
+        if (!isset($this->mountsForUsers[$user->getUID()])) {
+            $builder = $this->connection->getQueryBuilder();
+            $query = $builder->select('storage_id', 'root_id', 'user_id', 'mount_point', 'mount_id', 'f.path', 'mount_provider_class')
+                ->from('mounts', 'm')
+                ->innerJoin('m', 'filecache', 'f', $builder->expr()->eq('m.root_id', 'f.fileid'))
+                ->where($builder->expr()->eq('user_id', $builder->createPositionalParameter($user->getUID())));
+
+            $result = $query->execute();
+            $rows = $result->fetchAll();
+            $result->closeCursor();
+
+            $this->mountsForUsers[$user->getUID()] = array_filter(array_map([$this, 'dbRowToMountInfo'], $rows));
+        }
+        return $this->mountsForUsers[$user->getUID()];
+    }
+
+    /**
+     * @param int $numericStorageId
+     * @param string|null $user limit the results to a single user
+     * @return CachedMountInfo[]
+     */
+    public function getMountsForStorageId($numericStorageId, $user = null) {
+        $builder = $this->connection->getQueryBuilder();
+        $query = $builder->select('storage_id', 'root_id', 'user_id', 'mount_point', 'mount_id', 'f.path', 'mount_provider_class')
+            ->from('mounts', 'm')
+            ->innerJoin('m', 'filecache', 'f', $builder->expr()->eq('m.root_id', 'f.fileid'))
+            ->where($builder->expr()->eq('storage_id', $builder->createPositionalParameter($numericStorageId, IQueryBuilder::PARAM_INT)));
+
+        if ($user) {
+            $query->andWhere($builder->expr()->eq('user_id', $builder->createPositionalParameter($user)));
+        }
+
+        $result = $query->execute();
+        $rows = $result->fetchAll();
+        $result->closeCursor();
+
+        return array_filter(array_map([$this, 'dbRowToMountInfo'], $rows));
+    }
+
+    /**
+     * @param int $rootFileId
+     * @return CachedMountInfo[]
+     */
+    public function getMountsForRootId($rootFileId) {
+        $builder = $this->connection->getQueryBuilder();
+        $query = $builder->select('storage_id', 'root_id', 'user_id', 'mount_point', 'mount_id', 'f.path', 'mount_provider_class')
+            ->from('mounts', 'm')
+            ->innerJoin('m', 'filecache', 'f', $builder->expr()->eq('m.root_id', 'f.fileid'))
+            ->where($builder->expr()->eq('root_id', $builder->createPositionalParameter($rootFileId, IQueryBuilder::PARAM_INT)));
+
+        $result = $query->execute();
+        $rows = $result->fetchAll();
+        $result->closeCursor();
+
+        return array_filter(array_map([$this, 'dbRowToMountInfo'], $rows));
+    }
+
+    /**
+     * @param $fileId
+     * @return array{int, string, int}
+     * @throws \OCP\Files\NotFoundException
+     */
+    private function getCacheInfoFromFileId($fileId): array {
+        if (!isset($this->cacheInfoCache[$fileId])) {
+            $builder = $this->connection->getQueryBuilder();
+            $query = $builder->select('storage', 'path', 'mimetype')
+                ->from('filecache')
+                ->where($builder->expr()->eq('fileid', $builder->createNamedParameter($fileId, IQueryBuilder::PARAM_INT)));
+
+            $result = $query->execute();
+            $row = $result->fetch();
+            $result->closeCursor();
+
+            if (is_array($row)) {
+                $this->cacheInfoCache[$fileId] = [
+                    (int)$row['storage'],
+                    (string)$row['path'],
+                    (int)$row['mimetype']
+                ];
+            } else {
+                throw new NotFoundException('File with id "' . $fileId . '" not found');
+            }
+        }
+        return $this->cacheInfoCache[$fileId];
+    }
+
+    /**
+     * @param int $fileId
+     * @param string|null $user optionally restrict the results to a single user
+     * @return ICachedMountFileInfo[]
+     * @since 9.0.0
+     */
+    public function getMountsForFileId($fileId, $user = null) {
+        try {
+            [$storageId, $internalPath] = $this->getCacheInfoFromFileId($fileId);
+        } catch (NotFoundException $e) {
+            return [];
+        }
+        $builder = $this->connection->getQueryBuilder();
+        $query = $builder->select('storage_id', 'root_id', 'user_id', 'mount_point', 'mount_id', 'f.path', 'mount_provider_class')
+            ->from('mounts', 'm')
+            ->innerJoin('m', 'filecache', 'f', $builder->expr()->eq('m.root_id', 'f.fileid'))
+            ->where($builder->expr()->eq('storage_id', $builder->createPositionalParameter($storageId, IQueryBuilder::PARAM_INT)));
+
+        if ($user) {
+            $query->andWhere($builder->expr()->eq('user_id', $builder->createPositionalParameter($user)));
+        }
+
+        $result = $query->execute();
+        $rows = $result->fetchAll();
+        $result->closeCursor();
+        // filter mounts that are from the same storage but a different directory
+        $filteredMounts = array_filter($rows, function (array $row) use ($internalPath, $fileId) {
+            if ($fileId === (int)$row['root_id']) {
+                return true;
+            }
+            $internalMountPath = $row['path'] ?? '';
+
+            return $internalMountPath === '' || substr($internalPath, 0, strlen($internalMountPath) + 1) === $internalMountPath . '/';
+        });
+
+        $filteredMounts = array_filter(array_map([$this, 'dbRowToMountInfo'], $filteredMounts));
+        return array_map(function (ICachedMountInfo $mount) use ($internalPath) {
+            return new CachedMountFileInfo(
+                $mount->getUser(),
+                $mount->getStorageId(),
+                $mount->getRootId(),
+                $mount->getMountPoint(),
+                $mount->getMountId(),
+                $mount->getMountProvider(),
+                $mount->getRootInternalPath(),
+                $internalPath
+            );
+        }, $filteredMounts);
+    }
+
+    /**
+     * Remove all cached mounts for a user
+     *
+     * @param IUser $user
+     */
+    public function removeUserMounts(IUser $user) {
+        $builder = $this->connection->getQueryBuilder();
+
+        $query = $builder->delete('mounts')
+            ->where($builder->expr()->eq('user_id', $builder->createNamedParameter($user->getUID())));
+        $query->execute();
+    }
+
+    public function removeUserStorageMount($storageId, $userId) {
+        $builder = $this->connection->getQueryBuilder();
+
+        $query = $builder->delete('mounts')
+            ->where($builder->expr()->eq('user_id', $builder->createNamedParameter($userId)))
+            ->andWhere($builder->expr()->eq('storage_id', $builder->createNamedParameter($storageId, IQueryBuilder::PARAM_INT)));
+        $query->execute();
+    }
+
+    public function remoteStorageMounts($storageId) {
+        $builder = $this->connection->getQueryBuilder();
+
+        $query = $builder->delete('mounts')
+            ->where($builder->expr()->eq('storage_id', $builder->createNamedParameter($storageId, IQueryBuilder::PARAM_INT)));
+        $query->execute();
+    }
+
+    /**
+     * @param array $users
+     * @return array
+     */
+    public function getUsedSpaceForUsers(array $users) {
+        $builder = $this->connection->getQueryBuilder();
+
+        $slash = $builder->createNamedParameter('/');
+
+        $mountPoint = $builder->func()->concat(
+            $builder->func()->concat($slash, 'user_id'),
+            $slash
+        );
+
+        $userIds = array_map(function (IUser $user) {
+            return $user->getUID();
+        }, $users);
+
+        $query = $builder->select('m.user_id', 'f.size')
+            ->from('mounts', 'm')
+            ->innerJoin('m', 'filecache', 'f',
+                $builder->expr()->andX(
+                    $builder->expr()->eq('m.storage_id', 'f.storage'),
+                    $builder->expr()->eq('f.path_hash', $builder->createNamedParameter(md5('files')))
+                ))
+            ->where($builder->expr()->eq('m.mount_point', $mountPoint))
+            ->andWhere($builder->expr()->in('m.user_id', $builder->createNamedParameter($userIds, IQueryBuilder::PARAM_STR_ARRAY)));
+
+        $result = $query->execute();
+
+        $results = [];
+        while ($row = $result->fetch()) {
+            $results[$row['user_id']] = $row['size'];
+        }
+        $result->closeCursor();
+        return $results;
+    }
+
+    public function clear(): void {
+        $this->cacheInfoCache = new CappedMemoryCache();
+        $this->mountsForUsers = new CappedMemoryCache();
+    }
+
+    public function getMountForPath(IUser $user, string $path): ICachedMountInfo {
+        $mounts = $this->getMountsForUser($user);
+        $mountPoints = array_map(function (ICachedMountInfo $mount) {
+            return $mount->getMountPoint();
+        }, $mounts);
+        $mounts = array_combine($mountPoints, $mounts);
+
+        $current = $path;
+        // walk up the directory tree until we find a path that has a mountpoint set
+        // the loop will return if a mountpoint is found or break if none are found
+        while (true) {
+            $mountPoint = $current . '/';
+            if (isset($mounts[$mountPoint])) {
+                return $mounts[$mountPoint];
+            } elseif ($current === '') {
+                break;
+            }
+
+            $current = dirname($current);
+            if ($current === '.' || $current === '/') {
+                $current = '';
+            }
+        }
+
+        throw new NotFoundException("No cached mount for path " . $path);
+    }
+
+    public function getMountsInPath(IUser $user, string $path): array {
+        $path = rtrim($path, '/') . '/';
+        $mounts = $this->getMountsForUser($user);
+        return array_filter($mounts, function (ICachedMountInfo $mount) use ($path) {
+            return $mount->getMountPoint() !== $path && str_starts_with($mount->getMountPoint(), $path);
+        });
+    }
 }

Spacing +28 added lines, -28 removed lines

@@ -79,11 +79,11 @@ 
 	public function registerMounts(IUser $user, array $mounts, array $mountProviderClasses = null) {
 		$this->eventLogger->start('fs:setup:user:register', 'Registering mounts for user');
 		// filter out non-proper storages coming from unit tests
-		$mounts = array_filter($mounts, function (IMountPoint $mount) {
+		$mounts = array_filter($mounts, function(IMountPoint $mount) {
 			return $mount instanceof SharedMount || ($mount->getStorage() && $mount->getStorage()->getCache());
 		});
 		/** @var ICachedMountInfo[] $newMounts */
-		$newMounts = array_map(function (IMountPoint $mount) use ($user) {
+		$newMounts = array_map(function(IMountPoint $mount) use ($user) {
 			// filter out any storages which aren't scanned yet since we aren't interested in files from those storages (yet)
 			if ($mount->getStorageRootId() === -1) {
 				return null;
@@ -92,25 +92,25 @@ 
 			}
 		}, $mounts);
 		$newMounts = array_values(array_filter($newMounts));
-		$newMountKeys = array_map(function (ICachedMountInfo $mount) {
-			return $mount->getRootId() . '::' . $mount->getMountPoint();
+		$newMountKeys = array_map(function(ICachedMountInfo $mount) {
+			return $mount->getRootId().'::'.$mount->getMountPoint();
 		}, $newMounts);
 		$newMounts = array_combine($newMountKeys, $newMounts);
 
 		$cachedMounts = $this->getMountsForUser($user);
 		if (is_array($mountProviderClasses)) {
-			$cachedMounts = array_filter($cachedMounts, function (ICachedMountInfo $mountInfo) use ($mountProviderClasses, $newMounts) {
+			$cachedMounts = array_filter($cachedMounts, function(ICachedMountInfo $mountInfo) use ($mountProviderClasses, $newMounts) {
 				// for existing mounts that didn't have a mount provider set
 				// we still want the ones that map to new mounts
-				$mountKey = $mountInfo->getRootId() . '::' . $mountInfo->getMountPoint();
+				$mountKey = $mountInfo->getRootId().'::'.$mountInfo->getMountPoint();
 				if ($mountInfo->getMountProvider() === '' && isset($newMounts[$mountKey])) {
 					return true;
 				}
 				return in_array($mountInfo->getMountProvider(), $mountProviderClasses);
 			});
 		}
-		$cachedRootKeys = array_map(function (ICachedMountInfo $mount) {
-			return $mount->getRootId() . '::' . $mount->getMountPoint();
+		$cachedRootKeys = array_map(function(ICachedMountInfo $mount) {
+			return $mount->getRootId().'::'.$mount->getMountPoint();
 		}, $cachedMounts);
 		$cachedMounts = array_combine($cachedRootKeys, $cachedMounts);
 
@@ -162,11 +162,11 @@ 
 	private function findChangedMounts(array $newMounts, array $cachedMounts) {
 		$new = [];
 		foreach ($newMounts as $mount) {
-			$new[$mount->getRootId() . '::' . $mount->getMountPoint()] = $mount;
+			$new[$mount->getRootId().'::'.$mount->getMountPoint()] = $mount;
 		}
 		$changed = [];
 		foreach ($cachedMounts as $cachedMount) {
-			$key = $cachedMount->getRootId() . '::' . $cachedMount->getMountPoint();
+			$key = $cachedMount->getRootId().'::'.$cachedMount->getMountPoint();
 			if (isset($new[$key])) {
 				$newMount = $new[$key];
 				if (
@@ -194,7 +194,7 @@ 
 			], ['root_id', 'user_id', 'mount_point']);
 		} else {
 			// in some cases this is legitimate, like orphaned shares
-			$this->logger->debug('Could not get storage info for mount at ' . $mount->getMountPoint());
+			$this->logger->debug('Could not get storage info for mount at '.$mount->getMountPoint());
 		}
 	}
 
@@ -229,12 +229,12 @@ 
 		}
 		$mount_id = $row['mount_id'];
 		if (!is_null($mount_id)) {
-			$mount_id = (int)$mount_id;
+			$mount_id = (int) $mount_id;
 		}
 		return new CachedMountInfo(
 			$user,
-			(int)$row['storage_id'],
-			(int)$row['root_id'],
+			(int) $row['storage_id'],
+			(int) $row['root_id'],
 			$row['mount_point'],
 			$row['mount_provider_class'] ?? '',
 			$mount_id,
@@ -322,12 +322,12 @@ 
 
 			if (is_array($row)) {
 				$this->cacheInfoCache[$fileId] = [
-					(int)$row['storage'],
-					(string)$row['path'],
-					(int)$row['mimetype']
+					(int) $row['storage'],
+					(string) $row['path'],
+					(int) $row['mimetype']
 				];
 			} else {
-				throw new NotFoundException('File with id "' . $fileId . '" not found');
+				throw new NotFoundException('File with id "'.$fileId.'" not found');
 			}
 		}
 		return $this->cacheInfoCache[$fileId];
@@ -359,17 +359,17 @@ 
 		$rows = $result->fetchAll();
 		$result->closeCursor();
 		// filter mounts that are from the same storage but a different directory
-		$filteredMounts = array_filter($rows, function (array $row) use ($internalPath, $fileId) {
-			if ($fileId === (int)$row['root_id']) {
+		$filteredMounts = array_filter($rows, function(array $row) use ($internalPath, $fileId) {
+			if ($fileId === (int) $row['root_id']) {
 				return true;
 			}
 			$internalMountPath = $row['path'] ?? '';
 
-			return $internalMountPath === '' || substr($internalPath, 0, strlen($internalMountPath) + 1) === $internalMountPath . '/';
+			return $internalMountPath === '' || substr($internalPath, 0, strlen($internalMountPath) + 1) === $internalMountPath.'/';
 		});
 
 		$filteredMounts = array_filter(array_map([$this, 'dbRowToMountInfo'], $filteredMounts));
-		return array_map(function (ICachedMountInfo $mount) use ($internalPath) {
+		return array_map(function(ICachedMountInfo $mount) use ($internalPath) {
 			return new CachedMountFileInfo(
 				$mount->getUser(),
 				$mount->getStorageId(),
@@ -427,7 +427,7 @@ 
 			$slash
 		);
 
-		$userIds = array_map(function (IUser $user) {
+		$userIds = array_map(function(IUser $user) {
 			return $user->getUID();
 		}, $users);
 
@@ -458,7 +458,7 @@ 
 
 	public function getMountForPath(IUser $user, string $path): ICachedMountInfo {
 		$mounts = $this->getMountsForUser($user);
-		$mountPoints = array_map(function (ICachedMountInfo $mount) {
+		$mountPoints = array_map(function(ICachedMountInfo $mount) {
 			return $mount->getMountPoint();
 		}, $mounts);
 		$mounts = array_combine($mountPoints, $mounts);
@@ -467,7 +467,7 @@ 
 		// walk up the directory tree until we find a path that has a mountpoint set
 		// the loop will return if a mountpoint is found or break if none are found
 		while (true) {
-			$mountPoint = $current . '/';
+			$mountPoint = $current.'/';
 			if (isset($mounts[$mountPoint])) {
 				return $mounts[$mountPoint];
 			} elseif ($current === '') {
@@ -480,13 +480,13 @@ 
 			}
 		}
 
-		throw new NotFoundException("No cached mount for path " . $path);
+		throw new NotFoundException("No cached mount for path ".$path);
 	}
 
 	public function getMountsInPath(IUser $user, string $path): array {
-		$path = rtrim($path, '/') . '/';
+		$path = rtrim($path, '/').'/';
 		$mounts = $this->getMountsForUser($user);
-		return array_filter($mounts, function (ICachedMountInfo $mount) use ($path) {
+		return array_filter($mounts, function(ICachedMountInfo $mount) use ($path) {
 			return $mount->getMountPoint() !== $path && str_starts_with($mount->getMountPoint(), $path);
 		});
 	}

lib/private/Files/Filesystem.php

Indentation +713 added lines, -713 removed lines

@@ -50,717 +50,717 @@
 use OCP\IUserSession;
 
 class Filesystem {
-	private static ?Mount\Manager $mounts = null;
-
-	public static bool $loaded = false;
-
-	private static ?View $defaultInstance = null;
-
-	private static ?CappedMemoryCache $normalizedPathCache = null;
-
-	/** @var string[]|null */
-	private static ?array $blacklist = null;
-
-	/**
-	 * classname which used for hooks handling
-	 * used as signalclass in OC_Hooks::emit()
-	 */
-	public const CLASSNAME = 'OC_Filesystem';
-
-	/**
-	 * signalname emitted before file renaming
-	 *
-	 * @param string $oldpath
-	 * @param string $newpath
-	 */
-	public const signal_rename = 'rename';
-
-	/**
-	 * signal emitted after file renaming
-	 *
-	 * @param string $oldpath
-	 * @param string $newpath
-	 */
-	public const signal_post_rename = 'post_rename';
-
-	/**
-	 * signal emitted before file/dir creation
-	 *
-	 * @param string $path
-	 * @param bool $run changing this flag to false in hook handler will cancel event
-	 */
-	public const signal_create = 'create';
-
-	/**
-	 * signal emitted after file/dir creation
-	 *
-	 * @param string $path
-	 * @param bool $run changing this flag to false in hook handler will cancel event
-	 */
-	public const signal_post_create = 'post_create';
-
-	/**
-	 * signal emits before file/dir copy
-	 *
-	 * @param string $oldpath
-	 * @param string $newpath
-	 * @param bool $run changing this flag to false in hook handler will cancel event
-	 */
-	public const signal_copy = 'copy';
-
-	/**
-	 * signal emits after file/dir copy
-	 *
-	 * @param string $oldpath
-	 * @param string $newpath
-	 */
-	public const signal_post_copy = 'post_copy';
-
-	/**
-	 * signal emits before file/dir save
-	 *
-	 * @param string $path
-	 * @param bool $run changing this flag to false in hook handler will cancel event
-	 */
-	public const signal_write = 'write';
-
-	/**
-	 * signal emits after file/dir save
-	 *
-	 * @param string $path
-	 */
-	public const signal_post_write = 'post_write';
-
-	/**
-	 * signal emitted before file/dir update
-	 *
-	 * @param string $path
-	 * @param bool $run changing this flag to false in hook handler will cancel event
-	 */
-	public const signal_update = 'update';
-
-	/**
-	 * signal emitted after file/dir update
-	 *
-	 * @param string $path
-	 * @param bool $run changing this flag to false in hook handler will cancel event
-	 */
-	public const signal_post_update = 'post_update';
-
-	/**
-	 * signal emits when reading file/dir
-	 *
-	 * @param string $path
-	 */
-	public const signal_read = 'read';
-
-	/**
-	 * signal emits when removing file/dir
-	 *
-	 * @param string $path
-	 */
-	public const signal_delete = 'delete';
-
-	/**
-	 * parameters definitions for signals
-	 */
-	public const signal_param_path = 'path';
-	public const signal_param_oldpath = 'oldpath';
-	public const signal_param_newpath = 'newpath';
-
-	/**
-	 * run - changing this flag to false in hook handler will cancel event
-	 */
-	public const signal_param_run = 'run';
-
-	public const signal_create_mount = 'create_mount';
-	public const signal_delete_mount = 'delete_mount';
-	public const signal_param_mount_type = 'mounttype';
-	public const signal_param_users = 'users';
-
-	private static ?\OC\Files\Storage\StorageFactory $loader = null;
-
-	private static bool $logWarningWhenAddingStorageWrapper = true;
-
-	/**
-	 * @param bool $shouldLog
-	 * @return bool previous value
-	 * @internal
-	 */
-	public static function logWarningWhenAddingStorageWrapper(bool $shouldLog): bool {
-		$previousValue = self::$logWarningWhenAddingStorageWrapper;
-		self::$logWarningWhenAddingStorageWrapper = $shouldLog;
-		return $previousValue;
-	}
-
-	/**
-	 * @param string $wrapperName
-	 * @param callable $wrapper
-	 * @param int $priority
-	 */
-	public static function addStorageWrapper($wrapperName, $wrapper, $priority = 50) {
-		if (self::$logWarningWhenAddingStorageWrapper) {
-			\OC::$server->getLogger()->warning("Storage wrapper '{wrapper}' was not registered via the 'OC_Filesystem - preSetup' hook which could cause potential problems.", [
-				'wrapper' => $wrapperName,
-				'app' => 'filesystem',
-			]);
-		}
-
-		$mounts = self::getMountManager()->getAll();
-		if (!self::getLoader()->addStorageWrapper($wrapperName, $wrapper, $priority, $mounts)) {
-			// do not re-wrap if storage with this name already existed
-			return;
-		}
-	}
-
-	/**
-	 * Returns the storage factory
-	 *
-	 * @return IStorageFactory
-	 */
-	public static function getLoader() {
-		if (!self::$loader) {
-			self::$loader = \OC::$server->get(IStorageFactory::class);
-		}
-		return self::$loader;
-	}
-
-	/**
-	 * Returns the mount manager
-	 */
-	public static function getMountManager(): Mount\Manager {
-		self::initMountManager();
-		assert(self::$mounts !== null);
-		return self::$mounts;
-	}
-
-	/**
-	 * get the mountpoint of the storage object for a path
-	 * ( note: because a storage is not always mounted inside the fakeroot, the
-	 * returned mountpoint is relative to the absolute root of the filesystem
-	 * and doesn't take the chroot into account )
-	 *
-	 * @param string $path
-	 * @return string
-	 */
-	public static function getMountPoint($path) {
-		if (!self::$mounts) {
-			\OC_Util::setupFS();
-		}
-		$mount = self::$mounts->find($path);
-		return $mount->getMountPoint();
-	}
-
-	/**
-	 * get a list of all mount points in a directory
-	 *
-	 * @param string $path
-	 * @return string[]
-	 */
-	public static function getMountPoints($path) {
-		if (!self::$mounts) {
-			\OC_Util::setupFS();
-		}
-		$result = [];
-		$mounts = self::$mounts->findIn($path);
-		foreach ($mounts as $mount) {
-			$result[] = $mount->getMountPoint();
-		}
-		return $result;
-	}
-
-	/**
-	 * get the storage mounted at $mountPoint
-	 *
-	 * @param string $mountPoint
-	 * @return \OC\Files\Storage\Storage|null
-	 */
-	public static function getStorage($mountPoint) {
-		$mount = self::getMountManager()->find($mountPoint);
-		return $mount->getStorage();
-	}
-
-	/**
-	 * @param string $id
-	 * @return Mount\MountPoint[]
-	 */
-	public static function getMountByStorageId($id) {
-		return self::getMountManager()->findByStorageId($id);
-	}
-
-	/**
-	 * @param int $id
-	 * @return Mount\MountPoint[]
-	 */
-	public static function getMountByNumericId($id) {
-		return self::getMountManager()->findByNumericId($id);
-	}
-
-	/**
-	 * resolve a path to a storage and internal path
-	 *
-	 * @param string $path
-	 * @return array{?\OCP\Files\Storage\IStorage, string} an array consisting of the storage and the internal path
-	 */
-	public static function resolvePath($path): array {
-		$mount = self::getMountManager()->find($path);
-		return [$mount->getStorage(), rtrim($mount->getInternalPath($path), '/')];
-	}
-
-	public static function init(string|IUser|null $user, string $root): bool {
-		if (self::$defaultInstance) {
-			return false;
-		}
-		self::initInternal($root);
-
-		//load custom mount config
-		self::initMountPoints($user);
-
-		return true;
-	}
-
-	public static function initInternal(string $root): bool {
-		if (self::$defaultInstance) {
-			return false;
-		}
-		self::getLoader();
-		self::$defaultInstance = new View($root);
-		/** @var IEventDispatcher $eventDispatcher */
-		$eventDispatcher = \OC::$server->get(IEventDispatcher::class);
-		$eventDispatcher->addListener(FilesystemTornDownEvent::class, function () {
-			self::$defaultInstance = null;
-			self::$loaded = false;
-		});
-
-		self::initMountManager();
-
-		self::$loaded = true;
-
-		return true;
-	}
-
-	public static function initMountManager(): void {
-		if (!self::$mounts) {
-			self::$mounts = \OC::$server->get(IMountManager::class);
-		}
-	}
-
-	/**
-	 * Initialize system and personal mount points for a user
-	 *
-	 * @throws \OC\User\NoUserException if the user is not available
-	 */
-	public static function initMountPoints(string|IUser|null $user = ''): void {
-		/** @var IUserManager $userManager */
-		$userManager = \OC::$server->get(IUserManager::class);
-
-		$userObject = ($user instanceof IUser) ? $user : $userManager->get($user);
-		if ($userObject) {
-			/** @var SetupManager $setupManager */
-			$setupManager = \OC::$server->get(SetupManager::class);
-			$setupManager->setupForUser($userObject);
-		} else {
-			throw new NoUserException();
-		}
-	}
-
-	/**
-	 * Get the default filesystem view
-	 */
-	public static function getView(): ?View {
-		if (!self::$defaultInstance) {
-			/** @var IUserSession $session */
-			$session = \OC::$server->get(IUserSession::class);
-			$user = $session->getUser();
-			if ($user) {
-				$userDir = '/' . $user->getUID() . '/files';
-				self::initInternal($userDir);
-			}
-		}
-		return self::$defaultInstance;
-	}
-
-	/**
-	 * tear down the filesystem, removing all storage providers
-	 */
-	public static function tearDown() {
-		\OC_Util::tearDownFS();
-	}
-
-	/**
-	 * get the relative path of the root data directory for the current user
-	 *
-	 * @return ?string
-	 *
-	 * Returns path like /admin/files
-	 */
-	public static function getRoot() {
-		if (!self::$defaultInstance) {
-			return null;
-		}
-		return self::$defaultInstance->getRoot();
-	}
-
-	/**
-	 * mount an \OC\Files\Storage\Storage in our virtual filesystem
-	 *
-	 * @param \OC\Files\Storage\Storage|string $class
-	 * @param array $arguments
-	 * @param string $mountpoint
-	 */
-	public static function mount($class, $arguments, $mountpoint) {
-		if (!self::$mounts) {
-			\OC_Util::setupFS();
-		}
-		$mount = new Mount\MountPoint($class, $mountpoint, $arguments, self::getLoader());
-		self::$mounts->addMount($mount);
-	}
-
-	/**
-	 * return the path to a local version of the file
-	 * we need this because we can't know if a file is stored local or not from
-	 * outside the filestorage and for some purposes a local file is needed
-	 */
-	public static function getLocalFile(string $path): string|false {
-		return self::$defaultInstance->getLocalFile($path);
-	}
-
-	/**
-	 * return path to file which reflects one visible in browser
-	 *
-	 * @param string $path
-	 * @return string
-	 */
-	public static function getLocalPath($path) {
-		$datadir = \OC_User::getHome(\OC_User::getUser()) . '/files';
-		$newpath = $path;
-		if (strncmp($newpath, $datadir, strlen($datadir)) == 0) {
-			$newpath = substr($path, strlen($datadir));
-		}
-		return $newpath;
-	}
-
-	/**
-	 * check if the requested path is valid
-	 *
-	 * @param string $path
-	 * @return bool
-	 */
-	public static function isValidPath($path) {
-		$path = self::normalizePath($path);
-		if (!$path || $path[0] !== '/') {
-			$path = '/' . $path;
-		}
-		if (str_contains($path, '/../') || strrchr($path, '/') === '/..') {
-			return false;
-		}
-		return true;
-	}
-
-	/**
-	 * @param string $filename
-	 * @return bool
-	 */
-	public static function isFileBlacklisted($filename) {
-		$filename = self::normalizePath($filename);
-
-		if (self::$blacklist === null) {
-			self::$blacklist = \OC::$server->getConfig()->getSystemValue('blacklisted_files', ['.htaccess']);
-		}
-
-		$filename = strtolower(basename($filename));
-		return in_array($filename, self::$blacklist);
-	}
-
-	/**
-	 * check if the directory should be ignored when scanning
-	 * NOTE: the special directories . and .. would cause never ending recursion
-	 *
-	 * @param string $dir
-	 * @return boolean
-	 */
-	public static function isIgnoredDir($dir) {
-		if ($dir === '.' || $dir === '..') {
-			return true;
-		}
-		return false;
-	}
-
-	/**
-	 * following functions are equivalent to their php builtin equivalents for arguments/return values.
-	 */
-	public static function mkdir($path) {
-		return self::$defaultInstance->mkdir($path);
-	}
-
-	public static function rmdir($path) {
-		return self::$defaultInstance->rmdir($path);
-	}
-
-	public static function is_dir($path) {
-		return self::$defaultInstance->is_dir($path);
-	}
-
-	public static function is_file($path) {
-		return self::$defaultInstance->is_file($path);
-	}
-
-	public static function stat($path) {
-		return self::$defaultInstance->stat($path);
-	}
-
-	public static function filetype($path) {
-		return self::$defaultInstance->filetype($path);
-	}
-
-	public static function filesize($path) {
-		return self::$defaultInstance->filesize($path);
-	}
-
-	public static function readfile($path) {
-		return self::$defaultInstance->readfile($path);
-	}
-
-	public static function isCreatable($path) {
-		return self::$defaultInstance->isCreatable($path);
-	}
-
-	public static function isReadable($path) {
-		return self::$defaultInstance->isReadable($path);
-	}
-
-	public static function isUpdatable($path) {
-		return self::$defaultInstance->isUpdatable($path);
-	}
-
-	public static function isDeletable($path) {
-		return self::$defaultInstance->isDeletable($path);
-	}
-
-	public static function isSharable($path) {
-		return self::$defaultInstance->isSharable($path);
-	}
-
-	public static function file_exists($path) {
-		return self::$defaultInstance->file_exists($path);
-	}
-
-	public static function filemtime($path) {
-		return self::$defaultInstance->filemtime($path);
-	}
-
-	public static function touch($path, $mtime = null) {
-		return self::$defaultInstance->touch($path, $mtime);
-	}
-
-	/**
-	 * @return string|false
-	 */
-	public static function file_get_contents($path) {
-		return self::$defaultInstance->file_get_contents($path);
-	}
-
-	public static function file_put_contents($path, $data) {
-		return self::$defaultInstance->file_put_contents($path, $data);
-	}
-
-	public static function unlink($path) {
-		return self::$defaultInstance->unlink($path);
-	}
-
-	public static function rename($source, $target) {
-		return self::$defaultInstance->rename($source, $target);
-	}
-
-	public static function copy($source, $target) {
-		return self::$defaultInstance->copy($source, $target);
-	}
-
-	public static function fopen($path, $mode) {
-		return self::$defaultInstance->fopen($path, $mode);
-	}
-
-	/**
-	 * @param string $path
-	 * @throws \OCP\Files\InvalidPathException
-	 */
-	public static function toTmpFile($path): string|false {
-		return self::$defaultInstance->toTmpFile($path);
-	}
-
-	public static function fromTmpFile($tmpFile, $path) {
-		return self::$defaultInstance->fromTmpFile($tmpFile, $path);
-	}
-
-	public static function getMimeType($path) {
-		return self::$defaultInstance->getMimeType($path);
-	}
-
-	public static function hash($type, $path, $raw = false) {
-		return self::$defaultInstance->hash($type, $path, $raw);
-	}
-
-	public static function free_space($path = '/') {
-		return self::$defaultInstance->free_space($path);
-	}
-
-	public static function search($query) {
-		return self::$defaultInstance->search($query);
-	}
-
-	/**
-	 * @param string $query
-	 */
-	public static function searchByMime($query) {
-		return self::$defaultInstance->searchByMime($query);
-	}
-
-	/**
-	 * @param string|int $tag name or tag id
-	 * @param string $userId owner of the tags
-	 * @return FileInfo[] array or file info
-	 */
-	public static function searchByTag($tag, $userId) {
-		return self::$defaultInstance->searchByTag($tag, $userId);
-	}
-
-	/**
-	 * check if a file or folder has been updated since $time
-	 *
-	 * @param string $path
-	 * @param int $time
-	 * @return bool
-	 */
-	public static function hasUpdated($path, $time) {
-		return self::$defaultInstance->hasUpdated($path, $time);
-	}
-
-	/**
-	 * Fix common problems with a file path
-	 *
-	 * @param string $path
-	 * @param bool $stripTrailingSlash whether to strip the trailing slash
-	 * @param bool $isAbsolutePath whether the given path is absolute
-	 * @param bool $keepUnicode true to disable unicode normalization
-	 * @psalm-taint-escape file
-	 * @return string
-	 */
-	public static function normalizePath($path, $stripTrailingSlash = true, $isAbsolutePath = false, $keepUnicode = false) {
-		/**
-		 * FIXME: This is a workaround for existing classes and files which call
-		 *        this function with another type than a valid string. This
-		 *        conversion should get removed as soon as all existing
-		 *        function calls have been fixed.
-		 */
-		$path = (string)$path;
-
-		if ($path === '') {
-			return '/';
-		}
-
-		if (is_null(self::$normalizedPathCache)) {
-			self::$normalizedPathCache = new CappedMemoryCache(2048);
-		}
-
-		$cacheKey = json_encode([$path, $stripTrailingSlash, $isAbsolutePath, $keepUnicode]);
-
-		if ($cacheKey && isset(self::$normalizedPathCache[$cacheKey])) {
-			return self::$normalizedPathCache[$cacheKey];
-		}
-
-		//normalize unicode if possible
-		if (!$keepUnicode) {
-			$path = \OC_Util::normalizeUnicode($path);
-		}
-
-		//add leading slash, if it is already there we strip it anyway
-		$path = '/' . $path;
-
-		$patterns = [
-			'#\\\\#s',       // no windows style '\\' slashes
-			'#/\.(/\.)*/#s', // remove '/./'
-			'#\//+#s',       // remove sequence of slashes
-			'#/\.$#s',       // remove trailing '/.'
-		];
-
-		do {
-			$count = 0;
-			$path = preg_replace($patterns, '/', $path, -1, $count);
-		} while ($count > 0);
-
-		//remove trailing slash
-		if ($stripTrailingSlash && strlen($path) > 1) {
-			$path = rtrim($path, '/');
-		}
-
-		self::$normalizedPathCache[$cacheKey] = $path;
-
-		return $path;
-	}
-
-	/**
-	 * get the filesystem info
-	 *
-	 * @param string $path
-	 * @param bool|string $includeMountPoints whether to add mountpoint sizes,
-	 * defaults to true
-	 * @return \OC\Files\FileInfo|false False if file does not exist
-	 */
-	public static function getFileInfo($path, $includeMountPoints = true) {
-		return self::getView()->getFileInfo($path, $includeMountPoints);
-	}
-
-	/**
-	 * change file metadata
-	 *
-	 * @param string $path
-	 * @param array $data
-	 * @return int
-	 *
-	 * returns the fileid of the updated file
-	 */
-	public static function putFileInfo($path, $data) {
-		return self::$defaultInstance->putFileInfo($path, $data);
-	}
-
-	/**
-	 * get the content of a directory
-	 *
-	 * @param string $directory path under datadirectory
-	 * @param string $mimetype_filter limit returned content to this mimetype or mimepart
-	 * @return \OC\Files\FileInfo[]
-	 */
-	public static function getDirectoryContent($directory, $mimetype_filter = '') {
-		return self::$defaultInstance->getDirectoryContent($directory, $mimetype_filter);
-	}
-
-	/**
-	 * Get the path of a file by id
-	 *
-	 * Note that the resulting path is not guaranteed to be unique for the id, multiple paths can point to the same file
-	 *
-	 * @param int $id
-	 * @throws NotFoundException
-	 * @return string
-	 */
-	public static function getPath($id) {
-		return self::$defaultInstance->getPath($id);
-	}
-
-	/**
-	 * Get the owner for a file or folder
-	 *
-	 * @param string $path
-	 * @return string
-	 */
-	public static function getOwner($path) {
-		return self::$defaultInstance->getOwner($path);
-	}
-
-	/**
-	 * get the ETag for a file or folder
-	 */
-	public static function getETag(string $path): string|false {
-		return self::$defaultInstance->getETag($path);
-	}
+    private static ?Mount\Manager $mounts = null;
+
+    public static bool $loaded = false;
+
+    private static ?View $defaultInstance = null;
+
+    private static ?CappedMemoryCache $normalizedPathCache = null;
+
+    /** @var string[]|null */
+    private static ?array $blacklist = null;
+
+    /**
+     * classname which used for hooks handling
+     * used as signalclass in OC_Hooks::emit()
+     */
+    public const CLASSNAME = 'OC_Filesystem';
+
+    /**
+     * signalname emitted before file renaming
+     *
+     * @param string $oldpath
+     * @param string $newpath
+     */
+    public const signal_rename = 'rename';
+
+    /**
+     * signal emitted after file renaming
+     *
+     * @param string $oldpath
+     * @param string $newpath
+     */
+    public const signal_post_rename = 'post_rename';
+
+    /**
+     * signal emitted before file/dir creation
+     *
+     * @param string $path
+     * @param bool $run changing this flag to false in hook handler will cancel event
+     */
+    public const signal_create = 'create';
+
+    /**
+     * signal emitted after file/dir creation
+     *
+     * @param string $path
+     * @param bool $run changing this flag to false in hook handler will cancel event
+     */
+    public const signal_post_create = 'post_create';
+
+    /**
+     * signal emits before file/dir copy
+     *
+     * @param string $oldpath
+     * @param string $newpath
+     * @param bool $run changing this flag to false in hook handler will cancel event
+     */
+    public const signal_copy = 'copy';
+
+    /**
+     * signal emits after file/dir copy
+     *
+     * @param string $oldpath
+     * @param string $newpath
+     */
+    public const signal_post_copy = 'post_copy';
+
+    /**
+     * signal emits before file/dir save
+     *
+     * @param string $path
+     * @param bool $run changing this flag to false in hook handler will cancel event
+     */
+    public const signal_write = 'write';
+
+    /**
+     * signal emits after file/dir save
+     *
+     * @param string $path
+     */
+    public const signal_post_write = 'post_write';
+
+    /**
+     * signal emitted before file/dir update
+     *
+     * @param string $path
+     * @param bool $run changing this flag to false in hook handler will cancel event
+     */
+    public const signal_update = 'update';
+
+    /**
+     * signal emitted after file/dir update
+     *
+     * @param string $path
+     * @param bool $run changing this flag to false in hook handler will cancel event
+     */
+    public const signal_post_update = 'post_update';
+
+    /**
+     * signal emits when reading file/dir
+     *
+     * @param string $path
+     */
+    public const signal_read = 'read';
+
+    /**
+     * signal emits when removing file/dir
+     *
+     * @param string $path
+     */
+    public const signal_delete = 'delete';
+
+    /**
+     * parameters definitions for signals
+     */
+    public const signal_param_path = 'path';
+    public const signal_param_oldpath = 'oldpath';
+    public const signal_param_newpath = 'newpath';
+
+    /**
+     * run - changing this flag to false in hook handler will cancel event
+     */
+    public const signal_param_run = 'run';
+
+    public const signal_create_mount = 'create_mount';
+    public const signal_delete_mount = 'delete_mount';
+    public const signal_param_mount_type = 'mounttype';
+    public const signal_param_users = 'users';
+
+    private static ?\OC\Files\Storage\StorageFactory $loader = null;
+
+    private static bool $logWarningWhenAddingStorageWrapper = true;
+
+    /**
+     * @param bool $shouldLog
+     * @return bool previous value
+     * @internal
+     */
+    public static function logWarningWhenAddingStorageWrapper(bool $shouldLog): bool {
+        $previousValue = self::$logWarningWhenAddingStorageWrapper;
+        self::$logWarningWhenAddingStorageWrapper = $shouldLog;
+        return $previousValue;
+    }
+
+    /**
+     * @param string $wrapperName
+     * @param callable $wrapper
+     * @param int $priority
+     */
+    public static function addStorageWrapper($wrapperName, $wrapper, $priority = 50) {
+        if (self::$logWarningWhenAddingStorageWrapper) {
+            \OC::$server->getLogger()->warning("Storage wrapper '{wrapper}' was not registered via the 'OC_Filesystem - preSetup' hook which could cause potential problems.", [
+                'wrapper' => $wrapperName,
+                'app' => 'filesystem',
+            ]);
+        }
+
+        $mounts = self::getMountManager()->getAll();
+        if (!self::getLoader()->addStorageWrapper($wrapperName, $wrapper, $priority, $mounts)) {
+            // do not re-wrap if storage with this name already existed
+            return;
+        }
+    }
+
+    /**
+     * Returns the storage factory
+     *
+     * @return IStorageFactory
+     */
+    public static function getLoader() {
+        if (!self::$loader) {
+            self::$loader = \OC::$server->get(IStorageFactory::class);
+        }
+        return self::$loader;
+    }
+
+    /**
+     * Returns the mount manager
+     */
+    public static function getMountManager(): Mount\Manager {
+        self::initMountManager();
+        assert(self::$mounts !== null);
+        return self::$mounts;
+    }
+
+    /**
+     * get the mountpoint of the storage object for a path
+     * ( note: because a storage is not always mounted inside the fakeroot, the
+     * returned mountpoint is relative to the absolute root of the filesystem
+     * and doesn't take the chroot into account )
+     *
+     * @param string $path
+     * @return string
+     */
+    public static function getMountPoint($path) {
+        if (!self::$mounts) {
+            \OC_Util::setupFS();
+        }
+        $mount = self::$mounts->find($path);
+        return $mount->getMountPoint();
+    }
+
+    /**
+     * get a list of all mount points in a directory
+     *
+     * @param string $path
+     * @return string[]
+     */
+    public static function getMountPoints($path) {
+        if (!self::$mounts) {
+            \OC_Util::setupFS();
+        }
+        $result = [];
+        $mounts = self::$mounts->findIn($path);
+        foreach ($mounts as $mount) {
+            $result[] = $mount->getMountPoint();
+        }
+        return $result;
+    }
+
+    /**
+     * get the storage mounted at $mountPoint
+     *
+     * @param string $mountPoint
+     * @return \OC\Files\Storage\Storage|null
+     */
+    public static function getStorage($mountPoint) {
+        $mount = self::getMountManager()->find($mountPoint);
+        return $mount->getStorage();
+    }
+
+    /**
+     * @param string $id
+     * @return Mount\MountPoint[]
+     */
+    public static function getMountByStorageId($id) {
+        return self::getMountManager()->findByStorageId($id);
+    }
+
+    /**
+     * @param int $id
+     * @return Mount\MountPoint[]
+     */
+    public static function getMountByNumericId($id) {
+        return self::getMountManager()->findByNumericId($id);
+    }
+
+    /**
+     * resolve a path to a storage and internal path
+     *
+     * @param string $path
+     * @return array{?\OCP\Files\Storage\IStorage, string} an array consisting of the storage and the internal path
+     */
+    public static function resolvePath($path): array {
+        $mount = self::getMountManager()->find($path);
+        return [$mount->getStorage(), rtrim($mount->getInternalPath($path), '/')];
+    }
+
+    public static function init(string|IUser|null $user, string $root): bool {
+        if (self::$defaultInstance) {
+            return false;
+        }
+        self::initInternal($root);
+
+        //load custom mount config
+        self::initMountPoints($user);
+
+        return true;
+    }
+
+    public static function initInternal(string $root): bool {
+        if (self::$defaultInstance) {
+            return false;
+        }
+        self::getLoader();
+        self::$defaultInstance = new View($root);
+        /** @var IEventDispatcher $eventDispatcher */
+        $eventDispatcher = \OC::$server->get(IEventDispatcher::class);
+        $eventDispatcher->addListener(FilesystemTornDownEvent::class, function () {
+            self::$defaultInstance = null;
+            self::$loaded = false;
+        });
+
+        self::initMountManager();
+
+        self::$loaded = true;
+
+        return true;
+    }
+
+    public static function initMountManager(): void {
+        if (!self::$mounts) {
+            self::$mounts = \OC::$server->get(IMountManager::class);
+        }
+    }
+
+    /**
+     * Initialize system and personal mount points for a user
+     *
+     * @throws \OC\User\NoUserException if the user is not available
+     */
+    public static function initMountPoints(string|IUser|null $user = ''): void {
+        /** @var IUserManager $userManager */
+        $userManager = \OC::$server->get(IUserManager::class);
+
+        $userObject = ($user instanceof IUser) ? $user : $userManager->get($user);
+        if ($userObject) {
+            /** @var SetupManager $setupManager */
+            $setupManager = \OC::$server->get(SetupManager::class);
+            $setupManager->setupForUser($userObject);
+        } else {
+            throw new NoUserException();
+        }
+    }
+
+    /**
+     * Get the default filesystem view
+     */
+    public static function getView(): ?View {
+        if (!self::$defaultInstance) {
+            /** @var IUserSession $session */
+            $session = \OC::$server->get(IUserSession::class);
+            $user = $session->getUser();
+            if ($user) {
+                $userDir = '/' . $user->getUID() . '/files';
+                self::initInternal($userDir);
+            }
+        }
+        return self::$defaultInstance;
+    }
+
+    /**
+     * tear down the filesystem, removing all storage providers
+     */
+    public static function tearDown() {
+        \OC_Util::tearDownFS();
+    }
+
+    /**
+     * get the relative path of the root data directory for the current user
+     *
+     * @return ?string
+     *
+     * Returns path like /admin/files
+     */
+    public static function getRoot() {
+        if (!self::$defaultInstance) {
+            return null;
+        }
+        return self::$defaultInstance->getRoot();
+    }
+
+    /**
+     * mount an \OC\Files\Storage\Storage in our virtual filesystem
+     *
+     * @param \OC\Files\Storage\Storage|string $class
+     * @param array $arguments
+     * @param string $mountpoint
+     */
+    public static function mount($class, $arguments, $mountpoint) {
+        if (!self::$mounts) {
+            \OC_Util::setupFS();
+        }
+        $mount = new Mount\MountPoint($class, $mountpoint, $arguments, self::getLoader());
+        self::$mounts->addMount($mount);
+    }
+
+    /**
+     * return the path to a local version of the file
+     * we need this because we can't know if a file is stored local or not from
+     * outside the filestorage and for some purposes a local file is needed
+     */
+    public static function getLocalFile(string $path): string|false {
+        return self::$defaultInstance->getLocalFile($path);
+    }
+
+    /**
+     * return path to file which reflects one visible in browser
+     *
+     * @param string $path
+     * @return string
+     */
+    public static function getLocalPath($path) {
+        $datadir = \OC_User::getHome(\OC_User::getUser()) . '/files';
+        $newpath = $path;
+        if (strncmp($newpath, $datadir, strlen($datadir)) == 0) {
+            $newpath = substr($path, strlen($datadir));
+        }
+        return $newpath;
+    }
+
+    /**
+     * check if the requested path is valid
+     *
+     * @param string $path
+     * @return bool
+     */
+    public static function isValidPath($path) {
+        $path = self::normalizePath($path);
+        if (!$path || $path[0] !== '/') {
+            $path = '/' . $path;
+        }
+        if (str_contains($path, '/../') || strrchr($path, '/') === '/..') {
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * @param string $filename
+     * @return bool
+     */
+    public static function isFileBlacklisted($filename) {
+        $filename = self::normalizePath($filename);
+
+        if (self::$blacklist === null) {
+            self::$blacklist = \OC::$server->getConfig()->getSystemValue('blacklisted_files', ['.htaccess']);
+        }
+
+        $filename = strtolower(basename($filename));
+        return in_array($filename, self::$blacklist);
+    }
+
+    /**
+     * check if the directory should be ignored when scanning
+     * NOTE: the special directories . and .. would cause never ending recursion
+     *
+     * @param string $dir
+     * @return boolean
+     */
+    public static function isIgnoredDir($dir) {
+        if ($dir === '.' || $dir === '..') {
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * following functions are equivalent to their php builtin equivalents for arguments/return values.
+     */
+    public static function mkdir($path) {
+        return self::$defaultInstance->mkdir($path);
+    }
+
+    public static function rmdir($path) {
+        return self::$defaultInstance->rmdir($path);
+    }
+
+    public static function is_dir($path) {
+        return self::$defaultInstance->is_dir($path);
+    }
+
+    public static function is_file($path) {
+        return self::$defaultInstance->is_file($path);
+    }
+
+    public static function stat($path) {
+        return self::$defaultInstance->stat($path);
+    }
+
+    public static function filetype($path) {
+        return self::$defaultInstance->filetype($path);
+    }
+
+    public static function filesize($path) {
+        return self::$defaultInstance->filesize($path);
+    }
+
+    public static function readfile($path) {
+        return self::$defaultInstance->readfile($path);
+    }
+
+    public static function isCreatable($path) {
+        return self::$defaultInstance->isCreatable($path);
+    }
+
+    public static function isReadable($path) {
+        return self::$defaultInstance->isReadable($path);
+    }
+
+    public static function isUpdatable($path) {
+        return self::$defaultInstance->isUpdatable($path);
+    }
+
+    public static function isDeletable($path) {
+        return self::$defaultInstance->isDeletable($path);
+    }
+
+    public static function isSharable($path) {
+        return self::$defaultInstance->isSharable($path);
+    }
+
+    public static function file_exists($path) {
+        return self::$defaultInstance->file_exists($path);
+    }
+
+    public static function filemtime($path) {
+        return self::$defaultInstance->filemtime($path);
+    }
+
+    public static function touch($path, $mtime = null) {
+        return self::$defaultInstance->touch($path, $mtime);
+    }
+
+    /**
+     * @return string|false
+     */
+    public static function file_get_contents($path) {
+        return self::$defaultInstance->file_get_contents($path);
+    }
+
+    public static function file_put_contents($path, $data) {
+        return self::$defaultInstance->file_put_contents($path, $data);
+    }
+
+    public static function unlink($path) {
+        return self::$defaultInstance->unlink($path);
+    }
+
+    public static function rename($source, $target) {
+        return self::$defaultInstance->rename($source, $target);
+    }
+
+    public static function copy($source, $target) {
+        return self::$defaultInstance->copy($source, $target);
+    }
+
+    public static function fopen($path, $mode) {
+        return self::$defaultInstance->fopen($path, $mode);
+    }
+
+    /**
+     * @param string $path
+     * @throws \OCP\Files\InvalidPathException
+     */
+    public static function toTmpFile($path): string|false {
+        return self::$defaultInstance->toTmpFile($path);
+    }
+
+    public static function fromTmpFile($tmpFile, $path) {
+        return self::$defaultInstance->fromTmpFile($tmpFile, $path);
+    }
+
+    public static function getMimeType($path) {
+        return self::$defaultInstance->getMimeType($path);
+    }
+
+    public static function hash($type, $path, $raw = false) {
+        return self::$defaultInstance->hash($type, $path, $raw);
+    }
+
+    public static function free_space($path = '/') {
+        return self::$defaultInstance->free_space($path);
+    }
+
+    public static function search($query) {
+        return self::$defaultInstance->search($query);
+    }
+
+    /**
+     * @param string $query
+     */
+    public static function searchByMime($query) {
+        return self::$defaultInstance->searchByMime($query);
+    }
+
+    /**
+     * @param string|int $tag name or tag id
+     * @param string $userId owner of the tags
+     * @return FileInfo[] array or file info
+     */
+    public static function searchByTag($tag, $userId) {
+        return self::$defaultInstance->searchByTag($tag, $userId);
+    }
+
+    /**
+     * check if a file or folder has been updated since $time
+     *
+     * @param string $path
+     * @param int $time
+     * @return bool
+     */
+    public static function hasUpdated($path, $time) {
+        return self::$defaultInstance->hasUpdated($path, $time);
+    }
+
+    /**
+     * Fix common problems with a file path
+     *
+     * @param string $path
+     * @param bool $stripTrailingSlash whether to strip the trailing slash
+     * @param bool $isAbsolutePath whether the given path is absolute
+     * @param bool $keepUnicode true to disable unicode normalization
+     * @psalm-taint-escape file
+     * @return string
+     */
+    public static function normalizePath($path, $stripTrailingSlash = true, $isAbsolutePath = false, $keepUnicode = false) {
+        /**
+         * FIXME: This is a workaround for existing classes and files which call
+         *        this function with another type than a valid string. This
+         *        conversion should get removed as soon as all existing
+         *        function calls have been fixed.
+         */
+        $path = (string)$path;
+
+        if ($path === '') {
+            return '/';
+        }
+
+        if (is_null(self::$normalizedPathCache)) {
+            self::$normalizedPathCache = new CappedMemoryCache(2048);
+        }
+
+        $cacheKey = json_encode([$path, $stripTrailingSlash, $isAbsolutePath, $keepUnicode]);
+
+        if ($cacheKey && isset(self::$normalizedPathCache[$cacheKey])) {
+            return self::$normalizedPathCache[$cacheKey];
+        }
+
+        //normalize unicode if possible
+        if (!$keepUnicode) {
+            $path = \OC_Util::normalizeUnicode($path);
+        }
+
+        //add leading slash, if it is already there we strip it anyway
+        $path = '/' . $path;
+
+        $patterns = [
+            '#\\\\#s',       // no windows style '\\' slashes
+            '#/\.(/\.)*/#s', // remove '/./'
+            '#\//+#s',       // remove sequence of slashes
+            '#/\.$#s',       // remove trailing '/.'
+        ];
+
+        do {
+            $count = 0;
+            $path = preg_replace($patterns, '/', $path, -1, $count);
+        } while ($count > 0);
+
+        //remove trailing slash
+        if ($stripTrailingSlash && strlen($path) > 1) {
+            $path = rtrim($path, '/');
+        }
+
+        self::$normalizedPathCache[$cacheKey] = $path;
+
+        return $path;
+    }
+
+    /**
+     * get the filesystem info
+     *
+     * @param string $path
+     * @param bool|string $includeMountPoints whether to add mountpoint sizes,
+     * defaults to true
+     * @return \OC\Files\FileInfo|false False if file does not exist
+     */
+    public static function getFileInfo($path, $includeMountPoints = true) {
+        return self::getView()->getFileInfo($path, $includeMountPoints);
+    }
+
+    /**
+     * change file metadata
+     *
+     * @param string $path
+     * @param array $data
+     * @return int
+     *
+     * returns the fileid of the updated file
+     */
+    public static function putFileInfo($path, $data) {
+        return self::$defaultInstance->putFileInfo($path, $data);
+    }
+
+    /**
+     * get the content of a directory
+     *
+     * @param string $directory path under datadirectory
+     * @param string $mimetype_filter limit returned content to this mimetype or mimepart
+     * @return \OC\Files\FileInfo[]
+     */
+    public static function getDirectoryContent($directory, $mimetype_filter = '') {
+        return self::$defaultInstance->getDirectoryContent($directory, $mimetype_filter);
+    }
+
+    /**
+     * Get the path of a file by id
+     *
+     * Note that the resulting path is not guaranteed to be unique for the id, multiple paths can point to the same file
+     *
+     * @param int $id
+     * @throws NotFoundException
+     * @return string
+     */
+    public static function getPath($id) {
+        return self::$defaultInstance->getPath($id);
+    }
+
+    /**
+     * Get the owner for a file or folder
+     *
+     * @param string $path
+     * @return string
+     */
+    public static function getOwner($path) {
+        return self::$defaultInstance->getOwner($path);
+    }
+
+    /**
+     * get the ETag for a file or folder
+     */
+    public static function getETag(string $path): string|false {
+        return self::$defaultInstance->getETag($path);
+    }
 }

Spacing +17 added lines, -17 removed lines

@@ -50,7 +50,7 @@ 
 use OCP\IUserSession;
 
 class Filesystem {
-	private static ?Mount\Manager $mounts = null;
+	private static ? Mount\Manager $mounts = null;
 
 	public static bool $loaded = false;
 
@@ -59,7 +59,7 @@ 
 	private static ?CappedMemoryCache $normalizedPathCache = null;
 
 	/** @var string[]|null */
-	private static ?array $blacklist = null;
+	private static ? array $blacklist = null;
 
 	/**
 	 * classname which used for hooks handling
@@ -178,7 +178,7 @@ 
 	public const signal_param_mount_type = 'mounttype';
 	public const signal_param_users = 'users';
 
-	private static ?\OC\Files\Storage\StorageFactory $loader = null;
+	private static ? \OC\Files\Storage\StorageFactory $loader = null;
 
 	private static bool $logWarningWhenAddingStorageWrapper = true;
 
@@ -307,7 +307,7 @@ 
 		return [$mount->getStorage(), rtrim($mount->getInternalPath($path), '/')];
 	}
 
-	public static function init(string|IUser|null $user, string $root): bool {
+	public static function init(string | IUser | null $user, string $root): bool {
 		if (self::$defaultInstance) {
 			return false;
 		}
@@ -327,7 +327,7 @@ 
 		self::$defaultInstance = new View($root);
 		/** @var IEventDispatcher $eventDispatcher */
 		$eventDispatcher = \OC::$server->get(IEventDispatcher::class);
-		$eventDispatcher->addListener(FilesystemTornDownEvent::class, function () {
+		$eventDispatcher->addListener(FilesystemTornDownEvent::class, function() {
 			self::$defaultInstance = null;
 			self::$loaded = false;
 		});
@@ -350,7 +350,7 @@ 
 	 *
 	 * @throws \OC\User\NoUserException if the user is not available
 	 */
-	public static function initMountPoints(string|IUser|null $user = ''): void {
+	public static function initMountPoints(string | IUser | null $user = ''): void {
 		/** @var IUserManager $userManager */
 		$userManager = \OC::$server->get(IUserManager::class);
 
@@ -373,7 +373,7 @@ 
 			$session = \OC::$server->get(IUserSession::class);
 			$user = $session->getUser();
 			if ($user) {
-				$userDir = '/' . $user->getUID() . '/files';
+				$userDir = '/'.$user->getUID().'/files';
 				self::initInternal($userDir);
 			}
 		}
@@ -421,7 +421,7 @@ 
 	 * we need this because we can't know if a file is stored local or not from
 	 * outside the filestorage and for some purposes a local file is needed
 	 */
-	public static function getLocalFile(string $path): string|false {
+	public static function getLocalFile(string $path): string | false {
 		return self::$defaultInstance->getLocalFile($path);
 	}
 
@@ -432,7 +432,7 @@ 
 	 * @return string
 	 */
 	public static function getLocalPath($path) {
-		$datadir = \OC_User::getHome(\OC_User::getUser()) . '/files';
+		$datadir = \OC_User::getHome(\OC_User::getUser()).'/files';
 		$newpath = $path;
 		if (strncmp($newpath, $datadir, strlen($datadir)) == 0) {
 			$newpath = substr($path, strlen($datadir));
@@ -449,7 +449,7 @@ 
 	public static function isValidPath($path) {
 		$path = self::normalizePath($path);
 		if (!$path || $path[0] !== '/') {
-			$path = '/' . $path;
+			$path = '/'.$path;
 		}
 		if (str_contains($path, '/../') || strrchr($path, '/') === '/..') {
 			return false;
@@ -584,7 +584,7 @@ 
 	 * @param string $path
 	 * @throws \OCP\Files\InvalidPathException
 	 */
-	public static function toTmpFile($path): string|false {
+	public static function toTmpFile($path): string | false {
 		return self::$defaultInstance->toTmpFile($path);
 	}
 
@@ -652,7 +652,7 @@ 
 		 *        conversion should get removed as soon as all existing
 		 *        function calls have been fixed.
 		 */
-		$path = (string)$path;
+		$path = (string) $path;
 
 		if ($path === '') {
 			return '/';
@@ -674,13 +674,13 @@ 
 		}
 
 		//add leading slash, if it is already there we strip it anyway
-		$path = '/' . $path;
+		$path = '/'.$path;
 
 		$patterns = [
-			'#\\\\#s',       // no windows style '\\' slashes
+			'#\\\\#s', // no windows style '\\' slashes
 			'#/\.(/\.)*/#s', // remove '/./'
-			'#\//+#s',       // remove sequence of slashes
-			'#/\.$#s',       // remove trailing '/.'
+			'#\//+#s', // remove sequence of slashes
+			'#/\.$#s', // remove trailing '/.'
 		];
 
 		do {
@@ -760,7 +760,7 @@ 
 	/**
 	 * get the ETag for a file or folder
 	 */
-	public static function getETag(string $path): string|false {
+	public static function getETag(string $path): string | false {
 		return self::$defaultInstance->getETag($path);
 	}
 }

lib/private/Files/Node/Folder.php

Indentation +398 added lines, -398 removed lines

@@ -50,402 +50,402 @@
 use OCP\IUserManager;
 
 class Folder extends Node implements \OCP\Files\Folder {
-	/**
-	 * Creates a Folder that represents a non-existing path
-	 *
-	 * @param string $path path
-	 * @return NonExistingFolder non-existing node
-	 */
-	protected function createNonExistingNode($path) {
-		return new NonExistingFolder($this->root, $this->view, $path);
-	}
-
-	/**
-	 * @param string $path path relative to the folder
-	 * @return string
-	 * @throws \OCP\Files\NotPermittedException
-	 */
-	public function getFullPath($path) {
-		$path = $this->normalizePath($path);
-		if (!$this->isValidPath($path)) {
-			throw new NotPermittedException('Invalid path "' . $path . '"');
-		}
-		return $this->path . $path;
-	}
-
-	/**
-	 * @param string $path
-	 * @return string|null
-	 */
-	public function getRelativePath($path) {
-		return PathHelper::getRelativePath($this->getPath(), $path);
-	}
-
-	/**
-	 * check if a node is a (grand-)child of the folder
-	 *
-	 * @param \OC\Files\Node\Node $node
-	 * @return bool
-	 */
-	public function isSubNode($node) {
-		return str_starts_with($node->getPath(), $this->path . '/');
-	}
-
-	/**
-	 * get the content of this directory
-	 *
-	 * @return Node[]
-	 * @throws \OCP\Files\NotFoundException
-	 */
-	public function getDirectoryListing() {
-		$folderContent = $this->view->getDirectoryContent($this->path, '', $this->getFileInfo(false));
-
-		return array_map(function (FileInfo $info) {
-			if ($info->getMimetype() === FileInfo::MIMETYPE_FOLDER) {
-				return new Folder($this->root, $this->view, $info->getPath(), $info, $this);
-			} else {
-				return new File($this->root, $this->view, $info->getPath(), $info, $this);
-			}
-		}, $folderContent);
-	}
-
-	/**
-	 * @param string $path
-	 * @param FileInfo $info
-	 * @return File|Folder
-	 */
-	protected function createNode($path, FileInfo $info = null, bool $infoHasSubMountsIncluded = true) {
-		if (is_null($info)) {
-			$isDir = $this->view->is_dir($path);
-		} else {
-			$isDir = $info->getType() === FileInfo::TYPE_FOLDER;
-		}
-		$parent = dirname($path) === $this->getPath() ? $this : null;
-		if ($isDir) {
-			return new Folder($this->root, $this->view, $path, $info, $parent, $infoHasSubMountsIncluded);
-		} else {
-			return new File($this->root, $this->view, $path, $info, $parent);
-		}
-	}
-
-	/**
-	 * Get the node at $path
-	 *
-	 * @param string $path
-	 * @return \OC\Files\Node\Node
-	 * @throws \OCP\Files\NotFoundException
-	 */
-	public function get($path) {
-		return $this->root->get($this->getFullPath($path));
-	}
-
-	/**
-	 * @param string $path
-	 * @return bool
-	 */
-	public function nodeExists($path) {
-		try {
-			$this->get($path);
-			return true;
-		} catch (NotFoundException $e) {
-			return false;
-		}
-	}
-
-	/**
-	 * @param string $path
-	 * @return \OC\Files\Node\Folder
-	 * @throws \OCP\Files\NotPermittedException
-	 */
-	public function newFolder($path) {
-		if ($this->checkPermissions(\OCP\Constants::PERMISSION_CREATE)) {
-			$fullPath = $this->getFullPath($path);
-			$nonExisting = new NonExistingFolder($this->root, $this->view, $fullPath);
-			$this->sendHooks(['preWrite', 'preCreate'], [$nonExisting]);
-			if (!$this->view->mkdir($fullPath)) {
-				throw new NotPermittedException('Could not create folder "' . $fullPath . '"');
-			}
-			$parent = dirname($fullPath) === $this->getPath() ? $this : null;
-			$node = new Folder($this->root, $this->view, $fullPath, null, $parent);
-			$this->sendHooks(['postWrite', 'postCreate'], [$node]);
-			return $node;
-		} else {
-			throw new NotPermittedException('No create permission for folder "' . $path . '"');
-		}
-	}
-
-	/**
-	 * @param string $path
-	 * @param string | resource | null $content
-	 * @return \OC\Files\Node\File
-	 * @throws \OCP\Files\NotPermittedException
-	 */
-	public function newFile($path, $content = null) {
-		if (empty($path)) {
-			throw new NotPermittedException('Could not create as provided path is empty');
-		}
-		if ($this->checkPermissions(\OCP\Constants::PERMISSION_CREATE)) {
-			$fullPath = $this->getFullPath($path);
-			$nonExisting = new NonExistingFile($this->root, $this->view, $fullPath);
-			$this->sendHooks(['preWrite', 'preCreate'], [$nonExisting]);
-			if ($content !== null) {
-				$result = $this->view->file_put_contents($fullPath, $content);
-			} else {
-				$result = $this->view->touch($fullPath);
-			}
-			if ($result === false) {
-				throw new NotPermittedException('Could not create path "' . $fullPath . '"');
-			}
-			$node = new File($this->root, $this->view, $fullPath, null, $this);
-			$this->sendHooks(['postWrite', 'postCreate'], [$node]);
-			return $node;
-		}
-		throw new NotPermittedException('No create permission for path "' . $path . '"');
-	}
-
-	private function queryFromOperator(ISearchOperator $operator, string $uid = null, int $limit = 0, int $offset = 0): ISearchQuery {
-		if ($uid === null) {
-			$user = null;
-		} else {
-			/** @var IUserManager $userManager */
-			$userManager = \OC::$server->query(IUserManager::class);
-			$user = $userManager->get($uid);
-		}
-		return new SearchQuery($operator, $limit, $offset, [], $user);
-	}
-
-	/**
-	 * search for files with the name matching $query
-	 *
-	 * @param string|ISearchQuery $query
-	 * @return \OC\Files\Node\Node[]
-	 */
-	public function search($query) {
-		if (is_string($query)) {
-			$query = $this->queryFromOperator(new SearchComparison(ISearchComparison::COMPARE_LIKE, 'name', '%' . $query . '%'));
-		}
-
-		// search is handled by a single query covering all caches that this folder contains
-		// this is done by collect
-
-		$limitToHome = $query->limitToHome();
-		if ($limitToHome && count(explode('/', $this->path)) !== 3) {
-			throw new \InvalidArgumentException('searching by owner is only allowed in the users home folder');
-		}
-
-		/** @var QuerySearchHelper $searchHelper */
-		$searchHelper = \OC::$server->get(QuerySearchHelper::class);
-		[$caches, $mountByMountPoint] = $searchHelper->getCachesAndMountPointsForSearch($this->root, $this->path, $limitToHome);
-		$resultsPerCache = $searchHelper->searchInCaches($query, $caches);
-
-		// loop through all results per-cache, constructing the FileInfo object from the CacheEntry and merge them all
-		$files = array_merge(...array_map(function (array $results, string $relativeMountPoint) use ($mountByMountPoint) {
-			$mount = $mountByMountPoint[$relativeMountPoint];
-			return array_map(function (ICacheEntry $result) use ($relativeMountPoint, $mount) {
-				return $this->cacheEntryToFileInfo($mount, $relativeMountPoint, $result);
-			}, $results);
-		}, array_values($resultsPerCache), array_keys($resultsPerCache)));
-
-		// don't include this folder in the results
-		$files = array_filter($files, function (FileInfo $file) {
-			return $file->getPath() !== $this->getPath();
-		});
-
-		// since results were returned per-cache, they are no longer fully sorted
-		$order = $query->getOrder();
-		if ($order) {
-			usort($files, function (FileInfo $a, FileInfo $b) use ($order) {
-				foreach ($order as $orderField) {
-					$cmp = $orderField->sortFileInfo($a, $b);
-					if ($cmp !== 0) {
-						return $cmp;
-					}
-				}
-				return 0;
-			});
-		}
-
-		return array_map(function (FileInfo $file) {
-			return $this->createNode($file->getPath(), $file);
-		}, $files);
-	}
-
-	private function cacheEntryToFileInfo(IMountPoint $mount, string $appendRoot, ICacheEntry $cacheEntry): FileInfo {
-		$cacheEntry['internalPath'] = $cacheEntry['path'];
-		$cacheEntry['path'] = rtrim($appendRoot . $cacheEntry->getPath(), '/');
-		$subPath = $cacheEntry['path'] !== '' ? '/' . $cacheEntry['path'] : '';
-		return new \OC\Files\FileInfo($this->path . $subPath, $mount->getStorage(), $cacheEntry['internalPath'], $cacheEntry, $mount);
-	}
-
-	/**
-	 * search for files by mimetype
-	 *
-	 * @param string $mimetype
-	 * @return Node[]
-	 */
-	public function searchByMime($mimetype) {
-		if (!str_contains($mimetype, '/')) {
-			$query = $this->queryFromOperator(new SearchComparison(ISearchComparison::COMPARE_LIKE, 'mimetype', $mimetype . '/%'));
-		} else {
-			$query = $this->queryFromOperator(new SearchComparison(ISearchComparison::COMPARE_EQUAL, 'mimetype', $mimetype));
-		}
-		return $this->search($query);
-	}
-
-	/**
-	 * search for files by tag
-	 *
-	 * @param string|int $tag name or tag id
-	 * @param string $userId owner of the tags
-	 * @return Node[]
-	 */
-	public function searchByTag($tag, $userId) {
-		$query = $this->queryFromOperator(new SearchComparison(ISearchComparison::COMPARE_EQUAL, 'tagname', $tag), $userId);
-		return $this->search($query);
-	}
-
-	/**
-	 * @param int $id
-	 * @return \OC\Files\Node\Node[]
-	 */
-	public function getById($id) {
-		return $this->root->getByIdInPath((int)$id, $this->getPath());
-	}
-
-	protected function getAppDataDirectoryName(): string {
-		$instanceId = \OC::$server->getConfig()->getSystemValueString('instanceid');
-		return 'appdata_' . $instanceId;
-	}
-
-	/**
-	 * In case the path we are currently in is inside the appdata_* folder,
-	 * the original getById method does not work, because it can only look inside
-	 * the user's mount points. But the user has no mount point for the root storage.
-	 *
-	 * So in that case we directly check the mount of the root if it contains
-	 * the id. If it does we check if the path is inside the path we are working
-	 * in.
-	 *
-	 * @param int $id
-	 * @return array
-	 */
-	protected function getByIdInRootMount(int $id): array {
-		$mount = $this->root->getMount('');
-		$cacheEntry = $mount->getStorage()->getCache($this->path)->get($id);
-		if (!$cacheEntry) {
-			return [];
-		}
-
-		$absolutePath = '/' . ltrim($cacheEntry->getPath(), '/');
-		$currentPath = rtrim($this->path, '/') . '/';
-
-		if (!str_starts_with($absolutePath, $currentPath)) {
-			return [];
-		}
-
-		return [$this->root->createNode(
-			$absolutePath, new \OC\Files\FileInfo(
-				$absolutePath,
-				$mount->getStorage(),
-				$cacheEntry->getPath(),
-				$cacheEntry,
-				$mount
-			))];
-	}
-
-	public function getFreeSpace() {
-		return $this->view->free_space($this->path);
-	}
-
-	public function delete() {
-		if ($this->checkPermissions(\OCP\Constants::PERMISSION_DELETE)) {
-			$this->sendHooks(['preDelete']);
-			$fileInfo = $this->getFileInfo();
-			$this->view->rmdir($this->path);
-			$nonExisting = new NonExistingFolder($this->root, $this->view, $this->path, $fileInfo);
-			$this->sendHooks(['postDelete'], [$nonExisting]);
-		} else {
-			throw new NotPermittedException('No delete permission for path "' . $this->path . '"');
-		}
-	}
-
-	/**
-	 * Add a suffix to the name in case the file exists
-	 *
-	 * @param string $name
-	 * @return string
-	 * @throws NotPermittedException
-	 */
-	public function getNonExistingName($name) {
-		$uniqueName = \OC_Helper::buildNotExistingFileNameForView($this->getPath(), $name, $this->view);
-		return trim($this->getRelativePath($uniqueName), '/');
-	}
-
-	/**
-	 * @param int $limit
-	 * @param int $offset
-	 * @return \OCP\Files\Node[]
-	 */
-	public function getRecent($limit, $offset = 0) {
-		$filterOutNonEmptyFolder = new SearchBinaryOperator(
-			// filter out non empty folders
-			ISearchBinaryOperator::OPERATOR_OR,
-			[
-				new SearchBinaryOperator(
-					ISearchBinaryOperator::OPERATOR_NOT,
-					[
-						new SearchComparison(
-							ISearchComparison::COMPARE_EQUAL,
-							'mimetype',
-							FileInfo::MIMETYPE_FOLDER
-						),
-					]
-				),
-				new SearchComparison(
-					ISearchComparison::COMPARE_EQUAL,
-					'size',
-					0
-				),
-			]
-		);
-
-		$filterNonRecentFiles = new SearchComparison(
-			ISearchComparison::COMPARE_GREATER_THAN,
-			'mtime',
-			strtotime("-2 week")
-		);
-		if ($offset === 0 && $limit <= 100) {
-			$query = new SearchQuery(
-				new SearchBinaryOperator(
-					ISearchBinaryOperator::OPERATOR_AND,
-					[
-						$filterOutNonEmptyFolder,
-						$filterNonRecentFiles,
-					],
-				),
-				$limit,
-				$offset,
-				[
-					new SearchOrder(
-						ISearchOrder::DIRECTION_DESCENDING,
-						'mtime'
-					),
-				]
-			);
-		} else {
-			$query = new SearchQuery(
-				$filterOutNonEmptyFolder,
-				$limit,
-				$offset,
-				[
-					new SearchOrder(
-						ISearchOrder::DIRECTION_DESCENDING,
-						'mtime'
-					),
-				]
-			);
-		}
-
-		return $this->search($query);
-	}
+    /**
+     * Creates a Folder that represents a non-existing path
+     *
+     * @param string $path path
+     * @return NonExistingFolder non-existing node
+     */
+    protected function createNonExistingNode($path) {
+        return new NonExistingFolder($this->root, $this->view, $path);
+    }
+
+    /**
+     * @param string $path path relative to the folder
+     * @return string
+     * @throws \OCP\Files\NotPermittedException
+     */
+    public function getFullPath($path) {
+        $path = $this->normalizePath($path);
+        if (!$this->isValidPath($path)) {
+            throw new NotPermittedException('Invalid path "' . $path . '"');
+        }
+        return $this->path . $path;
+    }
+
+    /**
+     * @param string $path
+     * @return string|null
+     */
+    public function getRelativePath($path) {
+        return PathHelper::getRelativePath($this->getPath(), $path);
+    }
+
+    /**
+     * check if a node is a (grand-)child of the folder
+     *
+     * @param \OC\Files\Node\Node $node
+     * @return bool
+     */
+    public function isSubNode($node) {
+        return str_starts_with($node->getPath(), $this->path . '/');
+    }
+
+    /**
+     * get the content of this directory
+     *
+     * @return Node[]
+     * @throws \OCP\Files\NotFoundException
+     */
+    public function getDirectoryListing() {
+        $folderContent = $this->view->getDirectoryContent($this->path, '', $this->getFileInfo(false));
+
+        return array_map(function (FileInfo $info) {
+            if ($info->getMimetype() === FileInfo::MIMETYPE_FOLDER) {
+                return new Folder($this->root, $this->view, $info->getPath(), $info, $this);
+            } else {
+                return new File($this->root, $this->view, $info->getPath(), $info, $this);
+            }
+        }, $folderContent);
+    }
+
+    /**
+     * @param string $path
+     * @param FileInfo $info
+     * @return File|Folder
+     */
+    protected function createNode($path, FileInfo $info = null, bool $infoHasSubMountsIncluded = true) {
+        if (is_null($info)) {
+            $isDir = $this->view->is_dir($path);
+        } else {
+            $isDir = $info->getType() === FileInfo::TYPE_FOLDER;
+        }
+        $parent = dirname($path) === $this->getPath() ? $this : null;
+        if ($isDir) {
+            return new Folder($this->root, $this->view, $path, $info, $parent, $infoHasSubMountsIncluded);
+        } else {
+            return new File($this->root, $this->view, $path, $info, $parent);
+        }
+    }
+
+    /**
+     * Get the node at $path
+     *
+     * @param string $path
+     * @return \OC\Files\Node\Node
+     * @throws \OCP\Files\NotFoundException
+     */
+    public function get($path) {
+        return $this->root->get($this->getFullPath($path));
+    }
+
+    /**
+     * @param string $path
+     * @return bool
+     */
+    public function nodeExists($path) {
+        try {
+            $this->get($path);
+            return true;
+        } catch (NotFoundException $e) {
+            return false;
+        }
+    }
+
+    /**
+     * @param string $path
+     * @return \OC\Files\Node\Folder
+     * @throws \OCP\Files\NotPermittedException
+     */
+    public function newFolder($path) {
+        if ($this->checkPermissions(\OCP\Constants::PERMISSION_CREATE)) {
+            $fullPath = $this->getFullPath($path);
+            $nonExisting = new NonExistingFolder($this->root, $this->view, $fullPath);
+            $this->sendHooks(['preWrite', 'preCreate'], [$nonExisting]);
+            if (!$this->view->mkdir($fullPath)) {
+                throw new NotPermittedException('Could not create folder "' . $fullPath . '"');
+            }
+            $parent = dirname($fullPath) === $this->getPath() ? $this : null;
+            $node = new Folder($this->root, $this->view, $fullPath, null, $parent);
+            $this->sendHooks(['postWrite', 'postCreate'], [$node]);
+            return $node;
+        } else {
+            throw new NotPermittedException('No create permission for folder "' . $path . '"');
+        }
+    }
+
+    /**
+     * @param string $path
+     * @param string | resource | null $content
+     * @return \OC\Files\Node\File
+     * @throws \OCP\Files\NotPermittedException
+     */
+    public function newFile($path, $content = null) {
+        if (empty($path)) {
+            throw new NotPermittedException('Could not create as provided path is empty');
+        }
+        if ($this->checkPermissions(\OCP\Constants::PERMISSION_CREATE)) {
+            $fullPath = $this->getFullPath($path);
+            $nonExisting = new NonExistingFile($this->root, $this->view, $fullPath);
+            $this->sendHooks(['preWrite', 'preCreate'], [$nonExisting]);
+            if ($content !== null) {
+                $result = $this->view->file_put_contents($fullPath, $content);
+            } else {
+                $result = $this->view->touch($fullPath);
+            }
+            if ($result === false) {
+                throw new NotPermittedException('Could not create path "' . $fullPath . '"');
+            }
+            $node = new File($this->root, $this->view, $fullPath, null, $this);
+            $this->sendHooks(['postWrite', 'postCreate'], [$node]);
+            return $node;
+        }
+        throw new NotPermittedException('No create permission for path "' . $path . '"');
+    }
+
+    private function queryFromOperator(ISearchOperator $operator, string $uid = null, int $limit = 0, int $offset = 0): ISearchQuery {
+        if ($uid === null) {
+            $user = null;
+        } else {
+            /** @var IUserManager $userManager */
+            $userManager = \OC::$server->query(IUserManager::class);
+            $user = $userManager->get($uid);
+        }
+        return new SearchQuery($operator, $limit, $offset, [], $user);
+    }
+
+    /**
+     * search for files with the name matching $query
+     *
+     * @param string|ISearchQuery $query
+     * @return \OC\Files\Node\Node[]
+     */
+    public function search($query) {
+        if (is_string($query)) {
+            $query = $this->queryFromOperator(new SearchComparison(ISearchComparison::COMPARE_LIKE, 'name', '%' . $query . '%'));
+        }
+
+        // search is handled by a single query covering all caches that this folder contains
+        // this is done by collect
+
+        $limitToHome = $query->limitToHome();
+        if ($limitToHome && count(explode('/', $this->path)) !== 3) {
+            throw new \InvalidArgumentException('searching by owner is only allowed in the users home folder');
+        }
+
+        /** @var QuerySearchHelper $searchHelper */
+        $searchHelper = \OC::$server->get(QuerySearchHelper::class);
+        [$caches, $mountByMountPoint] = $searchHelper->getCachesAndMountPointsForSearch($this->root, $this->path, $limitToHome);
+        $resultsPerCache = $searchHelper->searchInCaches($query, $caches);
+
+        // loop through all results per-cache, constructing the FileInfo object from the CacheEntry and merge them all
+        $files = array_merge(...array_map(function (array $results, string $relativeMountPoint) use ($mountByMountPoint) {
+            $mount = $mountByMountPoint[$relativeMountPoint];
+            return array_map(function (ICacheEntry $result) use ($relativeMountPoint, $mount) {
+                return $this->cacheEntryToFileInfo($mount, $relativeMountPoint, $result);
+            }, $results);
+        }, array_values($resultsPerCache), array_keys($resultsPerCache)));
+
+        // don't include this folder in the results
+        $files = array_filter($files, function (FileInfo $file) {
+            return $file->getPath() !== $this->getPath();
+        });
+
+        // since results were returned per-cache, they are no longer fully sorted
+        $order = $query->getOrder();
+        if ($order) {
+            usort($files, function (FileInfo $a, FileInfo $b) use ($order) {
+                foreach ($order as $orderField) {
+                    $cmp = $orderField->sortFileInfo($a, $b);
+                    if ($cmp !== 0) {
+                        return $cmp;
+                    }
+                }
+                return 0;
+            });
+        }
+
+        return array_map(function (FileInfo $file) {
+            return $this->createNode($file->getPath(), $file);
+        }, $files);
+    }
+
+    private function cacheEntryToFileInfo(IMountPoint $mount, string $appendRoot, ICacheEntry $cacheEntry): FileInfo {
+        $cacheEntry['internalPath'] = $cacheEntry['path'];
+        $cacheEntry['path'] = rtrim($appendRoot . $cacheEntry->getPath(), '/');
+        $subPath = $cacheEntry['path'] !== '' ? '/' . $cacheEntry['path'] : '';
+        return new \OC\Files\FileInfo($this->path . $subPath, $mount->getStorage(), $cacheEntry['internalPath'], $cacheEntry, $mount);
+    }
+
+    /**
+     * search for files by mimetype
+     *
+     * @param string $mimetype
+     * @return Node[]
+     */
+    public function searchByMime($mimetype) {
+        if (!str_contains($mimetype, '/')) {
+            $query = $this->queryFromOperator(new SearchComparison(ISearchComparison::COMPARE_LIKE, 'mimetype', $mimetype . '/%'));
+        } else {
+            $query = $this->queryFromOperator(new SearchComparison(ISearchComparison::COMPARE_EQUAL, 'mimetype', $mimetype));
+        }
+        return $this->search($query);
+    }
+
+    /**
+     * search for files by tag
+     *
+     * @param string|int $tag name or tag id
+     * @param string $userId owner of the tags
+     * @return Node[]
+     */
+    public function searchByTag($tag, $userId) {
+        $query = $this->queryFromOperator(new SearchComparison(ISearchComparison::COMPARE_EQUAL, 'tagname', $tag), $userId);
+        return $this->search($query);
+    }
+
+    /**
+     * @param int $id
+     * @return \OC\Files\Node\Node[]
+     */
+    public function getById($id) {
+        return $this->root->getByIdInPath((int)$id, $this->getPath());
+    }
+
+    protected function getAppDataDirectoryName(): string {
+        $instanceId = \OC::$server->getConfig()->getSystemValueString('instanceid');
+        return 'appdata_' . $instanceId;
+    }
+
+    /**
+     * In case the path we are currently in is inside the appdata_* folder,
+     * the original getById method does not work, because it can only look inside
+     * the user's mount points. But the user has no mount point for the root storage.
+     *
+     * So in that case we directly check the mount of the root if it contains
+     * the id. If it does we check if the path is inside the path we are working
+     * in.
+     *
+     * @param int $id
+     * @return array
+     */
+    protected function getByIdInRootMount(int $id): array {
+        $mount = $this->root->getMount('');
+        $cacheEntry = $mount->getStorage()->getCache($this->path)->get($id);
+        if (!$cacheEntry) {
+            return [];
+        }
+
+        $absolutePath = '/' . ltrim($cacheEntry->getPath(), '/');
+        $currentPath = rtrim($this->path, '/') . '/';
+
+        if (!str_starts_with($absolutePath, $currentPath)) {
+            return [];
+        }
+
+        return [$this->root->createNode(
+            $absolutePath, new \OC\Files\FileInfo(
+                $absolutePath,
+                $mount->getStorage(),
+                $cacheEntry->getPath(),
+                $cacheEntry,
+                $mount
+            ))];
+    }
+
+    public function getFreeSpace() {
+        return $this->view->free_space($this->path);
+    }
+
+    public function delete() {
+        if ($this->checkPermissions(\OCP\Constants::PERMISSION_DELETE)) {
+            $this->sendHooks(['preDelete']);
+            $fileInfo = $this->getFileInfo();
+            $this->view->rmdir($this->path);
+            $nonExisting = new NonExistingFolder($this->root, $this->view, $this->path, $fileInfo);
+            $this->sendHooks(['postDelete'], [$nonExisting]);
+        } else {
+            throw new NotPermittedException('No delete permission for path "' . $this->path . '"');
+        }
+    }
+
+    /**
+     * Add a suffix to the name in case the file exists
+     *
+     * @param string $name
+     * @return string
+     * @throws NotPermittedException
+     */
+    public function getNonExistingName($name) {
+        $uniqueName = \OC_Helper::buildNotExistingFileNameForView($this->getPath(), $name, $this->view);
+        return trim($this->getRelativePath($uniqueName), '/');
+    }
+
+    /**
+     * @param int $limit
+     * @param int $offset
+     * @return \OCP\Files\Node[]
+     */
+    public function getRecent($limit, $offset = 0) {
+        $filterOutNonEmptyFolder = new SearchBinaryOperator(
+            // filter out non empty folders
+            ISearchBinaryOperator::OPERATOR_OR,
+            [
+                new SearchBinaryOperator(
+                    ISearchBinaryOperator::OPERATOR_NOT,
+                    [
+                        new SearchComparison(
+                            ISearchComparison::COMPARE_EQUAL,
+                            'mimetype',
+                            FileInfo::MIMETYPE_FOLDER
+                        ),
+                    ]
+                ),
+                new SearchComparison(
+                    ISearchComparison::COMPARE_EQUAL,
+                    'size',
+                    0
+                ),
+            ]
+        );
+
+        $filterNonRecentFiles = new SearchComparison(
+            ISearchComparison::COMPARE_GREATER_THAN,
+            'mtime',
+            strtotime("-2 week")
+        );
+        if ($offset === 0 && $limit <= 100) {
+            $query = new SearchQuery(
+                new SearchBinaryOperator(
+                    ISearchBinaryOperator::OPERATOR_AND,
+                    [
+                        $filterOutNonEmptyFolder,
+                        $filterNonRecentFiles,
+                    ],
+                ),
+                $limit,
+                $offset,
+                [
+                    new SearchOrder(
+                        ISearchOrder::DIRECTION_DESCENDING,
+                        'mtime'
+                    ),
+                ]
+            );
+        } else {
+            $query = new SearchQuery(
+                $filterOutNonEmptyFolder,
+                $limit,
+                $offset,
+                [
+                    new SearchOrder(
+                        ISearchOrder::DIRECTION_DESCENDING,
+                        'mtime'
+                    ),
+                ]
+            );
+        }
+
+        return $this->search($query);
+    }
 }

Spacing +23 added lines, -23 removed lines

@@ -68,9 +68,9 @@ 
 	public function getFullPath($path) {
 		$path = $this->normalizePath($path);
 		if (!$this->isValidPath($path)) {
-			throw new NotPermittedException('Invalid path "' . $path . '"');
+			throw new NotPermittedException('Invalid path "'.$path.'"');
 		}
-		return $this->path . $path;
+		return $this->path.$path;
 	}
 
 	/**
@@ -88,7 +88,7 @@ 
 	 * @return bool
 	 */
 	public function isSubNode($node) {
-		return str_starts_with($node->getPath(), $this->path . '/');
+		return str_starts_with($node->getPath(), $this->path.'/');
 	}
 
 	/**
@@ -100,7 +100,7 @@ 
 	public function getDirectoryListing() {
 		$folderContent = $this->view->getDirectoryContent($this->path, '', $this->getFileInfo(false));
 
-		return array_map(function (FileInfo $info) {
+		return array_map(function(FileInfo $info) {
 			if ($info->getMimetype() === FileInfo::MIMETYPE_FOLDER) {
 				return new Folder($this->root, $this->view, $info->getPath(), $info, $this);
 			} else {
@@ -163,14 +163,14 @@ 
 			$nonExisting = new NonExistingFolder($this->root, $this->view, $fullPath);
 			$this->sendHooks(['preWrite', 'preCreate'], [$nonExisting]);
 			if (!$this->view->mkdir($fullPath)) {
-				throw new NotPermittedException('Could not create folder "' . $fullPath . '"');
+				throw new NotPermittedException('Could not create folder "'.$fullPath.'"');
 			}
 			$parent = dirname($fullPath) === $this->getPath() ? $this : null;
 			$node = new Folder($this->root, $this->view, $fullPath, null, $parent);
 			$this->sendHooks(['postWrite', 'postCreate'], [$node]);
 			return $node;
 		} else {
-			throw new NotPermittedException('No create permission for folder "' . $path . '"');
+			throw new NotPermittedException('No create permission for folder "'.$path.'"');
 		}
 	}
 
@@ -194,13 +194,13 @@ 
 				$result = $this->view->touch($fullPath);
 			}
 			if ($result === false) {
-				throw new NotPermittedException('Could not create path "' . $fullPath . '"');
+				throw new NotPermittedException('Could not create path "'.$fullPath.'"');
 			}
 			$node = new File($this->root, $this->view, $fullPath, null, $this);
 			$this->sendHooks(['postWrite', 'postCreate'], [$node]);
 			return $node;
 		}
-		throw new NotPermittedException('No create permission for path "' . $path . '"');
+		throw new NotPermittedException('No create permission for path "'.$path.'"');
 	}
 
 	private function queryFromOperator(ISearchOperator $operator, string $uid = null, int $limit = 0, int $offset = 0): ISearchQuery {
@@ -222,7 +222,7 @@ 
 	 */
 	public function search($query) {
 		if (is_string($query)) {
-			$query = $this->queryFromOperator(new SearchComparison(ISearchComparison::COMPARE_LIKE, 'name', '%' . $query . '%'));
+			$query = $this->queryFromOperator(new SearchComparison(ISearchComparison::COMPARE_LIKE, 'name', '%'.$query.'%'));
 		}
 
 		// search is handled by a single query covering all caches that this folder contains
@@ -239,22 +239,22 @@ 
 		$resultsPerCache = $searchHelper->searchInCaches($query, $caches);
 
 		// loop through all results per-cache, constructing the FileInfo object from the CacheEntry and merge them all
-		$files = array_merge(...array_map(function (array $results, string $relativeMountPoint) use ($mountByMountPoint) {
+		$files = array_merge(...array_map(function(array $results, string $relativeMountPoint) use ($mountByMountPoint) {
 			$mount = $mountByMountPoint[$relativeMountPoint];
-			return array_map(function (ICacheEntry $result) use ($relativeMountPoint, $mount) {
+			return array_map(function(ICacheEntry $result) use ($relativeMountPoint, $mount) {
 				return $this->cacheEntryToFileInfo($mount, $relativeMountPoint, $result);
 			}, $results);
 		}, array_values($resultsPerCache), array_keys($resultsPerCache)));
 
 		// don't include this folder in the results
-		$files = array_filter($files, function (FileInfo $file) {
+		$files = array_filter($files, function(FileInfo $file) {
 			return $file->getPath() !== $this->getPath();
 		});
 
 		// since results were returned per-cache, they are no longer fully sorted
 		$order = $query->getOrder();
 		if ($order) {
-			usort($files, function (FileInfo $a, FileInfo $b) use ($order) {
+			usort($files, function(FileInfo $a, FileInfo $b) use ($order) {
 				foreach ($order as $orderField) {
 					$cmp = $orderField->sortFileInfo($a, $b);
 					if ($cmp !== 0) {
@@ -265,16 +265,16 @@ 
 			});
 		}
 
-		return array_map(function (FileInfo $file) {
+		return array_map(function(FileInfo $file) {
 			return $this->createNode($file->getPath(), $file);
 		}, $files);
 	}
 
 	private function cacheEntryToFileInfo(IMountPoint $mount, string $appendRoot, ICacheEntry $cacheEntry): FileInfo {
 		$cacheEntry['internalPath'] = $cacheEntry['path'];
-		$cacheEntry['path'] = rtrim($appendRoot . $cacheEntry->getPath(), '/');
-		$subPath = $cacheEntry['path'] !== '' ? '/' . $cacheEntry['path'] : '';
-		return new \OC\Files\FileInfo($this->path . $subPath, $mount->getStorage(), $cacheEntry['internalPath'], $cacheEntry, $mount);
+		$cacheEntry['path'] = rtrim($appendRoot.$cacheEntry->getPath(), '/');
+		$subPath = $cacheEntry['path'] !== '' ? '/'.$cacheEntry['path'] : '';
+		return new \OC\Files\FileInfo($this->path.$subPath, $mount->getStorage(), $cacheEntry['internalPath'], $cacheEntry, $mount);
 	}
 
 	/**
@@ -285,7 +285,7 @@ 
 	 */
 	public function searchByMime($mimetype) {
 		if (!str_contains($mimetype, '/')) {
-			$query = $this->queryFromOperator(new SearchComparison(ISearchComparison::COMPARE_LIKE, 'mimetype', $mimetype . '/%'));
+			$query = $this->queryFromOperator(new SearchComparison(ISearchComparison::COMPARE_LIKE, 'mimetype', $mimetype.'/%'));
 		} else {
 			$query = $this->queryFromOperator(new SearchComparison(ISearchComparison::COMPARE_EQUAL, 'mimetype', $mimetype));
 		}
@@ -309,12 +309,12 @@ 
 	 * @return \OC\Files\Node\Node[]
 	 */
 	public function getById($id) {
-		return $this->root->getByIdInPath((int)$id, $this->getPath());
+		return $this->root->getByIdInPath((int) $id, $this->getPath());
 	}
 
 	protected function getAppDataDirectoryName(): string {
 		$instanceId = \OC::$server->getConfig()->getSystemValueString('instanceid');
-		return 'appdata_' . $instanceId;
+		return 'appdata_'.$instanceId;
 	}
 
 	/**
@@ -336,8 +336,8 @@ 
 			return [];
 		}
 
-		$absolutePath = '/' . ltrim($cacheEntry->getPath(), '/');
-		$currentPath = rtrim($this->path, '/') . '/';
+		$absolutePath = '/'.ltrim($cacheEntry->getPath(), '/');
+		$currentPath = rtrim($this->path, '/').'/';
 
 		if (!str_starts_with($absolutePath, $currentPath)) {
 			return [];
@@ -365,7 +365,7 @@ 
 			$nonExisting = new NonExistingFolder($this->root, $this->view, $this->path, $fileInfo);
 			$this->sendHooks(['postDelete'], [$nonExisting]);
 		} else {
-			throw new NotPermittedException('No delete permission for path "' . $this->path . '"');
+			throw new NotPermittedException('No delete permission for path "'.$this->path.'"');
 		}
 	}
 

lib/private/Files/Type/Detection.php

Indentation +334 added lines, -334 removed lines

@@ -53,338 +53,338 @@
  * @package OC\Files\Type
  */
 class Detection implements IMimeTypeDetector {
-	private const CUSTOM_MIMETYPEMAPPING = 'mimetypemapping.json';
-	private const CUSTOM_MIMETYPEALIASES = 'mimetypealiases.json';
-
-	protected $mimetypes = [];
-	protected $secureMimeTypes = [];
-
-	protected $mimetypeIcons = [];
-	/** @var string[] */
-	protected $mimeTypeAlias = [];
-
-	/** @var IURLGenerator */
-	private $urlGenerator;
-
-	private LoggerInterface $logger;
-
-	/** @var string */
-	private $customConfigDir;
-
-	/** @var string */
-	private $defaultConfigDir;
-
-	public function __construct(IURLGenerator $urlGenerator,
-								LoggerInterface $logger,
-								string $customConfigDir,
-								string $defaultConfigDir) {
-		$this->urlGenerator = $urlGenerator;
-		$this->logger = $logger;
-		$this->customConfigDir = $customConfigDir;
-		$this->defaultConfigDir = $defaultConfigDir;
-	}
-
-	/**
-	 * Add an extension -> mimetype mapping
-	 *
-	 * $mimetype is the assumed correct mime type
-	 * The optional $secureMimeType is an alternative to send to send
-	 * to avoid potential XSS.
-	 *
-	 * @param string $extension
-	 * @param string $mimetype
-	 * @param string|null $secureMimeType
-	 */
-	public function registerType(string $extension,
-								 string $mimetype,
-								 ?string $secureMimeType = null): void {
-		$this->mimetypes[$extension] = [$mimetype, $secureMimeType];
-		$this->secureMimeTypes[$mimetype] = $secureMimeType ?: $mimetype;
-	}
-
-	/**
-	 * Add an array of extension -> mimetype mappings
-	 *
-	 * The mimetype value is in itself an array where the first index is
-	 * the assumed correct mimetype and the second is either a secure alternative
-	 * or null if the correct is considered secure.
-	 *
-	 * @param array $types
-	 */
-	public function registerTypeArray(array $types): void {
-		$this->mimetypes = array_merge($this->mimetypes, $types);
-
-		// Update the alternative mimetypes to avoid having to look them up each time.
-		foreach ($this->mimetypes as $extension => $mimeType) {
-			if (str_starts_with($extension, '_comment')) {
-				continue;
-			}
-			$this->secureMimeTypes[$mimeType[0]] = $mimeType[1] ?? $mimeType[0];
-			if (isset($mimeType[1])) {
-				$this->secureMimeTypes[$mimeType[1]] = $mimeType[1];
-			}
-		}
-	}
-
-	private function loadCustomDefinitions(string $fileName, array $definitions): array {
-		if (file_exists($this->customConfigDir . '/' . $fileName)) {
-			$custom = json_decode(file_get_contents($this->customConfigDir . '/' . $fileName), true);
-			if (json_last_error() === JSON_ERROR_NONE) {
-				$definitions = array_merge($definitions, $custom);
-			} else {
-				$this->logger->warning('Failed to parse ' . $fileName . ': ' . json_last_error_msg());
-			}
-		}
-		return $definitions;
-	}
-
-	/**
-	 * Add the mimetype aliases if they are not yet present
-	 */
-	private function loadAliases(): void {
-		if (!empty($this->mimeTypeAlias)) {
-			return;
-		}
-
-		$this->mimeTypeAlias = json_decode(file_get_contents($this->defaultConfigDir . '/mimetypealiases.dist.json'), true);
-		$this->mimeTypeAlias = $this->loadCustomDefinitions(self::CUSTOM_MIMETYPEALIASES, $this->mimeTypeAlias);
-	}
-
-	/**
-	 * @return string[]
-	 */
-	public function getAllAliases(): array {
-		$this->loadAliases();
-		return $this->mimeTypeAlias;
-	}
-
-	public function getOnlyDefaultAliases(): array {
-		$this->loadMappings();
-		$this->mimeTypeAlias = json_decode(file_get_contents($this->defaultConfigDir . '/mimetypealiases.dist.json'), true);
-		return $this->mimeTypeAlias;
-	}
-
-	/**
-	 * Add mimetype mappings if they are not yet present
-	 */
-	private function loadMappings(): void {
-		if (!empty($this->mimetypes)) {
-			return;
-		}
-
-		$mimetypeMapping = json_decode(file_get_contents($this->defaultConfigDir . '/mimetypemapping.dist.json'), true);
-		$mimetypeMapping = $this->loadCustomDefinitions(self::CUSTOM_MIMETYPEMAPPING, $mimetypeMapping);
-
-		$this->registerTypeArray($mimetypeMapping);
-	}
-
-	/**
-	 * @return array
-	 */
-	public function getAllMappings(): array {
-		$this->loadMappings();
-		return $this->mimetypes;
-	}
-
-	/**
-	 * detect mimetype only based on filename, content of file is not used
-	 *
-	 * @param string $path
-	 * @return string
-	 */
-	public function detectPath($path): string {
-		$this->loadMappings();
-
-		$fileName = basename($path);
-
-		// remove leading dot on hidden files with a file extension
-		$fileName = ltrim($fileName, '.');
-
-		// note: leading dot doesn't qualify as extension
-		if (strpos($fileName, '.') > 0) {
-			// remove versioning extension: name.v1508946057 and transfer extension: name.ocTransferId2057600214.part
-			$fileName = preg_replace('!((\.v\d+)|((\.ocTransferId\d+)?\.part))$!', '', $fileName);
-
-			//try to guess the type by the file extension
-			$extension = strrchr($fileName, '.');
-			if ($extension !== false) {
-				$extension = strtolower($extension);
-				$extension = substr($extension, 1); //remove leading .
-				return $this->mimetypes[$extension][0] ?? 'application/octet-stream';
-			}
-		}
-
-		return 'application/octet-stream';
-	}
-
-	/**
-	 * detect mimetype only based on the content of file
-	 * @param string $path
-	 * @return string
-	 * @since 18.0.0
-	 */
-	public function detectContent(string $path): string {
-		$this->loadMappings();
-
-		if (@is_dir($path)) {
-			// directories are easy
-			return 'httpd/unix-directory';
-		}
-
-		if (function_exists('finfo_open')
-			&& function_exists('finfo_file')
-			&& $finfo = finfo_open(FILEINFO_MIME)) {
-			$info = @finfo_file($finfo, $path);
-			finfo_close($finfo);
-			if ($info) {
-				$info = strtolower($info);
-				$mimeType = str_contains($info, ';') ? substr($info, 0, strpos($info, ';')) : $info;
-				$mimeType = $this->getSecureMimeType($mimeType);
-				if ($mimeType !== 'application/octet-stream') {
-					return $mimeType;
-				}
-			}
-		}
-
-		if (str_starts_with($path, 'file://')) {
-			// Is the file wrapped in a stream?
-			return 'application/octet-stream';
-		}
-
-		if (function_exists('mime_content_type')) {
-			// use mime magic extension if available
-			$mimeType = mime_content_type($path);
-			if ($mimeType !== false) {
-				$mimeType = $this->getSecureMimeType($mimeType);
-				if ($mimeType !== 'application/octet-stream') {
-					return $mimeType;
-				}
-			}
-		}
-
-		if (\OC_Helper::canExecute('file')) {
-			// it looks like we have a 'file' command,
-			// lets see if it does have mime support
-			$path = escapeshellarg($path);
-			$fp = popen("test -f $path && file -b --mime-type $path", 'r');
-			$mimeType = fgets($fp);
-			pclose($fp);
-
-			if ($mimeType !== false) {
-				//trim the newline
-				$mimeType = trim($mimeType);
-				$mimeType = $this->getSecureMimeType($mimeType);
-				if ($mimeType !== 'application/octet-stream') {
-					return $mimeType;
-				}
-			}
-		}
-		return 'application/octet-stream';
-	}
-
-	/**
-	 * detect mimetype based on both filename and content
-	 *
-	 * @param string $path
-	 * @return string
-	 */
-	public function detect($path): string {
-		$mimeType = $this->detectPath($path);
-
-		if ($mimeType !== 'application/octet-stream') {
-			return $mimeType;
-		}
-
-		return $this->detectContent($path);
-	}
-
-	/**
-	 * detect mimetype based on the content of a string
-	 *
-	 * @param string $data
-	 * @return string
-	 */
-	public function detectString($data): string {
-		if (function_exists('finfo_open') && function_exists('finfo_file')) {
-			$finfo = finfo_open(FILEINFO_MIME);
-			$info = finfo_buffer($finfo, $data);
-			return str_contains($info, ';') ? substr($info, 0, strpos($info, ';')) : $info;
-		}
-
-		$tmpFile = \OC::$server->getTempManager()->getTemporaryFile();
-		$fh = fopen($tmpFile, 'wb');
-		fwrite($fh, $data, 8024);
-		fclose($fh);
-		$mime = $this->detect($tmpFile);
-		unset($tmpFile);
-		return $mime;
-	}
-
-	/**
-	 * Get a secure mimetype that won't expose potential XSS.
-	 *
-	 * @param string $mimeType
-	 * @return string
-	 */
-	public function getSecureMimeType($mimeType): string {
-		$this->loadMappings();
-
-		return $this->secureMimeTypes[$mimeType] ?? 'application/octet-stream';
-	}
-
-	/**
-	 * Get path to the icon of a file type
-	 * @param string $mimetype the MIME type
-	 * @return string the url
-	 */
-	public function mimeTypeIcon($mimetype): string {
-		$this->loadAliases();
-
-		while (isset($this->mimeTypeAlias[$mimetype])) {
-			$mimetype = $this->mimeTypeAlias[$mimetype];
-		}
-		if (isset($this->mimetypeIcons[$mimetype])) {
-			return $this->mimetypeIcons[$mimetype];
-		}
-
-		// Replace slash and backslash with a minus
-		$icon = str_replace(['/', '\\'], '-', $mimetype);
-
-		// Is it a dir?
-		if ($mimetype === 'dir') {
-			$this->mimetypeIcons[$mimetype] = $this->urlGenerator->imagePath('core', 'filetypes/folder.svg');
-			return $this->mimetypeIcons[$mimetype];
-		}
-		if ($mimetype === 'dir-shared') {
-			$this->mimetypeIcons[$mimetype] = $this->urlGenerator->imagePath('core', 'filetypes/folder-shared.svg');
-			return $this->mimetypeIcons[$mimetype];
-		}
-		if ($mimetype === 'dir-external') {
-			$this->mimetypeIcons[$mimetype] = $this->urlGenerator->imagePath('core', 'filetypes/folder-external.svg');
-			return $this->mimetypeIcons[$mimetype];
-		}
-
-		// Icon exists?
-		try {
-			$this->mimetypeIcons[$mimetype] = $this->urlGenerator->imagePath('core', 'filetypes/' . $icon . '.svg');
-			return $this->mimetypeIcons[$mimetype];
-		} catch (\RuntimeException $e) {
-			// Specified image not found
-		}
-
-		// Try only the first part of the filetype
-
-		if (strpos($icon, '-')) {
-			$mimePart = substr($icon, 0, strpos($icon, '-'));
-			try {
-				$this->mimetypeIcons[$mimetype] = $this->urlGenerator->imagePath('core', 'filetypes/' . $mimePart . '.svg');
-				return $this->mimetypeIcons[$mimetype];
-			} catch (\RuntimeException $e) {
-				// Image for the first part of the mimetype not found
-			}
-		}
-
-		$this->mimetypeIcons[$mimetype] = $this->urlGenerator->imagePath('core', 'filetypes/file.svg');
-		return $this->mimetypeIcons[$mimetype];
-	}
+    private const CUSTOM_MIMETYPEMAPPING = 'mimetypemapping.json';
+    private const CUSTOM_MIMETYPEALIASES = 'mimetypealiases.json';
+
+    protected $mimetypes = [];
+    protected $secureMimeTypes = [];
+
+    protected $mimetypeIcons = [];
+    /** @var string[] */
+    protected $mimeTypeAlias = [];
+
+    /** @var IURLGenerator */
+    private $urlGenerator;
+
+    private LoggerInterface $logger;
+
+    /** @var string */
+    private $customConfigDir;
+
+    /** @var string */
+    private $defaultConfigDir;
+
+    public function __construct(IURLGenerator $urlGenerator,
+                                LoggerInterface $logger,
+                                string $customConfigDir,
+                                string $defaultConfigDir) {
+        $this->urlGenerator = $urlGenerator;
+        $this->logger = $logger;
+        $this->customConfigDir = $customConfigDir;
+        $this->defaultConfigDir = $defaultConfigDir;
+    }
+
+    /**
+     * Add an extension -> mimetype mapping
+     *
+     * $mimetype is the assumed correct mime type
+     * The optional $secureMimeType is an alternative to send to send
+     * to avoid potential XSS.
+     *
+     * @param string $extension
+     * @param string $mimetype
+     * @param string|null $secureMimeType
+     */
+    public function registerType(string $extension,
+                                    string $mimetype,
+                                 ?string $secureMimeType = null): void {
+        $this->mimetypes[$extension] = [$mimetype, $secureMimeType];
+        $this->secureMimeTypes[$mimetype] = $secureMimeType ?: $mimetype;
+    }
+
+    /**
+     * Add an array of extension -> mimetype mappings
+     *
+     * The mimetype value is in itself an array where the first index is
+     * the assumed correct mimetype and the second is either a secure alternative
+     * or null if the correct is considered secure.
+     *
+     * @param array $types
+     */
+    public function registerTypeArray(array $types): void {
+        $this->mimetypes = array_merge($this->mimetypes, $types);
+
+        // Update the alternative mimetypes to avoid having to look them up each time.
+        foreach ($this->mimetypes as $extension => $mimeType) {
+            if (str_starts_with($extension, '_comment')) {
+                continue;
+            }
+            $this->secureMimeTypes[$mimeType[0]] = $mimeType[1] ?? $mimeType[0];
+            if (isset($mimeType[1])) {
+                $this->secureMimeTypes[$mimeType[1]] = $mimeType[1];
+            }
+        }
+    }
+
+    private function loadCustomDefinitions(string $fileName, array $definitions): array {
+        if (file_exists($this->customConfigDir . '/' . $fileName)) {
+            $custom = json_decode(file_get_contents($this->customConfigDir . '/' . $fileName), true);
+            if (json_last_error() === JSON_ERROR_NONE) {
+                $definitions = array_merge($definitions, $custom);
+            } else {
+                $this->logger->warning('Failed to parse ' . $fileName . ': ' . json_last_error_msg());
+            }
+        }
+        return $definitions;
+    }
+
+    /**
+     * Add the mimetype aliases if they are not yet present
+     */
+    private function loadAliases(): void {
+        if (!empty($this->mimeTypeAlias)) {
+            return;
+        }
+
+        $this->mimeTypeAlias = json_decode(file_get_contents($this->defaultConfigDir . '/mimetypealiases.dist.json'), true);
+        $this->mimeTypeAlias = $this->loadCustomDefinitions(self::CUSTOM_MIMETYPEALIASES, $this->mimeTypeAlias);
+    }
+
+    /**
+     * @return string[]
+     */
+    public function getAllAliases(): array {
+        $this->loadAliases();
+        return $this->mimeTypeAlias;
+    }
+
+    public function getOnlyDefaultAliases(): array {
+        $this->loadMappings();
+        $this->mimeTypeAlias = json_decode(file_get_contents($this->defaultConfigDir . '/mimetypealiases.dist.json'), true);
+        return $this->mimeTypeAlias;
+    }
+
+    /**
+     * Add mimetype mappings if they are not yet present
+     */
+    private function loadMappings(): void {
+        if (!empty($this->mimetypes)) {
+            return;
+        }
+
+        $mimetypeMapping = json_decode(file_get_contents($this->defaultConfigDir . '/mimetypemapping.dist.json'), true);
+        $mimetypeMapping = $this->loadCustomDefinitions(self::CUSTOM_MIMETYPEMAPPING, $mimetypeMapping);
+
+        $this->registerTypeArray($mimetypeMapping);
+    }
+
+    /**
+     * @return array
+     */
+    public function getAllMappings(): array {
+        $this->loadMappings();
+        return $this->mimetypes;
+    }
+
+    /**
+     * detect mimetype only based on filename, content of file is not used
+     *
+     * @param string $path
+     * @return string
+     */
+    public function detectPath($path): string {
+        $this->loadMappings();
+
+        $fileName = basename($path);
+
+        // remove leading dot on hidden files with a file extension
+        $fileName = ltrim($fileName, '.');
+
+        // note: leading dot doesn't qualify as extension
+        if (strpos($fileName, '.') > 0) {
+            // remove versioning extension: name.v1508946057 and transfer extension: name.ocTransferId2057600214.part
+            $fileName = preg_replace('!((\.v\d+)|((\.ocTransferId\d+)?\.part))$!', '', $fileName);
+
+            //try to guess the type by the file extension
+            $extension = strrchr($fileName, '.');
+            if ($extension !== false) {
+                $extension = strtolower($extension);
+                $extension = substr($extension, 1); //remove leading .
+                return $this->mimetypes[$extension][0] ?? 'application/octet-stream';
+            }
+        }
+
+        return 'application/octet-stream';
+    }
+
+    /**
+     * detect mimetype only based on the content of file
+     * @param string $path
+     * @return string
+     * @since 18.0.0
+     */
+    public function detectContent(string $path): string {
+        $this->loadMappings();
+
+        if (@is_dir($path)) {
+            // directories are easy
+            return 'httpd/unix-directory';
+        }
+
+        if (function_exists('finfo_open')
+            && function_exists('finfo_file')
+            && $finfo = finfo_open(FILEINFO_MIME)) {
+            $info = @finfo_file($finfo, $path);
+            finfo_close($finfo);
+            if ($info) {
+                $info = strtolower($info);
+                $mimeType = str_contains($info, ';') ? substr($info, 0, strpos($info, ';')) : $info;
+                $mimeType = $this->getSecureMimeType($mimeType);
+                if ($mimeType !== 'application/octet-stream') {
+                    return $mimeType;
+                }
+            }
+        }
+
+        if (str_starts_with($path, 'file://')) {
+            // Is the file wrapped in a stream?
+            return 'application/octet-stream';
+        }
+
+        if (function_exists('mime_content_type')) {
+            // use mime magic extension if available
+            $mimeType = mime_content_type($path);
+            if ($mimeType !== false) {
+                $mimeType = $this->getSecureMimeType($mimeType);
+                if ($mimeType !== 'application/octet-stream') {
+                    return $mimeType;
+                }
+            }
+        }
+
+        if (\OC_Helper::canExecute('file')) {
+            // it looks like we have a 'file' command,
+            // lets see if it does have mime support
+            $path = escapeshellarg($path);
+            $fp = popen("test -f $path && file -b --mime-type $path", 'r');
+            $mimeType = fgets($fp);
+            pclose($fp);
+
+            if ($mimeType !== false) {
+                //trim the newline
+                $mimeType = trim($mimeType);
+                $mimeType = $this->getSecureMimeType($mimeType);
+                if ($mimeType !== 'application/octet-stream') {
+                    return $mimeType;
+                }
+            }
+        }
+        return 'application/octet-stream';
+    }
+
+    /**
+     * detect mimetype based on both filename and content
+     *
+     * @param string $path
+     * @return string
+     */
+    public function detect($path): string {
+        $mimeType = $this->detectPath($path);
+
+        if ($mimeType !== 'application/octet-stream') {
+            return $mimeType;
+        }
+
+        return $this->detectContent($path);
+    }
+
+    /**
+     * detect mimetype based on the content of a string
+     *
+     * @param string $data
+     * @return string
+     */
+    public function detectString($data): string {
+        if (function_exists('finfo_open') && function_exists('finfo_file')) {
+            $finfo = finfo_open(FILEINFO_MIME);
+            $info = finfo_buffer($finfo, $data);
+            return str_contains($info, ';') ? substr($info, 0, strpos($info, ';')) : $info;
+        }
+
+        $tmpFile = \OC::$server->getTempManager()->getTemporaryFile();
+        $fh = fopen($tmpFile, 'wb');
+        fwrite($fh, $data, 8024);
+        fclose($fh);
+        $mime = $this->detect($tmpFile);
+        unset($tmpFile);
+        return $mime;
+    }
+
+    /**
+     * Get a secure mimetype that won't expose potential XSS.
+     *
+     * @param string $mimeType
+     * @return string
+     */
+    public function getSecureMimeType($mimeType): string {
+        $this->loadMappings();
+
+        return $this->secureMimeTypes[$mimeType] ?? 'application/octet-stream';
+    }
+
+    /**
+     * Get path to the icon of a file type
+     * @param string $mimetype the MIME type
+     * @return string the url
+     */
+    public function mimeTypeIcon($mimetype): string {
+        $this->loadAliases();
+
+        while (isset($this->mimeTypeAlias[$mimetype])) {
+            $mimetype = $this->mimeTypeAlias[$mimetype];
+        }
+        if (isset($this->mimetypeIcons[$mimetype])) {
+            return $this->mimetypeIcons[$mimetype];
+        }
+
+        // Replace slash and backslash with a minus
+        $icon = str_replace(['/', '\\'], '-', $mimetype);
+
+        // Is it a dir?
+        if ($mimetype === 'dir') {
+            $this->mimetypeIcons[$mimetype] = $this->urlGenerator->imagePath('core', 'filetypes/folder.svg');
+            return $this->mimetypeIcons[$mimetype];
+        }
+        if ($mimetype === 'dir-shared') {
+            $this->mimetypeIcons[$mimetype] = $this->urlGenerator->imagePath('core', 'filetypes/folder-shared.svg');
+            return $this->mimetypeIcons[$mimetype];
+        }
+        if ($mimetype === 'dir-external') {
+            $this->mimetypeIcons[$mimetype] = $this->urlGenerator->imagePath('core', 'filetypes/folder-external.svg');
+            return $this->mimetypeIcons[$mimetype];
+        }
+
+        // Icon exists?
+        try {
+            $this->mimetypeIcons[$mimetype] = $this->urlGenerator->imagePath('core', 'filetypes/' . $icon . '.svg');
+            return $this->mimetypeIcons[$mimetype];
+        } catch (\RuntimeException $e) {
+            // Specified image not found
+        }
+
+        // Try only the first part of the filetype
+
+        if (strpos($icon, '-')) {
+            $mimePart = substr($icon, 0, strpos($icon, '-'));
+            try {
+                $this->mimetypeIcons[$mimetype] = $this->urlGenerator->imagePath('core', 'filetypes/' . $mimePart . '.svg');
+                return $this->mimetypeIcons[$mimetype];
+            } catch (\RuntimeException $e) {
+                // Image for the first part of the mimetype not found
+            }
+        }
+
+        $this->mimetypeIcons[$mimetype] = $this->urlGenerator->imagePath('core', 'filetypes/file.svg');
+        return $this->mimetypeIcons[$mimetype];
+    }
 }

lib/private/Files/Mount/MountPoint.php

Indentation +250 added lines, -250 removed lines

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

Spacing +5 added lines, -5 removed lines

@@ -122,7 +122,7 @@ 
 		} else {
 			// Update old classes to new namespace
 			if (str_contains($storage, 'OC_Filestorage_')) {
-				$storage = '\OC\Files\Storage\\' . substr($storage, 15);
+				$storage = '\OC\Files\Storage\\'.substr($storage, 15);
 			}
 			$this->class = $storage;
 			$this->arguments = $arguments;
@@ -179,7 +179,7 @@ 
 				return;
 			}
 		} else {
-			\OC::$server->get(LoggerInterface::class)->error('Storage backend ' . $this->class . ' not found', ['app' => 'core']);
+			\OC::$server->get(LoggerInterface::class)->error('Storage backend '.$this->class.' not found', ['app' => 'core']);
 			$this->invalidStorage = true;
 			return;
 		}
@@ -232,13 +232,13 @@ 
 	 */
 	public function getInternalPath($path) {
 		$path = Filesystem::normalizePath($path, true, false, true);
-		if ($this->mountPoint === $path or $this->mountPoint . '/' === $path) {
+		if ($this->mountPoint === $path or $this->mountPoint.'/' === $path) {
 			$internalPath = '';
 		} else {
 			$internalPath = substr($path, strlen($this->mountPoint));
 		}
 		// substr returns false instead of an empty string, we always want a string
-		return (string)$internalPath;
+		return (string) $internalPath;
 	}
 
 	/**
@@ -296,7 +296,7 @@ 
 			if ($storage === null) {
 				$this->rootId = -1;
 			} else {
-				$this->rootId = (int)$storage->getCache()->getId('');
+				$this->rootId = (int) $storage->getCache()->getId('');
 			}
 		}
 		return $this->rootId;

lib/private/Files/Mount/RootMountProvider.php

Indentation +67 added lines, -67 removed lines

@@ -33,71 +33,71 @@
 use Psr\Log\LoggerInterface;
 
 class RootMountProvider implements IRootMountProvider {
-	private IConfig $config;
-	private LoggerInterface $logger;
-
-	public function __construct(IConfig $config, LoggerInterface $logger) {
-		$this->config = $config;
-		$this->logger = $logger;
-	}
-
-	public function getRootMounts(IStorageFactory $loader): array {
-		$objectStore = $this->config->getSystemValue('objectstore', null);
-		$objectStoreMultiBucket = $this->config->getSystemValue('objectstore_multibucket', null);
-
-		if ($objectStoreMultiBucket) {
-			return [$this->getMultiBucketStoreRootMount($loader, $objectStoreMultiBucket)];
-		} elseif ($objectStore) {
-			return [$this->getObjectStoreRootMount($loader, $objectStore)];
-		} else {
-			return [$this->getLocalRootMount($loader)];
-		}
-	}
-
-	private function validateObjectStoreConfig(array &$config) {
-		if (empty($config['class'])) {
-			$this->logger->error('No class given for objectstore', ['app' => 'files']);
-		}
-		if (!isset($config['arguments'])) {
-			$config['arguments'] = [];
-		}
-
-		// instantiate object store implementation
-		$name = $config['class'];
-		if (str_starts_with($name, 'OCA\\') && substr_count($name, '\\') >= 2) {
-			$segments = explode('\\', $name);
-			OC_App::loadApp(strtolower($segments[1]));
-		}
-	}
-
-	private function getLocalRootMount(IStorageFactory $loader): MountPoint {
-		$configDataDirectory = $this->config->getSystemValue("datadirectory", OC::$SERVERROOT . "/data");
-		return new MountPoint(LocalRootStorage::class, '/', ['datadir' => $configDataDirectory], $loader, null, null, self::class);
-	}
-
-	private function getObjectStoreRootMount(IStorageFactory $loader, array $config): MountPoint {
-		$this->validateObjectStoreConfig($config);
-
-		$config['arguments']['objectstore'] = new $config['class']($config['arguments']);
-		// mount with plain / root object store implementation
-		$config['class'] = ObjectStoreStorage::class;
-
-		return new MountPoint($config['class'], '/', $config['arguments'], $loader, null, null, self::class);
-	}
-
-	private function getMultiBucketStoreRootMount(IStorageFactory $loader, array $config): MountPoint {
-		$this->validateObjectStoreConfig($config);
-
-		if (!isset($config['arguments']['bucket'])) {
-			$config['arguments']['bucket'] = '';
-		}
-		// put the root FS always in first bucket for multibucket configuration
-		$config['arguments']['bucket'] .= '0';
-
-		$config['arguments']['objectstore'] = new $config['class']($config['arguments']);
-		// mount with plain / root object store implementation
-		$config['class'] = ObjectStoreStorage::class;
-
-		return new MountPoint($config['class'], '/', $config['arguments'], $loader, null, null, self::class);
-	}
+    private IConfig $config;
+    private LoggerInterface $logger;
+
+    public function __construct(IConfig $config, LoggerInterface $logger) {
+        $this->config = $config;
+        $this->logger = $logger;
+    }
+
+    public function getRootMounts(IStorageFactory $loader): array {
+        $objectStore = $this->config->getSystemValue('objectstore', null);
+        $objectStoreMultiBucket = $this->config->getSystemValue('objectstore_multibucket', null);
+
+        if ($objectStoreMultiBucket) {
+            return [$this->getMultiBucketStoreRootMount($loader, $objectStoreMultiBucket)];
+        } elseif ($objectStore) {
+            return [$this->getObjectStoreRootMount($loader, $objectStore)];
+        } else {
+            return [$this->getLocalRootMount($loader)];
+        }
+    }
+
+    private function validateObjectStoreConfig(array &$config) {
+        if (empty($config['class'])) {
+            $this->logger->error('No class given for objectstore', ['app' => 'files']);
+        }
+        if (!isset($config['arguments'])) {
+            $config['arguments'] = [];
+        }
+
+        // instantiate object store implementation
+        $name = $config['class'];
+        if (str_starts_with($name, 'OCA\\') && substr_count($name, '\\') >= 2) {
+            $segments = explode('\\', $name);
+            OC_App::loadApp(strtolower($segments[1]));
+        }
+    }
+
+    private function getLocalRootMount(IStorageFactory $loader): MountPoint {
+        $configDataDirectory = $this->config->getSystemValue("datadirectory", OC::$SERVERROOT . "/data");
+        return new MountPoint(LocalRootStorage::class, '/', ['datadir' => $configDataDirectory], $loader, null, null, self::class);
+    }
+
+    private function getObjectStoreRootMount(IStorageFactory $loader, array $config): MountPoint {
+        $this->validateObjectStoreConfig($config);
+
+        $config['arguments']['objectstore'] = new $config['class']($config['arguments']);
+        // mount with plain / root object store implementation
+        $config['class'] = ObjectStoreStorage::class;
+
+        return new MountPoint($config['class'], '/', $config['arguments'], $loader, null, null, self::class);
+    }
+
+    private function getMultiBucketStoreRootMount(IStorageFactory $loader, array $config): MountPoint {
+        $this->validateObjectStoreConfig($config);
+
+        if (!isset($config['arguments']['bucket'])) {
+            $config['arguments']['bucket'] = '';
+        }
+        // put the root FS always in first bucket for multibucket configuration
+        $config['arguments']['bucket'] .= '0';
+
+        $config['arguments']['objectstore'] = new $config['class']($config['arguments']);
+        // mount with plain / root object store implementation
+        $config['class'] = ObjectStoreStorage::class;
+
+        return new MountPoint($config['class'], '/', $config['arguments'], $loader, null, null, self::class);
+    }
 }

lib/private/Files/ObjectStore/S3Signature.php

Indentation +184 added lines, -184 removed lines

@@ -35,188 +35,188 @@
  * Legacy Amazon S3 signature implementation
  */
 class S3Signature implements SignatureInterface {
-	/** @var array Query string values that must be signed */
-	private $signableQueryString = [
-		'acl', 'cors', 'delete', 'lifecycle', 'location', 'logging',
-		'notification', 'partNumber', 'policy', 'requestPayment',
-		'response-cache-control', 'response-content-disposition',
-		'response-content-encoding', 'response-content-language',
-		'response-content-type', 'response-expires', 'restore', 'tagging',
-		'torrent', 'uploadId', 'uploads', 'versionId', 'versioning',
-		'versions', 'website'
-	];
-
-	/** @var array Sorted headers that must be signed */
-	private $signableHeaders = ['Content-MD5', 'Content-Type'];
-
-	/** @var \Aws\S3\S3UriParser S3 URI parser */
-	private $parser;
-
-	public function __construct() {
-		$this->parser = new S3UriParser();
-		// Ensure that the signable query string parameters are sorted
-		sort($this->signableQueryString);
-	}
-
-	public function signRequest(
-		RequestInterface $request,
-		CredentialsInterface $credentials
-	) {
-		$request = $this->prepareRequest($request, $credentials);
-		$stringToSign = $this->createCanonicalizedString($request);
-		$auth = 'AWS '
-			. $credentials->getAccessKeyId() . ':'
-			. $this->signString($stringToSign, $credentials);
-
-		return $request->withHeader('Authorization', $auth);
-	}
-
-	public function presign(
-		RequestInterface $request,
-		CredentialsInterface $credentials,
-		$expires,
-		array $options = []
-	) {
-		$query = [];
-		// URL encoding already occurs in the URI template expansion. Undo that
-		// and encode using the same encoding as GET object, PUT object, etc.
-		$uri = $request->getUri();
-		$path = S3Client::encodeKey(rawurldecode($uri->getPath()));
-		$request = $request->withUri($uri->withPath($path));
-
-		// Make sure to handle temporary credentials
-		if ($token = $credentials->getSecurityToken()) {
-			$request = $request->withHeader('X-Amz-Security-Token', $token);
-			$query['X-Amz-Security-Token'] = $token;
-		}
-
-		if ($expires instanceof \DateTime) {
-			$expires = $expires->getTimestamp();
-		} elseif (!is_numeric($expires)) {
-			$expires = strtotime($expires);
-		}
-
-		// Set query params required for pre-signed URLs
-		$query['AWSAccessKeyId'] = $credentials->getAccessKeyId();
-		$query['Expires'] = $expires;
-		$query['Signature'] = $this->signString(
-			$this->createCanonicalizedString($request, $expires),
-			$credentials
-		);
-
-		// Move X-Amz-* headers to the query string
-		foreach ($request->getHeaders() as $name => $header) {
-			$name = strtolower($name);
-			if (str_starts_with($name, 'x-amz-')) {
-				$query[$name] = implode(',', $header);
-			}
-		}
-
-		$queryString = http_build_query($query, null, '&', PHP_QUERY_RFC3986);
-
-		return $request->withUri($request->getUri()->withQuery($queryString));
-	}
-
-	/**
-	 * @param RequestInterface     $request
-	 * @param CredentialsInterface $creds
-	 *
-	 * @return RequestInterface
-	 */
-	private function prepareRequest(
-		RequestInterface $request,
-		CredentialsInterface $creds
-	) {
-		$modify = [
-			'remove_headers' => ['X-Amz-Date'],
-			'set_headers' => ['Date' => gmdate(\DateTimeInterface::RFC2822)]
-		];
-
-		// Add the security token header if one is being used by the credentials
-		if ($token = $creds->getSecurityToken()) {
-			$modify['set_headers']['X-Amz-Security-Token'] = $token;
-		}
-
-		return Psr7\Utils::modifyRequest($request, $modify);
-	}
-
-	private function signString($string, CredentialsInterface $credentials) {
-		return base64_encode(
-			hash_hmac('sha1', $string, $credentials->getSecretKey(), true)
-		);
-	}
-
-	private function createCanonicalizedString(
-		RequestInterface $request,
-		$expires = null
-	) {
-		$buffer = $request->getMethod() . "\n";
-
-		// Add the interesting headers
-		foreach ($this->signableHeaders as $header) {
-			$buffer .= $request->getHeaderLine($header) . "\n";
-		}
-
-		$date = $expires ?: $request->getHeaderLine('date');
-		$buffer .= "{$date}\n"
-			. $this->createCanonicalizedAmzHeaders($request)
-			. $this->createCanonicalizedResource($request);
-
-		return $buffer;
-	}
-
-	private function createCanonicalizedAmzHeaders(RequestInterface $request) {
-		$headers = [];
-		foreach ($request->getHeaders() as $name => $header) {
-			$name = strtolower($name);
-			if (str_starts_with($name, 'x-amz-')) {
-				$value = implode(',', $header);
-				if (strlen($value) > 0) {
-					$headers[$name] = $name . ':' . $value;
-				}
-			}
-		}
-
-		if (!$headers) {
-			return '';
-		}
-
-		ksort($headers);
-
-		return implode("\n", $headers) . "\n";
-	}
-
-	private function createCanonicalizedResource(RequestInterface $request) {
-		$data = $this->parser->parse($request->getUri());
-		$buffer = '/';
-
-		if ($data['bucket']) {
-			$buffer .= $data['bucket'];
-			if (!empty($data['key']) || !$data['path_style']) {
-				$buffer .= '/' . $data['key'];
-			}
-		}
-
-		// Add sub resource parameters if present.
-		$query = $request->getUri()->getQuery();
-
-		if ($query) {
-			$params = Psr7\Query::parse($query);
-			$first = true;
-			foreach ($this->signableQueryString as $key) {
-				if (array_key_exists($key, $params)) {
-					$value = $params[$key];
-					$buffer .= $first ? '?' : '&';
-					$first = false;
-					$buffer .= $key;
-					// Don't add values for empty sub-resources
-					if (strlen($value)) {
-						$buffer .= "={$value}";
-					}
-				}
-			}
-		}
-
-		return $buffer;
-	}
+    /** @var array Query string values that must be signed */
+    private $signableQueryString = [
+        'acl', 'cors', 'delete', 'lifecycle', 'location', 'logging',
+        'notification', 'partNumber', 'policy', 'requestPayment',
+        'response-cache-control', 'response-content-disposition',
+        'response-content-encoding', 'response-content-language',
+        'response-content-type', 'response-expires', 'restore', 'tagging',
+        'torrent', 'uploadId', 'uploads', 'versionId', 'versioning',
+        'versions', 'website'
+    ];
+
+    /** @var array Sorted headers that must be signed */
+    private $signableHeaders = ['Content-MD5', 'Content-Type'];
+
+    /** @var \Aws\S3\S3UriParser S3 URI parser */
+    private $parser;
+
+    public function __construct() {
+        $this->parser = new S3UriParser();
+        // Ensure that the signable query string parameters are sorted
+        sort($this->signableQueryString);
+    }
+
+    public function signRequest(
+        RequestInterface $request,
+        CredentialsInterface $credentials
+    ) {
+        $request = $this->prepareRequest($request, $credentials);
+        $stringToSign = $this->createCanonicalizedString($request);
+        $auth = 'AWS '
+            . $credentials->getAccessKeyId() . ':'
+            . $this->signString($stringToSign, $credentials);
+
+        return $request->withHeader('Authorization', $auth);
+    }
+
+    public function presign(
+        RequestInterface $request,
+        CredentialsInterface $credentials,
+        $expires,
+        array $options = []
+    ) {
+        $query = [];
+        // URL encoding already occurs in the URI template expansion. Undo that
+        // and encode using the same encoding as GET object, PUT object, etc.
+        $uri = $request->getUri();
+        $path = S3Client::encodeKey(rawurldecode($uri->getPath()));
+        $request = $request->withUri($uri->withPath($path));
+
+        // Make sure to handle temporary credentials
+        if ($token = $credentials->getSecurityToken()) {
+            $request = $request->withHeader('X-Amz-Security-Token', $token);
+            $query['X-Amz-Security-Token'] = $token;
+        }
+
+        if ($expires instanceof \DateTime) {
+            $expires = $expires->getTimestamp();
+        } elseif (!is_numeric($expires)) {
+            $expires = strtotime($expires);
+        }
+
+        // Set query params required for pre-signed URLs
+        $query['AWSAccessKeyId'] = $credentials->getAccessKeyId();
+        $query['Expires'] = $expires;
+        $query['Signature'] = $this->signString(
+            $this->createCanonicalizedString($request, $expires),
+            $credentials
+        );
+
+        // Move X-Amz-* headers to the query string
+        foreach ($request->getHeaders() as $name => $header) {
+            $name = strtolower($name);
+            if (str_starts_with($name, 'x-amz-')) {
+                $query[$name] = implode(',', $header);
+            }
+        }
+
+        $queryString = http_build_query($query, null, '&', PHP_QUERY_RFC3986);
+
+        return $request->withUri($request->getUri()->withQuery($queryString));
+    }
+
+    /**
+     * @param RequestInterface     $request
+     * @param CredentialsInterface $creds
+     *
+     * @return RequestInterface
+     */
+    private function prepareRequest(
+        RequestInterface $request,
+        CredentialsInterface $creds
+    ) {
+        $modify = [
+            'remove_headers' => ['X-Amz-Date'],
+            'set_headers' => ['Date' => gmdate(\DateTimeInterface::RFC2822)]
+        ];
+
+        // Add the security token header if one is being used by the credentials
+        if ($token = $creds->getSecurityToken()) {
+            $modify['set_headers']['X-Amz-Security-Token'] = $token;
+        }
+
+        return Psr7\Utils::modifyRequest($request, $modify);
+    }
+
+    private function signString($string, CredentialsInterface $credentials) {
+        return base64_encode(
+            hash_hmac('sha1', $string, $credentials->getSecretKey(), true)
+        );
+    }
+
+    private function createCanonicalizedString(
+        RequestInterface $request,
+        $expires = null
+    ) {
+        $buffer = $request->getMethod() . "\n";
+
+        // Add the interesting headers
+        foreach ($this->signableHeaders as $header) {
+            $buffer .= $request->getHeaderLine($header) . "\n";
+        }
+
+        $date = $expires ?: $request->getHeaderLine('date');
+        $buffer .= "{$date}\n"
+            . $this->createCanonicalizedAmzHeaders($request)
+            . $this->createCanonicalizedResource($request);
+
+        return $buffer;
+    }
+
+    private function createCanonicalizedAmzHeaders(RequestInterface $request) {
+        $headers = [];
+        foreach ($request->getHeaders() as $name => $header) {
+            $name = strtolower($name);
+            if (str_starts_with($name, 'x-amz-')) {
+                $value = implode(',', $header);
+                if (strlen($value) > 0) {
+                    $headers[$name] = $name . ':' . $value;
+                }
+            }
+        }
+
+        if (!$headers) {
+            return '';
+        }
+
+        ksort($headers);
+
+        return implode("\n", $headers) . "\n";
+    }
+
+    private function createCanonicalizedResource(RequestInterface $request) {
+        $data = $this->parser->parse($request->getUri());
+        $buffer = '/';
+
+        if ($data['bucket']) {
+            $buffer .= $data['bucket'];
+            if (!empty($data['key']) || !$data['path_style']) {
+                $buffer .= '/' . $data['key'];
+            }
+        }
+
+        // Add sub resource parameters if present.
+        $query = $request->getUri()->getQuery();
+
+        if ($query) {
+            $params = Psr7\Query::parse($query);
+            $first = true;
+            foreach ($this->signableQueryString as $key) {
+                if (array_key_exists($key, $params)) {
+                    $value = $params[$key];
+                    $buffer .= $first ? '?' : '&';
+                    $first = false;
+                    $buffer .= $key;
+                    // Don't add values for empty sub-resources
+                    if (strlen($value)) {
+                        $buffer .= "={$value}";
+                    }
+                }
+            }
+        }
+
+        return $buffer;
+    }
 }

Spacing +6 added lines, -6 removed lines

@@ -65,7 +65,7 @@ 
 		$request = $this->prepareRequest($request, $credentials);
 		$stringToSign = $this->createCanonicalizedString($request);
 		$auth = 'AWS '
-			. $credentials->getAccessKeyId() . ':'
+			. $credentials->getAccessKeyId().':'
 			. $this->signString($stringToSign, $credentials);
 
 		return $request->withHeader('Authorization', $auth);
@@ -150,11 +150,11 @@ 
 		RequestInterface $request,
 		$expires = null
 	) {
-		$buffer = $request->getMethod() . "\n";
+		$buffer = $request->getMethod()."\n";
 
 		// Add the interesting headers
 		foreach ($this->signableHeaders as $header) {
-			$buffer .= $request->getHeaderLine($header) . "\n";
+			$buffer .= $request->getHeaderLine($header)."\n";
 		}
 
 		$date = $expires ?: $request->getHeaderLine('date');
@@ -172,7 +172,7 @@ 
 			if (str_starts_with($name, 'x-amz-')) {
 				$value = implode(',', $header);
 				if (strlen($value) > 0) {
-					$headers[$name] = $name . ':' . $value;
+					$headers[$name] = $name.':'.$value;
 				}
 			}
 		}
@@ -183,7 +183,7 @@ 
 
 		ksort($headers);
 
-		return implode("\n", $headers) . "\n";
+		return implode("\n", $headers)."\n";
 	}
 
 	private function createCanonicalizedResource(RequestInterface $request) {
@@ -193,7 +193,7 @@ 
 		if ($data['bucket']) {
 			$buffer .= $data['bucket'];
 			if (!empty($data['key']) || !$data['path_style']) {
-				$buffer .= '/' . $data['key'];
+				$buffer .= '/'.$data['key'];
 			}
 		}