merge master into filecache_mtime

17 files changed, 1246 insertions, 472 deletions

diff --git a/lib/files/cache/backgroundwatcher.php b/lib/files/cache/backgroundwatcher.php
new file mode 100644
index 00000000000..8933101577d
--- /dev/null
+++ b/lib/files/cache/backgroundwatcher.php
@@ -0,0 +1,104 @@
+<?php
+/**
+ * Copyright (c) 2013 Robin Appelman <icewind@owncloud.com>
+ * This file is licensed under the Affero General Public License version 3 or
+ * later.
+ * See the COPYING-README file.
+ */
+
+namespace OC\Files\Cache;
+
+use \OC\Files\Mount;
+use \OC\Files\Filesystem;
+
+class BackgroundWatcher {
+	static $folderMimetype = null;
+
+	static private function getFolderMimetype() {
+		if (!is_null(self::$folderMimetype)) {
+			return self::$folderMimetype;
+		}
+		$query = \OC_DB::prepare('SELECT `id` FROM `*PREFIX*mimetypes` WHERE `mimetype` = ?');
+		$result = $query->execute(array('httpd/unix-directory'));
+		$row = $result->fetchRow();
+		return $row['id'];
+	}
+
+	static private function checkUpdate($id) {
+		$cacheItem = Cache::getById($id);
+		if (is_null($cacheItem)) {
+			return;
+		}
+		list($storageId, $internalPath) = $cacheItem;
+		$mounts = Filesystem::getMountByStorageId($storageId);
+
+		if (count($mounts) === 0) {
+			//if the storage we need isn't mounted on default, try to find a user that has access to the storage
+			$permissionsCache = new Permissions($storageId);
+			$users = $permissionsCache->getUsers($id);
+			if (count($users) === 0) {
+				return;
+			}
+			Filesystem::initMountPoints($users[0]);
+			$mounts = Filesystem::getMountByStorageId($storageId);
+			if (count($mounts) === 0) {
+				return;
+			}
+		}
+		$storage = $mounts[0]->getStorage();
+		$watcher = new Watcher($storage);
+		$watcher->checkUpdate($internalPath);
+	}
+
+	/**
+	 * get the next fileid in the cache
+	 *
+	 * @param int $previous
+	 * @param bool $folder
+	 * @return int
+	 */
+	static private function getNextFileId($previous, $folder) {
+		if ($folder) {
+			$query = \OC_DB::prepare('SELECT `fileid` FROM `*PREFIX*filecache` WHERE `fileid` > ? AND mimetype = ' . self::getFolderMimetype() . ' ORDER BY `fileid` ASC', 1);
+		} else {
+			$query = \OC_DB::prepare('SELECT `fileid` FROM `*PREFIX*filecache` WHERE `fileid` > ? AND mimetype != ' . self::getFolderMimetype() . ' ORDER BY `fileid` ASC', 1);
+		}
+		$result = $query->execute(array($previous));
+		if ($row = $result->fetchRow()) {
+			return $row['fileid'];
+		} else {
+			return 0;
+		}
+	}
+
+	static public function checkNext() {
+		// check both 1 file and 1 folder, this way new files are detected quicker because there are less folders than files usually
+		$previousFile = \OC_Appconfig::getValue('files', 'backgroundwatcher_previous_file', 0);
+		$previousFolder = \OC_Appconfig::getValue('files', 'backgroundwatcher_previous_folder', 0);
+		$nextFile = self::getNextFileId($previousFile, false);
+		$nextFolder = self::getNextFileId($previousFolder, true);
+		\OC_Appconfig::setValue('files', 'backgroundwatcher_previous_file', $nextFile);
+		\OC_Appconfig::setValue('files', 'backgroundwatcher_previous_folder', $nextFolder);
+		if ($nextFile > 0) {
+			self::checkUpdate($nextFile);
+		}
+		if ($nextFolder > 0) {
+			self::checkUpdate($nextFolder);
+		}
+	}
+
+	static public function checkAll() {
+		$previous = 0;
+		$next = 1;
+		while ($next != 0) {
+			$next = self::getNextFileId($previous, true);
+			self::checkUpdate($next);
+		}
+		$previous = 0;
+		$next = 1;
+		while ($next != 0) {
+			$next = self::getNextFileId($previous, false);
+			self::checkUpdate($next);
+		}
+	}
+}
diff --git a/lib/files/cache/cache.php b/lib/files/cache/cache.php
index 2413c05b8cd..0617471079b 100644
--- a/lib/files/cache/cache.php
+++ b/lib/files/cache/cache.php
@@ -30,11 +30,9 @@ class Cache {
 	private $storageId;
 
 	/**
-	 * numeric storage id
-	 *
-	 * @var int $numericId
+	 * @var Storage $storageCache
 	 */
-	private $numericId;
+	private $storageCache;
 
 	private $mimetypeIds = array();
 	private $mimetypes = array();
@@ -52,19 +50,11 @@ class Cache {
 			$this->storageId = md5($this->storageId);
 		}
 
-		$query = \OC_DB::prepare('SELECT `numeric_id` FROM `*PREFIX*storages` WHERE `id` = ?');
-		$result = $query->execute(array($this->storageId));
-		if ($row = $result->fetchRow()) {
-			$this->numericId = $row['numeric_id'];
-		} else {
-			$query = \OC_DB::prepare('INSERT INTO `*PREFIX*storages`(`id`) VALUES(?)');
-			$query->execute(array($this->storageId));
-			$this->numericId = \OC_DB::insertid('*PREFIX*storages');
-		}
+		$this->storageCache = new Storage($storage);
 	}
 
 	public function getNumericStorageId() {
-		return $this->numericId;
+		return $this->storageCache->getNumericId();
 	}
 
 	/**
@@ -111,7 +101,7 @@ class Cache {
 	public function get($file) {
 		if (is_string($file) or $file == '') {
 			$where = 'WHERE `storage` = ? AND `path_hash` = ?';
-			$params = array($this->numericId, md5($file));
+			$params = array($this->getNumericStorageId(), md5($file));
 		} else { //file id
 			$where = 'WHERE `fileid` = ?';
 			$params = array($file);
@@ -204,12 +194,15 @@ class Cache {
 
 			list($queryParts, $params) = $this->buildParts($data);
 			$queryParts[] = '`storage`';
-			$params[] = $this->numericId;
+			$params[] = $this->getNumericStorageId();
 			$valuesPlaceholder = array_fill(0, count($queryParts), '?');
 
 			$query = \OC_DB::prepare('INSERT INTO `*PREFIX*filecache`(' . implode(', ', $queryParts) . ')'
 				. ' VALUES(' . implode(', ', $valuesPlaceholder) . ')');
-			$query->execute($params);
+			$result = $query->execute($params);
+			if (\OC_DB::isError($result)) {
+				\OCP\Util::writeLog('cache', 'Insert to cache failed: ' . $result, \OCP\Util::ERROR);
+			}
 
 			return (int)\OC_DB::insertid('*PREFIX*filecache');
 		}
@@ -272,7 +265,7 @@ class Cache {
 		$pathHash = md5($file);
 
 		$query = \OC_DB::prepare('SELECT `fileid` FROM `*PREFIX*filecache` WHERE `storage` = ? AND `path_hash` = ?');
-		$result = $query->execute(array($this->numericId, $pathHash));
+		$result = $query->execute(array($this->getNumericStorageId(), $pathHash));
 
 		if ($row = $result->fetchRow()) {
 			return $row['fileid'];
@@ -336,24 +329,27 @@ class Cache {
 	 * @param string $target
 	 */
 	public function move($source, $target) {
-		$sourceId = $this->getId($source);
+		$sourceData = $this->get($source);
+		$sourceId = $sourceData['fileid'];
 		$newParentId = $this->getParentId($target);
 
-		//find all child entries
-		$query = \OC_DB::prepare('SELECT `path`, `fileid` FROM `*PREFIX*filecache` WHERE `path` LIKE ?');
-		$result = $query->execute(array($source . '/%'));
-		$childEntries = $result->fetchAll();
-		$sourceLength = strlen($source);
-		$query = \OC_DB::prepare('UPDATE `*PREFIX*filecache` SET `path` = ?, `path_hash` = ? WHERE `fileid` = ?');
-
-		foreach ($childEntries as $child) {
-			$targetPath = $target . substr($child['path'], $sourceLength);
-			$query->execute(array($targetPath, md5($targetPath), $child['fileid']));
+		if ($sourceData['mimetype'] === 'httpd/unix-directory') {
+			//find all child entries
+			$query = \OC_DB::prepare('SELECT `path`, `fileid` FROM `*PREFIX*filecache` WHERE `path` LIKE ?');
+			$result = $query->execute(array($source . '/%'));
+			$childEntries = $result->fetchAll();
+			$sourceLength = strlen($source);
+			$query = \OC_DB::prepare('UPDATE `*PREFIX*filecache` SET `path` = ?, `path_hash` = ? WHERE `fileid` = ?');
+
+			foreach ($childEntries as $child) {
+				$targetPath = $target . substr($child['path'], $sourceLength);
+				$query->execute(array($targetPath, md5($targetPath), $child['fileid']));
+			}
 		}
 
-		$query = \OC_DB::prepare('UPDATE `*PREFIX*filecache` SET `path` = ?, `path_hash` = ?, `parent` =?'
+		$query = \OC_DB::prepare('UPDATE `*PREFIX*filecache` SET `path` = ?, `path_hash` = ?, `name` = ?, `parent` =?'
 			. ' WHERE `fileid` = ?');
-		$query->execute(array($target, md5($target), $newParentId, $sourceId));
+		$query->execute(array($target, md5($target), basename($target), $newParentId, $sourceId));
 	}
 
 	/**
@@ -361,7 +357,7 @@ class Cache {
 	 */
 	public function clear() {
 		$query = \OC_DB::prepare('DELETE FROM `*PREFIX*filecache` WHERE storage = ?');
-		$query->execute(array($this->numericId));
+		$query->execute(array($this->getNumericStorageId()));
 
 		$query = \OC_DB::prepare('DELETE FROM `*PREFIX*storages` WHERE id = ?');
 		$query->execute(array($this->storageId));
@@ -375,7 +371,7 @@ class Cache {
 	public function getStatus($file) {
 		$pathHash = md5($file);
 		$query = \OC_DB::prepare('SELECT `size` FROM `*PREFIX*filecache` WHERE `storage` = ? AND `path_hash` = ?');
-		$result = $query->execute(array($this->numericId, $pathHash));
+		$result = $query->execute(array($this->getNumericStorageId(), $pathHash));
 		if ($row = $result->fetchRow()) {
 			if ((int)$row['size'] === -1) {
 				return self::SHALLOW;
@@ -402,7 +398,7 @@ class Cache {
 			SELECT `fileid`, `storage`, `path`, `parent`, `name`, `mimetype`, `mimepart`, `size`, `mtime`, `encrypted`, `etag`
 			FROM `*PREFIX*filecache` WHERE `name` LIKE ? AND `storage` = ?'
 		);
-		$result = $query->execute(array($pattern, $this->numericId));
+		$result = $query->execute(array($pattern, $this->getNumericStorageId()));
 		$files = array();
 		while ($row = $result->fetchRow()) {
 			$row['mimetype'] = $this->getMimetype($row['mimetype']);
@@ -429,7 +425,7 @@ class Cache {
 			FROM `*PREFIX*filecache` WHERE ' . $where . ' AND `storage` = ?'
 		);
 		$mimetype = $this->getMimetypeId($mimetype);
-		$result = $query->execute(array($mimetype, $this->numericId));
+		$result = $query->execute(array($mimetype, $this->getNumericStorageId()));
 		$files = array();
 		while ($row = $result->fetchRow()) {
 			$row['mimetype'] = $this->getMimetype($row['mimetype']);
@@ -448,7 +444,7 @@ class Cache {
 		$this->calculateFolderSize($path);
 		if ($path !== '') {
 			$parent = dirname($path);
-			if ($parent === '.') {
+			if ($parent === '.' or $parent === '/') {
 				$parent = '';
 			}
 			$this->correctFolderSize($parent);
@@ -467,7 +463,7 @@ class Cache {
 			return 0;
 		}
 		$query = \OC_DB::prepare('SELECT `size` FROM `*PREFIX*filecache` WHERE `parent` = ? AND `storage` = ?');
-		$result = $query->execute(array($id, $this->numericId));
+		$result = $query->execute(array($id, $this->getNumericStorageId()));
 		$totalSize = 0;
 		$hasChilds = 0;
 		while ($row = $result->fetchRow()) {
@@ -494,7 +490,7 @@ class Cache {
 	 */
 	public function getAll() {
 		$query = \OC_DB::prepare('SELECT `fileid` FROM `*PREFIX*filecache` WHERE `storage` = ?');
-		$result = $query->execute(array($this->numericId));
+		$result = $query->execute(array($this->getNumericStorageId()));
 		$ids = array();
 		while ($row = $result->fetchRow()) {
 			$ids[] = $row['fileid'];
@@ -514,7 +510,7 @@ class Cache {
 	public function getIncomplete() {
 		$query = \OC_DB::prepare('SELECT `path` FROM `*PREFIX*filecache`'
 			. ' WHERE `storage` = ? AND `size` = -1 ORDER BY `fileid` DESC LIMIT 1');
-		$result = $query->execute(array($this->numericId));
+		$result = $query->execute(array($this->getNumericStorageId()));
 		if ($row = $result->fetchRow()) {
 			return $row['path'];
 		} else {
@@ -525,6 +521,7 @@ class Cache {
 	/**
 	 * get the storage id of the storage for a file and the internal path of the file
 	 *
+	 * @param int $id
 	 * @return array, first element holding the storage id, second the path
 	 */
 	static public function getById($id) {
@@ -537,10 +534,8 @@ class Cache {
 			return null;
 		}
 
-		$query = \OC_DB::prepare('SELECT `id` FROM `*PREFIX*storages` WHERE `numeric_id` = ?');
-		$result = $query->execute(array($numericId));
-		if ($row = $result->fetchRow()) {
-			return array($row['id'], $path);
+		if ($id = Storage::getStorageId($numericId)) {
+			return array($id, $path);
 		} else {
 			return null;
 		}
diff --git a/lib/files/cache/legacy.php b/lib/files/cache/legacy.php
index 2b8689fcbda..b8e2548639b 100644
--- a/lib/files/cache/legacy.php
+++ b/lib/files/cache/legacy.php
@@ -20,6 +20,11 @@ class Legacy {
 		$this->user = $user;
 	}
 
+	/**
+	 * get the numbers of items in the legacy cache
+	 *
+	 * @return int
+	 */
 	function getCount() {
 		$query = \OC_DB::prepare('SELECT COUNT(`id`) AS `count` FROM `*PREFIX*fscache` WHERE `user` = ?');
 		$result = $query->execute(array($this->user));
@@ -62,6 +67,8 @@ class Legacy {
 	}
 
 	/**
+	 * get an item from the legacy cache
+	 *
 	 * @param string|int $path
 	 * @return array
 	 */
@@ -72,16 +79,59 @@ class Legacy {
 			$query = \OC_DB::prepare('SELECT * FROM `*PREFIX*fscache` WHERE `path` = ?');
 		}
 		$result = $query->execute(array($path));
-		return $result->fetchRow();
+		$data = $result->fetchRow();
+		$data['etag'] = $this->getEtag($data['path'], $data['user']);
+		return $data;
 	}
 
 	/**
+	 * Get the ETag for the given path
+	 *
+	 * @param type $path
+	 * @return string
+	 */
+	function getEtag($path, $user = null) {
+		static $query = null;
+
+		$pathDetails = explode('/', $path, 4);
+		if((!$user) && !isset($pathDetails[1])) {
+			//no user!? Too odd, return empty string.
+			return '';
+		} else if(!$user) {
+			//guess user from path, if no user passed.
+			$user = $pathDetails[1];
+		}
+
+		if(!isset($pathDetails[3]) || is_null($pathDetails[3])) {
+			$relativePath = '';
+		} else {
+			$relativePath = $pathDetails[3];
+		}
+
+		if(is_null($query)){
+			$query = \OC_DB::prepare('SELECT `propertyvalue` FROM `*PREFIX*properties` WHERE `userid` = ? AND `propertypath` = ? AND `propertyname` = \'{DAV:}getetag\'');
+		}
+		$result = $query->execute(array($user, '/' . $relativePath));
+		if ($row = $result->fetchRow()) {
+			return trim($row['propertyvalue'], '"');
+		} else {
+			return '';
+		}
+	}
+
+	/**
+	 * get all child items of an item from the legacy cache
+	 *
 	 * @param int $id
 	 * @return array
 	 */
 	function getChildren($id) {
 		$query = \OC_DB::prepare('SELECT * FROM `*PREFIX*fscache` WHERE `parent` = ?');
 		$result = $query->execute(array($id));
-		return $result->fetchAll();
+		$data = $result->fetchAll();
+		foreach ($data as $i => $item) {
+			$data[$i]['etag'] = $this->getEtag($item['path'], $item['user']);
+		}
+		return $data;
 	}
 }
diff --git a/lib/files/cache/permissions.php b/lib/files/cache/permissions.php
index a5c9c144054..faa5ff5eacc 100644
--- a/lib/files/cache/permissions.php
+++ b/lib/files/cache/permissions.php
@@ -107,4 +107,19 @@ class Permissions {
 			$query->execute(array($fileId, $user));
 		}
 	}
+
+	/**
+	 * get the list of users which have permissions stored for a file
+	 *
+	 * @param int $fileId
+	 */
+	public function getUsers($fileId) {
+		$query = \OC_DB::prepare('SELECT `user` FROM `*PREFIX*permissions` WHERE `fileid` = ?');
+		$result = $query->execute(array($fileId));
+		$users = array();
+		while ($row = $result->fetchRow()) {
+			$users[] = $row['user'];
+		}
+		return $users;
+	}
 }
diff --git a/lib/files/cache/scanner.php b/lib/files/cache/scanner.php
index 9c5ce9df7fc..a98953b42aa 100644
--- a/lib/files/cache/scanner.php
+++ b/lib/files/cache/scanner.php
@@ -63,36 +63,44 @@ class Scanner {
 	 * @return array with metadata of the scanned file
 	 */
 	public function scanFile($file, $checkExisting = false) {
-		\OC_Hook::emit('\OC\Files\Cache\Scanner', 'scan_file', array('path' => $file, 'storage' => $this->storageId));
-		$data = $this->getData($file);
-		if ($data) {
-			if ($file) {
-				$parent = dirname($file);
-				if ($parent === '.') {
-					$parent = '';
-				}
-				if (!$this->cache->inCache($parent)) {
-					$this->scanFile($parent);
+		if ( ! self::isPartialFile($file)
+			and ! \OC\Files\Filesystem::isFileBlacklisted($file)
+		) {
+			\OC_Hook::emit('\OC\Files\Cache\Scanner', 'scan_file', array('path' => $file, 'storage' => $this->storageId));
+			$data = $this->getData($file);
+			if ($data) {
+				if ($file) {
+					$parent = dirname($file);
+					if ($parent === '.' or $parent === '/') {
+						$parent = '';
+					}
+					if (!$this->cache->inCache($parent)) {
+						$this->scanFile($parent);
+					}
 				}
-			}
-			if ($checkExisting and $cacheData = $this->cache->get($file)) {
-				if ($data['size'] === -1) {
-					$data['size'] = $cacheData['size'];
+				if($cacheData = $this->cache->get($file)) {
+					if ($data['mtime'] === $cacheData['mtime'] &&
+						$data['size'] === $cacheData['size']) {
+						$data['etag'] = $cacheData['etag'];
+					}
 				}
-				if ($data['mtime'] === $cacheData['mtime']) {
-					$data['etag'] = $cacheData['etag'];
+				if ($checkExisting and $cacheData) {
+					if ($data['size'] === -1) {
+						$data['size'] = $cacheData['size'];
+					}
 				}
+				$this->cache->put($file, $data);
 			}
-			$this->cache->put($file, $data);
+			return $data;
 		}
-		return $data;
+		return null;
 	}
 
 	/**
 	 * scan all the files in a folder and store them in the cache
 	 *
 	 * @param string $path
-	 * @param SCAN_RECURSIVE/SCAN_SHALLOW $recursive
+	 * @param bool $recursive
 	 * @param bool $onlyChilds
 	 * @return int the size of the scanned folder or -1 if the size is unknown at this stage
 	 */
@@ -107,8 +115,8 @@ class Scanner {
 		if ($this->storage->is_dir($path) && ($dh = $this->storage->opendir($path))) {
 			\OC_DB::beginTransaction();
 			while ($file = readdir($dh)) {
-				if (!$this->isIgnoredFile($file)) {
-					$child = ($path) ? $path . '/' . $file : $file;
+				$child = ($path) ? $path . '/' . $file : $file;
+				if (!$this->isIgnoredDir($file)) {
 					$data = $this->scanFile($child, $recursive === self::SCAN_SHALLOW);
 					if ($data) {
 						if ($data['size'] === -1) {
@@ -143,16 +151,26 @@ class Scanner {
 	}
 
 	/**
+	 * @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
+	 */
+	private function isIgnoredDir($dir) {
+		if ($dir === '.' || $dir === '..') {
+			return true;
+		}
+		return false;
+	}
+	/**
 	 * @brief check if the file should be ignored when scanning
 	 * NOTE: files with a '.part' extension are ignored as well!
 	 *       prevents unfinished put requests to be scanned
 	 * @param String $file
 	 * @return boolean
 	 */
-	private function isIgnoredFile($file) {
-		if ($file === '.' || $file === '..'
-			|| pathinfo($file, PATHINFO_EXTENSION) === 'part'
-		) {
+	public static function isPartialFile($file) {
+		if (pathinfo($file, PATHINFO_EXTENSION) === 'part') {
 			return true;
 		}
 		return false;
@@ -162,9 +180,11 @@ class Scanner {
 	 * walk over any folders that are not fully scanned yet and scan them
 	 */
 	public function backgroundScan() {
-		while (($path = $this->cache->getIncomplete()) !== false) {
+		$lastPath = null;
+		while (($path = $this->cache->getIncomplete()) !== false && $path !== $lastPath) {
 			$this->scan($path);
 			$this->cache->correctFolderSize($path);
+			$lastPath = $path;
 		}
 	}
 }
diff --git a/lib/files/cache/storage.php b/lib/files/cache/storage.php
new file mode 100644
index 00000000000..72de376798c
--- /dev/null
+++ b/lib/files/cache/storage.php
@@ -0,0 +1,59 @@
+<?php
+/**
+ * Copyright (c) 2013 Robin Appelman <icewind@owncloud.com>
+ * This file is licensed under the Affero General Public License version 3 or
+ * later.
+ * See the COPYING-README file.
+ */
+
+namespace OC\Files\Cache;
+
+/**
+ * Class Storage
+ *
+ * cache storage specific data
+ *
+ * @package OC\Files\Cache
+ */
+class Storage {
+	private $storageId;
+	private $numericId;
+
+	/**
+	 * @param \OC\Files\Storage\Storage|string $storage
+	 */
+	public function __construct($storage) {
+		if ($storage instanceof \OC\Files\Storage\Storage) {
+			$this->storageId = $storage->getId();
+		} else {
+			$this->storageId = $storage;
+		}
+		if (strlen($this->storageId) > 64) {
+			$this->storageId = md5($this->storageId);
+		}
+
+		$query = \OC_DB::prepare('SELECT `numeric_id` FROM `*PREFIX*storages` WHERE `id` = ?');
+		$result = $query->execute(array($this->storageId));
+		if ($row = $result->fetchRow()) {
+			$this->numericId = $row['numeric_id'];
+		} else {
+			$query = \OC_DB::prepare('INSERT INTO `*PREFIX*storages`(`id`) VALUES(?)');
+			$query->execute(array($this->storageId));
+			$this->numericId = \OC_DB::insertid('*PREFIX*storages');
+		}
+	}
+
+	public function getNumericId() {
+		return $this->numericId;
+	}
+
+	public static function getStorageId($numericId) {
+		$query = \OC_DB::prepare('SELECT `id` FROM `*PREFIX*storages` WHERE `numeric_id` = ?');
+		$result = $query->execute(array($numericId));
+		if ($row = $result->fetchRow()) {
+			return $row['id'];
+		} else {
+			return null;
+		}
+	}
+}
diff --git a/lib/files/cache/updater.php b/lib/files/cache/updater.php
index d04541c219f..417a47f3830 100644
--- a/lib/files/cache/updater.php
+++ b/lib/files/cache/updater.php
@@ -16,7 +16,7 @@ class Updater {
 	/**
 	 * resolve a path to a storage and internal path
 	 *
-	 * @param string $path
+	 * @param string $path the relative path
 	 * @return array consisting of the storage and the internal path
 	 */
 	static public function resolvePath($path) {
@@ -24,6 +24,11 @@ class Updater {
 		return $view->resolvePath($path);
 	}
 
+	/**
+	 * preform a write update
+	 *
+	 * @param string $path the relative path of the file
+	 */
 	static public function writeUpdate($path) {
 		/**
 		 * @var \OC\Files\Storage\Storage $storage
@@ -39,6 +44,11 @@ class Updater {
 		}
 	}
 
+	/**
+	 * preform a delete update
+	 *
+	 * @param string $path the relative path of the file
+	 */
 	static public function deleteUpdate($path) {
 		/**
 		 * @var \OC\Files\Storage\Storage $storage
@@ -54,11 +64,41 @@ class Updater {
 	}
 
 	/**
-	* Update the mtime and ETag of all parent folders
-	*
-	* @param string $path
-	* @param string $time
-	*/
+	 * preform a rename update
+	 *
+	 * @param string $from the relative path of the source file
+	 * @param string $to the relative path of the target file
+	 */
+	static public function renameUpdate($from, $to) {
+		/**
+		 * @var \OC\Files\Storage\Storage $storageFrom
+		 * @var \OC\Files\Storage\Storage $storageTo
+		 * @var string $internalFrom
+		 * @var string $internalTo
+		 */
+		list($storageFrom, $internalFrom) = self::resolvePath($from);
+		list($storageTo, $internalTo) = self::resolvePath($to);
+		if ($storageFrom && $storageTo) {
+			if ($storageFrom === $storageTo) {
+				$cache = $storageFrom->getCache($internalFrom);
+				$cache->move($internalFrom, $internalTo);
+				$cache->correctFolderSize($internalFrom);
+				$cache->correctFolderSize($internalTo);
+				self::correctFolder($from, time());
+				self::correctFolder($to, time());
+			} else {
+				self::deleteUpdate($from);
+				self::writeUpdate($to);
+			}
+		}
+	}
+
+	/**
+	 * Update the mtime and ETag of all parent folders
+	 *
+	 * @param string $path
+	 * @param string $time
+	 */
 	static public function correctFolder($path, $time) {
 		if ($path !== '' && $path !== '/') {
 			$parent = dirname($path);
@@ -66,9 +106,9 @@ class Updater {
 				$parent = '';
 			}
 			/**
-			* @var \OC\Files\Storage\Storage $storage
-			* @var string $internalPath
-			*/
+			 * @var \OC\Files\Storage\Storage $storage
+			 * @var string $internalPath
+			 */
 			list($storage, $internalPath) = self::resolvePath($parent);
 			if ($storage) {
 				$cache = $storage->getCache();
@@ -91,9 +131,22 @@ class Updater {
 	/**
 	 * @param array $params
 	 */
+	static public function touchHook($params) {
+		$path = $params['path'];
+		list($storage, $internalPath) = self::resolvePath($path);
+		$cache = $storage->getCache();
+		$id = $cache->getId($internalPath);
+		if ($id !== -1) {
+			$cache->update($id, array('etag' => $storage->getETag($internalPath)));
+		}
+		self::writeUpdate($path);
+	}
+
+	/**
+	 * @param array $params
+	 */
 	static public function renameHook($params) {
-		self::deleteUpdate($params['oldpath']);
-		self::writeUpdate($params['newpath']);
+		self::renameUpdate($params['oldpath'], $params['newpath']);
 	}
 
 	/**
diff --git a/lib/files/cache/upgrade.php b/lib/files/cache/upgrade.php
index 811d82d7437..ca044ba81de 100644
--- a/lib/files/cache/upgrade.php
+++ b/lib/files/cache/upgrade.php
@@ -26,63 +26,77 @@ class Upgrade {
 	}
 
 	/**
-	 * Preform a shallow upgrade
+	 * Preform a upgrade a path and it's childs
 	 *
 	 * @param string $path
-	 * @param int $mode
+	 * @param bool $mode
 	 */
 	function upgradePath($path, $mode = Scanner::SCAN_RECURSIVE) {
 		if (!$this->legacy->hasItems()) {
 			return;
 		}
 		\OC_Hook::emit('\OC\Files\Cache\Upgrade', 'migrate_path', $path);
-
 		if ($row = $this->legacy->get($path)) {
 			$data = $this->getNewData($row);
-			$this->insert($data);
-
-			$this->upgradeChilds($data['id'], $mode);
+			if ($data) {
+				$this->insert($data);
+				$this->upgradeChilds($data['id'], $mode);
+			}
 		}
 	}
 
 	/**
+	 * upgrade all child elements of an item
+	 *
 	 * @param int $id
+	 * @param bool $mode
 	 */
 	function upgradeChilds($id, $mode = Scanner::SCAN_RECURSIVE) {
 		$children = $this->legacy->getChildren($id);
 		foreach ($children as $child) {
 			$childData = $this->getNewData($child);
 			\OC_Hook::emit('\OC\Files\Cache\Upgrade', 'migrate_path', $child['path']);
-			$this->insert($childData);
-			if ($mode == Scanner::SCAN_RECURSIVE) {
-				$this->upgradeChilds($child['id']);
+			if ($childData) {
+				$this->insert($childData);
+				if ($mode == Scanner::SCAN_RECURSIVE) {
+					$this->upgradeChilds($child['id']);
+				}
 			}
 		}
 	}
 
 	/**
+	 * insert data into the new cache
+	 *
 	 * @param array $data the data for the new cache
 	 */
 	function insert($data) {
-		if (!$this->inCache($data['storage'], $data['path_hash'], $data['id'])) {
+		static $insertQuery = null;
+		if(is_null($insertQuery)) {
 			$insertQuery = \OC_DB::prepare('INSERT INTO `*PREFIX*filecache`
-					( `fileid`, `storage`, `path`, `path_hash`, `parent`, `name`, `mimetype`, `mimepart`, `size`, `mtime`, `encrypted` )
-					VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)');
-
+				( `fileid`, `storage`, `path`, `path_hash`, `parent`, `name`, `mimetype`, `mimepart`, `size`, `mtime`, `encrypted`, `etag` )
+				VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)');
+		}
+		if (!$this->inCache($data['storage'], $data['path_hash'], $data['id'])) {
 			$insertQuery->execute(array($data['id'], $data['storage'],
 				$data['path'], $data['path_hash'], $data['parent'], $data['name'],
-				$data['mimetype'], $data['mimepart'], $data['size'], $data['mtime'], $data['encrypted']));
+				$data['mimetype'], $data['mimepart'], $data['size'], $data['mtime'], $data['encrypted'], $data['etag']));
 		}
 	}
 
 	/**
+	 * check if an item is already in the new cache
+	 *
 	 * @param string $storage
 	 * @param string $pathHash
 	 * @param string $id
 	 * @return bool
 	 */
 	function inCache($storage, $pathHash, $id) {
-		$query = \OC_DB::prepare('SELECT `fileid` FROM `*PREFIX*filecache` WHERE (`storage` = ? AND `path_hash` = ?) OR `fileid` = ?');
+		static $query = null;
+		if(is_null($query)) {
+			$query = \OC_DB::prepare('SELECT `fileid` FROM `*PREFIX*filecache` WHERE (`storage` = ? AND `path_hash` = ?) OR `fileid` = ?');
+		}
 		$result = $query->execute(array($storage, $pathHash, $id));
 		return (bool)$result->fetchRow();
 	}
@@ -91,24 +105,53 @@ class Upgrade {
 	 * get the new data array from the old one
 	 *
 	 * @param array $data the data from the old cache
+	 * Example data array
+	 * Array
+	 *	(
+	 *		[id] => 418
+	 *		[path] => /tina/files/picture.jpg		//relative to datadir
+	 *		[path_hash] => 66d4547e372888deed80b24fec9b192b
+	 *		[parent] => 234
+	 *		[name] => picture.jpg
+	 *		[user] => tina
+	 *		[size] => 1265283
+	 *		[ctime] => 1363909709
+	 *		[mtime] => 1363909709
+	 *		[mimetype] => image/jpeg
+	 *		[mimepart] => image
+	 *		[encrypted] => 0
+	 *		[versioned] => 0
+	 *		[writable] => 1
+	 *	)
+	 *
 	 * @return array
 	 */
 	function getNewData($data) {
+		//Make sure there is a path, otherwise we can do nothing.
+		if(!isset($data['path'])) {
+			return false;
+		}
 		$newData = $data;
-		list($storage, $internalPath) = \OC\Files\Filesystem::resolvePath($data['path']);
 		/**
 		 * @var \OC\Files\Storage\Storage $storage
 		 * @var string $internalPath;
 		 */
-		$newData['path_hash'] = md5($internalPath);
-		$newData['path'] = $internalPath;
-		$newData['storage'] = $this->getNumericId($storage);
-		$newData['parent'] = ($internalPath === '') ? -1 : $data['parent'];
-		$newData['permissions'] = ($data['writable']) ? \OCP\PERMISSION_ALL : \OCP\PERMISSION_READ;
-		$newData['storage_object'] = $storage;
-		$newData['mimetype'] = $this->getMimetypeId($newData['mimetype'], $storage);
-		$newData['mimepart'] = $this->getMimetypeId($newData['mimepart'], $storage);
-		return $newData;
+		list($storage, $internalPath) = \OC\Files\Filesystem::resolvePath($data['path']);
+		if ($storage) {
+			$newData['etag'] = $data['etag'];
+			$newData['path_hash'] = md5($internalPath);
+			$newData['path'] = $internalPath;
+			$newData['storage'] = $this->getNumericId($storage);
+			$newData['parent'] = ($internalPath === '') ? -1 : $data['parent'];
+			$newData['permissions'] = ($data['writable']) ? \OCP\PERMISSION_ALL : \OCP\PERMISSION_READ;
+			$newData['storage_object'] = $storage;
+			$newData['mimetype'] = $this->getMimetypeId($newData['mimetype'], $storage);
+			$newData['mimepart'] = $this->getMimetypeId($newData['mimepart'], $storage);
+			return $newData;
+		} else {
+			\OC_Log::write('core', 'Unable to migrate data from old cache for '.$data['path'].' because the storage was not found', \OC_Log::ERROR);
+			return false;
+		}
 	}
 
 	/**
@@ -127,6 +170,8 @@ class Upgrade {
 	}
 
 	/**
+	 * get the numeric id for a mimetype
+	 *
 	 * @param string $mimetype
 	 * @param \OC\Files\Storage\Storage $storage
 	 * @return int
@@ -158,4 +203,25 @@ class Upgrade {
 	static function upgradeDone($user) {
 		\OCP\Config::setUserValue($user, 'files', 'cache_version', 5);
 	}
+
+	/**
+	 * Does a "silent" upgrade, i.e. without an Event-Source as triggered
+	 * on User-Login via Ajax. This method is called within the regular
+	 * ownCloud upgrade.
+	 *
+	 * @param string $user a User ID
+	 */
+	public static function doSilentUpgrade($user) {
+		if(!self::needUpgrade($user)) {
+			return;
+		}
+		$legacy = new \OC\Files\Cache\Legacy($user);
+		if ($legacy->hasItems()) {
+			\OC_DB::beginTransaction();
+			$upgrade = new \OC\Files\Cache\Upgrade($legacy);
+			$upgrade->upgradePath('/' . $user . '/files');
+			\OC_DB::commit();
+		}
+		\OC\Files\Cache\Upgrade::upgradeDone($user);
+	}
 }
diff --git a/lib/files/filesystem.php b/lib/files/filesystem.php
index 0bbd7550d74..d60d430d77c 100644
--- a/lib/files/filesystem.php
+++ b/lib/files/filesystem.php
@@ -23,6 +23,7 @@
  *   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
  */
@@ -30,8 +31,14 @@
 namespace OC\Files;
 
 const FREE_SPACE_UNKNOWN = -2;
+const FREE_SPACE_UNLIMITED = -3;
 
 class Filesystem {
+	/**
+	 * @var Mount\Manager $mounts
+	 */
+	private static $mounts;
+
 	public static $loaded = false;
 	/**
 	 * @var \OC\Files\View $defaultInstance
@@ -145,7 +152,7 @@ class Filesystem {
 	 * @return string
 	 */
 	static public function getMountPoint($path) {
-		$mount = Mount::find($path);
+		$mount = self::$mounts->find($path);
 		if ($mount) {
 			return $mount->getMountPoint();
 		} else {
@@ -161,7 +168,7 @@ class Filesystem {
 	 */
 	static public function getMountPoints($path) {
 		$result = array();
-		$mounts = Mount::findIn($path);
+		$mounts = self::$mounts->findIn($path);
 		foreach ($mounts as $mount) {
 			$result[] = $mount->getMountPoint();
 		}
@@ -175,18 +182,34 @@ class Filesystem {
 	 * @return \OC\Files\Storage\Storage
 	 */
 	public static function getStorage($mountPoint) {
-		$mount = Mount::find($mountPoint);
+		$mount = self::$mounts->find($mountPoint);
 		return $mount->getStorage();
 	}
 
 	/**
+	 * @param $id
+	 * @return Mount\Mount[]
+	 */
+	public static function getMountByStorageId($id) {
+		return self::$mounts->findByStorageId($id);
+	}
+
+	/**
+	 * @param $id
+	 * @return Mount\Mount[]
+	 */
+	public static function getMountByNumericId($id) {
+		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) {
-		$mount = Mount::find($path);
+		$mount = self::$mounts->find($path);
 		if ($mount) {
 			return array($mount->getStorage(), $mount->getInternalPath($path));
 		} else {
@@ -200,6 +223,10 @@ class Filesystem {
 		}
 		self::$defaultInstance = new View($root);
 
+		if(!self::$mounts) {
+			self::$mounts = new Mount\Manager();
+		}
+
 		//load custom mount config
 		self::initMountPoints($user);
 
@@ -208,6 +235,10 @@ class Filesystem {
 		return true;
 	}
 
+	static public function initMounts(){
+		self::$mounts = new Mount\Manager();
+	}
+
 	/**
 	 * Initialize system and personal mount points for a user
 	 *
@@ -221,11 +252,16 @@ class Filesystem {
 
 		$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(\OC::$SERVERROOT . '/config/mount.json')) {
-			if (is_file(\OC::$SERVERROOT . '/config/mount.json')) {
-				$mountConfig = json_decode(file_get_contents(\OC::$SERVERROOT . '/config/mount.json'), true);
+		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'));
 			}
@@ -249,7 +285,7 @@ class Filesystem {
 			}
 			if (isset($mountConfig['user'])) {
 				foreach ($mountConfig['user'] as $mountUser => $mounts) {
-					if ($user === 'all' or strtolower($mountUser) === strtolower($user)) {
+					if ($mountUser === 'all' or strtolower($mountUser) === strtolower($user)) {
 						foreach ($mounts as $mountPoint => $options) {
 							$mountPoint = self::setUserVars($user, $mountPoint);
 							foreach ($options as &$option) {
@@ -274,12 +310,15 @@ class Filesystem {
 				}
 			}
 		}
+
+		// 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, and $password placeholders
+	 * fill in the correct values for $user
 	 *
-	 * @param string $input
+	 * @param string $user
 	 * @param string $input
 	 * @return string
 	 */
@@ -301,6 +340,7 @@ class Filesystem {
 	 */
 	static public function tearDown() {
 		self::clearMounts();
+		self::$defaultInstance = null;
 	}
 
 	/**
@@ -317,7 +357,7 @@ class Filesystem {
 	 * clear all mounts and storage backends
 	 */
 	public static function clearMounts() {
-		Mount::clear();
+		self::$mounts->clear();
 	}
 
 	/**
@@ -328,7 +368,8 @@ class Filesystem {
 	 * @param string $mountpoint
 	 */
 	static public function mount($class, $arguments, $mountpoint) {
-		new Mount($class, $mountpoint, $arguments);
+		$mount = new Mount\Mount($class, $mountpoint, $arguments);
+		self::$mounts->addMount($mount);
 	}
 
 	/**
@@ -615,10 +656,11 @@ class Filesystem {
 	 * 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) {
-		return self::$defaultInstance->getDirectoryContent($directory);
+	public static function getDirectoryContent($directory, $mimetype_filter = '') {
+		return self::$defaultInstance->getDirectoryContent($directory, $mimetype_filter);
 	}
 
 	/**
@@ -654,8 +696,4 @@ class Filesystem {
 	}
 }
 
-\OC_Hook::connect('OC_Filesystem', 'post_write', '\OC\Files\Cache\Updater', 'writeHook');
-\OC_Hook::connect('OC_Filesystem', 'post_delete', '\OC\Files\Cache\Updater', 'deleteHook');
-\OC_Hook::connect('OC_Filesystem', 'post_rename', '\OC\Files\Cache\Updater', 'renameHook');
-
 \OC_Util::setupFS();
diff --git a/lib/files/mapper.php b/lib/files/mapper.php
index 520fadbd8c6..15f5f0628b5 100644
--- a/lib/files/mapper.php
+++ b/lib/files/mapper.php
@@ -77,7 +77,9 @@ class Mapper
 		$result = $query->execute(array($path1.'%'));
 		$updateQuery = \OC_DB::prepare('UPDATE `*PREFIX*file_map`'
 			.' SET `logic_path` = ?'
-			.' AND `physic_path` = ?'
+			.' , `logic_path_hash` = ?'
+			.' , `physic_path` = ?'
+			.' , `physic_path_hash` = ?'
 			.' WHERE `logic_path` = ?');
 		while( $row = $result->fetchRow()) {
 			$currentLogic = $row['logic_path'];
@@ -86,7 +88,7 @@ class Mapper
 			$newPhysic = $physicPath2.$this->stripRootFolder($currentPhysic, $physicPath1);
 			if ($path1 !== $currentLogic) {
 				try {
-					$updateQuery->execute(array($newLogic, $newPhysic, $currentLogic));
+					$updateQuery->execute(array($newLogic, md5($newLogic), $newPhysic, md5($newPhysic), $currentLogic));
 				} catch (\Exception $e) {
 					error_log('Mapper::Copy failed '.$currentLogic.' -> '.$newLogic.'\n'.$e);
 					throw $e;
@@ -149,7 +151,7 @@ class Mapper
 
 		// detect duplicates
 		while ($this->resolvePhysicalPath($physicalPath) !== null) {
-			$physicalPath = $this->slugifyPath($physicalPath, $index++);
+			$physicalPath = $this->slugifyPath($logicPath, $index++);
 		}
 
 		// insert the new path mapping if requested
@@ -165,32 +167,41 @@ class Mapper
 		$query->execute(array($logicPath, $physicalPath, md5($logicPath), md5($physicalPath)));
 	}
 
-	private function slugifyPath($path, $index=null) {
+	public function slugifyPath($path, $index=null) {
 		$path = $this->stripRootFolder($path, $this->unchangedPhysicalRoot);
 
 		$pathElements = explode('/', $path);
 		$sluggedElements = array();
 
+		// rip off the extension ext from last element
+		$last= end($pathElements);
+		$parts = pathinfo($last);
+		$filename = $parts['filename'];
+		array_pop($pathElements);
+		array_push($pathElements, $filename);
+
 		foreach ($pathElements as $pathElement) {
 			// remove empty elements
 			if (empty($pathElement)) {
 				continue;
 			}
 
-			// TODO: remove file ext before slugify on last element
 			$sluggedElements[] = self::slugify($pathElement);
 		}
 
-		//
-		// TODO: add the index before the file extension
-		//
+		// apply index to file name
 		if ($index !== null) {
-			$last= end($sluggedElements);
-			array_pop($sluggedElements);
+			$last= array_pop($sluggedElements);
 			array_push($sluggedElements, $last.'-'.$index);
 		}
 
-		$sluggedPath = $this->unchangedPhysicalRoot.implode(DIRECTORY_SEPARATOR, $sluggedElements);
+		// add back the extension
+		if (isset($parts['extension'])) {
+			$last= array_pop($sluggedElements);
+			array_push($sluggedElements, $last.'.'.$parts['extension']);
+		}
+
+		$sluggedPath = $this->unchangedPhysicalRoot.implode('/', $sluggedElements);
 		return $this->stripLast($sluggedPath);
 	}
 
@@ -210,7 +221,7 @@ class Mapper
 
 		// transliterate
 		if (function_exists('iconv')) {
-			$text = iconv('utf-8', 'us-ascii//TRANSLIT', $text);
+			$text = iconv('utf-8', 'us-ascii//TRANSLIT//IGNORE', $text);
 		}
 
 		// lowercase
@@ -219,10 +230,8 @@ class Mapper
 		// remove unwanted characters
 		$text = preg_replace('~[^-\w]+~', '', $text);
 
-		if (empty($text))
-		{
-			// TODO: we better generate a guid in this case
-			return 'n-a';
+		if (empty($text)) {
+			return uniqid();
 		}
 
 		return $text;
diff --git a/lib/files/mount/manager.php b/lib/files/mount/manager.php
new file mode 100644
index 00000000000..25a5fe241cc
--- /dev/null
+++ b/lib/files/mount/manager.php
@@ -0,0 +1,120 @@
+<?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.
+ */
+
+namespace OC\Files\Mount;
+
+use \OC\Files\Filesystem;
+
+class Manager {
+	/**
+	 * @var Mount[]
+	 */
+	private $mounts = array();
+
+	/**
+	 * @param Mount $mount
+	 */
+	public function addMount($mount) {
+		$this->mounts[$mount->getMountPoint()] = $mount;
+	}
+
+	/**
+	 * Find the mount for $path
+	 *
+	 * @param $path
+	 * @return Mount
+	 */
+	public function find($path) {
+		\OC_Util::setupFS();
+		$path = $this->formatPath($path);
+		if (isset($this->mounts[$path])) {
+			return $this->mounts[$path];
+		}
+
+		\OC_Hook::emit('OC_Filesystem', 'get_mountpoint', array('path' => $path));
+		$foundMountPoint = '';
+		$mountPoints = array_keys($this->mounts);
+		foreach ($mountPoints as $mountpoint) {
+			if (strpos($path, $mountpoint) === 0 and strlen($mountpoint) > strlen($foundMountPoint)) {
+				$foundMountPoint = $mountpoint;
+			}
+		}
+		if (isset($this->mounts[$foundMountPoint])) {
+			return $this->mounts[$foundMountPoint];
+		} else {
+			return null;
+		}
+	}
+
+	/**
+	 * Find all mounts in $path
+	 *
+	 * @param $path
+	 * @return Mount[]
+	 */
+	public function findIn($path) {
+		\OC_Util::setupFS();
+		$path = $this->formatPath($path);
+		$result = array();
+		$pathLength = strlen($path);
+		$mountPoints = array_keys($this->mounts);
+		foreach ($mountPoints as $mountPoint) {
+			if (substr($mountPoint, 0, $pathLength) === $path and strlen($mountPoint) > $pathLength) {
+				$result[] = $this->mounts[$mountPoint];
+			}
+		}
+		return $result;
+	}
+
+	public function clear() {
+		$this->mounts = array();
+	}
+
+	/**
+	 * Find mounts by storage id
+	 *
+	 * @param string $id
+	 * @return Mount[]
+	 */
+	public function findByStorageId($id) {
+		\OC_Util::setupFS();
+		if (strlen($id) > 64) {
+			$id = md5($id);
+		}
+		$result = array();
+		foreach ($this->mounts as $mount) {
+			if ($mount->getStorageId() === $id) {
+				$result[] = $mount;
+			}
+		}
+		return $result;
+	}
+
+	/**
+	 * Find mounts by numeric storage id
+	 *
+	 * @param string $id
+	 * @return Mount
+	 */
+	public function findByNumericId($id) {
+		$storageId = \OC\Files\Cache\Storage::getStorageId($id);
+		return $this->findByStorageId($storageId);
+	}
+
+	/**
+	 * @param string $path
+	 * @return string
+	 */
+	private function formatPath($path) {
+		$path = Filesystem::normalizePath($path);
+		if (strlen($path) > 1) {
+			$path .= '/';
+		}
+		return $path;
+	}
+}
diff --git a/lib/files/mount.php b/lib/files/mount/mount.php
index 1c9382d78e7..69b8285ab4c 100644
--- a/lib/files/mount.php
+++ b/lib/files/mount/mount.php
@@ -6,13 +6,12 @@
  * See the COPYING-README file.
  */
 
-namespace OC\Files;
+namespace OC\Files\Mount;
+
+use \OC\Files\Filesystem;
 
 class Mount {
-	/**
-	 * @var Mount[]
-	 */
-	static private $mounts = array();
+
 
 	/**
 	 * @var \OC\Files\Storage\Storage $storage
@@ -33,7 +32,7 @@ class Mount {
 			$arguments = array();
 		}
 
-		$mountpoint = self::formatPath($mountpoint);
+		$mountpoint = $this->formatPath($mountpoint);
 		if ($storage instanceof \OC\Files\Storage\Storage) {
 			$this->class = get_class($storage);
 			$this->storage = $storage;
@@ -46,8 +45,6 @@ class Mount {
 			$this->arguments = $arguments;
 		}
 		$this->mountPoint = $mountpoint;
-
-		self::$mounts[$this->mountPoint] = $this;
 	}
 
 	/**
@@ -58,6 +55,8 @@ class Mount {
 	}
 
 	/**
+	 * create the storage that is mounted
+	 *
 	 * @return \OC\Files\Storage\Storage
 	 */
 	private function createStorage() {
@@ -90,7 +89,11 @@ class Mount {
 	public function getStorageId() {
 		if (!$this->storageId) {
 			if (is_null($this->storage)) {
-				$this->storage = $this->createStorage();
+				$storage = $this->createStorage(); //FIXME: start using exceptions
+				if (is_null($storage)) {
+					return null;
+				}
+				$this->storage = $storage;
 			}
 			$this->storageId = $this->storage->getId();
 			if (strlen($this->storageId) > 64) {
@@ -117,100 +120,11 @@ class Mount {
 	 * @param string $path
 	 * @return string
 	 */
-	private static function formatPath($path) {
+	private function formatPath($path) {
 		$path = Filesystem::normalizePath($path);
 		if (strlen($path) > 1) {
 			$path .= '/';
 		}
 		return $path;
 	}
-
-	/**
-	 * Find the mount for $path
-	 *
-	 * @param $path
-	 * @return Mount
-	 */
-	public static function find($path) {
-		$path = self::formatPath($path);
-		if (isset(self::$mounts[$path])) {
-			return self::$mounts[$path];
-		}
-
-		\OC_Hook::emit('OC_Filesystem', 'get_mountpoint', array('path' => $path));
-		$foundMountPoint = '';
-		$mountPoints = array_keys(self::$mounts);
-		foreach ($mountPoints as $mountpoint) {
-			if (strpos($path, $mountpoint) === 0 and strlen($mountpoint) > strlen($foundMountPoint)) {
-				$foundMountPoint = $mountpoint;
-			}
-		}
-		if (isset(self::$mounts[$foundMountPoint])) {
-			return self::$mounts[$foundMountPoint];
-		} else {
-			return null;
-		}
-	}
-
-	/**
-	 * Find all mounts in $path
-	 *
-	 * @param $path
-	 * @return Mount[]
-	 */
-	public static function findIn($path) {
-		$path = self::formatPath($path);
-		$result = array();
-		$pathLength = strlen($path);
-		$mountPoints = array_keys(self::$mounts);
-		foreach ($mountPoints as $mountPoint) {
-			if (substr($mountPoint, 0, $pathLength) === $path and strlen($mountPoint) > $pathLength) {
-				$result[] = self::$mounts[$mountPoint];
-			}
-		}
-		return $result;
-	}
-
-	public static function clear() {
-		self::$mounts = array();
-	}
-
-	/**
-	 * Find mounts by storage id
-	 *
-	 * @param string $id
-	 * @return Mount[]
-	 */
-	public static function findByStorageId($id) {
-		if (strlen($id) > 64) {
-			$id = md5($id);
-		}
-		$result = array();
-		foreach (self::$mounts as $mount) {
-			if ($mount->getStorageId() === $id) {
-				$result[] = $mount;
-			}
-		}
-		return $result;
-	}
-
-	/**
-	 * Find mounts by numeric storage id
-	 *
-	 * @param string $id
-	 * @return Mount
-	 */
-	public static function findByNumericId($id) {
-		$query = \OC_DB::prepare('SELECT `id` FROM `*PREFIX*storages` WHERE `numeric_id` = ?');
-		$result = $query->execute(array($id))->fetchOne();
-		if ($result) {
-			$id = $result;
-			foreach (self::$mounts as $mount) {
-				if ($mount->getStorageId() === $id) {
-					return $mount;
-				}
-			}
-		}
-		return false;
-	}
 }
diff --git a/lib/files/storage/common.php b/lib/files/storage/common.php
index 8aa227ec0b7..e87fe3b5239 100644
--- a/lib/files/storage/common.php
+++ b/lib/files/storage/common.php
@@ -21,6 +21,11 @@ namespace OC\Files\Storage;
  */
 
 abstract class Common implements \OC\Files\Storage\Storage {
+	private $cache;
+	private $scanner;
+	private $permissioncache;
+	private $watcher;
+	private $storageCache;
 
 	public function __construct($parameters) {
 	}
@@ -269,19 +274,38 @@ abstract class Common implements \OC\Files\Storage\Storage {
 	}
 
 	public function getCache($path = '') {
-		return new \OC\Files\Cache\Cache($this);
+		if (!isset($this->cache)) {
+			$this->cache = new \OC\Files\Cache\Cache($this);
+		}
+		return $this->cache;
 	}
 
 	public function getScanner($path = '') {
-		return new \OC\Files\Cache\Scanner($this);
+		if (!isset($this->scanner)) {
+			$this->scanner = new \OC\Files\Cache\Scanner($this);
+		}
+		return $this->scanner;
 	}
 
 	public function getPermissionsCache($path = '') {
-		return new \OC\Files\Cache\Permissions($this);
+		if (!isset($this->permissioncache)) {
+			$this->permissioncache = new \OC\Files\Cache\Permissions($this);
+		}
+		return $this->permissioncache;
 	}
 
 	public function getWatcher($path = '') {
-		return new \OC\Files\Cache\Watcher($this);
+		if (!isset($this->watcher)) {
+			$this->watcher = new \OC\Files\Cache\Watcher($this);
+		}
+		return $this->watcher;
+	}
+
+	public function getStorageCache(){
+		if (!isset($this->storageCache)) {
+			$this->storageCache = new \OC\Files\Cache\Storage($this);
+		}
+		return $this->storageCache;
 	}
 
 	/**
@@ -345,7 +369,7 @@ abstract class Common implements \OC\Files\Storage\Storage {
 	 * get the free space in the storage
 	 *
 	 * @param $path
-	 * return int
+	 * @return int
 	 */
 	public function free_space($path) {
 		return \OC\Files\FREE_SPACE_UNKNOWN;
diff --git a/lib/files/storage/local.php b/lib/files/storage/local.php
index da6597c8057..d684905bf9a 100644
--- a/lib/files/storage/local.php
+++ b/lib/files/storage/local.php
@@ -14,245 +14,277 @@ if (\OC_Util::runningOnWindows()) {
 	}
 } else {
 
-/**
- * for local filestore, we only have to map the paths
- */
-class Local extends \OC\Files\Storage\Common{
-	protected $datadir;
-	public function __construct($arguments) {
-		$this->datadir=$arguments['datadir'];
-		if(substr($this->datadir, -1)!=='/') {
-			$this->datadir.='/';
+	/**
+	 * for local filestore, we only have to map the paths
+	 */
+	class Local extends \OC\Files\Storage\Common {
+		protected $datadir;
+
+		public function __construct($arguments) {
+			$this->datadir = $arguments['datadir'];
+			if (substr($this->datadir, -1) !== '/') {
+				$this->datadir .= '/';
+			}
 		}
-	}
-	public function __destruct() {
-	}
-	public function getId(){
-		return 'local::'.$this->datadir;
-	}
-	public function mkdir($path) {
-		return @mkdir($this->datadir.$path);
-	}
-	public function rmdir($path) {
-		return @rmdir($this->datadir.$path);
-	}
-	public function opendir($path) {
-		return opendir($this->datadir.$path);
-	}
-	public function is_dir($path) {
-		if(substr($path, -1)=='/') {
-			$path=substr($path, 0, -1);
+
+		public function __destruct() {
 		}
-		return is_dir($this->datadir.$path);
-	}
-	public function is_file($path) {
-		return is_file($this->datadir.$path);
-	}
-	public function stat($path) {
-		$fullPath = $this->datadir . $path;
-		$statResult = stat($fullPath);
 
-		if ($statResult['size'] < 0) {
-			$size = self::getFileSizeFromOS($fullPath);
-			$statResult['size'] = $size;
-			$statResult[7] = $size;
+		public function getId() {
+			return 'local::' . $this->datadir;
 		}
-		return $statResult;
-	}
-	public function filetype($path) {
-		$filetype=filetype($this->datadir.$path);
-		if($filetype=='link') {
-			$filetype=filetype(realpath($this->datadir.$path));
+
+		public function mkdir($path) {
+			return @mkdir($this->datadir . $path);
 		}
-		return $filetype;
-	}
-	public function filesize($path) {
-		if($this->is_dir($path)) {
-			return 0;
-		}else{
+
+		public function rmdir($path) {
+			return @rmdir($this->datadir . $path);
+		}
+
+		public function opendir($path) {
+			return opendir($this->datadir . $path);
+		}
+
+		public function is_dir($path) {
+			if (substr($path, -1) == '/') {
+				$path = substr($path, 0, -1);
+			}
+			return is_dir($this->datadir . $path);
+		}
+
+		public function is_file($path) {
+			return is_file($this->datadir . $path);
+		}
+
+		public function stat($path) {
 			$fullPath = $this->datadir . $path;
-			$fileSize = filesize($fullPath);
-			if ($fileSize < 0) {
-				return self::getFileSizeFromOS($fullPath);
+			$statResult = stat($fullPath);
+
+			if ($statResult['size'] < 0) {
+				$size = self::getFileSizeFromOS($fullPath);
+				$statResult['size'] = $size;
+				$statResult[7] = $size;
 			}
+			return $statResult;
+		}
 
-			return $fileSize;
+		public function filetype($path) {
+			$filetype = filetype($this->datadir . $path);
+			if ($filetype == 'link') {
+				$filetype = filetype(realpath($this->datadir . $path));
+			}
+			return $filetype;
 		}
-	}
-	public function isReadable($path) {
-		return is_readable($this->datadir.$path);
-	}
-	public function isUpdatable($path) {
-		return is_writable($this->datadir.$path);
-	}
-	public function file_exists($path) {
-		return file_exists($this->datadir.$path);
-	}
-	public function filemtime($path) {
-		return filemtime($this->datadir.$path);
-	}
-	public function touch($path, $mtime=null) {
-		// sets the modification time of the file to the given value.
-		// If mtime is nil the current time is set.
-		// note that the access time of the file always changes to the current time.
-		if(!is_null($mtime)) {
-			$result=touch( $this->datadir.$path, $mtime );
-		}else{
-			$result=touch( $this->datadir.$path);
+
+		public function filesize($path) {
+			if ($this->is_dir($path)) {
+				return 0;
+			} else {
+				$fullPath = $this->datadir . $path;
+				$fileSize = filesize($fullPath);
+				if ($fileSize < 0) {
+					return self::getFileSizeFromOS($fullPath);
+				}
+
+				return $fileSize;
+			}
 		}
-		if( $result ) {
-			clearstatcache( true, $this->datadir.$path );
+
+		public function isReadable($path) {
+			return is_readable($this->datadir . $path);
 		}
 
-		return $result;
-	}
-	public function file_get_contents($path) {
-		return file_get_contents($this->datadir.$path);
-	}
-	public function file_put_contents($path, $data) {//trigger_error("$path = ".var_export($path, 1));
-		return file_put_contents($this->datadir.$path, $data);
-	}
-	public function unlink($path) {
-		return $this->delTree($path);
-	}
-	public function rename($path1, $path2) {
-		if (!$this->isUpdatable($path1)) {
-			\OC_Log::write('core', 'unable to rename, file is not writable : '.$path1, \OC_Log::ERROR);
-			return false;
+		public function isUpdatable($path) {
+			return is_writable($this->datadir . $path);
 		}
-		if(! $this->file_exists($path1)) {
-			\OC_Log::write('core', 'unable to rename, file does not exists : '.$path1, \OC_Log::ERROR);
-			return false;
+
+		public function file_exists($path) {
+			return file_exists($this->datadir . $path);
 		}
 
-		if($return=rename($this->datadir.$path1, $this->datadir.$path2)) {
+		public function filemtime($path) {
+			return filemtime($this->datadir . $path);
 		}
-		return $return;
-	}
-	public function copy($path1, $path2) {
-		if($this->is_dir($path2)) {
-			if(!$this->file_exists($path2)) {
-				$this->mkdir($path2);
+
+		public function touch($path, $mtime = null) {
+			// sets the modification time of the file to the given value.
+			// If mtime is nil the current time is set.
+			// note that the access time of the file always changes to the current time.
+			if ($this->file_exists($path) and !$this->isUpdatable($path)) {
+				return false;
+			}
+			if (!is_null($mtime)) {
+				$result = touch($this->datadir . $path, $mtime);
+			} else {
+				$result = touch($this->datadir . $path);
 			}
-			$source=substr($path1, strrpos($path1, '/')+1);
-			$path2.=$source;
+			if ($result) {
+				clearstatcache(true, $this->datadir . $path);
+			}
+
+			return $result;
 		}
-		return copy($this->datadir.$path1, $this->datadir.$path2);
-	}
-	public function fopen($path, $mode) {
-		if($return=fopen($this->datadir.$path, $mode)) {
-			switch($mode) {
-				case 'r':
-					break;
-				case 'r+':
-				case 'w+':
-				case 'x+':
-				case 'a+':
-					break;
-				case 'w':
-				case 'x':
-				case 'a':
-					break;
+
+		public function file_get_contents($path) {
+			return file_get_contents($this->datadir . $path);
+		}
+
+		public function file_put_contents($path, $data) { //trigger_error("$path = ".var_export($path, 1));
+			return file_put_contents($this->datadir . $path, $data);
+		}
+
+		public function unlink($path) {
+			return $this->delTree($path);
+		}
+
+		public function rename($path1, $path2) {
+			if (!$this->isUpdatable($path1)) {
+				\OC_Log::write('core', 'unable to rename, file is not writable : ' . $path1, \OC_Log::ERROR);
+				return false;
+			}
+			if (!$this->file_exists($path1)) {
+				\OC_Log::write('core', 'unable to rename, file does not exists : ' . $path1, \OC_Log::ERROR);
+				return false;
+			}
+
+			if ($return = rename($this->datadir . $path1, $this->datadir . $path2)) {
 			}
+			return $return;
 		}
-		return $return;
-	}
 
-	public function getMimeType($path) {
-		if($this->isReadable($path)) {
-			return \OC_Helper::getMimeType($this->datadir . $path);
-		}else{
-			return false;
+		public function copy($path1, $path2) {
+			if ($this->is_dir($path2)) {
+				if (!$this->file_exists($path2)) {
+					$this->mkdir($path2);
+				}
+				$source = substr($path1, strrpos($path1, '/') + 1);
+				$path2 .= $source;
+			}
+			return copy($this->datadir . $path1, $this->datadir . $path2);
 		}
-	}
 
-	private function delTree($dir) {
-		$dirRelative=$dir;
-		$dir=$this->datadir.$dir;
-		if (!file_exists($dir)) return true;
-		if (!is_dir($dir) || is_link($dir)) return unlink($dir);
-		foreach (scandir($dir) as $item) {
-			if ($item == '.' || $item == '..') continue;
-			if(is_file($dir.'/'.$item)) {
-				if(unlink($dir.'/'.$item)) {
+		public function fopen($path, $mode) {
+			if ($return = fopen($this->datadir . $path, $mode)) {
+				switch ($mode) {
+					case 'r':
+						break;
+					case 'r+':
+					case 'w+':
+					case 'x+':
+					case 'a+':
+						break;
+					case 'w':
+					case 'x':
+					case 'a':
+						break;
 				}
-			}elseif(is_dir($dir.'/'.$item)) {
-				if (!$this->delTree($dirRelative. "/" . $item)) {
-					return false;
-				};
 			}
+			return $return;
 		}
-		if($return=rmdir($dir)) {
+
+		public function getMimeType($path) {
+			if ($this->isReadable($path)) {
+				return \OC_Helper::getMimeType($this->datadir . $path);
+			} else {
+				return false;
+			}
 		}
-		return $return;
-	}
 
-	private static function getFileSizeFromOS($fullPath) {
-		$name = strtolower(php_uname('s'));
-		// Windows OS: we use COM to access the filesystem
-		if (strpos($name, 'win') !== false) {
-			if (class_exists('COM')) {
-				$fsobj = new \COM("Scripting.FileSystemObject");
-				$f = $fsobj->GetFile($fullPath);
-				return $f->Size;
+		private function delTree($dir) {
+			$dirRelative = $dir;
+			$dir = $this->datadir . $dir;
+			if (!file_exists($dir)) return true;
+			if (!is_dir($dir) || is_link($dir)) return unlink($dir);
+			foreach (scandir($dir) as $item) {
+				if ($item == '.' || $item == '..') continue;
+				if (is_file($dir . '/' . $item)) {
+					if (unlink($dir . '/' . $item)) {
+					}
+				} elseif (is_dir($dir . '/' . $item)) {
+					if (!$this->delTree($dirRelative . "/" . $item)) {
+						return false;
+					};
+				}
 			}
-		} else if (strpos($name, 'bsd') !== false) {
-			if (\OC_Helper::is_function_enabled('exec')) {
-				return (float)exec('stat -f %z ' . escapeshellarg($fullPath));
+			if ($return = rmdir($dir)) {
 			}
-		} else if (strpos($name, 'linux') !== false) {
-			if (\OC_Helper::is_function_enabled('exec')) {
-				return (float)exec('stat -c %s ' . escapeshellarg($fullPath));
+			return $return;
+		}
+
+		private static function getFileSizeFromOS($fullPath) {
+			$name = strtolower(php_uname('s'));
+			// Windows OS: we use COM to access the filesystem
+			if (strpos($name, 'win') !== false) {
+				if (class_exists('COM')) {
+					$fsobj = new \COM("Scripting.FileSystemObject");
+					$f = $fsobj->GetFile($fullPath);
+					return $f->Size;
+				}
+			} else if (strpos($name, 'bsd') !== false) {
+				if (\OC_Helper::is_function_enabled('exec')) {
+					return (float)exec('stat -f %z ' . escapeshellarg($fullPath));
+				}
+			} else if (strpos($name, 'linux') !== false) {
+				if (\OC_Helper::is_function_enabled('exec')) {
+					return (float)exec('stat -c %s ' . escapeshellarg($fullPath));
+				}
+			} else {
+				\OC_Log::write('core',
+					'Unable to determine file size of "' . $fullPath . '". Unknown OS: ' . $name,
+					\OC_Log::ERROR);
 			}
-		} else {
-			\OC_Log::write('core',
-				'Unable to determine file size of "'.$fullPath.'". Unknown OS: '.$name,
-				\OC_Log::ERROR);
+
+			return 0;
 		}
 
-		return 0;
-	}
+		public function hash($path, $type, $raw = false) {
+			return hash_file($type, $this->datadir . $path, $raw);
+		}
 
-	public function hash($path, $type, $raw=false) {
-		return hash_file($type, $this->datadir.$path, $raw);
-	}
+		public function free_space($path) {
+			$space = @disk_free_space($this->datadir . $path);
+			if ($space === false) {
+				return \OC\Files\FREE_SPACE_UNKNOWN;
+			}
+			return $space;
+		}
 
-	public function free_space($path) {
-		return @disk_free_space($this->datadir.$path);
-	}
+		public function search($query) {
+			return $this->searchInDir($query);
+		}
 
-	public function search($query) {
-		return $this->searchInDir($query);
-	}
-	public function getLocalFile($path) {
-		return $this->datadir.$path;
-	}
-	public function getLocalFolder($path) {
-		return $this->datadir.$path;
-	}
+		public function getLocalFile($path) {
+			return $this->datadir . $path;
+		}
 
-	protected function searchInDir($query, $dir='') {
-		$files=array();
-		foreach (scandir($this->datadir.$dir) as $item) {
-			if ($item == '.' || $item == '..') continue;
-			if(strstr(strtolower($item), strtolower($query))!==false) {
-				$files[]=$dir.'/'.$item;
-			}
-			if(is_dir($this->datadir.$dir.'/'.$item)) {
-				$files=array_merge($files, $this->searchInDir($query, $dir.'/'.$item));
+		public function getLocalFolder($path) {
+			return $this->datadir . $path;
+		}
+
+		protected function searchInDir($query, $dir = '') {
+			$files = array();
+			foreach (scandir($this->datadir . $dir) as $item) {
+				if ($item == '.' || $item == '..') continue;
+				if (strstr(strtolower($item), strtolower($query)) !== false) {
+					$files[] = $dir . '/' . $item;
+				}
+				if (is_dir($this->datadir . $dir . '/' . $item)) {
+					$files = array_merge($files, $this->searchInDir($query, $dir . '/' . $item));
+				}
 			}
+			return $files;
 		}
-		return $files;
-	}
 
-	/**
-	 * check if a file or folder has been updated since $time
-	 * @param string $path
-	 * @param int $time
-	 * @return bool
-	 */
-	public function hasUpdated($path, $time) {
-		return $this->filemtime($path)>$time;
+		/**
+		 * check if a file or folder has been updated since $time
+		 *
+		 * @param string $path
+		 * @param int $time
+		 * @return bool
+		 */
+		public function hasUpdated($path, $time) {
+			return $this->filemtime($path) > $time;
+		}
 	}
 }
-}
diff --git a/lib/files/storage/mappedlocal.php b/lib/files/storage/mappedlocal.php
index 434c10bcbf7..ba3fcdc5c9e 100644
--- a/lib/files/storage/mappedlocal.php
+++ b/lib/files/storage/mappedlocal.php
@@ -50,7 +50,7 @@ class MappedLocal extends \OC\Files\Storage\Common{
 				continue;
 			}
 
-			$logicalFilePath = $this->mapper->physicalToLogic($physicalPath.DIRECTORY_SEPARATOR.$file);
+			$logicalFilePath = $this->mapper->physicalToLogic($physicalPath.'/'.$file);
 
 			$file= $this->mapper->stripRootFolder($logicalFilePath, $logicalPath);
 			$file = $this->stripLeading($file);
@@ -130,7 +130,7 @@ class MappedLocal extends \OC\Files\Storage\Common{
 	public function file_get_contents($path) {
 		return file_get_contents($this->buildPath($path));
 	}
-	public function file_put_contents($path, $data) {//trigger_error("$path = ".var_export($path, 1));
+	public function file_put_contents($path, $data) {
 		return file_put_contents($this->buildPath($path), $data);
 	}
 	public function unlink($path) {
@@ -280,7 +280,7 @@ class MappedLocal extends \OC\Files\Storage\Common{
 		foreach (scandir($physicalDir) as $item) {
 			if ($item == '.' || $item == '..')
 				continue;
-			$physicalItem = $this->mapper->physicalToLogic($physicalDir.DIRECTORY_SEPARATOR.$item);
+			$physicalItem = $this->mapper->physicalToLogic($physicalDir.'/'.$item);
 			$item = substr($physicalItem, strlen($physicalDir)+1);
 
 			if(strstr(strtolower($item), strtolower($query)) !== false) {
@@ -331,6 +331,9 @@ class MappedLocal extends \OC\Files\Storage\Common{
 		if(strpos($path, '/') === 0) {
 			$path = substr($path, 1);
 		}
+		if(strpos($path, '\\') === 0) {
+			$path = substr($path, 1);
+		}
 		if ($path === false) {
 			return '';
 		}
diff --git a/lib/files/storage/storage.php b/lib/files/storage/storage.php
index 2cc835236ba..c96caebf4af 100644
--- a/lib/files/storage/storage.php
+++ b/lib/files/storage/storage.php
@@ -10,73 +10,328 @@ namespace OC\Files\Storage;
 
 /**
  * Provide a common interface to all different storage options
+ *
+ * All paths passed to the storage are relative to the storage and should NOT have a leading slash.
  */
-interface Storage{
+interface Storage {
+	/**
+	 * $parameters is a free form array with the configuration options needed to construct the storage
+	 *
+	 * @param array $parameters
+	 */
 	public function __construct($parameters);
+
+	/**
+	 * Get the identifier for the storage,
+	 * the returned id should be the same for every storage object that is created with the same parameters
+	 * and two storage objects with the same id should refer to two storages that display the same files.
+	 *
+	 * @return string
+	 */
 	public function getId();
+
+	/**
+	 * see http://php.net/manual/en/function.mkdir.php
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
 	public function mkdir($path);
+
+	/**
+	 * see http://php.net/manual/en/function.rmdir.php
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
 	public function rmdir($path);
+
+	/**
+	 * see http://php.net/manual/en/function.opendir.php
+	 *
+	 * @param string $path
+	 * @return resource
+	 */
 	public function opendir($path);
+
+	/**
+	 * see http://php.net/manual/en/function.is_dir.php
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
 	public function is_dir($path);
+
+	/**
+	 * see http://php.net/manual/en/function.is_file.php
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
 	public function is_file($path);
+
+	/**
+	 * see http://php.net/manual/en/function.stat.php
+	 * only the following keys are required in the result: size and mtime
+	 *
+	 * @param string $path
+	 * @return array
+	 */
 	public function stat($path);
+
+	/**
+	 * see http://php.net/manual/en/function.filetype.php
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
 	public function filetype($path);
+
+	/**
+	 * see http://php.net/manual/en/function.filesize.php
+	 * The result for filesize when called on a folder is required to be 0
+	 *
+	 * @param string $path
+	 * @return int
+	 */
 	public function filesize($path);
+
+	/**
+	 * check if a file can be created in $path
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
 	public function isCreatable($path);
+
+	/**
+	 * check if a file can be read
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
 	public function isReadable($path);
+
+	/**
+	 * check if a file can be written to
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
 	public function isUpdatable($path);
+
+	/**
+	 * check if a file can be deleted
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
 	public function isDeletable($path);
+
+	/**
+	 * check if a file can be shared
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
 	public function isSharable($path);
+
+	/**
+	 * get the full permissions of a path.
+	 * Should return a combination of the PERMISSION_ constants defined in lib/public/constants.php
+	 *
+	 * @param string $path
+	 * @return int
+	 */
 	public function getPermissions($path);
+
+	/**
+	 * see http://php.net/manual/en/function.file_exists.php
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
 	public function file_exists($path);
+
+	/**
+	 * see http://php.net/manual/en/function.filemtime.php
+	 *
+	 * @param string $path
+	 * @return int
+	 */
 	public function filemtime($path);
+
+	/**
+	 * see http://php.net/manual/en/function.file_get_contents.php
+	 *
+	 * @param string $path
+	 * @return string
+	 */
 	public function file_get_contents($path);
-	public function file_put_contents($path,$data);
+
+	/**
+	 * see http://php.net/manual/en/function.file_put_contents.php
+	 *
+	 * @param string $path
+	 * @param string $data
+	 * @return bool
+	 */
+	public function file_put_contents($path, $data);
+
+	/**
+	 * see http://php.net/manual/en/function.unlink.php
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
 	public function unlink($path);
-	public function rename($path1,$path2);
-	public function copy($path1,$path2);
-	public function fopen($path,$mode);
+
+	/**
+	 * see http://php.net/manual/en/function.rename.php
+	 *
+	 * @param string $path1
+	 * @param string $path2
+	 * @return bool
+	 */
+	public function rename($path1, $path2);
+
+	/**
+	 * see http://php.net/manual/en/function.copy.php
+	 *
+	 * @param string $path1
+	 * @param string $path2
+	 * @return bool
+	 */
+	public function copy($path1, $path2);
+
+	/**
+	 * see http://php.net/manual/en/function.fopen.php
+	 *
+	 * @param string $path
+	 * @param string $mode
+	 * @return resource
+	 */
+	public function fopen($path, $mode);
+
+	/**
+	 * get the mimetype for a file or folder
+	 * The mimetype for a folder is required to be "httpd/unix-directory"
+	 *
+	 * @param string $path
+	 * @return string
+	 */
 	public function getMimeType($path);
-	public function hash($type,$path,$raw = false);
+
+	/**
+	 * see http://php.net/manual/en/function.hash.php
+	 *
+	 * @param string $type
+	 * @param string $path
+	 * @param bool $raw
+	 * @return string
+	 */
+	public function hash($type, $path, $raw = false);
+
+	/**
+	 * see http://php.net/manual/en/function.free_space.php
+	 *
+	 * @param string $path
+	 * @return int
+	 */
 	public function free_space($path);
+
+	/**
+	 * search for occurrences of $query in file names
+	 *
+	 * @param string $query
+	 * @return array
+	 */
 	public function search($query);
-	public function touch($path, $mtime=null);
-	public function getLocalFile($path);// get a path to a local version of the file, whether the original file is local or remote
-	public function getLocalFolder($path);// get a path to a local version of the folder, whether the original file is local or remote
+
+	/**
+	 * see http://php.net/manual/en/function.touch.php
+	 * If the backend does not support the operation, false should be returned
+	 *
+	 * @param string $path
+	 * @param int $mtime
+	 * @return bool
+	 */
+	public function touch($path, $mtime = null);
+
+	/**
+	 * get the path to a local version of the file.
+	 * The local version of the file can be temporary and doesn't have to be persistent across requests
+	 *
+	 * @param string $path
+	 * @return string
+	 */
+	public function getLocalFile($path);
+
+	/**
+	 * get the path to a local version of the folder.
+	 * The local version of the folder can be temporary and doesn't have to be persistent across requests
+	 *
+	 * @param string $path
+	 * @return string
+	 */
+	public function getLocalFolder($path);
 	/**
 	 * check if a file or folder has been updated since $time
+	 *
+	 * @param string $path
 	 * @param int $time
 	 * @return bool
 	 *
 	 * hasUpdated for folders should return at least true if a file inside the folder is add, removed or renamed.
 	 * returning true for other changes in the folder is optional
 	 */
-	public function hasUpdated($path,$time);
+	public function hasUpdated($path, $time);
 
 	/**
+	 * get a cache instance for the storage
+	 *
 	 * @param string $path
 	 * @return \OC\Files\Cache\Cache
 	 */
-	public function getCache($path='');
+	public function getCache($path = '');
+
 	/**
+	 * get a scanner instance for the storage
+	 *
 	 * @param string $path
 	 * @return \OC\Files\Cache\Scanner
 	 */
-	public function getScanner($path='');
+	public function getScanner($path = '');
 
+
+	/**
+	 * get the user id of the owner of a file or folder
+	 *
+	 * @param string $path
+	 * @return string
+	 */
 	public function getOwner($path);
 
 	/**
+	 * get a permissions cache instance for the cache
+	 *
 	 * @param string $path
 	 * @return \OC\Files\Cache\Permissions
 	 */
-	public function getPermissionsCache($path='');
+	public function getPermissionsCache($path = '');
 
 	/**
+	 * get a watcher instance for the cache
+	 *
 	 * @param string $path
 	 * @return \OC\Files\Cache\Watcher
 	 */
-	public function getWatcher($path='');
+	public function getWatcher($path = '');
+
+	/**
+	 * @return \OC\Files\Cache\Storage
+	 */
+	public function getStorageCache();
 
 	/**
 	 * get the ETag for a file or folder
diff --git a/lib/files/view.php b/lib/files/view.php
index 3cea8b082dc..bc6b80c505a 100644
--- a/lib/files/view.php
+++ b/lib/files/view.php
@@ -245,7 +245,9 @@ class View {
 		if (!is_null($mtime) and !is_numeric($mtime)) {
 			$mtime = strtotime($mtime);
 		}
+
 		$hooks = array('touch');
+
 		if (!$this->file_exists($path)) {
 			$hooks[] = 'write';
 		}
@@ -264,11 +266,13 @@ class View {
 		if (is_resource($data)) { //not having to deal with streams in file_put_contents makes life easier
 			$absolutePath = Filesystem::normalizePath($this->getAbsolutePath($path));
 			if (\OC_FileProxy::runPreProxies('file_put_contents', $absolutePath, $data)
-				&& Filesystem::isValidPath($path)) {
+				and Filesystem::isValidPath($path)
+				and ! Filesystem::isFileBlacklisted($path)
+			) {
 				$path = $this->getRelativePath($absolutePath);
 				$exists = $this->file_exists($path);
 				$run = true;
-				if ($this->fakeRoot == Filesystem::getRoot()) {
+				if ($this->fakeRoot == Filesystem::getRoot() && !Cache\Scanner::isPartialFile($path)) {
 					if (!$exists) {
 						\OC_Hook::emit(
 							Filesystem::CLASSNAME,
@@ -296,7 +300,7 @@ class View {
 					list ($count, $result) = \OC_Helper::streamCopy($data, $target);
 					fclose($target);
 					fclose($data);
-					if ($this->fakeRoot == Filesystem::getRoot()) {
+					if ($this->fakeRoot == Filesystem::getRoot() && !Cache\Scanner::isPartialFile($path)) {
 						if (!$exists) {
 							\OC_Hook::emit(
 								Filesystem::CLASSNAME,
@@ -336,8 +340,12 @@ class View {
 		$postFix2 = (substr($path2, -1, 1) === '/') ? '/' : '';
 		$absolutePath1 = Filesystem::normalizePath($this->getAbsolutePath($path1));
 		$absolutePath2 = Filesystem::normalizePath($this->getAbsolutePath($path2));
-		if (\OC_FileProxy::runPreProxies('rename', $absolutePath1, $absolutePath2)
-			and Filesystem::isValidPath($path2)) {
+		if (
+			\OC_FileProxy::runPreProxies('rename', $absolutePath1, $absolutePath2)
+			and Filesystem::isValidPath($path2)
+			and Filesystem::isValidPath($path1)
+			and ! Filesystem::isFileBlacklisted($path2)
+		) {
 			$path1 = $this->getRelativePath($absolutePath1);
 			$path2 = $this->getRelativePath($absolutePath2);
 
@@ -345,7 +353,7 @@ class View {
 				return false;
 			}
 			$run = true;
-			if ($this->fakeRoot == Filesystem::getRoot()) {
+			if ($this->fakeRoot == Filesystem::getRoot() && !Cache\Scanner::isPartialFile($path1)) {
 				\OC_Hook::emit(
 					Filesystem::CLASSNAME, Filesystem::signal_rename,
 					array(
@@ -373,7 +381,7 @@ class View {
 					list($storage1, $internalPath1) = Filesystem::resolvePath($absolutePath1 . $postFix1);
 					$storage1->unlink($internalPath1);
 				}
-				if ($this->fakeRoot == Filesystem::getRoot()) {
+				if ($this->fakeRoot == Filesystem::getRoot() && !Cache\Scanner::isPartialFile($path1)) {
 					\OC_Hook::emit(
 						Filesystem::CLASSNAME,
 						Filesystem::signal_post_rename,
@@ -397,7 +405,12 @@ class View {
 		$postFix2 = (substr($path2, -1, 1) === '/') ? '/' : '';
 		$absolutePath1 = Filesystem::normalizePath($this->getAbsolutePath($path1));
 		$absolutePath2 = Filesystem::normalizePath($this->getAbsolutePath($path2));
-		if (\OC_FileProxy::runPreProxies('copy', $absolutePath1, $absolutePath2) and Filesystem::isValidPath($path2)) {
+		if (
+			\OC_FileProxy::runPreProxies('copy', $absolutePath1, $absolutePath2)
+			and Filesystem::isValidPath($path2)
+			and Filesystem::isValidPath($path1)
+			and ! Filesystem::isFileBlacklisted($path2)
+		) {
 			$path1 = $this->getRelativePath($absolutePath1);
 			$path2 = $this->getRelativePath($absolutePath2);
 
@@ -599,7 +612,10 @@ class View {
 	private function basicOperation($operation, $path, $hooks = array(), $extraParam = null) {
 		$postFix = (substr($path, -1, 1) === '/') ? '/' : '';
 		$absolutePath = Filesystem::normalizePath($this->getAbsolutePath($path));
-		if (\OC_FileProxy::runPreProxies($operation, $absolutePath, $extraParam) and Filesystem::isValidPath($path)) {
+		if (\OC_FileProxy::runPreProxies($operation, $absolutePath, $extraParam)
+			and Filesystem::isValidPath($path)
+			and ! Filesystem::isFileBlacklisted($path)
+		) {
 			$path = $this->getRelativePath($absolutePath);
 			if ($path == null) {
 				return false;
@@ -732,6 +748,7 @@ class View {
 	 * 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 function getDirectoryContent($directory, $mimetype_filter = '') {
@@ -969,7 +986,7 @@ class View {
 	 */
 	public function getPath($id) {
 		list($storage, $internalPath) = Cache\Cache::getById($id);
-		$mounts = Mount::findByStorageId($storage);
+		$mounts = Filesystem::getMountByStorageId($storage);
 		foreach ($mounts as $mount) {
 			/**
 			 * @var \OC\Files\Mount $mount