From 9c9dc276b7a1d2592c4fb0a887888632dc1f1e29 Mon Sep 17 00:00:00 2001
From: Thomas Müller <thomas.mueller@tmit.eu>
Date: Wed, 25 Sep 2013 13:36:30 +0200
Subject: move the private namespace OC into lib/private - OCP will stay in
 lib/public

Conflicts:
	lib/private/vcategories.php
---
 lib/private/files/filesystem.php | 770 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 770 insertions(+)
 create mode 100644 lib/private/files/filesystem.php

(limited to 'lib/private/files/filesystem.php')

diff --git a/lib/private/files/filesystem.php b/lib/private/files/filesystem.php
new file mode 100644
index 00000000000..10ec5c41d11
--- /dev/null
+++ b/lib/private/files/filesystem.php
@@ -0,0 +1,770 @@
+<?php
+/**
+ * Copyright (c) 2012 Robin Appelman <icewind@owncloud.com>
+ * This file is licensed under the Affero General Public License version 3 or
+ * later.
+ * See the COPYING-README file.
+ */
+
+/**
+ * Class for abstraction of filesystem functions
+ * This class won't call any filesystem functions for itself but will pass them to the correct OC_Filestorage object
+ * this class should also handle all the file permission related stuff
+ *
+ * Hooks provided:
+ *   read(path)
+ *   write(path, &run)
+ *   post_write(path)
+ *   create(path, &run) (when a file is created, both create and write will be emitted in that order)
+ *   post_create(path)
+ *   delete(path, &run)
+ *   post_delete(path)
+ *   rename(oldpath,newpath, &run)
+ *   post_rename(oldpath,newpath)
+ *   copy(oldpath,newpath, &run) (if the newpath doesn't exists yes, copy, create and write will be emitted in that order)
+ *   post_rename(oldpath,newpath)
+ *   post_initMountPoints(user, user_dir)
+ *
+ *   the &run parameter can be set to false to prevent the operation from occurring
+ */
+
+namespace OC\Files;
+
+use OC\Files\Storage\Loader;
+const SPACE_NOT_COMPUTED = -1;
+const SPACE_UNKNOWN = -2;
+const SPACE_UNLIMITED = -3;
+
+class Filesystem {
+	/**
+	 * @var Mount\Manager $mounts
+	 */
+	private static $mounts;
+
+	public static $loaded = false;
+	/**
+	 * @var \OC\Files\View $defaultInstance
+	 */
+	static private $defaultInstance;
+
+
+	/**
+	 * classname which used for hooks handling
+	 * used as signalclass in OC_Hooks::emit()
+	 */
+	const CLASSNAME = 'OC_Filesystem';
+
+	/**
+	 * signalname emitted before file renaming
+	 *
+	 * @param string $oldpath
+	 * @param string $newpath
+	 */
+	const signal_rename = 'rename';
+
+	/**
+	 * signal emitted after file renaming
+	 *
+	 * @param string $oldpath
+	 * @param string $newpath
+	 */
+	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
+	 */
+	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
+	 */
+	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
+	 */
+	const signal_copy = 'copy';
+
+	/**
+	 * signal emits after file/dir copy
+	 *
+	 * @param string $oldpath
+	 * @param string $newpath
+	 */
+	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
+	 */
+	const signal_write = 'write';
+
+	/**
+	 * signal emits after file/dir save
+	 *
+	 * @param string $path
+	 */
+	const signal_post_write = 'post_write';
+
+	/**
+	 * signal emits when reading file/dir
+	 *
+	 * @param string $path
+	 */
+	const signal_read = 'read';
+
+	/**
+	 * signal emits when removing file/dir
+	 *
+	 * @param string $path
+	 */
+	const signal_delete = 'delete';
+
+	/**
+	 * parameters definitions for signals
+	 */
+	const signal_param_path = 'path';
+	const signal_param_oldpath = 'oldpath';
+	const signal_param_newpath = 'newpath';
+
+	/**
+	 * run - changing this flag to false in hook handler will cancel event
+	 */
+	const signal_param_run = 'run';
+
+	/**
+	 * @var \OC\Files\Storage\Loader $loader
+	 */
+	private static $loader;
+
+	/**
+	 * @param callable $wrapper
+	 */
+	public static function addStorageWrapper($wrapper) {
+		self::getLoader()->addStorageWrapper($wrapper);
+
+		$mounts = self::getMountManager()->getAll();
+		foreach ($mounts as $mount) {
+			$mount->wrapStorage($wrapper);
+		}
+	}
+
+	public static function getLoader() {
+		if (!self::$loader) {
+			self::$loader = new Loader();
+		}
+		return self::$loader;
+	}
+
+	public static function getMountManager() {
+		if (!self::$mounts) {
+			\OC_Util::setupFS();
+		}
+		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
+	 */
+	static public function getMountPoint($path) {
+		if (!self::$mounts) {
+			\OC_Util::setupFS();
+		}
+		$mount = self::$mounts->find($path);
+		if ($mount) {
+			return $mount->getMountPoint();
+		} else {
+			return '';
+		}
+	}
+
+	/**
+	 * get a list of all mount points in a directory
+	 *
+	 * @param string $path
+	 * @return string[]
+	 */
+	static public function getMountPoints($path) {
+		if (!self::$mounts) {
+			\OC_Util::setupFS();
+		}
+		$result = array();
+		$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
+	 */
+	public static function getStorage($mountPoint) {
+		if (!self::$mounts) {
+			\OC_Util::setupFS();
+		}
+		$mount = self::$mounts->find($mountPoint);
+		return $mount->getStorage();
+	}
+
+	/**
+	 * @param $id
+	 * @return Mount\Mount[]
+	 */
+	public static function getMountByStorageId($id) {
+		if (!self::$mounts) {
+			\OC_Util::setupFS();
+		}
+		return self::$mounts->findByStorageId($id);
+	}
+
+	/**
+	 * @param $id
+	 * @return Mount\Mount[]
+	 */
+	public static function getMountByNumericId($id) {
+		if (!self::$mounts) {
+			\OC_Util::setupFS();
+		}
+		return self::$mounts->findByNumericId($id);
+	}
+
+	/**
+	 * resolve a path to a storage and internal path
+	 *
+	 * @param string $path
+	 * @return array consisting of the storage and the internal path
+	 */
+	static public function resolvePath($path) {
+		if (!self::$mounts) {
+			\OC_Util::setupFS();
+		}
+		$mount = self::$mounts->find($path);
+		if ($mount) {
+			return array($mount->getStorage(), $mount->getInternalPath($path));
+		} else {
+			return array(null, null);
+		}
+	}
+
+	static public function init($user, $root) {
+		if (self::$defaultInstance) {
+			return false;
+		}
+		self::getLoader();
+		self::$defaultInstance = new View($root);
+
+		if (!self::$mounts) {
+			self::$mounts = new Mount\Manager();
+		}
+
+		//load custom mount config
+		self::initMountPoints($user);
+
+		self::$loaded = true;
+
+		return true;
+	}
+
+	static public function initMounts() {
+		if (!self::$mounts) {
+			self::$mounts = new Mount\Manager();
+		}
+	}
+
+	/**
+	 * Initialize system and personal mount points for a user
+	 *
+	 * @param string $user
+	 */
+	public static function initMountPoints($user = '') {
+		if ($user == '') {
+			$user = \OC_User::getUser();
+		}
+		$parser = new \OC\ArrayParser();
+
+		$root = \OC_User::getHome($user);
+		self::mount('\OC\Files\Storage\Local', array('datadir' => $root), $user);
+		$datadir = \OC_Config::getValue("datadirectory", \OC::$SERVERROOT . "/data");
+
+		//move config file to it's new position
+		if (is_file(\OC::$SERVERROOT . '/config/mount.json')) {
+			rename(\OC::$SERVERROOT . '/config/mount.json', $datadir . '/mount.json');
+		}
+		// Load system mount points
+		if (is_file(\OC::$SERVERROOT . '/config/mount.php') or is_file($datadir . '/mount.json')) {
+			if (is_file($datadir . '/mount.json')) {
+				$mountConfig = json_decode(file_get_contents($datadir . '/mount.json'), true);
+			} elseif (is_file(\OC::$SERVERROOT . '/config/mount.php')) {
+				$mountConfig = $parser->parsePHP(file_get_contents(\OC::$SERVERROOT . '/config/mount.php'));
+			}
+			if (isset($mountConfig['global'])) {
+				foreach ($mountConfig['global'] as $mountPoint => $options) {
+					self::mount($options['class'], $options['options'], $mountPoint);
+				}
+			}
+			if (isset($mountConfig['group'])) {
+				foreach ($mountConfig['group'] as $group => $mounts) {
+					if (\OC_Group::inGroup($user, $group)) {
+						foreach ($mounts as $mountPoint => $options) {
+							$mountPoint = self::setUserVars($user, $mountPoint);
+							foreach ($options as &$option) {
+								$option = self::setUserVars($user, $option);
+							}
+							self::mount($options['class'], $options['options'], $mountPoint);
+						}
+					}
+				}
+			}
+			if (isset($mountConfig['user'])) {
+				foreach ($mountConfig['user'] as $mountUser => $mounts) {
+					if ($mountUser === 'all' or strtolower($mountUser) === strtolower($user)) {
+						foreach ($mounts as $mountPoint => $options) {
+							$mountPoint = self::setUserVars($user, $mountPoint);
+							foreach ($options as &$option) {
+								$option = self::setUserVars($user, $option);
+							}
+							self::mount($options['class'], $options['options'], $mountPoint);
+						}
+					}
+				}
+			}
+		}
+		// Load personal mount points
+		if (is_file($root . '/mount.php') or is_file($root . '/mount.json')) {
+			if (is_file($root . '/mount.json')) {
+				$mountConfig = json_decode(file_get_contents($root . '/mount.json'), true);
+			} elseif (is_file($root . '/mount.php')) {
+				$mountConfig = $parser->parsePHP(file_get_contents($root . '/mount.php'));
+			}
+			if (isset($mountConfig['user'][$user])) {
+				foreach ($mountConfig['user'][$user] as $mountPoint => $options) {
+					self::mount($options['class'], $options['options'], $mountPoint);
+				}
+			}
+		}
+
+		// Chance to mount for other storages
+		\OC_Hook::emit('OC_Filesystem', 'post_initMountPoints', array('user' => $user, 'user_dir' => $root));
+	}
+
+	/**
+	 * fill in the correct values for $user
+	 *
+	 * @param string $user
+	 * @param string $input
+	 * @return string
+	 */
+	private static function setUserVars($user, $input) {
+		return str_replace('$user', $user, $input);
+	}
+
+	/**
+	 * get the default filesystem view
+	 *
+	 * @return View
+	 */
+	static public function getView() {
+		return self::$defaultInstance;
+	}
+
+	/**
+	 * tear down the filesystem, removing all storage providers
+	 */
+	static public function tearDown() {
+		self::clearMounts();
+		self::$defaultInstance = null;
+	}
+
+	/**
+	 * @brief get the relative path of the root data directory for the current user
+	 * @return string
+	 *
+	 * Returns path like /admin/files
+	 */
+	static public function getRoot() {
+		return self::$defaultInstance->getRoot();
+	}
+
+	/**
+	 * clear all mounts and storage backends
+	 */
+	public static function clearMounts() {
+		if (self::$mounts) {
+			self::$mounts->clear();
+		}
+	}
+
+	/**
+	 * mount an \OC\Files\Storage\Storage in our virtual filesystem
+	 *
+	 * @param \OC\Files\Storage\Storage|string $class
+	 * @param array $arguments
+	 * @param string $mountpoint
+	 */
+	static public function mount($class, $arguments, $mountpoint) {
+		if (!self::$mounts) {
+			\OC_Util::setupFS();
+		}
+		$mount = new Mount\Mount($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
+	 *
+	 * @param string $path
+	 * @return string
+	 */
+	static public function getLocalFile($path) {
+		return self::$defaultInstance->getLocalFile($path);
+	}
+
+	/**
+	 * @param string $path
+	 * @return string
+	 */
+	static public function getLocalFolder($path) {
+		return self::$defaultInstance->getLocalFolder($path);
+	}
+
+	/**
+	 * return path to file which reflects one visible in browser
+	 *
+	 * @param string $path
+	 * @return string
+	 */
+	static public 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
+	 */
+	static public function isValidPath($path) {
+		$path = self::normalizePath($path);
+		if (!$path || $path[0] !== '/') {
+			$path = '/' . $path;
+		}
+		if (strstr($path, '/../') || strrchr($path, '/') === '/..') {
+			return false;
+		}
+		return true;
+	}
+
+	/**
+	 * checks if a file is blacklisted for storage in the filesystem
+	 * Listens to write and rename hooks
+	 *
+	 * @param array $data from hook
+	 */
+	static public function isBlacklisted($data) {
+		if (isset($data['path'])) {
+			$path = $data['path'];
+		} else if (isset($data['newpath'])) {
+			$path = $data['newpath'];
+		}
+		if (isset($path)) {
+			if (self::isFileBlacklisted($path)) {
+				$data['run'] = false;
+			}
+		}
+	}
+
+	/**
+	 * @param string $filename
+	 * @return bool
+	 */
+	static public function isFileBlacklisted($filename) {
+		$blacklist = \OC_Config::getValue('blacklisted_files', array('.htaccess'));
+		$filename = strtolower(basename($filename));
+		return (in_array($filename, $blacklist));
+	}
+
+	/**
+	 * @brief check if the directory should be ignored when scanning
+	 * NOTE: the special directories . and .. would cause never ending recursion
+	 * @param String $dir
+	 * @return boolean
+	 */
+	static public function isIgnoredDir($dir) {
+		if ($dir === '.' || $dir === '..') {
+			return true;
+		}
+		return false;
+	}
+
+	/**
+	 * following functions are equivalent to their php builtin equivalents for arguments/return values.
+	 */
+	static public function mkdir($path) {
+		return self::$defaultInstance->mkdir($path);
+	}
+
+	static public function rmdir($path) {
+		return self::$defaultInstance->rmdir($path);
+	}
+
+	static public function opendir($path) {
+		return self::$defaultInstance->opendir($path);
+	}
+
+	static public function readdir($path) {
+		return self::$defaultInstance->readdir($path);
+	}
+
+	static public function is_dir($path) {
+		return self::$defaultInstance->is_dir($path);
+	}
+
+	static public function is_file($path) {
+		return self::$defaultInstance->is_file($path);
+	}
+
+	static public function stat($path) {
+		return self::$defaultInstance->stat($path);
+	}
+
+	static public function filetype($path) {
+		return self::$defaultInstance->filetype($path);
+	}
+
+	static public function filesize($path) {
+		return self::$defaultInstance->filesize($path);
+	}
+
+	static public function readfile($path) {
+		return self::$defaultInstance->readfile($path);
+	}
+
+	static public function isCreatable($path) {
+		return self::$defaultInstance->isCreatable($path);
+	}
+
+	static public function isReadable($path) {
+		return self::$defaultInstance->isReadable($path);
+	}
+
+	static public function isUpdatable($path) {
+		return self::$defaultInstance->isUpdatable($path);
+	}
+
+	static public function isDeletable($path) {
+		return self::$defaultInstance->isDeletable($path);
+	}
+
+	static public function isSharable($path) {
+		return self::$defaultInstance->isSharable($path);
+	}
+
+	static public function file_exists($path) {
+		return self::$defaultInstance->file_exists($path);
+	}
+
+	static public function filemtime($path) {
+		return self::$defaultInstance->filemtime($path);
+	}
+
+	static public function touch($path, $mtime = null) {
+		return self::$defaultInstance->touch($path, $mtime);
+	}
+
+	static public function file_get_contents($path) {
+		return self::$defaultInstance->file_get_contents($path);
+	}
+
+	static public function file_put_contents($path, $data) {
+		return self::$defaultInstance->file_put_contents($path, $data);
+	}
+
+	static public function unlink($path) {
+		return self::$defaultInstance->unlink($path);
+	}
+
+	static public function rename($path1, $path2) {
+		return self::$defaultInstance->rename($path1, $path2);
+	}
+
+	static public function copy($path1, $path2) {
+		return self::$defaultInstance->copy($path1, $path2);
+	}
+
+	static public function fopen($path, $mode) {
+		return self::$defaultInstance->fopen($path, $mode);
+	}
+
+	static public function toTmpFile($path) {
+		return self::$defaultInstance->toTmpFile($path);
+	}
+
+	static public function fromTmpFile($tmpFile, $path) {
+		return self::$defaultInstance->fromTmpFile($tmpFile, $path);
+	}
+
+	static public function getMimeType($path) {
+		return self::$defaultInstance->getMimeType($path);
+	}
+
+	static public function hash($type, $path, $raw = false) {
+		return self::$defaultInstance->hash($type, $path, $raw);
+	}
+
+	static public function free_space($path = '/') {
+		return self::$defaultInstance->free_space($path);
+	}
+
+	static public function search($query) {
+		return self::$defaultInstance->search($query);
+	}
+
+	static public function searchByMime($query) {
+		return self::$defaultInstance->searchByMime($query);
+	}
+
+	/**
+	 * check if a file or folder has been updated since $time
+	 *
+	 * @param string $path
+	 * @param int $time
+	 * @return bool
+	 */
+	static public function hasUpdated($path, $time) {
+		return self::$defaultInstance->hasUpdated($path, $time);
+	}
+
+	/**
+	 * @brief Fix common problems with a file path
+	 * @param string $path
+	 * @param bool $stripTrailingSlash
+	 * @return string
+	 */
+	public static function normalizePath($path, $stripTrailingSlash = true) {
+		if ($path == '') {
+			return '/';
+		}
+		//no windows style slashes
+		$path = str_replace('\\', '/', $path);
+		//add leading slash
+		if ($path[0] !== '/') {
+			$path = '/' . $path;
+		}
+		//remove duplicate slashes
+		while (strpos($path, '//') !== false) {
+			$path = str_replace('//', '/', $path);
+		}
+		//remove trailing slash
+		if ($stripTrailingSlash and strlen($path) > 1 and substr($path, -1, 1) === '/') {
+			$path = substr($path, 0, -1);
+		}
+		//normalize unicode if possible
+		$path = \OC_Util::normalizeUnicode($path);
+
+		return $path;
+	}
+
+	/**
+	 * get the filesystem info
+	 *
+	 * @param string $path
+	 * @return array
+	 *
+	 * returns an associative array with the following keys:
+	 * - size
+	 * - mtime
+	 * - mimetype
+	 * - encrypted
+	 * - versioned
+	 */
+	public static function getFileInfo($path) {
+		return self::$defaultInstance->getFileInfo($path);
+	}
+
+	/**
+	 * 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 array
+	 */
+	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
+	 * @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
+	 *
+	 * @param string $path
+	 * @return string
+	 */
+	static public function getETag($path) {
+		return self::$defaultInstance->getETag($path);
+	}
+}
+
+\OC_Util::setupFS();
-- 
cgit v1.2.3


From e273c14540ed9bbf65d68e0847447466315268f8 Mon Sep 17 00:00:00 2001
From: Robin Appelman <icewind@owncloud.com>
Date: Tue, 29 Oct 2013 00:26:35 +0100
Subject: use the new home storage backend when no existing local storage
 backend exists for the user's home

---
 lib/private/files/cache/storage.php | 15 ++++++++++++++-
 lib/private/files/filesystem.php    |  8 +++++++-
 2 files changed, 21 insertions(+), 2 deletions(-)

(limited to 'lib/private/files/filesystem.php')

diff --git a/lib/private/files/cache/storage.php b/lib/private/files/cache/storage.php
index 8a9e47ca36d..5657cf06e12 100644
--- a/lib/private/files/cache/storage.php
+++ b/lib/private/files/cache/storage.php
@@ -48,7 +48,7 @@ class Storage {
 	}
 
 	public static function getStorageId($numericId) {
-		
+
 		$sql = 'SELECT `id` FROM `*PREFIX*storages` WHERE `numeric_id` = ?';
 		$result = \OC_DB::executeAudited($sql, array($numericId));
 		if ($row = $result->fetchRow()) {
@@ -57,4 +57,17 @@ class Storage {
 			return null;
 		}
 	}
+
+	public static function exists($storageId) {
+		if (strlen($storageId) > 64) {
+			$storageId = md5($storageId);
+		}
+		$sql = 'SELECT `numeric_id` FROM `*PREFIX*storages` WHERE `id` = ?';
+		$result = \OC_DB::executeAudited($sql, array($storageId));
+		if ($row = $result->fetchRow()) {
+			return true;
+		} else {
+			return false;
+		}
+	}
 }
diff --git a/lib/private/files/filesystem.php b/lib/private/files/filesystem.php
index 10ec5c41d11..beed3831081 100644
--- a/lib/private/files/filesystem.php
+++ b/lib/private/files/filesystem.php
@@ -305,7 +305,13 @@ class Filesystem {
 		$parser = new \OC\ArrayParser();
 
 		$root = \OC_User::getHome($user);
-		self::mount('\OC\Files\Storage\Local', array('datadir' => $root), $user);
+
+		if (\OC\Files\Cache\Storage::exists('local::' . $root . '/')) {
+			self::mount('\OC\Files\Storage\Local', array('datadir' => $root), $user);
+		} else {
+			$userObject = \OC_User::getManager()->get($user);
+			self::mount('\OC\Files\Storage\Home', array('user' => $userObject), $user);
+		}
 		$datadir = \OC_Config::getValue("datadirectory", \OC::$SERVERROOT . "/data");
 
 		//move config file to it's new position
-- 
cgit v1.2.3


From 0e92a4896df11d6fd3ee4ed73dfa1cb121d66895 Mon Sep 17 00:00:00 2001
From: Robin Appelman <icewind@owncloud.com>
Date: Tue, 29 Oct 2013 13:12:28 +0100
Subject: dont use the home storage for non-existing users

---
 lib/private/files/filesystem.php | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'lib/private/files/filesystem.php')

diff --git a/lib/private/files/filesystem.php b/lib/private/files/filesystem.php
index beed3831081..e40502bbe64 100644
--- a/lib/private/files/filesystem.php
+++ b/lib/private/files/filesystem.php
@@ -306,10 +306,10 @@ class Filesystem {
 
 		$root = \OC_User::getHome($user);
 
-		if (\OC\Files\Cache\Storage::exists('local::' . $root . '/')) {
+		$userObject = \OC_User::getManager()->get($user);
+		if (\OC\Files\Cache\Storage::exists('local::' . $root . '/') or is_null($userObject)) {
 			self::mount('\OC\Files\Storage\Local', array('datadir' => $root), $user);
 		} else {
-			$userObject = \OC_User::getManager()->get($user);
 			self::mount('\OC\Files\Storage\Home', array('user' => $userObject), $user);
 		}
 		$datadir = \OC_Config::getValue("datadirectory", \OC::$SERVERROOT . "/data");
-- 
cgit v1.2.3


From 34c92f665639baf6ea86a265855a2b2862755537 Mon Sep 17 00:00:00 2001
From: Vincent Petry <pvince81@owncloud.com>
Date: Tue, 12 Nov 2013 15:46:01 +0100
Subject: Now using HomeStorage for legacy home storage ids

Legacy home storage ids with the format "local://path/to/datadir/user1"
are now also wrapped by the HomeStorage.
---
 lib/private/files/filesystem.php   | 14 +++++++--
 lib/private/files/storage/home.php | 14 ++++++++-
 tests/lib/files/filesystem.php     | 64 ++++++++++++++++++++++++++++++++++++++
 tests/lib/files/storage/home.php   | 29 +++++++++++++++--
 4 files changed, 115 insertions(+), 6 deletions(-)

(limited to 'lib/private/files/filesystem.php')

diff --git a/lib/private/files/filesystem.php b/lib/private/files/filesystem.php
index e40502bbe64..899666f3e1a 100644
--- a/lib/private/files/filesystem.php
+++ b/lib/private/files/filesystem.php
@@ -307,10 +307,18 @@ class Filesystem {
 		$root = \OC_User::getHome($user);
 
 		$userObject = \OC_User::getManager()->get($user);
-		if (\OC\Files\Cache\Storage::exists('local::' . $root . '/') or is_null($userObject)) {
+
+		if (!is_null($userObject)) {
+			// check for legacy home id (<= 5.0.12)
+			if (\OC\Files\Cache\Storage::exists('local::' . $root . '/')) {
+				self::mount('\OC\Files\Storage\Home', array('user' => $userObject, 'legacy' => true), $user);
+			}
+			else {
+				self::mount('\OC\Files\Storage\Home', array('user' => $userObject), $user);
+			}
+		}
+		else {
 			self::mount('\OC\Files\Storage\Local', array('datadir' => $root), $user);
-		} else {
-			self::mount('\OC\Files\Storage\Home', array('user' => $userObject), $user);
 		}
 		$datadir = \OC_Config::getValue("datadirectory", \OC::$SERVERROOT . "/data");
 
diff --git a/lib/private/files/storage/home.php b/lib/private/files/storage/home.php
index 22753519ad3..b4ceb8f4f9b 100644
--- a/lib/private/files/storage/home.php
+++ b/lib/private/files/storage/home.php
@@ -12,6 +12,11 @@ namespace OC\Files\Storage;
  * Specialized version of Local storage for home directory usage
  */
 class Home extends Local {
+	/**
+	 * @var string
+	 */
+	protected $id;
+
 	/**
 	 * @var \OC\User\User $user
 	 */
@@ -20,12 +25,19 @@ class Home extends Local {
 	public function __construct($arguments) {
 		$this->user = $arguments['user'];
 		$datadir = $this->user->getHome();
+		if (isset($arguments['legacy']) && $arguments['legacy']) {
+			// legacy home id (<= 5.0.12)
+			$this->id = 'local::' . $datadir . '/';
+		}
+		else {
+		    $this->id = 'home::' . $this->user->getUID();
+		}
 
 		parent::__construct(array('datadir' => $datadir));
 	}
 
 	public function getId() {
-		return 'home::' . $this->user->getUID();
+		return $this->id;
 	}
 
 	public function getCache($path = '') {
diff --git a/tests/lib/files/filesystem.php b/tests/lib/files/filesystem.php
index bef70cc725b..990e95ca595 100644
--- a/tests/lib/files/filesystem.php
+++ b/tests/lib/files/filesystem.php
@@ -41,9 +41,12 @@ class Filesystem extends \PHPUnit_Framework_TestCase {
 		foreach ($this->tmpDirs as $dir) {
 			\OC_Helper::rmdirr($dir);
 		}
+		\OC\Files\Filesystem::clearMounts();
+		\OC_User::setUserId('');
 	}
 
 	public function setUp() {
+		\OC_User::setUserId('');
 		\OC\Files\Filesystem::clearMounts();
 	}
 
@@ -103,6 +106,67 @@ class Filesystem extends \PHPUnit_Framework_TestCase {
 //		\OC\Files\Filesystem::file_put_contents('/bar//foo', $fh);
 	}
 
+	/**
+	 * Tests that a local storage mount is used when passed user
+	 * does not exist.
+	 */
+	public function testLocalMountWhenUserDoesNotExist() {
+		$datadir = \OC_Config::getValue("datadirectory", \OC::$SERVERROOT . "/data");
+		$userId = uniqid('user_');
+
+		\OC\Files\Filesystem::initMountPoints($userId);
+
+		$homeMount = \OC\Files\Filesystem::getStorage('/' . $userId . '/');
+
+		$this->assertInstanceOf('\OC\Files\Storage\Local', $homeMount);
+		$this->assertEquals('local::' . $datadir . '/' . $userId . '/', $homeMount->getId());
+	}
+
+	/**
+	 * Tests that the home storage is used for the user's mount point
+	 */
+	public function testHomeMount() {
+		$userId = uniqid('user_');
+
+		\OC_User::createUser($userId, $userId);
+
+		\OC\Files\Filesystem::initMountPoints($userId);
+
+		$homeMount = \OC\Files\Filesystem::getStorage('/' . $userId . '/');
+
+		$this->assertInstanceOf('\OC\Files\Storage\Home', $homeMount);
+		$this->assertEquals('home::' . $userId, $homeMount->getId());
+
+		\OC_User::deleteUser($userId);
+	}
+
+	/**
+	 * Tests that the home storage is used in legacy mode
+	 * for the user's mount point
+	 */
+	public function testLegacyHomeMount() {
+		$datadir = \OC_Config::getValue("datadirectory", \OC::$SERVERROOT . "/data");
+		$userId = uniqid('user_');
+
+		// insert storage into DB by constructing it
+		// to make initMountsPoint find its existence
+		$localStorage = new \OC\Files\Storage\Local(array('datadir' => $datadir . '/' . $userId . '/'));
+		// this will trigger the insert
+		$cache = $localStorage->getCache();
+
+		\OC_User::createUser($userId, $userId);
+		\OC\Files\Filesystem::initMountPoints($userId);
+
+		$homeMount = \OC\Files\Filesystem::getStorage('/' . $userId . '/');
+
+		$this->assertInstanceOf('\OC\Files\Storage\Home', $homeMount);
+		$this->assertEquals('local::' . $datadir. '/' . $userId . '/', $homeMount->getId());
+
+		\OC_User::deleteUser($userId);
+		// delete storage entry
+		$cache->clear();
+	}
+
 	public function dummyHook($arguments) {
 		$path = $arguments['path'];
 		$this->assertEquals($path, \OC\Files\Filesystem::normalizePath($path)); //the path passed to the hook should already be normalized
diff --git a/tests/lib/files/storage/home.php b/tests/lib/files/storage/home.php
index b01e07f7457..885291e4404 100644
--- a/tests/lib/files/storage/home.php
+++ b/tests/lib/files/storage/home.php
@@ -56,8 +56,8 @@ class Home extends Storage {
 
 	public function setUp() {
 		$this->tmpDir = \OC_Helper::tmpFolder();
-		$userId = uniqid('user_');
-		$this->user = new DummyUser($userId, $this->tmpDir);
+		$this->userId = uniqid('user_');
+		$this->user = new DummyUser($this->userId, $this->tmpDir);
 		$this->instance = new \OC\Files\Storage\Home(array('user' => $this->user));
 	}
 
@@ -65,7 +65,32 @@ class Home extends Storage {
 		\OC_Helper::rmdirr($this->tmpDir);
 	}
 
+	/**
+	 * Tests that the root path matches the data dir
+	 */
 	public function testRoot() {
 		$this->assertEquals($this->tmpDir, $this->instance->getLocalFolder(''));
 	}
+
+	/**
+	 * Tests that the home id is in the format home::user1
+	 */
+	public function testId() {
+		$this->assertEquals('home::' . $this->userId, $this->instance->getId());
+	}
+
+	/**
+	 * Tests that the legacy home id is in the format local::/path/to/datadir/user1/
+	 */
+	public function testLegacyId() {
+		$this->instance = new \OC\Files\Storage\Home(array('user' => $this->user, 'legacy' => true));
+		$this->assertEquals('local::' . $this->tmpDir . '/', $this->instance->getId());
+	}
+
+	/**
+	 * Tests that getCache() returns an instance of HomeCache
+	 */
+	public function testGetCacheReturnsHomeCache() {
+		$this->assertInstanceOf('\OC\Files\Cache\HomeCache', $this->instance->getCache());
+	}
 }
-- 
cgit v1.2.3


From c06d8bb0071839480f9e458e58630ca0c205b9cb Mon Sep 17 00:00:00 2001
From: Vincent Petry <pvince81@owncloud.com>
Date: Thu, 14 Nov 2013 13:15:03 +0100
Subject: Fixed normalizePath() to strip out single dot dirs

Now removing "/./" and trailing "/." from the paths when normalizing.
---
 lib/private/files/filesystem.php | 20 ++++++++++++---
 tests/lib/files/filesystem.php   | 55 +++++++++++++++++++++++++++++++++++++++-
 2 files changed, 71 insertions(+), 4 deletions(-)

(limited to 'lib/private/files/filesystem.php')

diff --git a/lib/private/files/filesystem.php b/lib/private/files/filesystem.php
index 899666f3e1a..8500b3c581b 100644
--- a/lib/private/files/filesystem.php
+++ b/lib/private/files/filesystem.php
@@ -689,18 +689,32 @@ class Filesystem {
 		}
 		//no windows style slashes
 		$path = str_replace('\\', '/', $path);
+
 		//add leading slash
 		if ($path[0] !== '/') {
 			$path = '/' . $path;
 		}
-		//remove duplicate slashes
-		while (strpos($path, '//') !== false) {
-			$path = str_replace('//', '/', $path);
+
+		// remove '/./'
+		// ugly, but str_replace() can't replace them all in one go
+		// as the replacement itself is part of the search string
+		// which will only be found during the next iteration
+		while (strpos($path, '/./') !== false) {
+			$path = str_replace('/./', '/', $path);
 		}
+		// remove sequences of slashes
+		$path = preg_replace('#/{2,}#', '/', $path);
+
 		//remove trailing slash
 		if ($stripTrailingSlash and strlen($path) > 1 and substr($path, -1, 1) === '/') {
 			$path = substr($path, 0, -1);
 		}
+
+		// remove trailing '/.'
+		if (substr($path, -2) == '/.') {
+			$path = substr($path, 0, -2);
+		}
+
 		//normalize unicode if possible
 		$path = \OC_Util::normalizeUnicode($path);
 
diff --git a/tests/lib/files/filesystem.php b/tests/lib/files/filesystem.php
index 990e95ca595..e703a961299 100644
--- a/tests/lib/files/filesystem.php
+++ b/tests/lib/files/filesystem.php
@@ -69,17 +69,70 @@ class Filesystem extends \PHPUnit_Framework_TestCase {
 	}
 
 	public function testNormalize() {
+		$this->assertEquals('/', \OC\Files\Filesystem::normalizePath(''));
+		$this->assertEquals('/', \OC\Files\Filesystem::normalizePath('/'));
+		$this->assertEquals('/', \OC\Files\Filesystem::normalizePath('/', false));
+		$this->assertEquals('/', \OC\Files\Filesystem::normalizePath('//'));
+		$this->assertEquals('/', \OC\Files\Filesystem::normalizePath('//', false));
 		$this->assertEquals('/path', \OC\Files\Filesystem::normalizePath('/path/'));
 		$this->assertEquals('/path/', \OC\Files\Filesystem::normalizePath('/path/', false));
 		$this->assertEquals('/path', \OC\Files\Filesystem::normalizePath('path'));
-		$this->assertEquals('/path', \OC\Files\Filesystem::normalizePath('\path'));
 		$this->assertEquals('/foo/bar', \OC\Files\Filesystem::normalizePath('/foo//bar/'));
+		$this->assertEquals('/foo/bar/', \OC\Files\Filesystem::normalizePath('/foo//bar/', false));
 		$this->assertEquals('/foo/bar', \OC\Files\Filesystem::normalizePath('/foo////bar'));
+		$this->assertEquals('/foo/bar', \OC\Files\Filesystem::normalizePath('/foo/////bar'));
+		$this->assertEquals('/foo/bar', \OC\Files\Filesystem::normalizePath('/foo/bar/.'));
+		$this->assertEquals('/foo/bar', \OC\Files\Filesystem::normalizePath('/foo/bar/./'));
+		$this->assertEquals('/foo/bar/', \OC\Files\Filesystem::normalizePath('/foo/bar/./', false));
+		$this->assertEquals('/foo/bar', \OC\Files\Filesystem::normalizePath('/foo/bar/./.'));
+		$this->assertEquals('/foo/bar', \OC\Files\Filesystem::normalizePath('/foo/bar/././'));
+		$this->assertEquals('/foo/bar/', \OC\Files\Filesystem::normalizePath('/foo/bar/././', false));
+		$this->assertEquals('/foo/bar', \OC\Files\Filesystem::normalizePath('/foo/./bar/'));
+		$this->assertEquals('/foo/bar/', \OC\Files\Filesystem::normalizePath('/foo/./bar/', false));
+		$this->assertEquals('/foo/.bar', \OC\Files\Filesystem::normalizePath('/foo/.bar/'));
+		$this->assertEquals('/foo/.bar/', \OC\Files\Filesystem::normalizePath('/foo/.bar/', false));
+		$this->assertEquals('/foo/.bar/tee', \OC\Files\Filesystem::normalizePath('/foo/.bar/tee'));
+
+		// normalize does not resolve '..' (by design)
+		$this->assertEquals('/foo/..', \OC\Files\Filesystem::normalizePath('/foo/../'));
+
 		if (class_exists('Patchwork\PHP\Shim\Normalizer')) {
 			$this->assertEquals("/foo/bar\xC3\xBC", \OC\Files\Filesystem::normalizePath("/foo/baru\xCC\x88"));
 		}
 	}
 
+	public function testNormalizeWindowsPaths() {
+		$this->assertEquals('/', \OC\Files\Filesystem::normalizePath(''));
+		$this->assertEquals('/', \OC\Files\Filesystem::normalizePath('\\'));
+		$this->assertEquals('/', \OC\Files\Filesystem::normalizePath('\\', false));
+		$this->assertEquals('/', \OC\Files\Filesystem::normalizePath('\\\\'));
+		$this->assertEquals('/', \OC\Files\Filesystem::normalizePath('\\\\', false));
+		$this->assertEquals('/path', \OC\Files\Filesystem::normalizePath('\\path\\'));
+		$this->assertEquals('/path/', \OC\Files\Filesystem::normalizePath('\\path\\', false));
+		$this->assertEquals('/foo/bar', \OC\Files\Filesystem::normalizePath('\\foo\\\\bar\\'));
+		$this->assertEquals('/foo/bar/', \OC\Files\Filesystem::normalizePath('\\foo\\\\bar\\', false));
+		$this->assertEquals('/foo/bar', \OC\Files\Filesystem::normalizePath('\\foo\\\\\\\\bar'));
+		$this->assertEquals('/foo/bar', \OC\Files\Filesystem::normalizePath('\\foo\\\\\\\\\\bar'));
+		$this->assertEquals('/foo/bar', \OC\Files\Filesystem::normalizePath('\\foo\\bar\\.'));
+		$this->assertEquals('/foo/bar', \OC\Files\Filesystem::normalizePath('\\foo\\bar\\.\\'));
+		$this->assertEquals('/foo/bar/', \OC\Files\Filesystem::normalizePath('\\foo\\bar\\.\\', false));
+		$this->assertEquals('/foo/bar', \OC\Files\Filesystem::normalizePath('\\foo\\bar\\.\\.'));
+		$this->assertEquals('/foo/bar', \OC\Files\Filesystem::normalizePath('\\foo\\bar\\.\\.\\'));
+		$this->assertEquals('/foo/bar/', \OC\Files\Filesystem::normalizePath('\\foo\\bar\\.\\.\\', false));
+		$this->assertEquals('/foo/bar', \OC\Files\Filesystem::normalizePath('\\foo\\.\\bar\\'));
+		$this->assertEquals('/foo/bar/', \OC\Files\Filesystem::normalizePath('\\foo\\.\\bar\\', false));
+		$this->assertEquals('/foo/.bar', \OC\Files\Filesystem::normalizePath('\\foo\\.bar\\'));
+		$this->assertEquals('/foo/.bar/', \OC\Files\Filesystem::normalizePath('\\foo\\.bar\\', false));
+		$this->assertEquals('/foo/.bar/tee', \OC\Files\Filesystem::normalizePath('\\foo\\.bar\\tee'));
+
+		// normalize does not resolve '..' (by design)
+		$this->assertEquals('/foo/..', \OC\Files\Filesystem::normalizePath('\\foo\\..\\'));
+
+		if (class_exists('Patchwork\PHP\Shim\Normalizer')) {
+			$this->assertEquals("/foo/bar\xC3\xBC", \OC\Files\Filesystem::normalizePath("\\foo\\baru\xCC\x88"));
+		}
+	}
+
 	public function testHooks() {
 		if(\OC\Files\Filesystem::getView()){
 			$user = \OC_User::getUser();
-- 
cgit v1.2.3


From 614e4d485c8b74f6879c401f8cbb93e9335bf9b3 Mon Sep 17 00:00:00 2001
From: Vincent Petry <pvince81@owncloud.com>
Date: Mon, 18 Nov 2013 17:29:30 +0100
Subject: External storage space is now not counted in total space

Added argument to getFileInfo() to disable adding the size of
mountpoints to a directory's size.

Fixes #5924
---
 lib/private/files.php            | 4 ++--
 lib/private/files/filesystem.php | 6 ++++--
 lib/private/files/view.php       | 6 ++++--
 lib/private/helper.php           | 3 ++-
 tests/lib/files/view.php         | 5 +++++
 5 files changed, 17 insertions(+), 7 deletions(-)

(limited to 'lib/private/files/filesystem.php')

diff --git a/lib/private/files.php b/lib/private/files.php
index c705d2adb1a..8b4d5c59aee 100644
--- a/lib/private/files.php
+++ b/lib/private/files.php
@@ -28,8 +28,8 @@
 class OC_Files {
 	static $tmpFiles = array();
 
-	static public function getFileInfo($path){
-		return \OC\Files\Filesystem::getFileInfo($path);
+	static public function getFileInfo($path, $includeMountPoints = true){
+		return \OC\Files\Filesystem::getFileInfo($path, $includeMountPoints);
 	}
 
 	static public function getDirectoryContent($path){
diff --git a/lib/private/files/filesystem.php b/lib/private/files/filesystem.php
index 8500b3c581b..a83e9aa86d2 100644
--- a/lib/private/files/filesystem.php
+++ b/lib/private/files/filesystem.php
@@ -725,6 +725,8 @@ class Filesystem {
 	 * get the filesystem info
 	 *
 	 * @param string $path
+	 * @param boolean $includeMountPoints whether to add mountpoint sizes,
+	 * defaults to true
 	 * @return array
 	 *
 	 * returns an associative array with the following keys:
@@ -734,8 +736,8 @@ class Filesystem {
 	 * - encrypted
 	 * - versioned
 	 */
-	public static function getFileInfo($path) {
-		return self::$defaultInstance->getFileInfo($path);
+	public static function getFileInfo($path, $includeMountPoints = true) {
+		return self::$defaultInstance->getFileInfo($path, $includeMountPoints);
 	}
 
 	/**
diff --git a/lib/private/files/view.php b/lib/private/files/view.php
index c0b9f0fc9c8..8cb56ede91b 100644
--- a/lib/private/files/view.php
+++ b/lib/private/files/view.php
@@ -762,6 +762,8 @@ class View {
 	 * get the filesystem info
 	 *
 	 * @param string $path
+	 * @param boolean $includeMountPoints whether to add mountpoint sizes,
+	 * defaults to true
 	 * @return array
 	 *
 	 * returns an associative array with the following keys:
@@ -771,7 +773,7 @@ class View {
 	 * - encrypted
 	 * - versioned
 	 */
-	public function getFileInfo($path) {
+	public function getFileInfo($path, $includeMountPoints = true) {
 		$data = array();
 		if (!Filesystem::isValidPath($path)) {
 			return $data;
@@ -798,7 +800,7 @@ class View {
 			$data = $cache->get($internalPath);
 
 			if ($data and $data['fileid']) {
-				if ($data['mimetype'] === 'httpd/unix-directory') {
+				if ($includeMountPoints and $data['mimetype'] === 'httpd/unix-directory') {
 					//add the sizes of other mountpoints to the folder
 					$mountPoints = Filesystem::getMountPoints($path);
 					foreach ($mountPoints as $mountPoint) {
diff --git a/lib/private/helper.php b/lib/private/helper.php
index 48031c1467f..c82d3bd4ef4 100644
--- a/lib/private/helper.php
+++ b/lib/private/helper.php
@@ -876,7 +876,8 @@ class OC_Helper {
 	 * @return array
 	 */
 	public static function getStorageInfo($path) {
-		$rootInfo = \OC\Files\Filesystem::getFileInfo($path);
+		// return storage info without adding mount points
+		$rootInfo = \OC\Files\Filesystem::getFileInfo($path, false);
 		$used = $rootInfo['size'];
 		if ($used < 0) {
 			$used = 0;
diff --git a/tests/lib/files/view.php b/tests/lib/files/view.php
index 0cc86d6651a..f358c15dd50 100644
--- a/tests/lib/files/view.php
+++ b/tests/lib/files/view.php
@@ -67,6 +67,11 @@ class View extends \PHPUnit_Framework_TestCase {
 		$this->assertEquals($storageSize * 3, $cachedData['size']);
 		$this->assertEquals('httpd/unix-directory', $cachedData['mimetype']);
 
+		// get cached data excluding mount points
+		$cachedData = $rootView->getFileInfo('/', false);
+		$this->assertEquals($storageSize, $cachedData['size']);
+		$this->assertEquals('httpd/unix-directory', $cachedData['mimetype']);
+
 		$cachedData = $rootView->getFileInfo('/folder');
 		$this->assertEquals($storageSize + $textSize, $cachedData['size']);
 		$this->assertEquals('httpd/unix-directory', $cachedData['mimetype']);
-- 
cgit v1.2.3