nextcloud / server

apps/files_external/lib/Config/ConfigAdapter.php

Indentation +138 added lines, -138 removed lines

@@ -48,142 +48,142 @@
  */
 class ConfigAdapter implements IMountProvider {
 
-	/** @var UserStoragesService */
-	private $userStoragesService;
-
-	/** @var UserGlobalStoragesService */
-	private $userGlobalStoragesService;
-	/** @var StorageMigrator  */
-	private $migrator;
-
-	/**
-	 * @param UserStoragesService $userStoragesService
-	 * @param UserGlobalStoragesService $userGlobalStoragesService
-	 * @param StorageMigrator $migrator
-	 */
-	public function __construct(
-		UserStoragesService $userStoragesService,
-		UserGlobalStoragesService $userGlobalStoragesService,
-		StorageMigrator $migrator
-	) {
-		$this->userStoragesService = $userStoragesService;
-		$this->userGlobalStoragesService = $userGlobalStoragesService;
-		$this->migrator = $migrator;
-	}
-
-	/**
-	 * Process storage ready for mounting
-	 *
-	 * @param StorageConfig $storage
-	 * @param IUser $user
-	 * @throws \OCP\AppFramework\QueryException
-	 */
-	private function prepareStorageConfig(StorageConfig &$storage, IUser $user) {
-		foreach ($storage->getBackendOptions() as $option => $value) {
-			$storage->setBackendOption($option, \OCA\Files_External\MountConfig::substitutePlaceholdersInConfig($value, $user->getUID()));
-		}
-
-		$objectStore = $storage->getBackendOption('objectstore');
-		if ($objectStore) {
-			$objectClass = $objectStore['class'];
-			if (!is_subclass_of($objectClass, '\OCP\Files\ObjectStore\IObjectStore')) {
-				throw new \InvalidArgumentException('Invalid object store');
-			}
-			$storage->setBackendOption('objectstore', new $objectClass($objectStore));
-		}
-
-		$storage->getAuthMechanism()->manipulateStorageConfig($storage, $user);
-		$storage->getBackend()->manipulateStorageConfig($storage, $user);
-	}
-
-	/**
-	 * Construct the storage implementation
-	 *
-	 * @param StorageConfig $storageConfig
-	 * @return Storage
-	 */
-	private function constructStorage(StorageConfig $storageConfig) {
-		$class = $storageConfig->getBackend()->getStorageClass();
-		$storage = new $class($storageConfig->getBackendOptions());
-
-		// auth mechanism should fire first
-		$storage = $storageConfig->getBackend()->wrapStorage($storage);
-		$storage = $storageConfig->getAuthMechanism()->wrapStorage($storage);
-
-		return $storage;
-	}
-
-	/**
-	 * Get all mountpoints applicable for the user
-	 *
-	 * @param \OCP\IUser $user
-	 * @param \OCP\Files\Storage\IStorageFactory $loader
-	 * @return \OCP\Files\Mount\IMountPoint[]
-	 */
-	public function getMountsForUser(IUser $user, IStorageFactory $loader) {
-		$this->migrator->migrateUser($user);
-
-		$this->userStoragesService->setUser($user);
-		$this->userGlobalStoragesService->setUser($user);
-
-		$storageConfigs = $this->userGlobalStoragesService->getAllStoragesForUser();
-
-		$storages = array_map(function (StorageConfig $storageConfig) use ($user) {
-			try {
-				$this->prepareStorageConfig($storageConfig, $user);
-				return $this->constructStorage($storageConfig);
-			} catch (\Exception $e) {
-				// propagate exception into filesystem
-				return new FailedStorage(['exception' => $e]);
-			}
-		}, $storageConfigs);
-
-
-		\OC\Files\Cache\Storage::getGlobalCache()->loadForStorageIds(array_map(function (Storage\IStorage $storage) {
-			return $storage->getId();
-		}, $storages));
-
-		$availableStorages = array_map(function (Storage\IStorage $storage, StorageConfig $storageConfig) {
-			try {
-				$availability = $storage->getAvailability();
-				if (!$availability['available'] && !Availability::shouldRecheck($availability)) {
-					$storage = new FailedStorage([
-						'exception' => new StorageNotAvailableException('Storage with mount id ' . $storageConfig->getId() . ' is not available')
-					]);
-				}
-			} catch (\Exception $e) {
-				// propagate exception into filesystem
-				$storage = new FailedStorage(['exception' => $e]);
-			}
-			return $storage;
-		}, $storages, $storageConfigs);
-
-		$mounts = array_map(function (StorageConfig $storageConfig, Storage\IStorage $storage) use ($user, $loader) {
-			if ($storageConfig->getType() === StorageConfig::MOUNT_TYPE_PERSONAl) {
-				return new PersonalMount(
-					$this->userStoragesService,
-					$storageConfig->getId(),
-					$storage,
-					'/' . $user->getUID() . '/files' . $storageConfig->getMountPoint(),
-					null,
-					$loader,
-					$storageConfig->getMountOptions()
-				);
-			} else {
-				return new ExternalMountPoint(
-					$storage,
-					'/' . $user->getUID() . '/files' . $storageConfig->getMountPoint(),
-					null,
-					$loader,
-					$storageConfig->getMountOptions(),
-					$storageConfig->getId()
-				);
-			}
-		}, $storageConfigs, $availableStorages);
-
-		$this->userStoragesService->resetUser();
-		$this->userGlobalStoragesService->resetUser();
-
-		return $mounts;
-	}
+    /** @var UserStoragesService */
+    private $userStoragesService;
+
+    /** @var UserGlobalStoragesService */
+    private $userGlobalStoragesService;
+    /** @var StorageMigrator  */
+    private $migrator;
+
+    /**
+     * @param UserStoragesService $userStoragesService
+     * @param UserGlobalStoragesService $userGlobalStoragesService
+     * @param StorageMigrator $migrator
+     */
+    public function __construct(
+        UserStoragesService $userStoragesService,
+        UserGlobalStoragesService $userGlobalStoragesService,
+        StorageMigrator $migrator
+    ) {
+        $this->userStoragesService = $userStoragesService;
+        $this->userGlobalStoragesService = $userGlobalStoragesService;
+        $this->migrator = $migrator;
+    }
+
+    /**
+     * Process storage ready for mounting
+     *
+     * @param StorageConfig $storage
+     * @param IUser $user
+     * @throws \OCP\AppFramework\QueryException
+     */
+    private function prepareStorageConfig(StorageConfig &$storage, IUser $user) {
+        foreach ($storage->getBackendOptions() as $option => $value) {
+            $storage->setBackendOption($option, \OCA\Files_External\MountConfig::substitutePlaceholdersInConfig($value, $user->getUID()));
+        }
+
+        $objectStore = $storage->getBackendOption('objectstore');
+        if ($objectStore) {
+            $objectClass = $objectStore['class'];
+            if (!is_subclass_of($objectClass, '\OCP\Files\ObjectStore\IObjectStore')) {
+                throw new \InvalidArgumentException('Invalid object store');
+            }
+            $storage->setBackendOption('objectstore', new $objectClass($objectStore));
+        }
+
+        $storage->getAuthMechanism()->manipulateStorageConfig($storage, $user);
+        $storage->getBackend()->manipulateStorageConfig($storage, $user);
+    }
+
+    /**
+     * Construct the storage implementation
+     *
+     * @param StorageConfig $storageConfig
+     * @return Storage
+     */
+    private function constructStorage(StorageConfig $storageConfig) {
+        $class = $storageConfig->getBackend()->getStorageClass();
+        $storage = new $class($storageConfig->getBackendOptions());
+
+        // auth mechanism should fire first
+        $storage = $storageConfig->getBackend()->wrapStorage($storage);
+        $storage = $storageConfig->getAuthMechanism()->wrapStorage($storage);
+
+        return $storage;
+    }
+
+    /**
+     * Get all mountpoints applicable for the user
+     *
+     * @param \OCP\IUser $user
+     * @param \OCP\Files\Storage\IStorageFactory $loader
+     * @return \OCP\Files\Mount\IMountPoint[]
+     */
+    public function getMountsForUser(IUser $user, IStorageFactory $loader) {
+        $this->migrator->migrateUser($user);
+
+        $this->userStoragesService->setUser($user);
+        $this->userGlobalStoragesService->setUser($user);
+
+        $storageConfigs = $this->userGlobalStoragesService->getAllStoragesForUser();
+
+        $storages = array_map(function (StorageConfig $storageConfig) use ($user) {
+            try {
+                $this->prepareStorageConfig($storageConfig, $user);
+                return $this->constructStorage($storageConfig);
+            } catch (\Exception $e) {
+                // propagate exception into filesystem
+                return new FailedStorage(['exception' => $e]);
+            }
+        }, $storageConfigs);
+
+
+        \OC\Files\Cache\Storage::getGlobalCache()->loadForStorageIds(array_map(function (Storage\IStorage $storage) {
+            return $storage->getId();
+        }, $storages));
+
+        $availableStorages = array_map(function (Storage\IStorage $storage, StorageConfig $storageConfig) {
+            try {
+                $availability = $storage->getAvailability();
+                if (!$availability['available'] && !Availability::shouldRecheck($availability)) {
+                    $storage = new FailedStorage([
+                        'exception' => new StorageNotAvailableException('Storage with mount id ' . $storageConfig->getId() . ' is not available')
+                    ]);
+                }
+            } catch (\Exception $e) {
+                // propagate exception into filesystem
+                $storage = new FailedStorage(['exception' => $e]);
+            }
+            return $storage;
+        }, $storages, $storageConfigs);
+
+        $mounts = array_map(function (StorageConfig $storageConfig, Storage\IStorage $storage) use ($user, $loader) {
+            if ($storageConfig->getType() === StorageConfig::MOUNT_TYPE_PERSONAl) {
+                return new PersonalMount(
+                    $this->userStoragesService,
+                    $storageConfig->getId(),
+                    $storage,
+                    '/' . $user->getUID() . '/files' . $storageConfig->getMountPoint(),
+                    null,
+                    $loader,
+                    $storageConfig->getMountOptions()
+                );
+            } else {
+                return new ExternalMountPoint(
+                    $storage,
+                    '/' . $user->getUID() . '/files' . $storageConfig->getMountPoint(),
+                    null,
+                    $loader,
+                    $storageConfig->getMountOptions(),
+                    $storageConfig->getId()
+                );
+            }
+        }, $storageConfigs, $availableStorages);
+
+        $this->userStoragesService->resetUser();
+        $this->userGlobalStoragesService->resetUser();
+
+        return $mounts;
+    }
 }

apps/files_external/lib/Lib/Backend/LegacyBackend.php

Indentation +63 added lines, -63 removed lines

@@ -32,72 +32,72 @@
  * Legacy compatibility for OCA\Files_External\MountConfig::registerBackend()
  */
 class LegacyBackend extends Backend {
-	use LegacyDependencyCheckPolyfill {
-		LegacyDependencyCheckPolyfill::checkDependencies as doCheckDependencies;
-	}
+    use LegacyDependencyCheckPolyfill {
+        LegacyDependencyCheckPolyfill::checkDependencies as doCheckDependencies;
+    }
 
-	/** @var bool */
-	protected $hasDependencies = false;
+    /** @var bool */
+    protected $hasDependencies = false;
 
-	/**
-	 * @param string $class
-	 * @param array $definition
-	 * @param Builtin $authMechanism
-	 */
-	public function __construct($class, array $definition, Builtin $authMechanism) {
-		$this
-			->setIdentifier($class)
-			->setStorageClass($class)
-			->setText($definition['backend'])
-			->addAuthScheme(Builtin::SCHEME_BUILTIN)
-			->setLegacyAuthMechanism($authMechanism)
-		;
+    /**
+     * @param string $class
+     * @param array $definition
+     * @param Builtin $authMechanism
+     */
+    public function __construct($class, array $definition, Builtin $authMechanism) {
+        $this
+            ->setIdentifier($class)
+            ->setStorageClass($class)
+            ->setText($definition['backend'])
+            ->addAuthScheme(Builtin::SCHEME_BUILTIN)
+            ->setLegacyAuthMechanism($authMechanism)
+        ;
 
-		foreach ($definition['configuration'] as $name => $placeholder) {
-			$flags = DefinitionParameter::FLAG_NONE;
-			$type = DefinitionParameter::VALUE_TEXT;
-			if ($placeholder[0] === '&') {
-				$flags = DefinitionParameter::FLAG_OPTIONAL;
-				$placeholder = substr($placeholder, 1);
-			}
-			switch ($placeholder[0]) {
-			case '!':
-				$type = DefinitionParameter::VALUE_BOOLEAN;
-				$placeholder = substr($placeholder, 1);
-				break;
-			case '*':
-				$type = DefinitionParameter::VALUE_PASSWORD;
-				$placeholder = substr($placeholder, 1);
-				break;
-			case '#':
-				$type = DefinitionParameter::VALUE_HIDDEN;
-				$placeholder = substr($placeholder, 1);
-				break;
-			}
-			$this->addParameter((new DefinitionParameter($name, $placeholder))
-				->setType($type)
-				->setFlags($flags)
-			);
-		}
+        foreach ($definition['configuration'] as $name => $placeholder) {
+            $flags = DefinitionParameter::FLAG_NONE;
+            $type = DefinitionParameter::VALUE_TEXT;
+            if ($placeholder[0] === '&') {
+                $flags = DefinitionParameter::FLAG_OPTIONAL;
+                $placeholder = substr($placeholder, 1);
+            }
+            switch ($placeholder[0]) {
+            case '!':
+                $type = DefinitionParameter::VALUE_BOOLEAN;
+                $placeholder = substr($placeholder, 1);
+                break;
+            case '*':
+                $type = DefinitionParameter::VALUE_PASSWORD;
+                $placeholder = substr($placeholder, 1);
+                break;
+            case '#':
+                $type = DefinitionParameter::VALUE_HIDDEN;
+                $placeholder = substr($placeholder, 1);
+                break;
+            }
+            $this->addParameter((new DefinitionParameter($name, $placeholder))
+                ->setType($type)
+                ->setFlags($flags)
+            );
+        }
 
-		if (isset($definition['priority'])) {
-			$this->setPriority($definition['priority']);
-		}
-		if (isset($definition['custom'])) {
-			$this->addCustomJs($definition['custom']);
-		}
-		if (isset($definition['has_dependencies']) && $definition['has_dependencies']) {
-			$this->hasDependencies = true;
-		}
-	}
+        if (isset($definition['priority'])) {
+            $this->setPriority($definition['priority']);
+        }
+        if (isset($definition['custom'])) {
+            $this->addCustomJs($definition['custom']);
+        }
+        if (isset($definition['has_dependencies']) && $definition['has_dependencies']) {
+            $this->hasDependencies = true;
+        }
+    }
 
-	/**
-	 * @return MissingDependency[]
-	 */
-	public function checkDependencies() {
-		if ($this->hasDependencies) {
-			return $this->doCheckDependencies();
-		}
-		return [];
-	}
+    /**
+     * @return MissingDependency[]
+     */
+    public function checkDependencies() {
+        if ($this->hasDependencies) {
+            return $this->doCheckDependencies();
+        }
+        return [];
+    }
 }

apps/files_external/lib/Command/Verify.php

Indentation +95 added lines, -95 removed lines

@@ -38,109 +38,109 @@
 use Symfony\Component\Console\Output\OutputInterface;
 
 class Verify extends Base {
-	/**
-	 * @var GlobalStoragesService
-	 */
-	protected $globalService;
+    /**
+     * @var GlobalStoragesService
+     */
+    protected $globalService;
 
-	public function __construct(GlobalStoragesService $globalService) {
-		parent::__construct();
-		$this->globalService = $globalService;
-	}
+    public function __construct(GlobalStoragesService $globalService) {
+        parent::__construct();
+        $this->globalService = $globalService;
+    }
 
-	protected function configure() {
-		$this
-			->setName('files_external:verify')
-			->setDescription('Verify mount configuration')
-			->addArgument(
-				'mount_id',
-				InputArgument::REQUIRED,
-				'The id of the mount to check'
-			)->addOption(
-				'config',
-				'c',
-				InputOption::VALUE_REQUIRED | InputOption::VALUE_IS_ARRAY,
-				'Additional config option to set before checking in key=value pairs, required for certain auth backends such as login credentails'
-			);
-		parent::configure();
-	}
+    protected function configure() {
+        $this
+            ->setName('files_external:verify')
+            ->setDescription('Verify mount configuration')
+            ->addArgument(
+                'mount_id',
+                InputArgument::REQUIRED,
+                'The id of the mount to check'
+            )->addOption(
+                'config',
+                'c',
+                InputOption::VALUE_REQUIRED | InputOption::VALUE_IS_ARRAY,
+                'Additional config option to set before checking in key=value pairs, required for certain auth backends such as login credentails'
+            );
+        parent::configure();
+    }
 
-	protected function execute(InputInterface $input, OutputInterface $output): int {
-		$mountId = $input->getArgument('mount_id');
-		$configInput = $input->getOption('config');
+    protected function execute(InputInterface $input, OutputInterface $output): int {
+        $mountId = $input->getArgument('mount_id');
+        $configInput = $input->getOption('config');
 
-		try {
-			$mount = $this->globalService->getStorage($mountId);
-		} catch (NotFoundException $e) {
-			$output->writeln('<error>Mount with id "' . $mountId . ' not found, check "occ files_external:list" to get available mounts"</error>');
-			return 404;
-		}
+        try {
+            $mount = $this->globalService->getStorage($mountId);
+        } catch (NotFoundException $e) {
+            $output->writeln('<error>Mount with id "' . $mountId . ' not found, check "occ files_external:list" to get available mounts"</error>');
+            return 404;
+        }
 
-		$this->updateStorageStatus($mount, $configInput, $output);
+        $this->updateStorageStatus($mount, $configInput, $output);
 
-		$this->writeArrayInOutputFormat($input, $output, [
-			'status' => StorageNotAvailableException::getStateCodeName($mount->getStatus()),
-			'code' => $mount->getStatus(),
-			'message' => $mount->getStatusMessage()
-		]);
-		return 0;
-	}
+        $this->writeArrayInOutputFormat($input, $output, [
+            'status' => StorageNotAvailableException::getStateCodeName($mount->getStatus()),
+            'code' => $mount->getStatus(),
+            'message' => $mount->getStatusMessage()
+        ]);
+        return 0;
+    }
 
-	private function manipulateStorageConfig(StorageConfig $storage) {
-		/** @var AuthMechanism */
-		$authMechanism = $storage->getAuthMechanism();
-		$authMechanism->manipulateStorageConfig($storage);
-		/** @var Backend */
-		$backend = $storage->getBackend();
-		$backend->manipulateStorageConfig($storage);
-	}
+    private function manipulateStorageConfig(StorageConfig $storage) {
+        /** @var AuthMechanism */
+        $authMechanism = $storage->getAuthMechanism();
+        $authMechanism->manipulateStorageConfig($storage);
+        /** @var Backend */
+        $backend = $storage->getBackend();
+        $backend->manipulateStorageConfig($storage);
+    }
 
-	private function updateStorageStatus(StorageConfig &$storage, $configInput, OutputInterface $output) {
-		try {
-			try {
-				$this->manipulateStorageConfig($storage);
-			} catch (InsufficientDataForMeaningfulAnswerException $e) {
-				if (count($configInput) === 0) { // extra config options might solve the error
-					throw $e;
-				}
-			}
+    private function updateStorageStatus(StorageConfig &$storage, $configInput, OutputInterface $output) {
+        try {
+            try {
+                $this->manipulateStorageConfig($storage);
+            } catch (InsufficientDataForMeaningfulAnswerException $e) {
+                if (count($configInput) === 0) { // extra config options might solve the error
+                    throw $e;
+                }
+            }
 
-			foreach ($configInput as $configOption) {
-				if (!strpos($configOption, '=')) {
-					$output->writeln('<error>Invalid mount configuration option "' . $configOption . '"</error>');
-					return;
-				}
-				list($key, $value) = explode('=', $configOption, 2);
-				$storage->setBackendOption($key, $value);
-			}
+            foreach ($configInput as $configOption) {
+                if (!strpos($configOption, '=')) {
+                    $output->writeln('<error>Invalid mount configuration option "' . $configOption . '"</error>');
+                    return;
+                }
+                list($key, $value) = explode('=', $configOption, 2);
+                $storage->setBackendOption($key, $value);
+            }
 
-			/** @var Backend */
-			$backend = $storage->getBackend();
-			// update status (can be time-consuming)
-			$storage->setStatus(
-				\OCA\Files_External\MountConfig::getBackendStatus(
-					$backend->getStorageClass(),
-					$storage->getBackendOptions(),
-					false
-				)
-			);
-		} catch (InsufficientDataForMeaningfulAnswerException $e) {
-			$status = $e->getCode() ? $e->getCode() : StorageNotAvailableException::STATUS_INDETERMINATE;
-			$storage->setStatus(
-				$status,
-				$e->getMessage()
-			);
-		} catch (StorageNotAvailableException $e) {
-			$storage->setStatus(
-				$e->getCode(),
-				$e->getMessage()
-			);
-		} catch (\Exception $e) {
-			// FIXME: convert storage exceptions to StorageNotAvailableException
-			$storage->setStatus(
-				StorageNotAvailableException::STATUS_ERROR,
-				get_class($e) . ': ' . $e->getMessage()
-			);
-		}
-	}
+            /** @var Backend */
+            $backend = $storage->getBackend();
+            // update status (can be time-consuming)
+            $storage->setStatus(
+                \OCA\Files_External\MountConfig::getBackendStatus(
+                    $backend->getStorageClass(),
+                    $storage->getBackendOptions(),
+                    false
+                )
+            );
+        } catch (InsufficientDataForMeaningfulAnswerException $e) {
+            $status = $e->getCode() ? $e->getCode() : StorageNotAvailableException::STATUS_INDETERMINATE;
+            $storage->setStatus(
+                $status,
+                $e->getMessage()
+            );
+        } catch (StorageNotAvailableException $e) {
+            $storage->setStatus(
+                $e->getCode(),
+                $e->getMessage()
+            );
+        } catch (\Exception $e) {
+            // FIXME: convert storage exceptions to StorageNotAvailableException
+            $storage->setStatus(
+                StorageNotAvailableException::STATUS_ERROR,
+                get_class($e) . ': ' . $e->getMessage()
+            );
+        }
+    }
 }

apps/files_external/lib/MountConfig.php

Indentation +383 added lines, -383 removed lines

@@ -60,387 +60,387 @@
  * Class to configure mount.json globally and for users
  */
 class MountConfig {
-	// TODO: make this class non-static and give it a proper namespace
-
-	public const MOUNT_TYPE_GLOBAL = 'global';
-	public const MOUNT_TYPE_GROUP = 'group';
-	public const MOUNT_TYPE_USER = 'user';
-	public const MOUNT_TYPE_PERSONAL = 'personal';
-
-	// whether to skip backend test (for unit tests, as this static class is not mockable)
-	public static $skipTest = false;
-
-	/** @var Application */
-	public static $app;
-
-	/**
-	 * @param string $class
-	 * @param array $definition
-	 * @return bool
-	 * @deprecated 8.2.0 use \OCA\Files_External\Service\BackendService::registerBackend()
-	 */
-	public static function registerBackend($class, $definition) {
-		$backendService = self::$app->getContainer()->query(BackendService::class);
-		$auth = self::$app->getContainer()->query(Builtin::class);
-
-		$backendService->registerBackend(new LegacyBackend($class, $definition, $auth));
-
-		return true;
-	}
-
-	/**
-	 * Returns the mount points for the given user.
-	 * The mount point is relative to the data directory.
-	 *
-	 * @param string $uid user
-	 * @return array of mount point string as key, mountpoint config as value
-	 *
-	 * @deprecated 8.2.0 use UserGlobalStoragesService::getStorages() and UserStoragesService::getStorages()
-	 */
-	public static function getAbsoluteMountPoints($uid) {
-		$mountPoints = [];
-
-		$userGlobalStoragesService = self::$app->getContainer()->query(UserGlobalStoragesService::class);
-		$userStoragesService = self::$app->getContainer()->query(UserStoragesService::class);
-		$user = self::$app->getContainer()->query(IUserManager::class)->get($uid);
-
-		$userGlobalStoragesService->setUser($user);
-		$userStoragesService->setUser($user);
-
-		foreach ($userGlobalStoragesService->getStorages() as $storage) {
-			/** @var \OCA\Files_External\Lib\StorageConfig $storage */
-			$mountPoint = '/'.$uid.'/files'.$storage->getMountPoint();
-			$mountEntry = self::prepareMountPointEntry($storage, false);
-			foreach ($mountEntry['options'] as &$option) {
-				$option = self::substitutePlaceholdersInConfig($option, $uid);
-			}
-			$mountPoints[$mountPoint] = $mountEntry;
-		}
-
-		foreach ($userStoragesService->getStorages() as $storage) {
-			$mountPoint = '/'.$uid.'/files'.$storage->getMountPoint();
-			$mountEntry = self::prepareMountPointEntry($storage, true);
-			foreach ($mountEntry['options'] as &$option) {
-				$option = self::substitutePlaceholdersInConfig($option, $uid);
-			}
-			$mountPoints[$mountPoint] = $mountEntry;
-		}
-
-		$userGlobalStoragesService->resetUser();
-		$userStoragesService->resetUser();
-
-		return $mountPoints;
-	}
-
-	/**
-	 * Get the system mount points
-	 *
-	 * @return array
-	 *
-	 * @deprecated 8.2.0 use GlobalStoragesService::getStorages()
-	 */
-	public static function getSystemMountPoints() {
-		$mountPoints = [];
-		$service = self::$app->getContainer()->query(GlobalStoragesService::class);
-
-		foreach ($service->getStorages() as $storage) {
-			$mountPoints[] = self::prepareMountPointEntry($storage, false);
-		}
-
-		return $mountPoints;
-	}
-
-	/**
-	 * Get the personal mount points of the current user
-	 *
-	 * @return array
-	 *
-	 * @deprecated 8.2.0 use UserStoragesService::getStorages()
-	 */
-	public static function getPersonalMountPoints() {
-		$mountPoints = [];
-		$service = self::$app->getContainer()->query(UserStoragesService::class);
-
-		foreach ($service->getStorages() as $storage) {
-			$mountPoints[] = self::prepareMountPointEntry($storage, true);
-		}
-
-		return $mountPoints;
-	}
-
-	/**
-	 * Convert a StorageConfig to the legacy mountPoints array format
-	 * There's a lot of extra information in here, to satisfy all of the legacy functions
-	 *
-	 * @param StorageConfig $storage
-	 * @param bool $isPersonal
-	 * @return array
-	 */
-	private static function prepareMountPointEntry(StorageConfig $storage, $isPersonal) {
-		$mountEntry = [];
-
-		$mountEntry['mountpoint'] = substr($storage->getMountPoint(), 1); // remove leading slash
-		$mountEntry['class'] = $storage->getBackend()->getIdentifier();
-		$mountEntry['backend'] = $storage->getBackend()->getText();
-		$mountEntry['authMechanism'] = $storage->getAuthMechanism()->getIdentifier();
-		$mountEntry['personal'] = $isPersonal;
-		$mountEntry['options'] = self::decryptPasswords($storage->getBackendOptions());
-		$mountEntry['mountOptions'] = $storage->getMountOptions();
-		$mountEntry['priority'] = $storage->getPriority();
-		$mountEntry['applicable'] = [
-			'groups' => $storage->getApplicableGroups(),
-			'users' => $storage->getApplicableUsers(),
-		];
-		// if mountpoint is applicable to all users the old API expects ['all']
-		if (empty($mountEntry['applicable']['groups']) && empty($mountEntry['applicable']['users'])) {
-			$mountEntry['applicable']['users'] = ['all'];
-		}
-
-		$mountEntry['id'] = $storage->getId();
-
-		return $mountEntry;
-	}
-
-	/**
-	 * fill in the correct values for $user
-	 *
-	 * @param string $user user value
-	 * @param string|array $input
-	 * @return string
-	 * @deprecated use self::substitutePlaceholdersInConfig($input)
-	 */
-	public static function setUserVars($user, $input) {
-		$handler = self::$app->getContainer()->query(UserPlaceholderHandler::class);
-		return $handler->handle($input);
-	}
-
-	/**
-	 * @param mixed $input
-	 * @param string|null $userId
-	 * @return mixed
-	 * @throws \OCP\AppFramework\QueryException
-	 * @since 16.0.0
-	 */
-	public static function substitutePlaceholdersInConfig($input, string $userId = null) {
-		/** @var BackendService $backendService */
-		$backendService = self::$app->getContainer()->query(BackendService::class);
-		/** @var IConfigHandler[] $handlers */
-		$handlers = $backendService->getConfigHandlers();
-		foreach ($handlers as $handler) {
-			if ($handler instanceof UserContext && $userId !== null) {
-				$handler->setUserId($userId);
-			}
-			$input = $handler->handle($input);
-		}
-		return $input;
-	}
-
-	/**
-	 * Test connecting using the given backend configuration
-	 *
-	 * @param string $class backend class name
-	 * @param array $options backend configuration options
-	 * @param boolean $isPersonal
-	 * @return int see self::STATUS_*
-	 * @throws Exception
-	 */
-	public static function getBackendStatus($class, $options, $isPersonal, $testOnly = true) {
-		if (self::$skipTest) {
-			return StorageNotAvailableException::STATUS_SUCCESS;
-		}
-		foreach ($options as $key => &$option) {
-			if ($key === 'password') {
-				// no replacements in passwords
-				continue;
-			}
-			$option = self::substitutePlaceholdersInConfig($option);
-		}
-		if (class_exists($class)) {
-			try {
-				/** @var \OC\Files\Storage\Common $storage */
-				$storage = new $class($options);
-
-				try {
-					$result = $storage->test($isPersonal, $testOnly);
-					$storage->setAvailability($result);
-					if ($result) {
-						return StorageNotAvailableException::STATUS_SUCCESS;
-					}
-				} catch (\Exception $e) {
-					$storage->setAvailability(false);
-					throw $e;
-				}
-			} catch (Exception $exception) {
-				\OC::$server->getLogger()->logException($exception, ['app' => 'files_external']);
-				throw $exception;
-			}
-		}
-		return StorageNotAvailableException::STATUS_ERROR;
-	}
-
-	/**
-	 * Read the mount points in the config file into an array
-	 *
-	 * @param string|null $user If not null, personal for $user, otherwise system
-	 * @return array
-	 */
-	public static function readData($user = null) {
-		if (isset($user)) {
-			$jsonFile = \OC::$server->getUserManager()->get($user)->getHome() . '/mount.json';
-		} else {
-			$config = \OC::$server->getConfig();
-			$datadir = $config->getSystemValue('datadirectory', \OC::$SERVERROOT . '/data/');
-			$jsonFile = $config->getSystemValue('mount_file', $datadir . '/mount.json');
-		}
-		if (is_file($jsonFile)) {
-			$mountPoints = json_decode(file_get_contents($jsonFile), true);
-			if (is_array($mountPoints)) {
-				return $mountPoints;
-			}
-		}
-		return [];
-	}
-
-	/**
-	 * Get backend dependency message
-	 * TODO: move into AppFramework along with templates
-	 *
-	 * @param Backend[] $backends
-	 * @return string
-	 */
-	public static function dependencyMessage($backends) {
-		$l = \OC::$server->getL10N('files_external');
-		$message = '';
-		$dependencyGroups = [];
-
-		foreach ($backends as $backend) {
-			foreach ($backend->checkDependencies() as $dependency) {
-				if ($message = $dependency->getMessage()) {
-					$message .= '<p>' . $message . '</p>';
-				} else {
-					$dependencyGroups[$dependency->getDependency()][] = $backend;
-				}
-			}
-		}
-
-		foreach ($dependencyGroups as $module => $dependants) {
-			$backends = implode(', ', array_map(function ($backend) {
-				return '"' . $backend->getText() . '"';
-			}, $dependants));
-			$message .= '<p>' . MountConfig::getSingleDependencyMessage($l, $module, $backends) . '</p>';
-		}
-
-		return $message;
-	}
-
-	/**
-	 * Returns a dependency missing message
-	 *
-	 * @param \OCP\IL10N $l
-	 * @param string $module
-	 * @param string $backend
-	 * @return string
-	 */
-	private static function getSingleDependencyMessage(\OCP\IL10N $l, $module, $backend) {
-		switch (strtolower($module)) {
-			case 'curl':
-				return (string)$l->t('The cURL support in PHP is not enabled or installed. Mounting of %s is not possible. Please ask your system administrator to install it.', [$backend]);
-			case 'ftp':
-				return (string)$l->t('The FTP support in PHP is not enabled or installed. Mounting of %s is not possible. Please ask your system administrator to install it.', [$backend]);
-			default:
-				return (string)$l->t('"%1$s" is not installed. Mounting of %2$s is not possible. Please ask your system administrator to install it.', [$module, $backend]);
-		}
-	}
-
-	/**
-	 * Encrypt passwords in the given config options
-	 *
-	 * @param array $options mount options
-	 * @return array updated options
-	 */
-	public static function encryptPasswords($options) {
-		if (isset($options['password'])) {
-			$options['password_encrypted'] = self::encryptPassword($options['password']);
-			// do not unset the password, we want to keep the keys order
-			// on load... because that's how the UI currently works
-			$options['password'] = '';
-		}
-		return $options;
-	}
-
-	/**
-	 * Decrypt passwords in the given config options
-	 *
-	 * @param array $options mount options
-	 * @return array updated options
-	 */
-	public static function decryptPasswords($options) {
-		// note: legacy options might still have the unencrypted password in the "password" field
-		if (isset($options['password_encrypted'])) {
-			$options['password'] = self::decryptPassword($options['password_encrypted']);
-			unset($options['password_encrypted']);
-		}
-		return $options;
-	}
-
-	/**
-	 * Encrypt a single password
-	 *
-	 * @param string $password plain text password
-	 * @return string encrypted password
-	 */
-	private static function encryptPassword($password) {
-		$cipher = self::getCipher();
-		$iv = \OC::$server->getSecureRandom()->generate(16);
-		$cipher->setIV($iv);
-		return base64_encode($iv . $cipher->encrypt($password));
-	}
-
-	/**
-	 * Decrypts a single password
-	 *
-	 * @param string $encryptedPassword encrypted password
-	 * @return string plain text password
-	 */
-	private static function decryptPassword($encryptedPassword) {
-		$cipher = self::getCipher();
-		$binaryPassword = base64_decode($encryptedPassword);
-		$iv = substr($binaryPassword, 0, 16);
-		$cipher->setIV($iv);
-		$binaryPassword = substr($binaryPassword, 16);
-		return $cipher->decrypt($binaryPassword);
-	}
-
-	/**
-	 * Returns the encryption cipher
-	 *
-	 * @return AES
-	 */
-	private static function getCipher() {
-		$cipher = new AES(AES::MODE_CBC);
-		$cipher->setKey(\OC::$server->getConfig()->getSystemValue('passwordsalt', null));
-		return $cipher;
-	}
-
-	/**
-	 * Computes a hash based on the given configuration.
-	 * This is mostly used to find out whether configurations
-	 * are the same.
-	 *
-	 * @param array $config
-	 * @return string
-	 */
-	public static function makeConfigHash($config) {
-		$data = json_encode(
-			[
-				'c' => $config['backend'],
-				'a' => $config['authMechanism'],
-				'm' => $config['mountpoint'],
-				'o' => $config['options'],
-				'p' => isset($config['priority']) ? $config['priority'] : -1,
-				'mo' => isset($config['mountOptions']) ? $config['mountOptions'] : [],
-			]
-		);
-		return hash('md5', $data);
-	}
+    // TODO: make this class non-static and give it a proper namespace
+
+    public const MOUNT_TYPE_GLOBAL = 'global';
+    public const MOUNT_TYPE_GROUP = 'group';
+    public const MOUNT_TYPE_USER = 'user';
+    public const MOUNT_TYPE_PERSONAL = 'personal';
+
+    // whether to skip backend test (for unit tests, as this static class is not mockable)
+    public static $skipTest = false;
+
+    /** @var Application */
+    public static $app;
+
+    /**
+     * @param string $class
+     * @param array $definition
+     * @return bool
+     * @deprecated 8.2.0 use \OCA\Files_External\Service\BackendService::registerBackend()
+     */
+    public static function registerBackend($class, $definition) {
+        $backendService = self::$app->getContainer()->query(BackendService::class);
+        $auth = self::$app->getContainer()->query(Builtin::class);
+
+        $backendService->registerBackend(new LegacyBackend($class, $definition, $auth));
+
+        return true;
+    }
+
+    /**
+     * Returns the mount points for the given user.
+     * The mount point is relative to the data directory.
+     *
+     * @param string $uid user
+     * @return array of mount point string as key, mountpoint config as value
+     *
+     * @deprecated 8.2.0 use UserGlobalStoragesService::getStorages() and UserStoragesService::getStorages()
+     */
+    public static function getAbsoluteMountPoints($uid) {
+        $mountPoints = [];
+
+        $userGlobalStoragesService = self::$app->getContainer()->query(UserGlobalStoragesService::class);
+        $userStoragesService = self::$app->getContainer()->query(UserStoragesService::class);
+        $user = self::$app->getContainer()->query(IUserManager::class)->get($uid);
+
+        $userGlobalStoragesService->setUser($user);
+        $userStoragesService->setUser($user);
+
+        foreach ($userGlobalStoragesService->getStorages() as $storage) {
+            /** @var \OCA\Files_External\Lib\StorageConfig $storage */
+            $mountPoint = '/'.$uid.'/files'.$storage->getMountPoint();
+            $mountEntry = self::prepareMountPointEntry($storage, false);
+            foreach ($mountEntry['options'] as &$option) {
+                $option = self::substitutePlaceholdersInConfig($option, $uid);
+            }
+            $mountPoints[$mountPoint] = $mountEntry;
+        }
+
+        foreach ($userStoragesService->getStorages() as $storage) {
+            $mountPoint = '/'.$uid.'/files'.$storage->getMountPoint();
+            $mountEntry = self::prepareMountPointEntry($storage, true);
+            foreach ($mountEntry['options'] as &$option) {
+                $option = self::substitutePlaceholdersInConfig($option, $uid);
+            }
+            $mountPoints[$mountPoint] = $mountEntry;
+        }
+
+        $userGlobalStoragesService->resetUser();
+        $userStoragesService->resetUser();
+
+        return $mountPoints;
+    }
+
+    /**
+     * Get the system mount points
+     *
+     * @return array
+     *
+     * @deprecated 8.2.0 use GlobalStoragesService::getStorages()
+     */
+    public static function getSystemMountPoints() {
+        $mountPoints = [];
+        $service = self::$app->getContainer()->query(GlobalStoragesService::class);
+
+        foreach ($service->getStorages() as $storage) {
+            $mountPoints[] = self::prepareMountPointEntry($storage, false);
+        }
+
+        return $mountPoints;
+    }
+
+    /**
+     * Get the personal mount points of the current user
+     *
+     * @return array
+     *
+     * @deprecated 8.2.0 use UserStoragesService::getStorages()
+     */
+    public static function getPersonalMountPoints() {
+        $mountPoints = [];
+        $service = self::$app->getContainer()->query(UserStoragesService::class);
+
+        foreach ($service->getStorages() as $storage) {
+            $mountPoints[] = self::prepareMountPointEntry($storage, true);
+        }
+
+        return $mountPoints;
+    }
+
+    /**
+     * Convert a StorageConfig to the legacy mountPoints array format
+     * There's a lot of extra information in here, to satisfy all of the legacy functions
+     *
+     * @param StorageConfig $storage
+     * @param bool $isPersonal
+     * @return array
+     */
+    private static function prepareMountPointEntry(StorageConfig $storage, $isPersonal) {
+        $mountEntry = [];
+
+        $mountEntry['mountpoint'] = substr($storage->getMountPoint(), 1); // remove leading slash
+        $mountEntry['class'] = $storage->getBackend()->getIdentifier();
+        $mountEntry['backend'] = $storage->getBackend()->getText();
+        $mountEntry['authMechanism'] = $storage->getAuthMechanism()->getIdentifier();
+        $mountEntry['personal'] = $isPersonal;
+        $mountEntry['options'] = self::decryptPasswords($storage->getBackendOptions());
+        $mountEntry['mountOptions'] = $storage->getMountOptions();
+        $mountEntry['priority'] = $storage->getPriority();
+        $mountEntry['applicable'] = [
+            'groups' => $storage->getApplicableGroups(),
+            'users' => $storage->getApplicableUsers(),
+        ];
+        // if mountpoint is applicable to all users the old API expects ['all']
+        if (empty($mountEntry['applicable']['groups']) && empty($mountEntry['applicable']['users'])) {
+            $mountEntry['applicable']['users'] = ['all'];
+        }
+
+        $mountEntry['id'] = $storage->getId();
+
+        return $mountEntry;
+    }
+
+    /**
+     * fill in the correct values for $user
+     *
+     * @param string $user user value
+     * @param string|array $input
+     * @return string
+     * @deprecated use self::substitutePlaceholdersInConfig($input)
+     */
+    public static function setUserVars($user, $input) {
+        $handler = self::$app->getContainer()->query(UserPlaceholderHandler::class);
+        return $handler->handle($input);
+    }
+
+    /**
+     * @param mixed $input
+     * @param string|null $userId
+     * @return mixed
+     * @throws \OCP\AppFramework\QueryException
+     * @since 16.0.0
+     */
+    public static function substitutePlaceholdersInConfig($input, string $userId = null) {
+        /** @var BackendService $backendService */
+        $backendService = self::$app->getContainer()->query(BackendService::class);
+        /** @var IConfigHandler[] $handlers */
+        $handlers = $backendService->getConfigHandlers();
+        foreach ($handlers as $handler) {
+            if ($handler instanceof UserContext && $userId !== null) {
+                $handler->setUserId($userId);
+            }
+            $input = $handler->handle($input);
+        }
+        return $input;
+    }
+
+    /**
+     * Test connecting using the given backend configuration
+     *
+     * @param string $class backend class name
+     * @param array $options backend configuration options
+     * @param boolean $isPersonal
+     * @return int see self::STATUS_*
+     * @throws Exception
+     */
+    public static function getBackendStatus($class, $options, $isPersonal, $testOnly = true) {
+        if (self::$skipTest) {
+            return StorageNotAvailableException::STATUS_SUCCESS;
+        }
+        foreach ($options as $key => &$option) {
+            if ($key === 'password') {
+                // no replacements in passwords
+                continue;
+            }
+            $option = self::substitutePlaceholdersInConfig($option);
+        }
+        if (class_exists($class)) {
+            try {
+                /** @var \OC\Files\Storage\Common $storage */
+                $storage = new $class($options);
+
+                try {
+                    $result = $storage->test($isPersonal, $testOnly);
+                    $storage->setAvailability($result);
+                    if ($result) {
+                        return StorageNotAvailableException::STATUS_SUCCESS;
+                    }
+                } catch (\Exception $e) {
+                    $storage->setAvailability(false);
+                    throw $e;
+                }
+            } catch (Exception $exception) {
+                \OC::$server->getLogger()->logException($exception, ['app' => 'files_external']);
+                throw $exception;
+            }
+        }
+        return StorageNotAvailableException::STATUS_ERROR;
+    }
+
+    /**
+     * Read the mount points in the config file into an array
+     *
+     * @param string|null $user If not null, personal for $user, otherwise system
+     * @return array
+     */
+    public static function readData($user = null) {
+        if (isset($user)) {
+            $jsonFile = \OC::$server->getUserManager()->get($user)->getHome() . '/mount.json';
+        } else {
+            $config = \OC::$server->getConfig();
+            $datadir = $config->getSystemValue('datadirectory', \OC::$SERVERROOT . '/data/');
+            $jsonFile = $config->getSystemValue('mount_file', $datadir . '/mount.json');
+        }
+        if (is_file($jsonFile)) {
+            $mountPoints = json_decode(file_get_contents($jsonFile), true);
+            if (is_array($mountPoints)) {
+                return $mountPoints;
+            }
+        }
+        return [];
+    }
+
+    /**
+     * Get backend dependency message
+     * TODO: move into AppFramework along with templates
+     *
+     * @param Backend[] $backends
+     * @return string
+     */
+    public static function dependencyMessage($backends) {
+        $l = \OC::$server->getL10N('files_external');
+        $message = '';
+        $dependencyGroups = [];
+
+        foreach ($backends as $backend) {
+            foreach ($backend->checkDependencies() as $dependency) {
+                if ($message = $dependency->getMessage()) {
+                    $message .= '<p>' . $message . '</p>';
+                } else {
+                    $dependencyGroups[$dependency->getDependency()][] = $backend;
+                }
+            }
+        }
+
+        foreach ($dependencyGroups as $module => $dependants) {
+            $backends = implode(', ', array_map(function ($backend) {
+                return '"' . $backend->getText() . '"';
+            }, $dependants));
+            $message .= '<p>' . MountConfig::getSingleDependencyMessage($l, $module, $backends) . '</p>';
+        }
+
+        return $message;
+    }
+
+    /**
+     * Returns a dependency missing message
+     *
+     * @param \OCP\IL10N $l
+     * @param string $module
+     * @param string $backend
+     * @return string
+     */
+    private static function getSingleDependencyMessage(\OCP\IL10N $l, $module, $backend) {
+        switch (strtolower($module)) {
+            case 'curl':
+                return (string)$l->t('The cURL support in PHP is not enabled or installed. Mounting of %s is not possible. Please ask your system administrator to install it.', [$backend]);
+            case 'ftp':
+                return (string)$l->t('The FTP support in PHP is not enabled or installed. Mounting of %s is not possible. Please ask your system administrator to install it.', [$backend]);
+            default:
+                return (string)$l->t('"%1$s" is not installed. Mounting of %2$s is not possible. Please ask your system administrator to install it.', [$module, $backend]);
+        }
+    }
+
+    /**
+     * Encrypt passwords in the given config options
+     *
+     * @param array $options mount options
+     * @return array updated options
+     */
+    public static function encryptPasswords($options) {
+        if (isset($options['password'])) {
+            $options['password_encrypted'] = self::encryptPassword($options['password']);
+            // do not unset the password, we want to keep the keys order
+            // on load... because that's how the UI currently works
+            $options['password'] = '';
+        }
+        return $options;
+    }
+
+    /**
+     * Decrypt passwords in the given config options
+     *
+     * @param array $options mount options
+     * @return array updated options
+     */
+    public static function decryptPasswords($options) {
+        // note: legacy options might still have the unencrypted password in the "password" field
+        if (isset($options['password_encrypted'])) {
+            $options['password'] = self::decryptPassword($options['password_encrypted']);
+            unset($options['password_encrypted']);
+        }
+        return $options;
+    }
+
+    /**
+     * Encrypt a single password
+     *
+     * @param string $password plain text password
+     * @return string encrypted password
+     */
+    private static function encryptPassword($password) {
+        $cipher = self::getCipher();
+        $iv = \OC::$server->getSecureRandom()->generate(16);
+        $cipher->setIV($iv);
+        return base64_encode($iv . $cipher->encrypt($password));
+    }
+
+    /**
+     * Decrypts a single password
+     *
+     * @param string $encryptedPassword encrypted password
+     * @return string plain text password
+     */
+    private static function decryptPassword($encryptedPassword) {
+        $cipher = self::getCipher();
+        $binaryPassword = base64_decode($encryptedPassword);
+        $iv = substr($binaryPassword, 0, 16);
+        $cipher->setIV($iv);
+        $binaryPassword = substr($binaryPassword, 16);
+        return $cipher->decrypt($binaryPassword);
+    }
+
+    /**
+     * Returns the encryption cipher
+     *
+     * @return AES
+     */
+    private static function getCipher() {
+        $cipher = new AES(AES::MODE_CBC);
+        $cipher->setKey(\OC::$server->getConfig()->getSystemValue('passwordsalt', null));
+        return $cipher;
+    }
+
+    /**
+     * Computes a hash based on the given configuration.
+     * This is mostly used to find out whether configurations
+     * are the same.
+     *
+     * @param array $config
+     * @return string
+     */
+    public static function makeConfigHash($config) {
+        $data = json_encode(
+            [
+                'c' => $config['backend'],
+                'a' => $config['authMechanism'],
+                'm' => $config['mountpoint'],
+                'o' => $config['options'],
+                'p' => isset($config['priority']) ? $config['priority'] : -1,
+                'mo' => isset($config['mountOptions']) ? $config['mountOptions'] : [],
+            ]
+        );
+        return hash('md5', $data);
+    }
 }

Spacing +11 added lines, -11 removed lines

@@ -286,11 +286,11 @@ 
 	 */
 	public static function readData($user = null) {
 		if (isset($user)) {
-			$jsonFile = \OC::$server->getUserManager()->get($user)->getHome() . '/mount.json';
+			$jsonFile = \OC::$server->getUserManager()->get($user)->getHome().'/mount.json';
 		} else {
 			$config = \OC::$server->getConfig();
-			$datadir = $config->getSystemValue('datadirectory', \OC::$SERVERROOT . '/data/');
-			$jsonFile = $config->getSystemValue('mount_file', $datadir . '/mount.json');
+			$datadir = $config->getSystemValue('datadirectory', \OC::$SERVERROOT.'/data/');
+			$jsonFile = $config->getSystemValue('mount_file', $datadir.'/mount.json');
 		}
 		if (is_file($jsonFile)) {
 			$mountPoints = json_decode(file_get_contents($jsonFile), true);
@@ -316,7 +316,7 @@ 
 		foreach ($backends as $backend) {
 			foreach ($backend->checkDependencies() as $dependency) {
 				if ($message = $dependency->getMessage()) {
-					$message .= '<p>' . $message . '</p>';
+					$message .= '<p>'.$message.'</p>';
 				} else {
 					$dependencyGroups[$dependency->getDependency()][] = $backend;
 				}
@@ -324,10 +324,10 @@ 
 		}
 
 		foreach ($dependencyGroups as $module => $dependants) {
-			$backends = implode(', ', array_map(function ($backend) {
-				return '"' . $backend->getText() . '"';
+			$backends = implode(', ', array_map(function($backend) {
+				return '"'.$backend->getText().'"';
 			}, $dependants));
-			$message .= '<p>' . MountConfig::getSingleDependencyMessage($l, $module, $backends) . '</p>';
+			$message .= '<p>'.MountConfig::getSingleDependencyMessage($l, $module, $backends).'</p>';
 		}
 
 		return $message;
@@ -344,11 +344,11 @@ 
 	private static function getSingleDependencyMessage(\OCP\IL10N $l, $module, $backend) {
 		switch (strtolower($module)) {
 			case 'curl':
-				return (string)$l->t('The cURL support in PHP is not enabled or installed. Mounting of %s is not possible. Please ask your system administrator to install it.', [$backend]);
+				return (string) $l->t('The cURL support in PHP is not enabled or installed. Mounting of %s is not possible. Please ask your system administrator to install it.', [$backend]);
 			case 'ftp':
-				return (string)$l->t('The FTP support in PHP is not enabled or installed. Mounting of %s is not possible. Please ask your system administrator to install it.', [$backend]);
+				return (string) $l->t('The FTP support in PHP is not enabled or installed. Mounting of %s is not possible. Please ask your system administrator to install it.', [$backend]);
 			default:
-				return (string)$l->t('"%1$s" is not installed. Mounting of %2$s is not possible. Please ask your system administrator to install it.', [$module, $backend]);
+				return (string) $l->t('"%1$s" is not installed. Mounting of %2$s is not possible. Please ask your system administrator to install it.', [$module, $backend]);
 		}
 	}
 
@@ -393,7 +393,7 @@ 
 		$cipher = self::getCipher();
 		$iv = \OC::$server->getSecureRandom()->generate(16);
 		$cipher->setIV($iv);
-		return base64_encode($iv . $cipher->encrypt($password));
+		return base64_encode($iv.$cipher->encrypt($password));
 	}
 
 	/**

lib/private/Encryption/File.php

Indentation +90 added lines, -90 removed lines

@@ -34,94 +34,94 @@
 
 class File implements \OCP\Encryption\IFile {
 
-	/** @var Util */
-	protected $util;
-
-	/** @var IRootFolder */
-	private $rootFolder;
-
-	/** @var IManager */
-	private $shareManager;
-
-	/**
-	 * cache results of already checked folders
-	 *
-	 * @var array
-	 */
-	protected $cache;
-
-	public function __construct(Util $util,
-								IRootFolder $rootFolder,
-								IManager $shareManager) {
-		$this->util = $util;
-		$this->cache = new CappedMemoryCache();
-		$this->rootFolder = $rootFolder;
-		$this->shareManager = $shareManager;
-	}
-
-
-	/**
-	 * get list of users with access to the file
-	 *
-	 * @param string $path to the file
-	 * @return array  ['users' => $uniqueUserIds, 'public' => $public]
-	 */
-	public function getAccessList($path) {
-
-		// Make sure that a share key is generated for the owner too
-		list($owner, $ownerPath) = $this->util->getUidAndFilename($path);
-
-		// always add owner to the list of users with access to the file
-		$userIds = [$owner];
-
-		if (!$this->util->isFile($owner . '/' . $ownerPath)) {
-			return ['users' => $userIds, 'public' => false];
-		}
-
-		$ownerPath = substr($ownerPath, strlen('/files'));
-		$userFolder = $this->rootFolder->getUserFolder($owner);
-		try {
-			$file = $userFolder->get($ownerPath);
-		} catch (NotFoundException $e) {
-			$file = null;
-		}
-		$ownerPath = $this->util->stripPartialFileExtension($ownerPath);
-
-		// first get the shares for the parent and cache the result so that we don't
-		// need to check all parents for every file
-		$parent = dirname($ownerPath);
-		$parentNode = $userFolder->get($parent);
-		if (isset($this->cache[$parent])) {
-			$resultForParents = $this->cache[$parent];
-		} else {
-			$resultForParents = $this->shareManager->getAccessList($parentNode);
-			$this->cache[$parent] = $resultForParents;
-		}
-		$userIds = array_merge($userIds, $resultForParents['users']);
-		$public = $resultForParents['public'] || $resultForParents['remote'];
-
-
-		// Find out who, if anyone, is sharing the file
-		if ($file !== null) {
-			$resultForFile = $this->shareManager->getAccessList($file, false);
-			$userIds = array_merge($userIds, $resultForFile['users']);
-			$public = $resultForFile['public'] || $resultForFile['remote'] || $public;
-		}
-
-		// check if it is a group mount
-		if (\OCP\App::isEnabled("files_external")) {
-			$mounts = \OCA\Files_External\MountConfig::getSystemMountPoints();
-			foreach ($mounts as $mount) {
-				if ($mount['mountpoint'] == substr($ownerPath, 1, strlen($mount['mountpoint']))) {
-					$mountedFor = $this->util->getUserWithAccessToMountPoint($mount['applicable']['users'], $mount['applicable']['groups']);
-					$userIds = array_merge($userIds, $mountedFor);
-				}
-			}
-		}
-
-		// Remove duplicate UIDs
-		$uniqueUserIds = array_unique($userIds);
-
-		return ['users' => $uniqueUserIds, 'public' => $public];
-	}
+    /** @var Util */
+    protected $util;
+
+    /** @var IRootFolder */
+    private $rootFolder;
+
+    /** @var IManager */
+    private $shareManager;
+
+    /**
+     * cache results of already checked folders
+     *
+     * @var array
+     */
+    protected $cache;
+
+    public function __construct(Util $util,
+                                IRootFolder $rootFolder,
+                                IManager $shareManager) {
+        $this->util = $util;
+        $this->cache = new CappedMemoryCache();
+        $this->rootFolder = $rootFolder;
+        $this->shareManager = $shareManager;
+    }
+
+
+    /**
+     * get list of users with access to the file
+     *
+     * @param string $path to the file
+     * @return array  ['users' => $uniqueUserIds, 'public' => $public]
+     */
+    public function getAccessList($path) {
+
+        // Make sure that a share key is generated for the owner too
+        list($owner, $ownerPath) = $this->util->getUidAndFilename($path);
+
+        // always add owner to the list of users with access to the file
+        $userIds = [$owner];
+
+        if (!$this->util->isFile($owner . '/' . $ownerPath)) {
+            return ['users' => $userIds, 'public' => false];
+        }
+
+        $ownerPath = substr($ownerPath, strlen('/files'));
+        $userFolder = $this->rootFolder->getUserFolder($owner);
+        try {
+            $file = $userFolder->get($ownerPath);
+        } catch (NotFoundException $e) {
+            $file = null;
+        }
+        $ownerPath = $this->util->stripPartialFileExtension($ownerPath);
+
+        // first get the shares for the parent and cache the result so that we don't
+        // need to check all parents for every file
+        $parent = dirname($ownerPath);
+        $parentNode = $userFolder->get($parent);
+        if (isset($this->cache[$parent])) {
+            $resultForParents = $this->cache[$parent];
+        } else {
+            $resultForParents = $this->shareManager->getAccessList($parentNode);
+            $this->cache[$parent] = $resultForParents;
+        }
+        $userIds = array_merge($userIds, $resultForParents['users']);
+        $public = $resultForParents['public'] || $resultForParents['remote'];
+
+
+        // Find out who, if anyone, is sharing the file
+        if ($file !== null) {
+            $resultForFile = $this->shareManager->getAccessList($file, false);
+            $userIds = array_merge($userIds, $resultForFile['users']);
+            $public = $resultForFile['public'] || $resultForFile['remote'] || $public;
+        }
+
+        // check if it is a group mount
+        if (\OCP\App::isEnabled("files_external")) {
+            $mounts = \OCA\Files_External\MountConfig::getSystemMountPoints();
+            foreach ($mounts as $mount) {
+                if ($mount['mountpoint'] == substr($ownerPath, 1, strlen($mount['mountpoint']))) {
+                    $mountedFor = $this->util->getUserWithAccessToMountPoint($mount['applicable']['users'], $mount['applicable']['groups']);
+                    $userIds = array_merge($userIds, $mountedFor);
+                }
+            }
+        }
+
+        // Remove duplicate UIDs
+        $uniqueUserIds = array_unique($userIds);
+
+        return ['users' => $uniqueUserIds, 'public' => $public];
+    }
 }

lib/private/Encryption/Util.php

Indentation +362 added lines, -362 removed lines

@@ -38,366 +38,366 @@
 use OCP\IUser;
 
 class Util {
-	public const HEADER_START = 'HBEGIN';
-	public const HEADER_END = 'HEND';
-	public const HEADER_PADDING_CHAR = '-';
-
-	public const HEADER_ENCRYPTION_MODULE_KEY = 'oc_encryption_module';
-
-	/**
-	 * block size will always be 8192 for a PHP stream
-	 * @see https://bugs.php.net/bug.php?id=21641
-	 * @var integer
-	 */
-	protected $headerSize = 8192;
-
-	/**
-	 * block size will always be 8192 for a PHP stream
-	 * @see https://bugs.php.net/bug.php?id=21641
-	 * @var integer
-	 */
-	protected $blockSize = 8192;
-
-	/** @var View */
-	protected $rootView;
-
-	/** @var array */
-	protected $ocHeaderKeys;
-
-	/** @var \OC\User\Manager */
-	protected $userManager;
-
-	/** @var IConfig */
-	protected $config;
-
-	/** @var array paths excluded from encryption */
-	protected $excludedPaths;
-
-	/** @var \OC\Group\Manager $manager */
-	protected $groupManager;
-
-	/**
-	 *
-	 * @param View $rootView
-	 * @param \OC\User\Manager $userManager
-	 * @param \OC\Group\Manager $groupManager
-	 * @param IConfig $config
-	 */
-	public function __construct(
-		View $rootView,
-		\OC\User\Manager $userManager,
-		\OC\Group\Manager $groupManager,
-		IConfig $config) {
-		$this->ocHeaderKeys = [
-			self::HEADER_ENCRYPTION_MODULE_KEY
-		];
-
-		$this->rootView = $rootView;
-		$this->userManager = $userManager;
-		$this->groupManager = $groupManager;
-		$this->config = $config;
-
-		$this->excludedPaths[] = 'files_encryption';
-		$this->excludedPaths[] = 'appdata_' . $config->getSystemValue('instanceid', null);
-		$this->excludedPaths[] = 'files_external';
-	}
-
-	/**
-	 * read encryption module ID from header
-	 *
-	 * @param array $header
-	 * @return string
-	 * @throws ModuleDoesNotExistsException
-	 */
-	public function getEncryptionModuleId(array $header = null) {
-		$id = '';
-		$encryptionModuleKey = self::HEADER_ENCRYPTION_MODULE_KEY;
-
-		if (isset($header[$encryptionModuleKey])) {
-			$id = $header[$encryptionModuleKey];
-		} elseif (isset($header['cipher'])) {
-			if (class_exists('\OCA\Encryption\Crypto\Encryption')) {
-				// fall back to default encryption if the user migrated from
-				// ownCloud <= 8.0 with the old encryption
-				$id = \OCA\Encryption\Crypto\Encryption::ID;
-			} else {
-				throw new ModuleDoesNotExistsException('Default encryption module missing');
-			}
-		}
-
-		return $id;
-	}
-
-	/**
-	 * create header for encrypted file
-	 *
-	 * @param array $headerData
-	 * @param IEncryptionModule $encryptionModule
-	 * @return string
-	 * @throws EncryptionHeaderToLargeException if header has to many arguments
-	 * @throws EncryptionHeaderKeyExistsException if header key is already in use
-	 */
-	public function createHeader(array $headerData, IEncryptionModule $encryptionModule) {
-		$header = self::HEADER_START . ':' . self::HEADER_ENCRYPTION_MODULE_KEY . ':' . $encryptionModule->getId() . ':';
-		foreach ($headerData as $key => $value) {
-			if (in_array($key, $this->ocHeaderKeys)) {
-				throw new EncryptionHeaderKeyExistsException($key);
-			}
-			$header .= $key . ':' . $value . ':';
-		}
-		$header .= self::HEADER_END;
-
-		if (strlen($header) > $this->getHeaderSize()) {
-			throw new EncryptionHeaderToLargeException();
-		}
-
-		$paddedHeader = str_pad($header, $this->headerSize, self::HEADER_PADDING_CHAR, STR_PAD_RIGHT);
-
-		return $paddedHeader;
-	}
-
-	/**
-	 * go recursively through a dir and collect all files and sub files.
-	 *
-	 * @param string $dir relative to the users files folder
-	 * @return array with list of files relative to the users files folder
-	 */
-	public function getAllFiles($dir) {
-		$result = [];
-		$dirList = [$dir];
-
-		while ($dirList) {
-			$dir = array_pop($dirList);
-			$content = $this->rootView->getDirectoryContent($dir);
-
-			foreach ($content as $c) {
-				if ($c->getType() === 'dir') {
-					$dirList[] = $c->getPath();
-				} else {
-					$result[] =  $c->getPath();
-				}
-			}
-		}
-
-		return $result;
-	}
-
-	/**
-	 * check if it is a file uploaded by the user stored in data/user/files
-	 * or a metadata file
-	 *
-	 * @param string $path relative to the data/ folder
-	 * @return boolean
-	 */
-	public function isFile($path) {
-		$parts = explode('/', Filesystem::normalizePath($path), 4);
-		if (isset($parts[2]) && $parts[2] === 'files') {
-			return true;
-		}
-		return false;
-	}
-
-	/**
-	 * return size of encryption header
-	 *
-	 * @return integer
-	 */
-	public function getHeaderSize() {
-		return $this->headerSize;
-	}
-
-	/**
-	 * return size of block read by a PHP stream
-	 *
-	 * @return integer
-	 */
-	public function getBlockSize() {
-		return $this->blockSize;
-	}
-
-	/**
-	 * get the owner and the path for the file relative to the owners files folder
-	 *
-	 * @param string $path
-	 * @return array
-	 * @throws \BadMethodCallException
-	 */
-	public function getUidAndFilename($path) {
-		$parts = explode('/', $path);
-		$uid = '';
-		if (count($parts) > 2) {
-			$uid = $parts[1];
-		}
-		if (!$this->userManager->userExists($uid)) {
-			throw new \BadMethodCallException(
-				'path needs to be relative to the system wide data folder and point to a user specific file'
-			);
-		}
-
-		$ownerPath = implode('/', array_slice($parts, 2));
-
-		return [$uid, Filesystem::normalizePath($ownerPath)];
-	}
-
-	/**
-	 * Remove .path extension from a file path
-	 * @param string $path Path that may identify a .part file
-	 * @return string File path without .part extension
-	 * @note this is needed for reusing keys
-	 */
-	public function stripPartialFileExtension($path) {
-		$extension = pathinfo($path, PATHINFO_EXTENSION);
-
-		if ($extension === 'part') {
-			$newLength = strlen($path) - 5; // 5 = strlen(".part")
-			$fPath = substr($path, 0, $newLength);
-
-			// if path also contains a transaction id, we remove it too
-			$extension = pathinfo($fPath, PATHINFO_EXTENSION);
-			if (substr($extension, 0, 12) === 'ocTransferId') { // 12 = strlen("ocTransferId")
-				$newLength = strlen($fPath) - strlen($extension) -1;
-				$fPath = substr($fPath, 0, $newLength);
-			}
-			return $fPath;
-		} else {
-			return $path;
-		}
-	}
-
-	public function getUserWithAccessToMountPoint($users, $groups) {
-		$result = [];
-		if (in_array('all', $users)) {
-			$users = $this->userManager->search('', null, null);
-			$result = array_map(function (IUser $user) {
-				return $user->getUID();
-			}, $users);
-		} else {
-			$result = array_merge($result, $users);
-
-			$groupManager = \OC::$server->getGroupManager();
-			foreach ($groups as $group) {
-				$groupObject = $groupManager->get($group);
-				if ($groupObject) {
-					$foundUsers = $groupObject->searchUsers('', -1, 0);
-					$userIds = [];
-					foreach ($foundUsers as $user) {
-						$userIds[] = $user->getUID();
-					}
-					$result = array_merge($result, $userIds);
-				}
-			}
-		}
-
-		return $result;
-	}
-
-	/**
-	 * check if the file is stored on a system wide mount point
-	 * @param string $path relative to /data/user with leading '/'
-	 * @param string $uid
-	 * @return boolean
-	 */
-	public function isSystemWideMountPoint($path, $uid) {
-		if (\OCP\App::isEnabled("files_external")) {
-			$mounts = \OCA\Files_External\MountConfig::getSystemMountPoints();
-			foreach ($mounts as $mount) {
-				if (strpos($path, '/files/' . $mount['mountpoint']) === 0) {
-					if ($this->isMountPointApplicableToUser($mount, $uid)) {
-						return true;
-					}
-				}
-			}
-		}
-		return false;
-	}
-
-	/**
-	 * check if mount point is applicable to user
-	 *
-	 * @param array $mount contains $mount['applicable']['users'], $mount['applicable']['groups']
-	 * @param string $uid
-	 * @return boolean
-	 */
-	private function isMountPointApplicableToUser($mount, $uid) {
-		$acceptedUids = ['all', $uid];
-		// check if mount point is applicable for the user
-		$intersection = array_intersect($acceptedUids, $mount['applicable']['users']);
-		if (!empty($intersection)) {
-			return true;
-		}
-		// check if mount point is applicable for group where the user is a member
-		foreach ($mount['applicable']['groups'] as $gid) {
-			if ($this->groupManager->isInGroup($uid, $gid)) {
-				return true;
-			}
-		}
-		return false;
-	}
-
-	/**
-	 * check if it is a path which is excluded by ownCloud from encryption
-	 *
-	 * @param string $path
-	 * @return boolean
-	 */
-	public function isExcluded($path) {
-		$normalizedPath = Filesystem::normalizePath($path);
-		$root = explode('/', $normalizedPath, 4);
-		if (count($root) > 1) {
-
-			// detect alternative key storage root
-			$rootDir = $this->getKeyStorageRoot();
-			if ($rootDir !== '' &&
-				0 === strpos(
-					Filesystem::normalizePath($path),
-					Filesystem::normalizePath($rootDir)
-				)
-			) {
-				return true;
-			}
-
-
-			//detect system wide folders
-			if (in_array($root[1], $this->excludedPaths)) {
-				return true;
-			}
-
-			// detect user specific folders
-			if ($this->userManager->userExists($root[1])
-				&& in_array($root[2], $this->excludedPaths)) {
-				return true;
-			}
-		}
-		return false;
-	}
-
-	/**
-	 * check if recovery key is enabled for user
-	 *
-	 * @param string $uid
-	 * @return boolean
-	 */
-	public function recoveryEnabled($uid) {
-		$enabled = $this->config->getUserValue($uid, 'encryption', 'recovery_enabled', '0');
-
-		return $enabled === '1';
-	}
-
-	/**
-	 * set new key storage root
-	 *
-	 * @param string $root new key store root relative to the data folder
-	 */
-	public function setKeyStorageRoot($root) {
-		$this->config->setAppValue('core', 'encryption_key_storage_root', $root);
-	}
-
-	/**
-	 * get key storage root
-	 *
-	 * @return string key storage root
-	 */
-	public function getKeyStorageRoot() {
-		return $this->config->getAppValue('core', 'encryption_key_storage_root', '');
-	}
+    public const HEADER_START = 'HBEGIN';
+    public const HEADER_END = 'HEND';
+    public const HEADER_PADDING_CHAR = '-';
+
+    public const HEADER_ENCRYPTION_MODULE_KEY = 'oc_encryption_module';
+
+    /**
+     * block size will always be 8192 for a PHP stream
+     * @see https://bugs.php.net/bug.php?id=21641
+     * @var integer
+     */
+    protected $headerSize = 8192;
+
+    /**
+     * block size will always be 8192 for a PHP stream
+     * @see https://bugs.php.net/bug.php?id=21641
+     * @var integer
+     */
+    protected $blockSize = 8192;
+
+    /** @var View */
+    protected $rootView;
+
+    /** @var array */
+    protected $ocHeaderKeys;
+
+    /** @var \OC\User\Manager */
+    protected $userManager;
+
+    /** @var IConfig */
+    protected $config;
+
+    /** @var array paths excluded from encryption */
+    protected $excludedPaths;
+
+    /** @var \OC\Group\Manager $manager */
+    protected $groupManager;
+
+    /**
+     *
+     * @param View $rootView
+     * @param \OC\User\Manager $userManager
+     * @param \OC\Group\Manager $groupManager
+     * @param IConfig $config
+     */
+    public function __construct(
+        View $rootView,
+        \OC\User\Manager $userManager,
+        \OC\Group\Manager $groupManager,
+        IConfig $config) {
+        $this->ocHeaderKeys = [
+            self::HEADER_ENCRYPTION_MODULE_KEY
+        ];
+
+        $this->rootView = $rootView;
+        $this->userManager = $userManager;
+        $this->groupManager = $groupManager;
+        $this->config = $config;
+
+        $this->excludedPaths[] = 'files_encryption';
+        $this->excludedPaths[] = 'appdata_' . $config->getSystemValue('instanceid', null);
+        $this->excludedPaths[] = 'files_external';
+    }
+
+    /**
+     * read encryption module ID from header
+     *
+     * @param array $header
+     * @return string
+     * @throws ModuleDoesNotExistsException
+     */
+    public function getEncryptionModuleId(array $header = null) {
+        $id = '';
+        $encryptionModuleKey = self::HEADER_ENCRYPTION_MODULE_KEY;
+
+        if (isset($header[$encryptionModuleKey])) {
+            $id = $header[$encryptionModuleKey];
+        } elseif (isset($header['cipher'])) {
+            if (class_exists('\OCA\Encryption\Crypto\Encryption')) {
+                // fall back to default encryption if the user migrated from
+                // ownCloud <= 8.0 with the old encryption
+                $id = \OCA\Encryption\Crypto\Encryption::ID;
+            } else {
+                throw new ModuleDoesNotExistsException('Default encryption module missing');
+            }
+        }
+
+        return $id;
+    }
+
+    /**
+     * create header for encrypted file
+     *
+     * @param array $headerData
+     * @param IEncryptionModule $encryptionModule
+     * @return string
+     * @throws EncryptionHeaderToLargeException if header has to many arguments
+     * @throws EncryptionHeaderKeyExistsException if header key is already in use
+     */
+    public function createHeader(array $headerData, IEncryptionModule $encryptionModule) {
+        $header = self::HEADER_START . ':' . self::HEADER_ENCRYPTION_MODULE_KEY . ':' . $encryptionModule->getId() . ':';
+        foreach ($headerData as $key => $value) {
+            if (in_array($key, $this->ocHeaderKeys)) {
+                throw new EncryptionHeaderKeyExistsException($key);
+            }
+            $header .= $key . ':' . $value . ':';
+        }
+        $header .= self::HEADER_END;
+
+        if (strlen($header) > $this->getHeaderSize()) {
+            throw new EncryptionHeaderToLargeException();
+        }
+
+        $paddedHeader = str_pad($header, $this->headerSize, self::HEADER_PADDING_CHAR, STR_PAD_RIGHT);
+
+        return $paddedHeader;
+    }
+
+    /**
+     * go recursively through a dir and collect all files and sub files.
+     *
+     * @param string $dir relative to the users files folder
+     * @return array with list of files relative to the users files folder
+     */
+    public function getAllFiles($dir) {
+        $result = [];
+        $dirList = [$dir];
+
+        while ($dirList) {
+            $dir = array_pop($dirList);
+            $content = $this->rootView->getDirectoryContent($dir);
+
+            foreach ($content as $c) {
+                if ($c->getType() === 'dir') {
+                    $dirList[] = $c->getPath();
+                } else {
+                    $result[] =  $c->getPath();
+                }
+            }
+        }
+
+        return $result;
+    }
+
+    /**
+     * check if it is a file uploaded by the user stored in data/user/files
+     * or a metadata file
+     *
+     * @param string $path relative to the data/ folder
+     * @return boolean
+     */
+    public function isFile($path) {
+        $parts = explode('/', Filesystem::normalizePath($path), 4);
+        if (isset($parts[2]) && $parts[2] === 'files') {
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * return size of encryption header
+     *
+     * @return integer
+     */
+    public function getHeaderSize() {
+        return $this->headerSize;
+    }
+
+    /**
+     * return size of block read by a PHP stream
+     *
+     * @return integer
+     */
+    public function getBlockSize() {
+        return $this->blockSize;
+    }
+
+    /**
+     * get the owner and the path for the file relative to the owners files folder
+     *
+     * @param string $path
+     * @return array
+     * @throws \BadMethodCallException
+     */
+    public function getUidAndFilename($path) {
+        $parts = explode('/', $path);
+        $uid = '';
+        if (count($parts) > 2) {
+            $uid = $parts[1];
+        }
+        if (!$this->userManager->userExists($uid)) {
+            throw new \BadMethodCallException(
+                'path needs to be relative to the system wide data folder and point to a user specific file'
+            );
+        }
+
+        $ownerPath = implode('/', array_slice($parts, 2));
+
+        return [$uid, Filesystem::normalizePath($ownerPath)];
+    }
+
+    /**
+     * Remove .path extension from a file path
+     * @param string $path Path that may identify a .part file
+     * @return string File path without .part extension
+     * @note this is needed for reusing keys
+     */
+    public function stripPartialFileExtension($path) {
+        $extension = pathinfo($path, PATHINFO_EXTENSION);
+
+        if ($extension === 'part') {
+            $newLength = strlen($path) - 5; // 5 = strlen(".part")
+            $fPath = substr($path, 0, $newLength);
+
+            // if path also contains a transaction id, we remove it too
+            $extension = pathinfo($fPath, PATHINFO_EXTENSION);
+            if (substr($extension, 0, 12) === 'ocTransferId') { // 12 = strlen("ocTransferId")
+                $newLength = strlen($fPath) - strlen($extension) -1;
+                $fPath = substr($fPath, 0, $newLength);
+            }
+            return $fPath;
+        } else {
+            return $path;
+        }
+    }
+
+    public function getUserWithAccessToMountPoint($users, $groups) {
+        $result = [];
+        if (in_array('all', $users)) {
+            $users = $this->userManager->search('', null, null);
+            $result = array_map(function (IUser $user) {
+                return $user->getUID();
+            }, $users);
+        } else {
+            $result = array_merge($result, $users);
+
+            $groupManager = \OC::$server->getGroupManager();
+            foreach ($groups as $group) {
+                $groupObject = $groupManager->get($group);
+                if ($groupObject) {
+                    $foundUsers = $groupObject->searchUsers('', -1, 0);
+                    $userIds = [];
+                    foreach ($foundUsers as $user) {
+                        $userIds[] = $user->getUID();
+                    }
+                    $result = array_merge($result, $userIds);
+                }
+            }
+        }
+
+        return $result;
+    }
+
+    /**
+     * check if the file is stored on a system wide mount point
+     * @param string $path relative to /data/user with leading '/'
+     * @param string $uid
+     * @return boolean
+     */
+    public function isSystemWideMountPoint($path, $uid) {
+        if (\OCP\App::isEnabled("files_external")) {
+            $mounts = \OCA\Files_External\MountConfig::getSystemMountPoints();
+            foreach ($mounts as $mount) {
+                if (strpos($path, '/files/' . $mount['mountpoint']) === 0) {
+                    if ($this->isMountPointApplicableToUser($mount, $uid)) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+
+    /**
+     * check if mount point is applicable to user
+     *
+     * @param array $mount contains $mount['applicable']['users'], $mount['applicable']['groups']
+     * @param string $uid
+     * @return boolean
+     */
+    private function isMountPointApplicableToUser($mount, $uid) {
+        $acceptedUids = ['all', $uid];
+        // check if mount point is applicable for the user
+        $intersection = array_intersect($acceptedUids, $mount['applicable']['users']);
+        if (!empty($intersection)) {
+            return true;
+        }
+        // check if mount point is applicable for group where the user is a member
+        foreach ($mount['applicable']['groups'] as $gid) {
+            if ($this->groupManager->isInGroup($uid, $gid)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * check if it is a path which is excluded by ownCloud from encryption
+     *
+     * @param string $path
+     * @return boolean
+     */
+    public function isExcluded($path) {
+        $normalizedPath = Filesystem::normalizePath($path);
+        $root = explode('/', $normalizedPath, 4);
+        if (count($root) > 1) {
+
+            // detect alternative key storage root
+            $rootDir = $this->getKeyStorageRoot();
+            if ($rootDir !== '' &&
+                0 === strpos(
+                    Filesystem::normalizePath($path),
+                    Filesystem::normalizePath($rootDir)
+                )
+            ) {
+                return true;
+            }
+
+
+            //detect system wide folders
+            if (in_array($root[1], $this->excludedPaths)) {
+                return true;
+            }
+
+            // detect user specific folders
+            if ($this->userManager->userExists($root[1])
+                && in_array($root[2], $this->excludedPaths)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * check if recovery key is enabled for user
+     *
+     * @param string $uid
+     * @return boolean
+     */
+    public function recoveryEnabled($uid) {
+        $enabled = $this->config->getUserValue($uid, 'encryption', 'recovery_enabled', '0');
+
+        return $enabled === '1';
+    }
+
+    /**
+     * set new key storage root
+     *
+     * @param string $root new key store root relative to the data folder
+     */
+    public function setKeyStorageRoot($root) {
+        $this->config->setAppValue('core', 'encryption_key_storage_root', $root);
+    }
+
+    /**
+     * get key storage root
+     *
+     * @return string key storage root
+     */
+    public function getKeyStorageRoot() {
+        return $this->config->getAppValue('core', 'encryption_key_storage_root', '');
+    }
 }

Spacing +7 added lines, -7 removed lines

@@ -98,7 +98,7 @@ 
 		$this->config = $config;
 
 		$this->excludedPaths[] = 'files_encryption';
-		$this->excludedPaths[] = 'appdata_' . $config->getSystemValue('instanceid', null);
+		$this->excludedPaths[] = 'appdata_'.$config->getSystemValue('instanceid', null);
 		$this->excludedPaths[] = 'files_external';
 	}
 
@@ -138,12 +138,12 @@ 
 	 * @throws EncryptionHeaderKeyExistsException if header key is already in use
 	 */
 	public function createHeader(array $headerData, IEncryptionModule $encryptionModule) {
-		$header = self::HEADER_START . ':' . self::HEADER_ENCRYPTION_MODULE_KEY . ':' . $encryptionModule->getId() . ':';
+		$header = self::HEADER_START.':'.self::HEADER_ENCRYPTION_MODULE_KEY.':'.$encryptionModule->getId().':';
 		foreach ($headerData as $key => $value) {
 			if (in_array($key, $this->ocHeaderKeys)) {
 				throw new EncryptionHeaderKeyExistsException($key);
 			}
-			$header .= $key . ':' . $value . ':';
+			$header .= $key.':'.$value.':';
 		}
 		$header .= self::HEADER_END;
 
@@ -174,7 +174,7 @@ 
 				if ($c->getType() === 'dir') {
 					$dirList[] = $c->getPath();
 				} else {
-					$result[] =  $c->getPath();
+					$result[] = $c->getPath();
 				}
 			}
 		}
@@ -255,7 +255,7 @@ 
 			// if path also contains a transaction id, we remove it too
 			$extension = pathinfo($fPath, PATHINFO_EXTENSION);
 			if (substr($extension, 0, 12) === 'ocTransferId') { // 12 = strlen("ocTransferId")
-				$newLength = strlen($fPath) - strlen($extension) -1;
+				$newLength = strlen($fPath) - strlen($extension) - 1;
 				$fPath = substr($fPath, 0, $newLength);
 			}
 			return $fPath;
@@ -268,7 +268,7 @@ 
 		$result = [];
 		if (in_array('all', $users)) {
 			$users = $this->userManager->search('', null, null);
-			$result = array_map(function (IUser $user) {
+			$result = array_map(function(IUser $user) {
 				return $user->getUID();
 			}, $users);
 		} else {
@@ -301,7 +301,7 @@ 
 		if (\OCP\App::isEnabled("files_external")) {
 			$mounts = \OCA\Files_External\MountConfig::getSystemMountPoints();
 			foreach ($mounts as $mount) {
-				if (strpos($path, '/files/' . $mount['mountpoint']) === 0) {
+				if (strpos($path, '/files/'.$mount['mountpoint']) === 0) {
 					if ($this->isMountPointApplicableToUser($mount, $uid)) {
 						return true;
 					}

lib/private/Log/ExceptionSerializer.php

Indentation +152 added lines, -152 removed lines

@@ -34,156 +34,156 @@
 use OC\Setup;
 
 class ExceptionSerializer {
-	public const methodsWithSensitiveParameters = [
-		// Session/User
-		'completeLogin',
-		'login',
-		'checkPassword',
-		'checkPasswordNoLogging',
-		'loginWithPassword',
-		'updatePrivateKeyPassword',
-		'validateUserPass',
-		'loginWithToken',
-		'{closure}',
-		'createSessionToken',
-
-		// Provisioning
-		'addUser',
-
-		// TokenProvider
-		'getToken',
-		'isTokenPassword',
-		'getPassword',
-		'decryptPassword',
-		'logClientIn',
-		'generateToken',
-		'validateToken',
-
-		// TwoFactorAuth
-		'solveChallenge',
-		'verifyChallenge',
-
-		// ICrypto
-		'calculateHMAC',
-		'encrypt',
-		'decrypt',
-
-		// LoginController
-		'tryLogin',
-		'confirmPassword',
-
-		// LDAP
-		'bind',
-		'areCredentialsValid',
-		'invokeLDAPMethod',
-
-		// Encryption
-		'storeKeyPair',
-		'setupUser',
-
-		// files_external: OCA\Files_External\MountConfig
-		'getBackendStatus',
-
-		// files_external: UserStoragesController
-		'update',
-	];
-
-	public const methodsWithSensitiveParametersByClass = [
-		SetupController::class => [
-			'run',
-			'display',
-			'loadAutoConfig',
-		],
-		Setup::class => [
-			'install'
-		],
-		Key::class => [
-			'__construct'
-		],
-	];
-
-	private function editTrace(array &$sensitiveValues, array $traceLine): array {
-		if (isset($traceLine['args'])) {
-			$sensitiveValues = array_merge($sensitiveValues, $traceLine['args']);
-		}
-		$traceLine['args'] = ['*** sensitive parameters replaced ***'];
-		return $traceLine;
-	}
-
-	private function filterTrace(array $trace) {
-		$sensitiveValues = [];
-		$trace = array_map(function (array $traceLine) use (&$sensitiveValues) {
-			$className = $traceLine['class'] ?? '';
-			if ($className && isset(self::methodsWithSensitiveParametersByClass[$className])
-				&& in_array($traceLine['function'], self::methodsWithSensitiveParametersByClass[$className], true)) {
-				return $this->editTrace($sensitiveValues, $traceLine);
-			}
-			foreach (self::methodsWithSensitiveParameters as $sensitiveMethod) {
-				if (strpos($traceLine['function'], $sensitiveMethod) !== false) {
-					return $this->editTrace($sensitiveValues, $traceLine);
-				}
-			}
-			return $traceLine;
-		}, $trace);
-		return array_map(function (array $traceLine) use ($sensitiveValues) {
-			if (isset($traceLine['args'])) {
-				$traceLine['args'] = $this->removeValuesFromArgs($traceLine['args'], $sensitiveValues);
-			}
-			return $traceLine;
-		}, $trace);
-	}
-
-	private function removeValuesFromArgs($args, $values) {
-		foreach ($args as &$arg) {
-			if (in_array($arg, $values, true)) {
-				$arg = '*** sensitive parameter replaced ***';
-			} elseif (is_array($arg)) {
-				$arg = $this->removeValuesFromArgs($arg, $values);
-			}
-		}
-		return $args;
-	}
-
-	private function encodeTrace($trace) {
-		$filteredTrace = $this->filterTrace($trace);
-		return array_map(function (array $line) {
-			if (isset($line['args'])) {
-				$line['args'] = array_map([$this, 'encodeArg'], $line['args']);
-			}
-			return $line;
-		}, $filteredTrace);
-	}
-
-	private function encodeArg($arg) {
-		if (is_object($arg)) {
-			$data = get_object_vars($arg);
-			$data['__class__'] = get_class($arg);
-			return array_map([$this, 'encodeArg'], $data);
-		} elseif (is_array($arg)) {
-			return array_map([$this, 'encodeArg'], $arg);
-		} else {
-			return $arg;
-		}
-	}
-
-	public function serializeException(\Throwable $exception) {
-		$data = [
-			'Exception' => get_class($exception),
-			'Message' => $exception->getMessage(),
-			'Code' => $exception->getCode(),
-			'Trace' => $this->encodeTrace($exception->getTrace()),
-			'File' => $exception->getFile(),
-			'Line' => $exception->getLine(),
-		];
-
-		if ($exception instanceof HintException) {
-			$data['Hint'] = $exception->getHint();
-		}
-
-		if ($exception->getPrevious()) {
-			$data['Previous'] = $this->serializeException($exception->getPrevious());
-		}
-
-		return $data;
-	}
+    public const methodsWithSensitiveParameters = [
+        // Session/User
+        'completeLogin',
+        'login',
+        'checkPassword',
+        'checkPasswordNoLogging',
+        'loginWithPassword',
+        'updatePrivateKeyPassword',
+        'validateUserPass',
+        'loginWithToken',
+        '{closure}',
+        'createSessionToken',
+
+        // Provisioning
+        'addUser',
+
+        // TokenProvider
+        'getToken',
+        'isTokenPassword',
+        'getPassword',
+        'decryptPassword',
+        'logClientIn',
+        'generateToken',
+        'validateToken',
+
+        // TwoFactorAuth
+        'solveChallenge',
+        'verifyChallenge',
+
+        // ICrypto
+        'calculateHMAC',
+        'encrypt',
+        'decrypt',
+
+        // LoginController
+        'tryLogin',
+        'confirmPassword',
+
+        // LDAP
+        'bind',
+        'areCredentialsValid',
+        'invokeLDAPMethod',
+
+        // Encryption
+        'storeKeyPair',
+        'setupUser',
+
+        // files_external: OCA\Files_External\MountConfig
+        'getBackendStatus',
+
+        // files_external: UserStoragesController
+        'update',
+    ];
+
+    public const methodsWithSensitiveParametersByClass = [
+        SetupController::class => [
+            'run',
+            'display',
+            'loadAutoConfig',
+        ],
+        Setup::class => [
+            'install'
+        ],
+        Key::class => [
+            '__construct'
+        ],
+    ];
+
+    private function editTrace(array &$sensitiveValues, array $traceLine): array {
+        if (isset($traceLine['args'])) {
+            $sensitiveValues = array_merge($sensitiveValues, $traceLine['args']);
+        }
+        $traceLine['args'] = ['*** sensitive parameters replaced ***'];
+        return $traceLine;
+    }
+
+    private function filterTrace(array $trace) {
+        $sensitiveValues = [];
+        $trace = array_map(function (array $traceLine) use (&$sensitiveValues) {
+            $className = $traceLine['class'] ?? '';
+            if ($className && isset(self::methodsWithSensitiveParametersByClass[$className])
+                && in_array($traceLine['function'], self::methodsWithSensitiveParametersByClass[$className], true)) {
+                return $this->editTrace($sensitiveValues, $traceLine);
+            }
+            foreach (self::methodsWithSensitiveParameters as $sensitiveMethod) {
+                if (strpos($traceLine['function'], $sensitiveMethod) !== false) {
+                    return $this->editTrace($sensitiveValues, $traceLine);
+                }
+            }
+            return $traceLine;
+        }, $trace);
+        return array_map(function (array $traceLine) use ($sensitiveValues) {
+            if (isset($traceLine['args'])) {
+                $traceLine['args'] = $this->removeValuesFromArgs($traceLine['args'], $sensitiveValues);
+            }
+            return $traceLine;
+        }, $trace);
+    }
+
+    private function removeValuesFromArgs($args, $values) {
+        foreach ($args as &$arg) {
+            if (in_array($arg, $values, true)) {
+                $arg = '*** sensitive parameter replaced ***';
+            } elseif (is_array($arg)) {
+                $arg = $this->removeValuesFromArgs($arg, $values);
+            }
+        }
+        return $args;
+    }
+
+    private function encodeTrace($trace) {
+        $filteredTrace = $this->filterTrace($trace);
+        return array_map(function (array $line) {
+            if (isset($line['args'])) {
+                $line['args'] = array_map([$this, 'encodeArg'], $line['args']);
+            }
+            return $line;
+        }, $filteredTrace);
+    }
+
+    private function encodeArg($arg) {
+        if (is_object($arg)) {
+            $data = get_object_vars($arg);
+            $data['__class__'] = get_class($arg);
+            return array_map([$this, 'encodeArg'], $data);
+        } elseif (is_array($arg)) {
+            return array_map([$this, 'encodeArg'], $arg);
+        } else {
+            return $arg;
+        }
+    }
+
+    public function serializeException(\Throwable $exception) {
+        $data = [
+            'Exception' => get_class($exception),
+            'Message' => $exception->getMessage(),
+            'Code' => $exception->getCode(),
+            'Trace' => $this->encodeTrace($exception->getTrace()),
+            'File' => $exception->getFile(),
+            'Line' => $exception->getLine(),
+        ];
+
+        if ($exception instanceof HintException) {
+            $data['Hint'] = $exception->getHint();
+        }
+
+        if ($exception->getPrevious()) {
+            $data['Previous'] = $this->serializeException($exception->getPrevious());
+        }
+
+        return $data;
+    }
 }