Move \OC\Files to PSR-4

18 files changed, 5925 insertions, 0 deletions

diff --git a/lib/private/Files/Storage/Common.php b/lib/private/Files/Storage/Common.php
new file mode 100644
index 00000000000..3a811b312c6
--- /dev/null
+++ b/lib/private/Files/Storage/Common.php
@@ -0,0 +1,697 @@
+<?php
+/**
+ * @author Arthur Schiwon <blizzz@owncloud.com>
+ * @author Bart Visscher <bartv@thisnet.nl>
+ * @author Björn Schießle <schiessle@owncloud.com>
+ * @author hkjolhede <hkjolhede@gmail.com>
+ * @author Joas Schilling <nickvergessen@owncloud.com>
+ * @author Jörn Friedrich Dreyer <jfd@butonic.de>
+ * @author Lukas Reschke <lukas@owncloud.com>
+ * @author Martin Mattel <martin.mattel@diemattels.at>
+ * @author Michael Gapczynski <GapczynskiM@gmail.com>
+ * @author Morris Jobke <hey@morrisjobke.de>
+ * @author Robin Appelman <icewind@owncloud.com>
+ * @author Robin McCorkell <robin@mccorkell.me.uk>
+ * @author Sam Tuke <mail@samtuke.com>
+ * @author scambra <sergio@entrecables.com>
+ * @author Thomas Müller <thomas.mueller@tmit.eu>
+ * @author Vincent Petry <pvince81@owncloud.com>
+ *
+ * @copyright Copyright (c) 2016, ownCloud, Inc.
+ * @license AGPL-3.0
+ *
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License, version 3,
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>
+ *
+ */
+
+namespace OC\Files\Storage;
+
+use OC\Files\Cache\Cache;
+use OC\Files\Cache\Propagator;
+use OC\Files\Cache\Scanner;
+use OC\Files\Cache\Updater;
+use OC\Files\Filesystem;
+use OC\Files\Cache\Watcher;
+use OCP\Files\FileNameTooLongException;
+use OCP\Files\InvalidCharacterInPathException;
+use OCP\Files\InvalidPathException;
+use OCP\Files\ReservedWordException;
+use OCP\Files\Storage\ILockingStorage;
+use OCP\Lock\ILockingProvider;
+
+/**
+ * Storage backend class for providing common filesystem operation methods
+ * which are not storage-backend specific.
+ *
+ * \OC\Files\Storage\Common is never used directly; it is extended by all other
+ * storage backends, where its methods may be overridden, and additional
+ * (backend-specific) methods are defined.
+ *
+ * Some \OC\Files\Storage\Common methods call functions which are first defined
+ * in classes which extend it, e.g. $this->stat() .
+ */
+abstract class Common implements Storage, ILockingStorage {
+
+	use LocalTempFileTrait;
+
+	protected $cache;
+	protected $scanner;
+	protected $watcher;
+	protected $propagator;
+	protected $storageCache;
+	protected $updater;
+
+	protected $mountOptions = [];
+	protected $owner = null;
+
+	public function __construct($parameters) {
+	}
+
+	/**
+	 * Remove a file or folder
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	protected function remove($path) {
+		if ($this->is_dir($path)) {
+			return $this->rmdir($path);
+		} else if ($this->is_file($path)) {
+			return $this->unlink($path);
+		} else {
+			return false;
+		}
+	}
+
+	public function is_dir($path) {
+		return $this->filetype($path) === 'dir';
+	}
+
+	public function is_file($path) {
+		return $this->filetype($path) === 'file';
+	}
+
+	public function filesize($path) {
+		if ($this->is_dir($path)) {
+			return 0; //by definition
+		} else {
+			$stat = $this->stat($path);
+			if (isset($stat['size'])) {
+				return $stat['size'];
+			} else {
+				return 0;
+			}
+		}
+	}
+
+	public function isReadable($path) {
+		// at least check whether it exists
+		// subclasses might want to implement this more thoroughly
+		return $this->file_exists($path);
+	}
+
+	public function isUpdatable($path) {
+		// at least check whether it exists
+		// subclasses might want to implement this more thoroughly
+		// a non-existing file/folder isn't updatable
+		return $this->file_exists($path);
+	}
+
+	public function isCreatable($path) {
+		if ($this->is_dir($path) && $this->isUpdatable($path)) {
+			return true;
+		}
+		return false;
+	}
+
+	public function isDeletable($path) {
+		if ($path === '' || $path === '/') {
+			return false;
+		}
+		$parent = dirname($path);
+		return $this->isUpdatable($parent) && $this->isUpdatable($path);
+	}
+
+	public function isSharable($path) {
+		return $this->isReadable($path);
+	}
+
+	public function getPermissions($path) {
+		$permissions = 0;
+		if ($this->isCreatable($path)) {
+			$permissions |= \OCP\Constants::PERMISSION_CREATE;
+		}
+		if ($this->isReadable($path)) {
+			$permissions |= \OCP\Constants::PERMISSION_READ;
+		}
+		if ($this->isUpdatable($path)) {
+			$permissions |= \OCP\Constants::PERMISSION_UPDATE;
+		}
+		if ($this->isDeletable($path)) {
+			$permissions |= \OCP\Constants::PERMISSION_DELETE;
+		}
+		if ($this->isSharable($path)) {
+			$permissions |= \OCP\Constants::PERMISSION_SHARE;
+		}
+		return $permissions;
+	}
+
+	public function filemtime($path) {
+		$stat = $this->stat($path);
+		if (isset($stat['mtime']) && $stat['mtime'] > 0) {
+			return $stat['mtime'];
+		} else {
+			return 0;
+		}
+	}
+
+	public function file_get_contents($path) {
+		$handle = $this->fopen($path, "r");
+		if (!$handle) {
+			return false;
+		}
+		$data = stream_get_contents($handle);
+		fclose($handle);
+		return $data;
+	}
+
+	public function file_put_contents($path, $data) {
+		$handle = $this->fopen($path, "w");
+		$this->removeCachedFile($path);
+		$count = fwrite($handle, $data);
+		fclose($handle);
+		return $count;
+	}
+
+	public function rename($path1, $path2) {
+		$this->remove($path2);
+
+		$this->removeCachedFile($path1);
+		return $this->copy($path1, $path2) and $this->remove($path1);
+	}
+
+	public function copy($path1, $path2) {
+		if ($this->is_dir($path1)) {
+			$this->remove($path2);
+			$dir = $this->opendir($path1);
+			$this->mkdir($path2);
+			while ($file = readdir($dir)) {
+				if (!Filesystem::isIgnoredDir($file)) {
+					if (!$this->copy($path1 . '/' . $file, $path2 . '/' . $file)) {
+						return false;
+					}
+				}
+			}
+			closedir($dir);
+			return true;
+		} else {
+			$source = $this->fopen($path1, 'r');
+			$target = $this->fopen($path2, 'w');
+			list(, $result) = \OC_Helper::streamCopy($source, $target);
+			$this->removeCachedFile($path2);
+			return $result;
+		}
+	}
+
+	public function getMimeType($path) {
+		if ($this->is_dir($path)) {
+			return 'httpd/unix-directory';
+		} elseif ($this->file_exists($path)) {
+			return \OC::$server->getMimeTypeDetector()->detectPath($path);
+		} else {
+			return false;
+		}
+	}
+
+	public function hash($type, $path, $raw = false) {
+		$fh = $this->fopen($path, 'rb');
+		$ctx = hash_init($type);
+		hash_update_stream($ctx, $fh);
+		fclose($fh);
+		return hash_final($ctx, $raw);
+	}
+
+	public function search($query) {
+		return $this->searchInDir($query);
+	}
+
+	public function getLocalFile($path) {
+		return $this->getCachedFile($path);
+	}
+
+	/**
+	 * @param string $path
+	 * @param string $target
+	 */
+	private function addLocalFolder($path, $target) {
+		$dh = $this->opendir($path);
+		if (is_resource($dh)) {
+			while (($file = readdir($dh)) !== false) {
+				if (!\OC\Files\Filesystem::isIgnoredDir($file)) {
+					if ($this->is_dir($path . '/' . $file)) {
+						mkdir($target . '/' . $file);
+						$this->addLocalFolder($path . '/' . $file, $target . '/' . $file);
+					} else {
+						$tmp = $this->toTmpFile($path . '/' . $file);
+						rename($tmp, $target . '/' . $file);
+					}
+				}
+			}
+		}
+	}
+
+	/**
+	 * @param string $query
+	 * @param string $dir
+	 * @return array
+	 */
+	protected function searchInDir($query, $dir = '') {
+		$files = array();
+		$dh = $this->opendir($dir);
+		if (is_resource($dh)) {
+			while (($item = readdir($dh)) !== false) {
+				if (\OC\Files\Filesystem::isIgnoredDir($item)) continue;
+				if (strstr(strtolower($item), strtolower($query)) !== false) {
+					$files[] = $dir . '/' . $item;
+				}
+				if ($this->is_dir($dir . '/' . $item)) {
+					$files = array_merge($files, $this->searchInDir($query, $dir . '/' . $item));
+				}
+			}
+		}
+		closedir($dh);
+		return $files;
+	}
+
+	/**
+	 * check if a file or folder has been updated since $time
+	 *
+	 * The method is only used to check if the cache needs to be updated. Storage backends that don't support checking
+	 * the mtime should always return false here. As a result storage implementations that always return false expect
+	 * exclusive access to the backend and will not pick up files that have been added in a way that circumvents
+	 * ownClouds filesystem.
+	 *
+	 * @param string $path
+	 * @param int $time
+	 * @return bool
+	 */
+	public function hasUpdated($path, $time) {
+		return $this->filemtime($path) > $time;
+	}
+
+	public function getCache($path = '', $storage = null) {
+		if (!$storage) {
+			$storage = $this;
+		}
+		if (!isset($storage->cache)) {
+			$storage->cache = new Cache($storage);
+		}
+		return $storage->cache;
+	}
+
+	public function getScanner($path = '', $storage = null) {
+		if (!$storage) {
+			$storage = $this;
+		}
+		if (!isset($storage->scanner)) {
+			$storage->scanner = new Scanner($storage);
+		}
+		return $storage->scanner;
+	}
+
+	public function getWatcher($path = '', $storage = null) {
+		if (!$storage) {
+			$storage = $this;
+		}
+		if (!isset($this->watcher)) {
+			$this->watcher = new Watcher($storage);
+			$globalPolicy = \OC::$server->getConfig()->getSystemValue('filesystem_check_changes', Watcher::CHECK_NEVER);
+			$this->watcher->setPolicy((int)$this->getMountOption('filesystem_check_changes', $globalPolicy));
+		}
+		return $this->watcher;
+	}
+
+	/**
+	 * get a propagator instance for the cache
+	 *
+	 * @param \OC\Files\Storage\Storage (optional) the storage to pass to the watcher
+	 * @return \OC\Files\Cache\Propagator
+	 */
+	public function getPropagator($storage = null) {
+		if (!$storage) {
+			$storage = $this;
+		}
+		if (!isset($storage->propagator)) {
+			$storage->propagator = new Propagator($storage);
+		}
+		return $storage->propagator;
+	}
+
+	public function getUpdater($storage = null) {
+		if (!$storage) {
+			$storage = $this;
+		}
+		if (!isset($storage->updater)) {
+			$storage->updater = new Updater($storage);
+		}
+		return $storage->updater;
+	}
+
+	public function getStorageCache($storage = null) {
+		if (!$storage) {
+			$storage = $this;
+		}
+		if (!isset($this->storageCache)) {
+			$this->storageCache = new \OC\Files\Cache\Storage($storage);
+		}
+		return $this->storageCache;
+	}
+
+	/**
+	 * get the owner of a path
+	 *
+	 * @param string $path The path to get the owner
+	 * @return string|false uid or false
+	 */
+	public function getOwner($path) {
+		if ($this->owner === null) {
+			$this->owner = \OC_User::getUser();
+		}
+
+		return $this->owner;
+	}
+
+	/**
+	 * get the ETag for a file or folder
+	 *
+	 * @param string $path
+	 * @return string
+	 */
+	public function getETag($path) {
+		return uniqid();
+	}
+
+	/**
+	 * clean a path, i.e. remove all redundant '.' and '..'
+	 * making sure that it can't point to higher than '/'
+	 *
+	 * @param string $path The path to clean
+	 * @return string cleaned path
+	 */
+	public function cleanPath($path) {
+		if (strlen($path) == 0 or $path[0] != '/') {
+			$path = '/' . $path;
+		}
+
+		$output = array();
+		foreach (explode('/', $path) as $chunk) {
+			if ($chunk == '..') {
+				array_pop($output);
+			} else if ($chunk == '.') {
+			} else {
+				$output[] = $chunk;
+			}
+		}
+		return implode('/', $output);
+	}
+
+	/**
+	 * Test a storage for availability
+	 *
+	 * @return bool
+	 */
+	public function test() {
+		if ($this->stat('')) {
+			return true;
+		}
+		return false;
+	}
+
+	/**
+	 * get the free space in the storage
+	 *
+	 * @param string $path
+	 * @return int|false
+	 */
+	public function free_space($path) {
+		return \OCP\Files\FileInfo::SPACE_UNKNOWN;
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function isLocal() {
+		// the common implementation returns a temporary file by
+		// default, which is not local
+		return false;
+	}
+
+	/**
+	 * Check if the storage is an instance of $class or is a wrapper for a storage that is an instance of $class
+	 *
+	 * @param string $class
+	 * @return bool
+	 */
+	public function instanceOfStorage($class) {
+		return is_a($this, $class);
+	}
+
+	/**
+	 * A custom storage implementation can return an url for direct download of a give file.
+	 *
+	 * For now the returned array can hold the parameter url - in future more attributes might follow.
+	 *
+	 * @param string $path
+	 * @return array|false
+	 */
+	public function getDirectDownload($path) {
+		return [];
+	}
+
+	/**
+	 * @inheritdoc
+	 */
+	public function verifyPath($path, $fileName) {
+		if (isset($fileName[255])) {
+			throw new FileNameTooLongException();
+		}
+
+		// NOTE: $path will remain unverified for now
+		if (\OC_Util::runningOnWindows()) {
+			$this->verifyWindowsPath($fileName);
+		} else {
+			$this->verifyPosixPath($fileName);
+		}
+	}
+
+	/**
+	 * https://msdn.microsoft.com/en-us/library/windows/desktop/aa365247%28v=vs.85%29.aspx
+	 * @param string $fileName
+	 * @throws InvalidPathException
+	 */
+	protected function verifyWindowsPath($fileName) {
+		$fileName = trim($fileName);
+		$this->scanForInvalidCharacters($fileName, "\\/<>:\"|?*");
+		$reservedNames = ['CON', 'PRN', 'AUX', 'NUL', 'COM1', 'COM2', 'COM3', 'COM4', 'COM5', 'COM6', 'COM7', 'COM8', 'COM9', 'LPT1', 'LPT2', 'LPT3', 'LPT4', 'LPT5', 'LPT6', 'LPT7', 'LPT8', 'LPT9'];
+		if (in_array(strtoupper($fileName), $reservedNames)) {
+			throw new ReservedWordException();
+		}
+	}
+
+	/**
+	 * @param string $fileName
+	 * @throws InvalidPathException
+	 */
+	protected function verifyPosixPath($fileName) {
+		$fileName = trim($fileName);
+		$this->scanForInvalidCharacters($fileName, "\\/");
+		$reservedNames = ['*'];
+		if (in_array($fileName, $reservedNames)) {
+			throw new ReservedWordException();
+		}
+	}
+
+	/**
+	 * @param string $fileName
+	 * @param string $invalidChars
+	 * @throws InvalidPathException
+	 */
+	private function scanForInvalidCharacters($fileName, $invalidChars) {
+		foreach (str_split($invalidChars) as $char) {
+			if (strpos($fileName, $char) !== false) {
+				throw new InvalidCharacterInPathException();
+			}
+		}
+
+		$sanitizedFileName = filter_var($fileName, FILTER_UNSAFE_RAW, FILTER_FLAG_STRIP_LOW);
+		if ($sanitizedFileName !== $fileName) {
+			throw new InvalidCharacterInPathException();
+		}
+	}
+
+	/**
+	 * @param array $options
+	 */
+	public function setMountOptions(array $options) {
+		$this->mountOptions = $options;
+	}
+
+	/**
+	 * @param string $name
+	 * @param mixed $default
+	 * @return mixed
+	 */
+	public function getMountOption($name, $default = null) {
+		return isset($this->mountOptions[$name]) ? $this->mountOptions[$name] : $default;
+	}
+
+	/**
+	 * @param \OCP\Files\Storage $sourceStorage
+	 * @param string $sourceInternalPath
+	 * @param string $targetInternalPath
+	 * @param bool $preserveMtime
+	 * @return bool
+	 */
+	public function copyFromStorage(\OCP\Files\Storage $sourceStorage, $sourceInternalPath, $targetInternalPath, $preserveMtime = false) {
+		if ($sourceStorage === $this) {
+			return $this->copy($sourceInternalPath, $targetInternalPath);
+		}
+
+		if ($sourceStorage->is_dir($sourceInternalPath)) {
+			$dh = $sourceStorage->opendir($sourceInternalPath);
+			$result = $this->mkdir($targetInternalPath);
+			if (is_resource($dh)) {
+				while ($result and ($file = readdir($dh)) !== false) {
+					if (!Filesystem::isIgnoredDir($file)) {
+						$result &= $this->copyFromStorage($sourceStorage, $sourceInternalPath . '/' . $file, $targetInternalPath . '/' . $file);
+					}
+				}
+			}
+		} else {
+			$source = $sourceStorage->fopen($sourceInternalPath, 'r');
+			// TODO: call fopen in a way that we execute again all storage wrappers
+			// to avoid that we bypass storage wrappers which perform important actions
+			// for this operation. Same is true for all other operations which
+			// are not the same as the original one.Once this is fixed we also
+			// need to adjust the encryption wrapper.
+			$target = $this->fopen($targetInternalPath, 'w');
+			list(, $result) = \OC_Helper::streamCopy($source, $target);
+			if ($result and $preserveMtime) {
+				$this->touch($targetInternalPath, $sourceStorage->filemtime($sourceInternalPath));
+			}
+			fclose($source);
+			fclose($target);
+
+			if (!$result) {
+				// delete partially written target file
+				$this->unlink($targetInternalPath);
+				// delete cache entry that was created by fopen
+				$this->getCache()->remove($targetInternalPath);
+			}
+		}
+		return (bool)$result;
+	}
+
+	/**
+	 * @param \OCP\Files\Storage $sourceStorage
+	 * @param string $sourceInternalPath
+	 * @param string $targetInternalPath
+	 * @return bool
+	 */
+	public function moveFromStorage(\OCP\Files\Storage $sourceStorage, $sourceInternalPath, $targetInternalPath) {
+		if ($sourceStorage === $this) {
+			return $this->rename($sourceInternalPath, $targetInternalPath);
+		}
+
+		if (!$sourceStorage->isDeletable($sourceInternalPath)) {
+			return false;
+		}
+
+		$result = $this->copyFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath, true);
+		if ($result) {
+			if ($sourceStorage->is_dir($sourceInternalPath)) {
+				$result &= $sourceStorage->rmdir($sourceInternalPath);
+			} else {
+				$result &= $sourceStorage->unlink($sourceInternalPath);
+			}
+		}
+		return $result;
+	}
+
+	/**
+	 * @inheritdoc
+	 */
+	public function getMetaData($path) {
+		$permissions = $this->getPermissions($path);
+		if (!$permissions & \OCP\Constants::PERMISSION_READ) {
+			//can't read, nothing we can do
+			return null;
+		}
+
+		$data = [];
+		$data['mimetype'] = $this->getMimeType($path);
+		$data['mtime'] = $this->filemtime($path);
+		if ($data['mimetype'] == 'httpd/unix-directory') {
+			$data['size'] = -1; //unknown
+		} else {
+			$data['size'] = $this->filesize($path);
+		}
+		$data['etag'] = $this->getETag($path);
+		$data['storage_mtime'] = $data['mtime'];
+		$data['permissions'] = $permissions;
+
+		return $data;
+	}
+
+	/**
+	 * @param string $path
+	 * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
+	 * @param \OCP\Lock\ILockingProvider $provider
+	 * @throws \OCP\Lock\LockedException
+	 */
+	public function acquireLock($path, $type, ILockingProvider $provider) {
+		$provider->acquireLock('files/' . md5($this->getId() . '::' . trim($path, '/')), $type);
+	}
+
+	/**
+	 * @param string $path
+	 * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
+	 * @param \OCP\Lock\ILockingProvider $provider
+	 */
+	public function releaseLock($path, $type, ILockingProvider $provider) {
+		$provider->releaseLock('files/' . md5($this->getId() . '::' . trim($path, '/')), $type);
+	}
+
+	/**
+	 * @param string $path
+	 * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
+	 * @param \OCP\Lock\ILockingProvider $provider
+	 */
+	public function changeLock($path, $type, ILockingProvider $provider) {
+		$provider->changeLock('files/' . md5($this->getId() . '::' . trim($path, '/')), $type);
+	}
+
+	/**
+	 * @return array [ available, last_checked ]
+	 */
+	public function getAvailability() {
+		return $this->getStorageCache()->getAvailability();
+	}
+
+	/**
+	 * @param bool $isAvailable
+	 */
+	public function setAvailability($isAvailable) {
+		$this->getStorageCache()->setAvailability($isAvailable);
+	}
+}
diff --git a/lib/private/Files/Storage/CommonTest.php b/lib/private/Files/Storage/CommonTest.php
new file mode 100644
index 00000000000..0047a51169c
--- /dev/null
+++ b/lib/private/Files/Storage/CommonTest.php
@@ -0,0 +1,84 @@
+<?php
+/**
+ * @author Bart Visscher <bartv@thisnet.nl>
+ * @author Christopher Schäpers <kondou@ts.unde.re>
+ * @author Felix Moeller <mail@felixmoeller.de>
+ * @author Michael Gapczynski <GapczynskiM@gmail.com>
+ * @author Morris Jobke <hey@morrisjobke.de>
+ * @author Robin Appelman <icewind@owncloud.com>
+ * @author Thomas Müller <thomas.mueller@tmit.eu>
+ *
+ * @copyright Copyright (c) 2016, ownCloud, Inc.
+ * @license AGPL-3.0
+ *
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License, version 3,
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>
+ *
+ */
+
+/**
+ * test implementation for \OC\Files\Storage\Common with \OC\Files\Storage\Local
+ */
+
+namespace OC\Files\Storage;
+
+class CommonTest extends \OC\Files\Storage\Common{
+	/**
+	 * underlying local storage used for missing functions
+	 * @var \OC\Files\Storage\Local
+	 */
+	private $storage;
+
+	public function __construct($params) {
+		$this->storage=new \OC\Files\Storage\Local($params);
+	}
+
+	public function getId(){
+		return 'test::'.$this->storage->getId();
+	}
+	public function mkdir($path) {
+		return $this->storage->mkdir($path);
+	}
+	public function rmdir($path) {
+		return $this->storage->rmdir($path);
+	}
+	public function opendir($path) {
+		return $this->storage->opendir($path);
+	}
+	public function stat($path) {
+		return $this->storage->stat($path);
+	}
+	public function filetype($path) {
+		return @$this->storage->filetype($path);
+	}
+	public function isReadable($path) {
+		return $this->storage->isReadable($path);
+	}
+	public function isUpdatable($path) {
+		return $this->storage->isUpdatable($path);
+	}
+	public function file_exists($path) {
+		return $this->storage->file_exists($path);
+	}
+	public function unlink($path) {
+		return $this->storage->unlink($path);
+	}
+	public function fopen($path, $mode) {
+		return $this->storage->fopen($path, $mode);
+	}
+	public function free_space($path) {
+		return $this->storage->free_space($path);
+	}
+	public function touch($path, $mtime=null) {
+		return $this->storage->touch($path, $mtime);
+	}
+}
diff --git a/lib/private/Files/Storage/DAV.php b/lib/private/Files/Storage/DAV.php
new file mode 100644
index 00000000000..8eebea1f3ba
--- /dev/null
+++ b/lib/private/Files/Storage/DAV.php
@@ -0,0 +1,817 @@
+<?php
+/**
+ * @author Bart Visscher <bartv@thisnet.nl>
+ * @author Björn Schießle <schiessle@owncloud.com>
+ * @author Carlos Cerrillo <ccerrillo@gmail.com>
+ * @author Felix Moeller <mail@felixmoeller.de>
+ * @author Jörn Friedrich Dreyer <jfd@butonic.de>
+ * @author Lukas Reschke <lukas@owncloud.com>
+ * @author Michael Gapczynski <GapczynskiM@gmail.com>
+ * @author Morris Jobke <hey@morrisjobke.de>
+ * @author Philipp Kapfer <philipp.kapfer@gmx.at>
+ * @author Robin Appelman <icewind@owncloud.com>
+ * @author Thomas Müller <thomas.mueller@tmit.eu>
+ * @author Vincent Petry <pvince81@owncloud.com>
+ *
+ * @copyright Copyright (c) 2016, ownCloud, Inc.
+ * @license AGPL-3.0
+ *
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License, version 3,
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>
+ *
+ */
+
+namespace OC\Files\Storage;
+
+use Exception;
+use GuzzleHttp\Exception\RequestException;
+use GuzzleHttp\Message\ResponseInterface;
+use OC\Files\Filesystem;
+use OC\Files\Stream\Close;
+use Icewind\Streams\IteratorDirectory;
+use OC\MemCache\ArrayCache;
+use OCP\AppFramework\Http;
+use OCP\Constants;
+use OCP\Files;
+use OCP\Files\FileInfo;
+use OCP\Files\StorageInvalidException;
+use OCP\Files\StorageNotAvailableException;
+use OCP\Util;
+use Sabre\DAV\Client;
+use Sabre\DAV\Exception\NotFound;
+use Sabre\DAV\Xml\Property\ResourceType;
+use Sabre\HTTP\ClientException;
+use Sabre\HTTP\ClientHttpException;
+
+/**
+ * Class DAV
+ *
+ * @package OC\Files\Storage
+ */
+class DAV extends Common {
+	/** @var string */
+	protected $password;
+	/** @var string */
+	protected $user;
+	/** @var string */
+	protected $host;
+	/** @var bool */
+	protected $secure;
+	/** @var string */
+	protected $root;
+	/** @var string */
+	protected $certPath;
+	/** @var bool */
+	protected $ready;
+	/** @var Client */
+	private $client;
+	/** @var ArrayCache */
+	private $statCache;
+	/** @var array */
+	private static $tempFiles = [];
+	/** @var \OCP\Http\Client\IClientService */
+	private $httpClientService;
+
+	/**
+	 * @param array $params
+	 * @throws \Exception
+	 */
+	public function __construct($params) {
+		$this->statCache = new ArrayCache();
+		$this->httpClientService = \OC::$server->getHTTPClientService();
+		if (isset($params['host']) && isset($params['user']) && isset($params['password'])) {
+			$host = $params['host'];
+			//remove leading http[s], will be generated in createBaseUri()
+			if (substr($host, 0, 8) == "https://") $host = substr($host, 8);
+			else if (substr($host, 0, 7) == "http://") $host = substr($host, 7);
+			$this->host = $host;
+			$this->user = $params['user'];
+			$this->password = $params['password'];
+			if (isset($params['secure'])) {
+				if (is_string($params['secure'])) {
+					$this->secure = ($params['secure'] === 'true');
+				} else {
+					$this->secure = (bool)$params['secure'];
+				}
+			} else {
+				$this->secure = false;
+			}
+			if ($this->secure === true) {
+				// inject mock for testing
+				$certPath = \OC_User::getHome(\OC_User::getUser()) . '/files_external/rootcerts.crt';
+				if (file_exists($certPath)) {
+					$this->certPath = $certPath;
+				}
+			}
+			$this->root = isset($params['root']) ? $params['root'] : '/';
+			if (!$this->root || $this->root[0] != '/') {
+				$this->root = '/' . $this->root;
+			}
+			if (substr($this->root, -1, 1) != '/') {
+				$this->root .= '/';
+			}
+		} else {
+			throw new \Exception('Invalid webdav storage configuration');
+		}
+	}
+
+	private function init() {
+		if ($this->ready) {
+			return;
+		}
+		$this->ready = true;
+
+		$settings = array(
+			'baseUri' => $this->createBaseUri(),
+			'userName' => $this->user,
+			'password' => $this->password,
+		);
+
+		$proxy = \OC::$server->getConfig()->getSystemValue('proxy', '');
+		if($proxy !== '') {
+			$settings['proxy'] = $proxy;
+		}
+
+		$this->client = new Client($settings);
+		$this->client->setThrowExceptions(true);
+		if ($this->secure === true && $this->certPath) {
+			$this->client->addCurlSetting(CURLOPT_CAINFO, $this->certPath);
+		}
+	}
+
+	/**
+	 * Clear the stat cache
+	 */
+	public function clearStatCache() {
+		$this->statCache->clear();
+	}
+
+	/** {@inheritdoc} */
+	public function getId() {
+		return 'webdav::' . $this->user . '@' . $this->host . '/' . $this->root;
+	}
+
+	/** {@inheritdoc} */
+	public function createBaseUri() {
+		$baseUri = 'http';
+		if ($this->secure) {
+			$baseUri .= 's';
+		}
+		$baseUri .= '://' . $this->host . $this->root;
+		return $baseUri;
+	}
+
+	/** {@inheritdoc} */
+	public function mkdir($path) {
+		$this->init();
+		$path = $this->cleanPath($path);
+		$result = $this->simpleResponse('MKCOL', $path, null, 201);
+		if ($result) {
+			$this->statCache->set($path, true);
+		}
+		return $result;
+	}
+
+	/** {@inheritdoc} */
+	public function rmdir($path) {
+		$this->init();
+		$path = $this->cleanPath($path);
+		// FIXME: some WebDAV impl return 403 when trying to DELETE
+		// a non-empty folder
+		$result = $this->simpleResponse('DELETE', $path . '/', null, 204);
+		$this->statCache->clear($path . '/');
+		$this->statCache->remove($path);
+		return $result;
+	}
+
+	/** {@inheritdoc} */
+	public function opendir($path) {
+		$this->init();
+		$path = $this->cleanPath($path);
+		try {
+			$response = $this->client->propfind(
+				$this->encodePath($path),
+				array(),
+				1
+			);
+			$id = md5('webdav' . $this->root . $path);
+			$content = array();
+			$files = array_keys($response);
+			array_shift($files); //the first entry is the current directory
+
+			if (!$this->statCache->hasKey($path)) {
+				$this->statCache->set($path, true);
+			}
+			foreach ($files as $file) {
+				$file = urldecode($file);
+				// do not store the real entry, we might not have all properties
+				if (!$this->statCache->hasKey($path)) {
+					$this->statCache->set($file, true);
+				}
+				$file = basename($file);
+				$content[] = $file;
+			}
+			return IteratorDirectory::wrap($content);
+		} catch (ClientHttpException $e) {
+			if ($e->getHttpStatus() === 404) {
+				$this->statCache->clear($path . '/');
+				$this->statCache->set($path, false);
+				return false;
+			}
+			$this->convertException($e, $path);
+		} catch (\Exception $e) {
+			$this->convertException($e, $path);
+		}
+		return false;
+	}
+
+	/**
+	 * Propfind call with cache handling.
+	 *
+	 * First checks if information is cached.
+	 * If not, request it from the server then store to cache.
+	 *
+	 * @param string $path path to propfind
+	 *
+	 * @return array propfind response
+	 *
+	 * @throws NotFound
+	 */
+	protected function propfind($path) {
+		$path = $this->cleanPath($path);
+		$cachedResponse = $this->statCache->get($path);
+		if ($cachedResponse === false) {
+			// we know it didn't exist
+			throw new NotFound();
+		}
+		// we either don't know it, or we know it exists but need more details
+		if (is_null($cachedResponse) || $cachedResponse === true) {
+			$this->init();
+			try {
+				$response = $this->client->propfind(
+					$this->encodePath($path),
+					array(
+						'{DAV:}getlastmodified',
+						'{DAV:}getcontentlength',
+						'{DAV:}getcontenttype',
+						'{http://owncloud.org/ns}permissions',
+						'{http://open-collaboration-services.org/ns}share-permissions',
+						'{DAV:}resourcetype',
+						'{DAV:}getetag',
+					)
+				);
+				$this->statCache->set($path, $response);
+			} catch (NotFound $e) {
+				// remember that this path did not exist
+				$this->statCache->clear($path . '/');
+				$this->statCache->set($path, false);
+				throw $e;
+			}
+		} else {
+			$response = $cachedResponse;
+		}
+		return $response;
+	}
+
+	/** {@inheritdoc} */
+	public function filetype($path) {
+		try {
+			$response = $this->propfind($path);
+			$responseType = array();
+			if (isset($response["{DAV:}resourcetype"])) {
+				/** @var ResourceType[] $response */
+				$responseType = $response["{DAV:}resourcetype"]->getValue();
+			}
+			return (count($responseType) > 0 and $responseType[0] == "{DAV:}collection") ? 'dir' : 'file';
+		} catch (ClientHttpException $e) {
+			if ($e->getHttpStatus() === 404) {
+				return false;
+			}
+			$this->convertException($e, $path);
+		} catch (\Exception $e) {
+			$this->convertException($e, $path);
+		}
+		return false;
+	}
+
+	/** {@inheritdoc} */
+	public function file_exists($path) {
+		try {
+			$path = $this->cleanPath($path);
+			$cachedState = $this->statCache->get($path);
+			if ($cachedState === false) {
+				// we know the file doesn't exist
+				return false;
+			} else if (!is_null($cachedState)) {
+				return true;
+			}
+			// need to get from server
+			$this->propfind($path);
+			return true; //no 404 exception
+		} catch (ClientHttpException $e) {
+			if ($e->getHttpStatus() === 404) {
+				return false;
+			}
+			$this->convertException($e, $path);
+		} catch (\Exception $e) {
+			$this->convertException($e, $path);
+		}
+		return false;
+	}
+
+	/** {@inheritdoc} */
+	public function unlink($path) {
+		$this->init();
+		$path = $this->cleanPath($path);
+		$result = $this->simpleResponse('DELETE', $path, null, 204);
+		$this->statCache->clear($path . '/');
+		$this->statCache->remove($path);
+		return $result;
+	}
+
+	/** {@inheritdoc} */
+	public function fopen($path, $mode) {
+		$this->init();
+		$path = $this->cleanPath($path);
+		switch ($mode) {
+			case 'r':
+			case 'rb':
+				try {
+					$response = $this->httpClientService
+							->newClient()
+							->get($this->createBaseUri() . $this->encodePath($path), [
+									'auth' => [$this->user, $this->password],
+									'stream' => true
+							]);
+				} catch (RequestException $e) {
+					if ($e->getResponse() instanceof ResponseInterface
+						&& $e->getResponse()->getStatusCode() === 404) {
+						return false;
+					} else {
+						throw $e;
+					}
+				}
+
+				if ($response->getStatusCode() !== Http::STATUS_OK) {
+					if ($response->getStatusCode() === Http::STATUS_LOCKED) {
+						throw new \OCP\Lock\LockedException($path);
+					} else {
+						Util::writeLog("webdav client", 'Guzzle get returned status code ' . $response->getStatusCode(), Util::ERROR);
+					}
+				}
+
+				return $response->getBody();
+			case 'w':
+			case 'wb':
+			case 'a':
+			case 'ab':
+			case 'r+':
+			case 'w+':
+			case 'wb+':
+			case 'a+':
+			case 'x':
+			case 'x+':
+			case 'c':
+			case 'c+':
+				//emulate these
+				$tempManager = \OC::$server->getTempManager();
+				if (strrpos($path, '.') !== false) {
+					$ext = substr($path, strrpos($path, '.'));
+				} else {
+					$ext = '';
+				}
+				if ($this->file_exists($path)) {
+					if (!$this->isUpdatable($path)) {
+						return false;
+					}
+					if ($mode === 'w' or $mode === 'w+') {
+						$tmpFile = $tempManager->getTemporaryFile($ext);
+					} else {
+						$tmpFile = $this->getCachedFile($path);
+					}
+				} else {
+					if (!$this->isCreatable(dirname($path))) {
+						return false;
+					}
+					$tmpFile = $tempManager->getTemporaryFile($ext);
+				}
+				Close::registerCallback($tmpFile, array($this, 'writeBack'));
+				self::$tempFiles[$tmpFile] = $path;
+				return fopen('close://' . $tmpFile, $mode);
+		}
+	}
+
+	/**
+	 * @param string $tmpFile
+	 */
+	public function writeBack($tmpFile) {
+		if (isset(self::$tempFiles[$tmpFile])) {
+			$this->uploadFile($tmpFile, self::$tempFiles[$tmpFile]);
+			unlink($tmpFile);
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function free_space($path) {
+		$this->init();
+		$path = $this->cleanPath($path);
+		try {
+			// TODO: cacheable ?
+			$response = $this->client->propfind($this->encodePath($path), array('{DAV:}quota-available-bytes'));
+			if (isset($response['{DAV:}quota-available-bytes'])) {
+				return (int)$response['{DAV:}quota-available-bytes'];
+			} else {
+				return FileInfo::SPACE_UNKNOWN;
+			}
+		} catch (\Exception $e) {
+			return FileInfo::SPACE_UNKNOWN;
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function touch($path, $mtime = null) {
+		$this->init();
+		if (is_null($mtime)) {
+			$mtime = time();
+		}
+		$path = $this->cleanPath($path);
+
+		// if file exists, update the mtime, else create a new empty file
+		if ($this->file_exists($path)) {
+			try {
+				$this->statCache->remove($path);
+				$this->client->proppatch($this->encodePath($path), array('{DAV:}lastmodified' => $mtime));
+			} catch (ClientHttpException $e) {
+				if ($e->getHttpStatus() === 501) {
+					return false;
+				}
+				$this->convertException($e, $path);
+				return false;
+			} catch (\Exception $e) {
+				$this->convertException($e, $path);
+				return false;
+			}
+		} else {
+			$this->file_put_contents($path, '');
+		}
+		return true;
+	}
+
+	/**
+	 * @param string $path
+	 * @param string $data
+	 * @return int
+	 */
+	public function file_put_contents($path, $data) {
+		$path = $this->cleanPath($path);
+		$result = parent::file_put_contents($path, $data);
+		$this->statCache->remove($path);
+		return $result;
+	}
+
+	/**
+	 * @param string $path
+	 * @param string $target
+	 */
+	protected function uploadFile($path, $target) {
+		$this->init();
+
+		// invalidate
+		$target = $this->cleanPath($target);
+		$this->statCache->remove($target);
+		$source = fopen($path, 'r');
+
+		$this->httpClientService
+			->newClient()
+			->put($this->createBaseUri() . $this->encodePath($target), [
+				'body' => $source,
+				'auth' => [$this->user, $this->password]
+			]);
+
+		$this->removeCachedFile($target);
+	}
+
+	/** {@inheritdoc} */
+	public function rename($path1, $path2) {
+		$this->init();
+		$path1 = $this->cleanPath($path1);
+		$path2 = $this->cleanPath($path2);
+		try {
+			$this->client->request(
+				'MOVE',
+				$this->encodePath($path1),
+				null,
+				array(
+					'Destination' => $this->createBaseUri() . $this->encodePath($path2)
+				)
+			);
+			$this->statCache->clear($path1 . '/');
+			$this->statCache->clear($path2 . '/');
+			$this->statCache->set($path1, false);
+			$this->statCache->set($path2, true);
+			$this->removeCachedFile($path1);
+			$this->removeCachedFile($path2);
+			return true;
+		} catch (\Exception $e) {
+			$this->convertException($e);
+		}
+		return false;
+	}
+
+	/** {@inheritdoc} */
+	public function copy($path1, $path2) {
+		$this->init();
+		$path1 = $this->encodePath($this->cleanPath($path1));
+		$path2 = $this->createBaseUri() . $this->encodePath($this->cleanPath($path2));
+		try {
+			$this->client->request('COPY', $path1, null, array('Destination' => $path2));
+			$this->statCache->clear($path2 . '/');
+			$this->statCache->set($path2, true);
+			$this->removeCachedFile($path2);
+			return true;
+		} catch (\Exception $e) {
+			$this->convertException($e);
+		}
+		return false;
+	}
+
+	/** {@inheritdoc} */
+	public function stat($path) {
+		try {
+			$response = $this->propfind($path);
+			return array(
+				'mtime' => strtotime($response['{DAV:}getlastmodified']),
+				'size' => (int)isset($response['{DAV:}getcontentlength']) ? $response['{DAV:}getcontentlength'] : 0,
+			);
+		} catch (ClientHttpException $e) {
+			if ($e->getHttpStatus() === 404) {
+				return array();
+			}
+			$this->convertException($e, $path);
+		} catch (\Exception $e) {
+			$this->convertException($e, $path);
+		}
+		return array();
+	}
+
+	/** {@inheritdoc} */
+	public function getMimeType($path) {
+		try {
+			$response = $this->propfind($path);
+			$responseType = array();
+			if (isset($response["{DAV:}resourcetype"])) {
+				/** @var ResourceType[] $response */
+				$responseType = $response["{DAV:}resourcetype"]->getValue();
+			}
+			$type = (count($responseType) > 0 and $responseType[0] == "{DAV:}collection") ? 'dir' : 'file';
+			if ($type == 'dir') {
+				return 'httpd/unix-directory';
+			} elseif (isset($response['{DAV:}getcontenttype'])) {
+				return $response['{DAV:}getcontenttype'];
+			} else {
+				return false;
+			}
+		} catch (ClientHttpException $e) {
+			if ($e->getHttpStatus() === 404) {
+				return false;
+			}
+			$this->convertException($e, $path);
+		} catch (\Exception $e) {
+			$this->convertException($e, $path);
+		}
+		return false;
+	}
+
+	/**
+	 * @param string $path
+	 * @return string
+	 */
+	public function cleanPath($path) {
+		if ($path === '') {
+			return $path;
+		}
+		$path = Filesystem::normalizePath($path);
+		// remove leading slash
+		return substr($path, 1);
+	}
+
+	/**
+	 * URL encodes the given path but keeps the slashes
+	 *
+	 * @param string $path to encode
+	 * @return string encoded path
+	 */
+	private function encodePath($path) {
+		// slashes need to stay
+		return str_replace('%2F', '/', rawurlencode($path));
+	}
+
+	/**
+	 * @param string $method
+	 * @param string $path
+	 * @param string|resource|null $body
+	 * @param int $expected
+	 * @return bool
+	 * @throws StorageInvalidException
+	 * @throws StorageNotAvailableException
+	 */
+	private function simpleResponse($method, $path, $body, $expected) {
+		$path = $this->cleanPath($path);
+		try {
+			$response = $this->client->request($method, $this->encodePath($path), $body);
+			return $response['statusCode'] == $expected;
+		} catch (ClientHttpException $e) {
+			if ($e->getHttpStatus() === 404 && $method === 'DELETE') {
+				$this->statCache->clear($path . '/');
+				$this->statCache->set($path, false);
+				return false;
+			}
+
+			$this->convertException($e, $path);
+		} catch (\Exception $e) {
+			$this->convertException($e, $path);
+		}
+		return false;
+	}
+
+	/**
+	 * check if curl is installed
+	 */
+	public static function checkDependencies() {
+		return true;
+	}
+
+	/** {@inheritdoc} */
+	public function isUpdatable($path) {
+		return (bool)($this->getPermissions($path) & Constants::PERMISSION_UPDATE);
+	}
+
+	/** {@inheritdoc} */
+	public function isCreatable($path) {
+		return (bool)($this->getPermissions($path) & Constants::PERMISSION_CREATE);
+	}
+
+	/** {@inheritdoc} */
+	public function isSharable($path) {
+		return (bool)($this->getPermissions($path) & Constants::PERMISSION_SHARE);
+	}
+
+	/** {@inheritdoc} */
+	public function isDeletable($path) {
+		return (bool)($this->getPermissions($path) & Constants::PERMISSION_DELETE);
+	}
+
+	/** {@inheritdoc} */
+	public function getPermissions($path) {
+		$this->init();
+		$path = $this->cleanPath($path);
+		$response = $this->propfind($path);
+		if (isset($response['{http://owncloud.org/ns}permissions'])) {
+			return $this->parsePermissions($response['{http://owncloud.org/ns}permissions']);
+		} else if ($this->is_dir($path)) {
+			return Constants::PERMISSION_ALL;
+		} else if ($this->file_exists($path)) {
+			return Constants::PERMISSION_ALL - Constants::PERMISSION_CREATE;
+		} else {
+			return 0;
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function getETag($path) {
+		$this->init();
+		$path = $this->cleanPath($path);
+		$response = $this->propfind($path);
+		if (isset($response['{DAV:}getetag'])) {
+			return trim($response['{DAV:}getetag'], '"');
+		}
+		return parent::getEtag($path);
+	}
+
+	/**
+	 * @param string $permissionsString
+	 * @return int
+	 */
+	protected function parsePermissions($permissionsString) {
+		$permissions = Constants::PERMISSION_READ;
+		if (strpos($permissionsString, 'R') !== false) {
+			$permissions |= Constants::PERMISSION_SHARE;
+		}
+		if (strpos($permissionsString, 'D') !== false) {
+			$permissions |= Constants::PERMISSION_DELETE;
+		}
+		if (strpos($permissionsString, 'W') !== false) {
+			$permissions |= Constants::PERMISSION_UPDATE;
+		}
+		if (strpos($permissionsString, 'CK') !== false) {
+			$permissions |= Constants::PERMISSION_CREATE;
+			$permissions |= Constants::PERMISSION_UPDATE;
+		}
+		return $permissions;
+	}
+
+	/**
+	 * check if a file or folder has been updated since $time
+	 *
+	 * @param string $path
+	 * @param int $time
+	 * @throws \OCP\Files\StorageNotAvailableException
+	 * @return bool
+	 */
+	public function hasUpdated($path, $time) {
+		$this->init();
+		$path = $this->cleanPath($path);
+		try {
+			// force refresh for $path
+			$this->statCache->remove($path);
+			$response = $this->propfind($path);
+			if (isset($response['{DAV:}getetag'])) {
+				$cachedData = $this->getCache()->get($path);
+				$etag = null;
+				if (isset($response['{DAV:}getetag'])) {
+					$etag = trim($response['{DAV:}getetag'], '"');
+				}
+				if (!empty($etag) && $cachedData['etag'] !== $etag) {
+					return true;
+				} else if (isset($response['{http://open-collaboration-services.org/ns}share-permissions'])) {
+					$sharePermissions = (int)$response['{http://open-collaboration-services.org/ns}share-permissions'];
+					return $sharePermissions !== $cachedData['permissions'];
+				} else if (isset($response['{http://owncloud.org/ns}permissions'])) {
+					$permissions = $this->parsePermissions($response['{http://owncloud.org/ns}permissions']);
+					return $permissions !== $cachedData['permissions'];
+				} else {
+					return false;
+				}
+			} else {
+				$remoteMtime = strtotime($response['{DAV:}getlastmodified']);
+				return $remoteMtime > $time;
+			}
+		} catch (ClientHttpException $e) {
+			if ($e->getHttpStatus() === 404 || $e->getHttpStatus() === 405) {
+				if ($path === '') {
+					// if root is gone it means the storage is not available
+					throw new StorageNotAvailableException(get_class($e) . ': ' . $e->getMessage());
+				}
+				return false;
+			}
+			$this->convertException($e, $path);
+			return false;
+		} catch (\Exception $e) {
+			$this->convertException($e, $path);
+			return false;
+		}
+	}
+
+	/**
+	 * Interpret the given exception and decide whether it is due to an
+	 * unavailable storage, invalid storage or other.
+	 * This will either throw StorageInvalidException, StorageNotAvailableException
+	 * or do nothing.
+	 *
+	 * @param Exception $e sabre exception
+	 * @param string $path optional path from the operation
+	 *
+	 * @throws StorageInvalidException if the storage is invalid, for example
+	 * when the authentication expired or is invalid
+	 * @throws StorageNotAvailableException if the storage is not available,
+	 * which might be temporary
+	 */
+	private function convertException(Exception $e, $path = '') {
+		Util::writeLog('files_external', $e->getMessage(), Util::ERROR);
+		if ($e instanceof ClientHttpException) {
+			if ($e->getHttpStatus() === 423) {
+				throw new \OCP\Lock\LockedException($path);
+			}
+			if ($e->getHttpStatus() === 401) {
+				// either password was changed or was invalid all along
+				throw new StorageInvalidException(get_class($e) . ': ' . $e->getMessage());
+			} else if ($e->getHttpStatus() === 405) {
+				// ignore exception for MethodNotAllowed, false will be returned
+				return;
+			}
+			throw new StorageNotAvailableException(get_class($e) . ': ' . $e->getMessage());
+		} else if ($e instanceof ClientException) {
+			// connection timeout or refused, server could be temporarily down
+			throw new StorageNotAvailableException(get_class($e) . ': ' . $e->getMessage());
+		} else if ($e instanceof \InvalidArgumentException) {
+			// parse error because the server returned HTML instead of XML,
+			// possibly temporarily down
+			throw new StorageNotAvailableException(get_class($e) . ': ' . $e->getMessage());
+		} else if (($e instanceof StorageNotAvailableException) || ($e instanceof StorageInvalidException)) {
+			// rethrow
+			throw $e;
+		}
+
+		// TODO: only log for now, but in the future need to wrap/rethrow exception
+	}
+}
+
diff --git a/lib/private/Files/Storage/FailedStorage.php b/lib/private/Files/Storage/FailedStorage.php
new file mode 100644
index 00000000000..df7f76856d5
--- /dev/null
+++ b/lib/private/Files/Storage/FailedStorage.php
@@ -0,0 +1,215 @@
+<?php
+/**
+ * @author Robin Appelman <icewind@owncloud.com>
+ * @author Robin McCorkell <robin@mccorkell.me.uk>
+ *
+ * @copyright Copyright (c) 2016, ownCloud, Inc.
+ * @license AGPL-3.0
+ *
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License, version 3,
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>
+ *
+ */
+
+namespace OC\Files\Storage;
+
+use OC\Files\Cache\FailedCache;
+use \OCP\Lock\ILockingProvider;
+use \OCP\Files\StorageNotAvailableException;
+
+/**
+ * Storage placeholder to represent a missing precondition, storage unavailable
+ */
+class FailedStorage extends Common {
+
+	/** @var \Exception */
+	protected $e;
+
+	/**
+	 * @param array $params ['exception' => \Exception]
+	 */
+	public function __construct($params) {
+		$this->e = $params['exception'];
+		if (!$this->e) {
+			throw new \InvalidArgumentException('Missing "exception" argument in FailedStorage constructor');
+		}
+	}
+
+	public function getId() {
+		// we can't return anything sane here
+		return 'failedstorage';
+	}
+
+	public function mkdir($path) {
+		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+	}
+
+	public function rmdir($path) {
+		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+	}
+
+	public function opendir($path) {
+		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+	}
+
+	public function is_dir($path) {
+		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+	}
+
+	public function is_file($path) {
+		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+	}
+
+	public function stat($path) {
+		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+	}
+
+	public function filetype($path) {
+		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+	}
+
+	public function filesize($path) {
+		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+	}
+
+	public function isCreatable($path) {
+		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+	}
+
+	public function isReadable($path) {
+		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+	}
+
+	public function isUpdatable($path) {
+		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+	}
+
+	public function isDeletable($path) {
+		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+	}
+
+	public function isSharable($path) {
+		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+	}
+
+	public function getPermissions($path) {
+		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+	}
+
+	public function file_exists($path) {
+		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+	}
+
+	public function filemtime($path) {
+		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+	}
+
+	public function file_get_contents($path) {
+		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+	}
+
+	public function file_put_contents($path, $data) {
+		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+	}
+
+	public function unlink($path) {
+		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+	}
+
+	public function rename($path1, $path2) {
+		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+	}
+
+	public function copy($path1, $path2) {
+		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+	}
+
+	public function fopen($path, $mode) {
+		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+	}
+
+	public function getMimeType($path) {
+		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+	}
+
+	public function hash($type, $path, $raw = false) {
+		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+	}
+
+	public function free_space($path) {
+		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+	}
+
+	public function search($query) {
+		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+	}
+
+	public function touch($path, $mtime = null) {
+		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+	}
+
+	public function getLocalFile($path) {
+		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+	}
+
+	public function getLocalFolder($path) {
+		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+	}
+
+	public function hasUpdated($path, $time) {
+		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+	}
+
+	public function getETag($path) {
+		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+	}
+
+	public function getDirectDownload($path) {
+		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+	}
+
+	public function verifyPath($path, $fileName) {
+		return true;
+	}
+
+	public function copyFromStorage(\OCP\Files\Storage $sourceStorage, $sourceInternalPath, $targetInternalPath) {
+		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+	}
+
+	public function moveFromStorage(\OCP\Files\Storage $sourceStorage, $sourceInternalPath, $targetInternalPath) {
+		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+	}
+
+	public function acquireLock($path, $type, ILockingProvider $provider) {
+		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+	}
+
+	public function releaseLock($path, $type, ILockingProvider $provider) {
+		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+	}
+
+	public function changeLock($path, $type, ILockingProvider $provider) {
+		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+	}
+
+	public function getAvailability() {
+		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+	}
+
+	public function setAvailability($isAvailable) {
+		throw new StorageNotAvailableException($this->e->getMessage(), $this->e->getCode(), $this->e);
+	}
+
+	public function getCache($path = '', $storage = null) {
+		return new FailedCache();
+	}
+}
diff --git a/lib/private/Files/Storage/Flysystem.php b/lib/private/Files/Storage/Flysystem.php
new file mode 100644
index 00000000000..608639b71a6
--- /dev/null
+++ b/lib/private/Files/Storage/Flysystem.php
@@ -0,0 +1,256 @@
+<?php
+/**
+ * @author Robin Appelman <icewind@owncloud.com>
+ *
+ * @copyright Copyright (c) 2016, ownCloud, Inc.
+ * @license AGPL-3.0
+ *
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License, version 3,
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>
+ *
+ */
+
+namespace OC\Files\Storage;
+
+use Icewind\Streams\CallbackWrapper;
+use Icewind\Streams\IteratorDirectory;
+use League\Flysystem\AdapterInterface;
+use League\Flysystem\FileNotFoundException;
+use League\Flysystem\Filesystem;
+use League\Flysystem\Plugin\GetWithMetadata;
+
+/**
+ * Generic adapter between flysystem adapters and owncloud's storage system
+ *
+ * To use: subclass and call $this->buildFlysystem with the flysystem adapter of choice
+ */
+abstract class Flysystem extends Common {
+	/**
+	 * @var Filesystem
+	 */
+	protected $flysystem;
+
+	/**
+	 * @var string
+	 */
+	protected $root = '';
+
+	/**
+	 * Initialize the storage backend with a flyssytem adapter
+	 *
+	 * @param \League\Flysystem\AdapterInterface $adapter
+	 */
+	protected function buildFlySystem(AdapterInterface $adapter) {
+		$this->flysystem = new Filesystem($adapter);
+		$this->flysystem->addPlugin(new GetWithMetadata());
+	}
+
+	protected function buildPath($path) {
+		$fullPath = \OC\Files\Filesystem::normalizePath($this->root . '/' . $path);
+		return ltrim($fullPath, '/');
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function file_get_contents($path) {
+		return $this->flysystem->read($this->buildPath($path));
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function file_put_contents($path, $data) {
+		return $this->flysystem->put($this->buildPath($path), $data);
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function file_exists($path) {
+		return $this->flysystem->has($this->buildPath($path));
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function unlink($path) {
+		if ($this->is_dir($path)) {
+			return $this->rmdir($path);
+		}
+		try {
+			return $this->flysystem->delete($this->buildPath($path));
+		} catch (FileNotFoundException $e) {
+			return false;
+		}
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function rename($source, $target) {
+		if ($this->file_exists($target)) {
+			$this->unlink($target);
+		}
+		return $this->flysystem->rename($this->buildPath($source), $this->buildPath($target));
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function copy($source, $target) {
+		if ($this->file_exists($target)) {
+			$this->unlink($target);
+		}
+		return $this->flysystem->copy($this->buildPath($source), $this->buildPath($target));
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function filesize($path) {
+		if ($this->is_dir($path)) {
+			return 0;
+		} else {
+			return $this->flysystem->getSize($this->buildPath($path));
+		}
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function mkdir($path) {
+		if ($this->file_exists($path)) {
+			return false;
+		}
+		return $this->flysystem->createDir($this->buildPath($path));
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function filemtime($path) {
+		return $this->flysystem->getTimestamp($this->buildPath($path));
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function rmdir($path) {
+		try {
+			return @$this->flysystem->deleteDir($this->buildPath($path));
+		} catch (FileNotFoundException $e) {
+			return false;
+		}
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function opendir($path) {
+		try {
+			$content = $this->flysystem->listContents($this->buildPath($path));
+		} catch (FileNotFoundException $e) {
+			return false;
+		}
+		$names = array_map(function ($object) {
+			return $object['basename'];
+		}, $content);
+		return IteratorDirectory::wrap($names);
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function fopen($path, $mode) {
+		$fullPath = $this->buildPath($path);
+		$useExisting = true;
+		switch ($mode) {
+			case 'r':
+			case 'rb':
+				try {
+					return $this->flysystem->readStream($fullPath);
+				} catch (FileNotFoundException $e) {
+					return false;
+				}
+			case 'w':
+			case 'w+':
+			case 'wb':
+			case 'wb+':
+				$useExisting = false;
+			case 'a':
+			case 'ab':
+			case 'r+':
+			case 'a+':
+			case 'x':
+			case 'x+':
+			case 'c':
+			case 'c+':
+				//emulate these
+				if ($useExisting and $this->file_exists($path)) {
+					if (!$this->isUpdatable($path)) {
+						return false;
+					}
+					$tmpFile = $this->getCachedFile($path);
+				} else {
+					if (!$this->isCreatable(dirname($path))) {
+						return false;
+					}
+					$tmpFile = \OCP\Files::tmpFile();
+				}
+				$source = fopen($tmpFile, $mode);
+				return CallbackWrapper::wrap($source, null, null, function () use ($tmpFile, $fullPath) {
+					$this->flysystem->putStream($fullPath, fopen($tmpFile, 'r'));
+					unlink($tmpFile);
+				});
+		}
+		return false;
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function touch($path, $mtime = null) {
+		if ($this->file_exists($path)) {
+			return false;
+		} else {
+			$this->file_put_contents($path, '');
+			return true;
+		}
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function stat($path) {
+		$info = $this->flysystem->getWithMetadata($this->buildPath($path), ['timestamp', 'size']);
+		return [
+			'mtime' => $info['timestamp'],
+			'size' => $info['size']
+		];
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function filetype($path) {
+		if ($path === '' or $path === '/' or $path === '.') {
+			return 'dir';
+		}
+		try {
+			$info = $this->flysystem->getMetadata($this->buildPath($path));
+		} catch (FileNotFoundException $e) {
+			return false;
+		}
+		return $info['type'];
+	}
+}
diff --git a/lib/private/Files/Storage/Home.php b/lib/private/Files/Storage/Home.php
new file mode 100644
index 00000000000..9b98f2f7e12
--- /dev/null
+++ b/lib/private/Files/Storage/Home.php
@@ -0,0 +1,114 @@
+<?php
+/**
+ * @author Björn Schießle <schiessle@owncloud.com>
+ * @author Morris Jobke <hey@morrisjobke.de>
+ * @author Robin Appelman <icewind@owncloud.com>
+ * @author Thomas Müller <thomas.mueller@tmit.eu>
+ * @author Vincent Petry <pvince81@owncloud.com>
+ *
+ * @copyright Copyright (c) 2016, ownCloud, Inc.
+ * @license AGPL-3.0
+ *
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License, version 3,
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>
+ *
+ */
+
+namespace OC\Files\Storage;
+use OC\Files\Cache\HomePropagator;
+
+/**
+ * Specialized version of Local storage for home directory usage
+ */
+class Home extends Local implements \OCP\Files\IHomeStorage {
+	/**
+	 * @var string
+	 */
+	protected $id;
+
+	/**
+	 * @var \OC\User\User $user
+	 */
+	protected $user;
+
+	/**
+	 * Construct a Home storage instance
+	 * @param array $arguments array with "user" containing the
+	 * storage owner and "legacy" containing "true" if the storage is
+	 * a legacy storage with "local::" URL instead of the new "home::" one.
+	 */
+	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 $this->id;
+	}
+
+	/**
+	 * @return \OC\Files\Cache\HomeCache
+	 */
+	public function getCache($path = '', $storage = null) {
+		if (!$storage) {
+			$storage = $this;
+		}
+		if (!isset($this->cache)) {
+			$this->cache = new \OC\Files\Cache\HomeCache($storage);
+		}
+		return $this->cache;
+	}
+
+	/**
+	 * get a propagator instance for the cache
+	 *
+	 * @param \OC\Files\Storage\Storage (optional) the storage to pass to the watcher
+	 * @return \OC\Files\Cache\Propagator
+	 */
+	public function getPropagator($storage = null) {
+		if (!$storage) {
+			$storage = $this;
+		}
+		if (!isset($this->propagator)) {
+			$this->propagator = new HomePropagator($storage);
+		}
+		return $this->propagator;
+	}
+
+
+	/**
+	 * Returns the owner of this home storage
+	 * @return \OC\User\User owner of this home storage
+	 */
+	public function getUser() {
+		return $this->user;
+	}
+
+	/**
+	 * get the owner of a path
+	 *
+	 * @param string $path The path to get the owner
+	 * @return string uid or false
+	 */
+	public function getOwner($path) {
+		return $this->user->getUID();
+	}
+}
diff --git a/lib/private/Files/Storage/Local.php b/lib/private/Files/Storage/Local.php
new file mode 100644
index 00000000000..25b202af5f8
--- /dev/null
+++ b/lib/private/Files/Storage/Local.php
@@ -0,0 +1,404 @@
+<?php
+/**
+ * @author Bart Visscher <bartv@thisnet.nl>
+ * @author Brice Maron <brice@bmaron.net>
+ * @author Jakob Sack <mail@jakobsack.de>
+ * @author Joas Schilling <nickvergessen@owncloud.com>
+ * @author Klaas Freitag <freitag@owncloud.com>
+ * @author Martin Mattel <martin.mattel@diemattels.at>
+ * @author Michael Gapczynski <GapczynskiM@gmail.com>
+ * @author Morris Jobke <hey@morrisjobke.de>
+ * @author Robin Appelman <icewind@owncloud.com>
+ * @author Sjors van der Pluijm <sjors@desjors.nl>
+ * @author Thomas Müller <thomas.mueller@tmit.eu>
+ * @author Tigran Mkrtchyan <tigran.mkrtchyan@desy.de>
+ * @author Vincent Petry <pvince81@owncloud.com>
+ *
+ * @copyright Copyright (c) 2016, ownCloud, Inc.
+ * @license AGPL-3.0
+ *
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License, version 3,
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>
+ *
+ */
+
+namespace OC\Files\Storage;
+/**
+ * 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->getSourcePath($path), 0777, true);
+	}
+
+	public function rmdir($path) {
+		if (!$this->isDeletable($path)) {
+			return false;
+		}
+		try {
+			$it = new \RecursiveIteratorIterator(
+				new \RecursiveDirectoryIterator($this->getSourcePath($path)),
+				\RecursiveIteratorIterator::CHILD_FIRST
+			);
+			/**
+			 * RecursiveDirectoryIterator on an NFS path isn't iterable with foreach
+			 * This bug is fixed in PHP 5.5.9 or before
+			 * See #8376
+			 */
+			$it->rewind();
+			while ($it->valid()) {
+				/**
+				 * @var \SplFileInfo $file
+				 */
+				$file = $it->current();
+				if (in_array($file->getBasename(), array('.', '..'))) {
+					$it->next();
+					continue;
+				} elseif ($file->isDir()) {
+					rmdir($file->getPathname());
+				} elseif ($file->isFile() || $file->isLink()) {
+					unlink($file->getPathname());
+				}
+				$it->next();
+			}
+			return rmdir($this->getSourcePath($path));
+		} catch (\UnexpectedValueException $e) {
+			return false;
+		}
+	}
+
+	public function opendir($path) {
+		return opendir($this->getSourcePath($path));
+	}
+
+	public function is_dir($path) {
+		if (substr($path, -1) == '/') {
+			$path = substr($path, 0, -1);
+		}
+		return is_dir($this->getSourcePath($path));
+	}
+
+	public function is_file($path) {
+		return is_file($this->getSourcePath($path));
+	}
+
+	public function stat($path) {
+		clearstatcache();
+		$fullPath = $this->getSourcePath($path);
+		$statResult = stat($fullPath);
+		if (PHP_INT_SIZE === 4 && !$this->is_dir($path)) {
+			$filesize = $this->filesize($path);
+			$statResult['size'] = $filesize;
+			$statResult[7] = $filesize;
+		}
+		return $statResult;
+	}
+
+	public function filetype($path) {
+		$filetype = filetype($this->getSourcePath($path));
+		if ($filetype == 'link') {
+			$filetype = filetype(realpath($this->getSourcePath($path)));
+		}
+		return $filetype;
+	}
+
+	public function filesize($path) {
+		if ($this->is_dir($path)) {
+			return 0;
+		}
+		$fullPath = $this->getSourcePath($path);
+		if (PHP_INT_SIZE === 4) {
+			$helper = new \OC\LargeFileHelper;
+			return $helper->getFilesize($fullPath);
+		}
+		return filesize($fullPath);
+	}
+
+	public function isReadable($path) {
+		return is_readable($this->getSourcePath($path));
+	}
+
+	public function isUpdatable($path) {
+		return is_writable($this->getSourcePath($path));
+	}
+
+	public function file_exists($path) {
+		return file_exists($this->getSourcePath($path));
+	}
+
+	public function filemtime($path) {
+		clearstatcache($this->getSourcePath($path));
+		return filemtime($this->getSourcePath($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 ($this->file_exists($path) and !$this->isUpdatable($path)) {
+			return false;
+		}
+		if (!is_null($mtime)) {
+			$result = touch($this->getSourcePath($path), $mtime);
+		} else {
+			$result = touch($this->getSourcePath($path));
+		}
+		if ($result) {
+			clearstatcache(true, $this->getSourcePath($path));
+		}
+
+		return $result;
+	}
+
+	public function file_get_contents($path) {
+		// file_get_contents() has a memory leak: https://bugs.php.net/bug.php?id=61961
+		$fileName = $this->getSourcePath($path);
+
+		$fileSize = filesize($fileName);
+		if ($fileSize === 0) {
+			return '';
+		}
+
+		$handle = fopen($fileName,'rb');
+		$content = fread($handle, $fileSize);
+		fclose($handle);
+		return $content;
+	}
+
+	public function file_put_contents($path, $data) {
+		return file_put_contents($this->getSourcePath($path), $data);
+	}
+
+	public function unlink($path) {
+		if ($this->is_dir($path)) {
+			return $this->rmdir($path);
+		} else if ($this->is_file($path)) {
+			return unlink($this->getSourcePath($path));
+		} else {
+			return false;
+		}
+
+	}
+
+	public function rename($path1, $path2) {
+		$srcParent = dirname($path1);
+		$dstParent = dirname($path2);
+
+		if (!$this->isUpdatable($srcParent)) {
+			\OCP\Util::writeLog('core', 'unable to rename, source directory is not writable : ' . $srcParent, \OCP\Util::ERROR);
+			return false;
+		}
+
+		if (!$this->isUpdatable($dstParent)) {
+			\OCP\Util::writeLog('core', 'unable to rename, destination directory is not writable : ' . $dstParent, \OCP\Util::ERROR);
+			return false;
+		}
+
+		if (!$this->file_exists($path1)) {
+			\OCP\Util::writeLog('core', 'unable to rename, file does not exists : ' . $path1, \OCP\Util::ERROR);
+			return false;
+		}
+
+		if ($this->is_dir($path2)) {
+			$this->rmdir($path2);
+		} else if ($this->is_file($path2)) {
+			$this->unlink($path2);
+		}
+
+		if ($this->is_dir($path1)) {
+			// we can't move folders across devices, use copy instead
+			$stat1 = stat(dirname($this->getSourcePath($path1)));
+			$stat2 = stat(dirname($this->getSourcePath($path2)));
+			if ($stat1['dev'] !== $stat2['dev']) {
+				$result = $this->copy($path1, $path2);
+				if ($result) {
+					$result &= $this->rmdir($path1);
+				}
+				return $result;
+			}
+		}
+
+		return rename($this->getSourcePath($path1), $this->getSourcePath($path2));
+	}
+
+	public function copy($path1, $path2) {
+		if ($this->is_dir($path1)) {
+			return parent::copy($path1, $path2);
+		} else {
+			return copy($this->getSourcePath($path1), $this->getSourcePath($path2));
+		}
+	}
+
+	public function fopen($path, $mode) {
+		return fopen($this->getSourcePath($path), $mode);
+	}
+
+	public function hash($type, $path, $raw = false) {
+		return hash_file($type, $this->getSourcePath($path), $raw);
+	}
+
+	public function free_space($path) {
+		$sourcePath = $this->getSourcePath($path);
+		// using !is_dir because $sourcePath might be a part file or
+		// non-existing file, so we'd still want to use the parent dir
+		// in such cases
+		if (!is_dir($sourcePath)) {
+			// disk_free_space doesn't work on files
+			$sourcePath = dirname($sourcePath);
+		}
+		$space = @disk_free_space($sourcePath);
+		if ($space === false || is_null($space)) {
+			return \OCP\Files\FileInfo::SPACE_UNKNOWN;
+		}
+		return $space;
+	}
+
+	public function search($query) {
+		return $this->searchInDir($query);
+	}
+
+	public function getLocalFile($path) {
+		return $this->getSourcePath($path);
+	}
+
+	public function getLocalFolder($path) {
+		return $this->getSourcePath($path);
+	}
+
+	/**
+	 * @param string $query
+	 * @param string $dir
+	 * @return array
+	 */
+	protected function searchInDir($query, $dir = '') {
+		$files = array();
+		$physicalDir = $this->getSourcePath($dir);
+		foreach (scandir($physicalDir) as $item) {
+			if (\OC\Files\Filesystem::isIgnoredDir($item))
+				continue;
+			$physicalItem = $physicalDir . '/' . $item;
+
+			if (strstr(strtolower($item), strtolower($query)) !== false) {
+				$files[] = $dir . '/' . $item;
+			}
+			if (is_dir($physicalItem)) {
+				$files = array_merge($files, $this->searchInDir($query, $dir . '/' . $item));
+			}
+		}
+		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) {
+		if ($this->file_exists($path)) {
+			return $this->filemtime($path) > $time;
+		} else {
+			return true;
+		}
+	}
+
+	/**
+	 * Get the source path (on disk) of a given path
+	 *
+	 * @param string $path
+	 * @return string
+	 */
+	public function getSourcePath($path) {
+		$fullPath = $this->datadir . $path;
+		return $fullPath;
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function isLocal() {
+		return true;
+	}
+
+	/**
+	 * get the ETag for a file or folder
+	 *
+	 * @param string $path
+	 * @return string
+	 */
+	public function getETag($path) {
+		if ($this->is_file($path)) {
+			$stat = $this->stat($path);
+			return md5(
+				$stat['mtime'] .
+				$stat['ino'] .
+				$stat['dev'] .
+				$stat['size']
+			);
+		} else {
+			return parent::getETag($path);
+		}
+	}
+
+	/**
+	 * @param \OCP\Files\Storage $sourceStorage
+	 * @param string $sourceInternalPath
+	 * @param string $targetInternalPath
+	 * @return bool
+	 */
+	public function copyFromStorage(\OCP\Files\Storage $sourceStorage, $sourceInternalPath, $targetInternalPath) {
+		if($sourceStorage->instanceOfStorage('\OC\Files\Storage\Local')){
+			/**
+			 * @var \OC\Files\Storage\Local $sourceStorage
+			 */
+			$rootStorage = new Local(['datadir' => '/']);
+			return $rootStorage->copy($sourceStorage->getSourcePath($sourceInternalPath), $this->getSourcePath($targetInternalPath));
+		} else {
+			return parent::copyFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath);
+		}
+	}
+
+	/**
+	 * @param \OCP\Files\Storage $sourceStorage
+	 * @param string $sourceInternalPath
+	 * @param string $targetInternalPath
+	 * @return bool
+	 */
+	public function moveFromStorage(\OCP\Files\Storage $sourceStorage, $sourceInternalPath, $targetInternalPath) {
+		if ($sourceStorage->instanceOfStorage('\OC\Files\Storage\Local')) {
+			/**
+			 * @var \OC\Files\Storage\Local $sourceStorage
+			 */
+			$rootStorage = new Local(['datadir' => '/']);
+			return $rootStorage->rename($sourceStorage->getSourcePath($sourceInternalPath), $this->getSourcePath($targetInternalPath));
+		} else {
+			return parent::moveFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath);
+		}
+	}
+}
diff --git a/lib/private/Files/Storage/LocalTempFileTrait.php b/lib/private/Files/Storage/LocalTempFileTrait.php
new file mode 100644
index 00000000000..88f11e4e752
--- /dev/null
+++ b/lib/private/Files/Storage/LocalTempFileTrait.php
@@ -0,0 +1,80 @@
+<?php
+/**
+ * @author Lukas Reschke <lukas@owncloud.com>
+ * @author Morris Jobke <hey@morrisjobke.de>
+ * @author Thomas Müller <thomas.mueller@tmit.eu>
+ *
+ * @copyright Copyright (c) 2016, ownCloud, Inc.
+ * @license AGPL-3.0
+ *
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License, version 3,
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>
+ *
+ */
+
+namespace OC\Files\Storage;
+
+/**
+ * Storage backend class for providing common filesystem operation methods
+ * which are not storage-backend specific.
+ *
+ * \OC\Files\Storage\Common is never used directly; it is extended by all other
+ * storage backends, where its methods may be overridden, and additional
+ * (backend-specific) methods are defined.
+ *
+ * Some \OC\Files\Storage\Common methods call functions which are first defined
+ * in classes which extend it, e.g. $this->stat() .
+ */
+trait LocalTempFileTrait {
+
+	/** @var string[] */
+	protected $cachedFiles = [];
+
+	/**
+	 * @param string $path
+	 * @return string
+	 */
+	protected function getCachedFile($path) {
+		if (!isset($this->cachedFiles[$path])) {
+			$this->cachedFiles[$path] = $this->toTmpFile($path);
+		}
+		return $this->cachedFiles[$path];
+	}
+
+	/**
+	 * @param string $path
+	 */
+	protected function removeCachedFile($path) {
+		unset($this->cachedFiles[$path]);
+	}
+
+	/**
+	 * @param string $path
+	 * @return string
+	 */
+	protected function toTmpFile($path) { //no longer in the storage api, still useful here
+		$source = $this->fopen($path, 'r');
+		if (!$source) {
+			return false;
+		}
+		if ($pos = strrpos($path, '.')) {
+			$extension = substr($path, $pos);
+		} else {
+			$extension = '';
+		}
+		$tmpFile = \OC::$server->getTempManager()->getTemporaryFile($extension);
+		$target = fopen($tmpFile, 'w');
+		\OC_Helper::streamCopy($source, $target);
+		fclose($target);
+		return $tmpFile;
+	}
+}
diff --git a/lib/private/Files/Storage/PolyFill/CopyDirectory.php b/lib/private/Files/Storage/PolyFill/CopyDirectory.php
new file mode 100644
index 00000000000..d4cac117ade
--- /dev/null
+++ b/lib/private/Files/Storage/PolyFill/CopyDirectory.php
@@ -0,0 +1,103 @@
+<?php
+/**
+ * @author Martin Mattel <martin.mattel@diemattels.at>
+ * @author Robin Appelman <icewind@owncloud.com>
+ *
+ * @copyright Copyright (c) 2016, ownCloud, Inc.
+ * @license AGPL-3.0
+ *
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License, version 3,
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>
+ *
+ */
+
+namespace OC\Files\Storage\PolyFill;
+
+trait CopyDirectory {
+	/**
+	 * Check if a path is a directory
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	abstract public function is_dir($path);
+
+	/**
+	 * Check if a file or folder exists
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	abstract public function file_exists($path);
+
+	/**
+	 * Delete a file or folder
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	abstract public function unlink($path);
+
+	/**
+	 * Open a directory handle for a folder
+	 *
+	 * @param string $path
+	 * @return resource | bool
+	 */
+	abstract public function opendir($path);
+
+	/**
+	 * Create a new folder
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	abstract public function mkdir($path);
+
+	public function copy($source, $target) {
+		if ($this->is_dir($source)) {
+			if ($this->file_exists($target)) {
+				$this->unlink($target);
+			}
+			$this->mkdir($target);
+			return $this->copyRecursive($source, $target);
+		} else {
+			return parent::copy($source, $target);
+		}
+	}
+
+	/**
+	 * For adapters that don't support copying folders natively
+	 *
+	 * @param $source
+	 * @param $target
+	 * @return bool
+	 */
+	protected function copyRecursive($source, $target) {
+		$dh = $this->opendir($source);
+		$result = true;
+		while ($file = readdir($dh)) {
+			if (!\OC\Files\Filesystem::isIgnoredDir($file)) {
+				if ($this->is_dir($source . '/' . $file)) {
+					$this->mkdir($target . '/' . $file);
+					$result = $this->copyRecursive($source . '/' . $file, $target . '/' . $file);
+				} else {
+					$result = parent::copy($source . '/' . $file, $target . '/' . $file);
+				}
+				if (!$result) {
+					break;
+				}
+			}
+		}
+		return $result;
+	}
+}
diff --git a/lib/private/Files/Storage/Storage.php b/lib/private/Files/Storage/Storage.php
new file mode 100644
index 00000000000..c066336d4b8
--- /dev/null
+++ b/lib/private/Files/Storage/Storage.php
@@ -0,0 +1,119 @@
+<?php
+/**
+ * @author Morris Jobke <hey@morrisjobke.de>
+ * @author Robin Appelman <icewind@owncloud.com>
+ * @author Thomas Müller <thomas.mueller@tmit.eu>
+ *
+ * @copyright Copyright (c) 2016, ownCloud, Inc.
+ * @license AGPL-3.0
+ *
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License, version 3,
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>
+ *
+ */
+
+namespace OC\Files\Storage;
+use OCP\Lock\ILockingProvider;
+
+/**
+ * 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 extends \OCP\Files\Storage {
+
+	/**
+	 * get a cache instance for the storage
+	 *
+	 * @param string $path
+	 * @param \OC\Files\Storage\Storage (optional) the storage to pass to the cache
+	 * @return \OC\Files\Cache\Cache
+	 */
+	public function getCache($path = '', $storage = null);
+
+	/**
+	 * get a scanner instance for the storage
+	 *
+	 * @param string $path
+	 * @param \OC\Files\Storage\Storage (optional) the storage to pass to the scanner
+	 * @return \OC\Files\Cache\Scanner
+	 */
+	public function getScanner($path = '', $storage = null);
+
+
+	/**
+	 * get the user id of the owner of a file or folder
+	 *
+	 * @param string $path
+	 * @return string
+	 */
+	public function getOwner($path);
+
+	/**
+	 * get a watcher instance for the cache
+	 *
+	 * @param string $path
+	 * @param \OC\Files\Storage\Storage (optional) the storage to pass to the watcher
+	 * @return \OC\Files\Cache\Watcher
+	 */
+	public function getWatcher($path = '', $storage = null);
+
+	/**
+	 * get a propagator instance for the cache
+	 *
+	 * @param \OC\Files\Storage\Storage (optional) the storage to pass to the watcher
+	 * @return \OC\Files\Cache\Propagator
+	 */
+	public function getPropagator($storage = null);
+
+	/**
+	 * get a updater instance for the cache
+	 *
+	 * @param \OC\Files\Storage\Storage (optional) the storage to pass to the watcher
+	 * @return \OC\Files\Cache\Updater
+	 */
+	public function getUpdater($storage = null);
+
+	/**
+	 * @return \OC\Files\Cache\Storage
+	 */
+	public function getStorageCache();
+
+	/**
+	 * @param string $path
+	 * @return array
+	 */
+	public function getMetaData($path);
+
+	/**
+	 * @param string $path The path of the file to acquire the lock for
+	 * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
+	 * @param \OCP\Lock\ILockingProvider $provider
+	 * @throws \OCP\Lock\LockedException
+	 */
+	public function acquireLock($path, $type, ILockingProvider $provider);
+
+	/**
+	 * @param string $path The path of the file to release the lock for
+	 * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
+	 * @param \OCP\Lock\ILockingProvider $provider
+	 */
+	public function releaseLock($path, $type, ILockingProvider $provider);
+
+	/**
+	 * @param string $path The path of the file to change the lock for
+	 * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
+	 * @param \OCP\Lock\ILockingProvider $provider
+	 * @throws \OCP\Lock\LockedException
+	 */
+	public function changeLock($path, $type, ILockingProvider $provider);
+}
diff --git a/lib/private/Files/Storage/StorageFactory.php b/lib/private/Files/Storage/StorageFactory.php
new file mode 100644
index 00000000000..84362cabecc
--- /dev/null
+++ b/lib/private/Files/Storage/StorageFactory.php
@@ -0,0 +1,107 @@
+<?php
+/**
+ * @author Jörn Friedrich Dreyer <jfd@butonic.de>
+ * @author Morris Jobke <hey@morrisjobke.de>
+ * @author Robin Appelman <icewind@owncloud.com>
+ * @author Vincent Petry <pvince81@owncloud.com>
+ *
+ * @copyright Copyright (c) 2016, ownCloud, Inc.
+ * @license AGPL-3.0
+ *
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License, version 3,
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>
+ *
+ */
+
+namespace OC\Files\Storage;
+
+use OCP\Files\Mount\IMountPoint;
+use OCP\Files\Storage\IStorageFactory;
+
+class StorageFactory implements IStorageFactory {
+	/**
+	 * @var array[] [$name=>['priority'=>$priority, 'wrapper'=>$callable] $storageWrappers
+	 */
+	private $storageWrappers = [];
+
+	/**
+	 * allow modifier storage behaviour by adding wrappers around storages
+	 *
+	 * $callback should be a function of type (string $mountPoint, Storage $storage) => Storage
+	 *
+	 * @param string $wrapperName name of the wrapper
+	 * @param callable $callback callback
+	 * @param int $priority wrappers with the lower priority are applied last (meaning they get called first)
+	 * @param \OCP\Files\Mount\IMountPoint[] $existingMounts existing mount points to apply the wrapper to
+	 * @return bool true if the wrapper was added, false if there was already a wrapper with this
+	 * name registered
+	 */
+	public function addStorageWrapper($wrapperName, $callback, $priority = 50, $existingMounts = []) {
+		if (isset($this->storageWrappers[$wrapperName])) {
+			return false;
+		}
+
+		// apply to existing mounts before registering it to prevent applying it double in MountPoint::createStorage
+		foreach ($existingMounts as $mount) {
+			$mount->wrapStorage($callback);
+		}
+
+		$this->storageWrappers[$wrapperName] = ['wrapper' => $callback, 'priority' => $priority];
+		return true;
+	}
+
+	/**
+	 * Remove a storage wrapper by name.
+	 * Note: internal method only to be used for cleanup
+	 *
+	 * @param string $wrapperName name of the wrapper
+	 * @internal
+	 */
+	public function removeStorageWrapper($wrapperName) {
+		unset($this->storageWrappers[$wrapperName]);
+	}
+
+	/**
+	 * Create an instance of a storage and apply the registered storage wrappers
+	 *
+	 * @param \OCP\Files\Mount\IMountPoint $mountPoint
+	 * @param string $class
+	 * @param array $arguments
+	 * @return \OCP\Files\Storage
+	 */
+	public function getInstance(IMountPoint $mountPoint, $class, $arguments) {
+		return $this->wrap($mountPoint, new $class($arguments));
+	}
+
+	/**
+	 * @param \OCP\Files\Mount\IMountPoint $mountPoint
+	 * @param \OCP\Files\Storage $storage
+	 * @return \OCP\Files\Storage
+	 */
+	public function wrap(IMountPoint $mountPoint, $storage) {
+		$wrappers = array_values($this->storageWrappers);
+		usort($wrappers, function ($a, $b) {
+			return $b['priority'] - $a['priority'];
+		});
+		/** @var callable[] $wrappers */
+		$wrappers = array_map(function ($wrapper) {
+			return $wrapper['wrapper'];
+		}, $wrappers);
+		foreach ($wrappers as $wrapper) {
+			$storage = $wrapper($mountPoint->getMountPoint(), $storage, $mountPoint);
+			if (!($storage instanceof \OCP\Files\Storage)) {
+				throw new \Exception('Invalid result from storage wrapper');
+			}
+		}
+		return $storage;
+	}
+}
diff --git a/lib/private/Files/Storage/Temporary.php b/lib/private/Files/Storage/Temporary.php
new file mode 100644
index 00000000000..2d8e84c2d52
--- /dev/null
+++ b/lib/private/Files/Storage/Temporary.php
@@ -0,0 +1,47 @@
+<?php
+/**
+ * @author Morris Jobke <hey@morrisjobke.de>
+ * @author Robin Appelman <icewind@owncloud.com>
+ * @author Thomas Müller <thomas.mueller@tmit.eu>
+ * @author Vincent Petry <pvince81@owncloud.com>
+ *
+ * @copyright Copyright (c) 2016, ownCloud, Inc.
+ * @license AGPL-3.0
+ *
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License, version 3,
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>
+ *
+ */
+
+namespace OC\Files\Storage;
+
+/**
+ * local storage backend in temporary folder for testing purpose
+ */
+class Temporary extends Local{
+	public function __construct($arguments = null) {
+		parent::__construct(array('datadir' => \OC::$server->getTempManager()->getTemporaryFolder()));
+	}
+
+	public function cleanUp() {
+		\OC_Helper::rmdirr($this->datadir);
+	}
+
+	public function __destruct() {
+		parent::__destruct();
+		$this->cleanUp();
+	}
+
+	public function getDataDir() {
+		return $this->datadir;
+	}
+}
diff --git a/lib/private/Files/Storage/Wrapper/Availability.php b/lib/private/Files/Storage/Wrapper/Availability.php
new file mode 100644
index 00000000000..0ed31ba854a
--- /dev/null
+++ b/lib/private/Files/Storage/Wrapper/Availability.php
@@ -0,0 +1,461 @@
+<?php
+/**
+ * @author Robin Appelman <icewind@owncloud.com>
+ * @author Robin McCorkell <robin@mccorkell.me.uk>
+ *
+ * @copyright Copyright (c) 2016, ownCloud, Inc.
+ * @license AGPL-3.0
+ *
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License, version 3,
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>
+ *
+ */
+namespace OC\Files\Storage\Wrapper;
+
+/**
+ * Availability checker for storages
+ *
+ * Throws a StorageNotAvailableException for storages with known failures
+ */
+class Availability extends Wrapper {
+	const RECHECK_TTL_SEC = 600; // 10 minutes
+
+	public static function shouldRecheck($availability) {
+		if (!$availability['available']) {
+			// trigger a recheck if TTL reached
+			if ((time() - $availability['last_checked']) > self::RECHECK_TTL_SEC) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	/**
+	 * @return bool
+	 */
+	private function updateAvailability() {
+		try {
+			$result = $this->test();
+		} catch (\Exception $e) {
+			$result = false;
+		}
+		$this->setAvailability($result);
+		return $result;
+	}
+
+	/**
+	 * @return bool
+	 */
+	private function isAvailable() {
+		$availability = $this->getAvailability();
+		if (self::shouldRecheck($availability)) {
+			return $this->updateAvailability();
+		}
+		return $availability['available'];
+	}
+
+	/**
+	 * @throws \OCP\Files\StorageNotAvailableException
+	 */
+	private function checkAvailability() {
+		if (!$this->isAvailable()) {
+			throw new \OCP\Files\StorageNotAvailableException();
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function mkdir($path) {
+		$this->checkAvailability();
+		try {
+			return parent::mkdir($path);
+		} catch (\OCP\Files\StorageNotAvailableException $e) {
+			$this->setAvailability(false);
+			throw $e;
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function rmdir($path) {
+		$this->checkAvailability();
+		try {
+			return parent::rmdir($path);
+		} catch (\OCP\Files\StorageNotAvailableException $e) {
+			$this->setAvailability(false);
+			throw $e;
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function opendir($path) {
+		$this->checkAvailability();
+		try {
+			return parent::opendir($path);
+		} catch (\OCP\Files\StorageNotAvailableException $e) {
+			$this->setAvailability(false);
+			throw $e;
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function is_dir($path) {
+		$this->checkAvailability();
+		try {
+			return parent::is_dir($path);
+		} catch (\OCP\Files\StorageNotAvailableException $e) {
+			$this->setAvailability(false);
+			throw $e;
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function is_file($path) {
+		$this->checkAvailability();
+		try {
+			return parent::is_file($path);
+		} catch (\OCP\Files\StorageNotAvailableException $e) {
+			$this->setAvailability(false);
+			throw $e;
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function stat($path) {
+		$this->checkAvailability();
+		try {
+			return parent::stat($path);
+		} catch (\OCP\Files\StorageNotAvailableException $e) {
+			$this->setAvailability(false);
+			throw $e;
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function filetype($path) {
+		$this->checkAvailability();
+		try {
+			return parent::filetype($path);
+		} catch (\OCP\Files\StorageNotAvailableException $e) {
+			$this->setAvailability(false);
+			throw $e;
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function filesize($path) {
+		$this->checkAvailability();
+		try {
+			return parent::filesize($path);
+		} catch (\OCP\Files\StorageNotAvailableException $e) {
+			$this->setAvailability(false);
+			throw $e;
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function isCreatable($path) {
+		$this->checkAvailability();
+		try {
+			return parent::isCreatable($path);
+		} catch (\OCP\Files\StorageNotAvailableException $e) {
+			$this->setAvailability(false);
+			throw $e;
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function isReadable($path) {
+		$this->checkAvailability();
+		try {
+			return parent::isReadable($path);
+		} catch (\OCP\Files\StorageNotAvailableException $e) {
+			$this->setAvailability(false);
+			throw $e;
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function isUpdatable($path) {
+		$this->checkAvailability();
+		try {
+			return parent::isUpdatable($path);
+		} catch (\OCP\Files\StorageNotAvailableException $e) {
+			$this->setAvailability(false);
+			throw $e;
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function isDeletable($path) {
+		$this->checkAvailability();
+		try {
+			return parent::isDeletable($path);
+		} catch (\OCP\Files\StorageNotAvailableException $e) {
+			$this->setAvailability(false);
+			throw $e;
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function isSharable($path) {
+		$this->checkAvailability();
+		try {
+			return parent::isSharable($path);
+		} catch (\OCP\Files\StorageNotAvailableException $e) {
+			$this->setAvailability(false);
+			throw $e;
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function getPermissions($path) {
+		$this->checkAvailability();
+		try {
+			return parent::getPermissions($path);
+		} catch (\OCP\Files\StorageNotAvailableException $e) {
+			$this->setAvailability(false);
+			throw $e;
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function file_exists($path) {
+		if ($path === '') {
+			return true;
+		}
+		$this->checkAvailability();
+		try {
+			return parent::file_exists($path);
+		} catch (\OCP\Files\StorageNotAvailableException $e) {
+			$this->setAvailability(false);
+			throw $e;
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function filemtime($path) {
+		$this->checkAvailability();
+		try {
+			return parent::filemtime($path);
+		} catch (\OCP\Files\StorageNotAvailableException $e) {
+			$this->setAvailability(false);
+			throw $e;
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function file_get_contents($path) {
+		$this->checkAvailability();
+		try {
+			return parent::file_get_contents($path);
+		} catch (\OCP\Files\StorageNotAvailableException $e) {
+			$this->setAvailability(false);
+			throw $e;
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function file_put_contents($path, $data) {
+		$this->checkAvailability();
+		try {
+			return parent::file_put_contents($path, $data);
+		} catch (\OCP\Files\StorageNotAvailableException $e) {
+			$this->setAvailability(false);
+			throw $e;
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function unlink($path) {
+		$this->checkAvailability();
+		try {
+			return parent::unlink($path);
+		} catch (\OCP\Files\StorageNotAvailableException $e) {
+			$this->setAvailability(false);
+			throw $e;
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function rename($path1, $path2) {
+		$this->checkAvailability();
+		try {
+			return parent::rename($path1, $path2);
+		} catch (\OCP\Files\StorageNotAvailableException $e) {
+			$this->setAvailability(false);
+			throw $e;
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function copy($path1, $path2) {
+		$this->checkAvailability();
+		try {
+			return parent::copy($path1, $path2);
+		} catch (\OCP\Files\StorageNotAvailableException $e) {
+			$this->setAvailability(false);
+			throw $e;
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function fopen($path, $mode) {
+		$this->checkAvailability();
+		try {
+			return parent::fopen($path, $mode);
+		} catch (\OCP\Files\StorageNotAvailableException $e) {
+			$this->setAvailability(false);
+			throw $e;
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function getMimeType($path) {
+		$this->checkAvailability();
+		try {
+			return parent::getMimeType($path);
+		} catch (\OCP\Files\StorageNotAvailableException $e) {
+			$this->setAvailability(false);
+			throw $e;
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function hash($type, $path, $raw = false) {
+		$this->checkAvailability();
+		try {
+			return parent::hash($type, $path, $raw);
+		} catch (\OCP\Files\StorageNotAvailableException $e) {
+			$this->setAvailability(false);
+			throw $e;
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function free_space($path) {
+		$this->checkAvailability();
+		try {
+			return parent::free_space($path);
+		} catch (\OCP\Files\StorageNotAvailableException $e) {
+			$this->setAvailability(false);
+			throw $e;
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function search($query) {
+		$this->checkAvailability();
+		try {
+			return parent::search($query);
+		} catch (\OCP\Files\StorageNotAvailableException $e) {
+			$this->setAvailability(false);
+			throw $e;
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function touch($path, $mtime = null) {
+		$this->checkAvailability();
+		try {
+			return parent::touch($path, $mtime);
+		} catch (\OCP\Files\StorageNotAvailableException $e) {
+			$this->setAvailability(false);
+			throw $e;
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function getLocalFile($path) {
+		$this->checkAvailability();
+		try {
+			return parent::getLocalFile($path);
+		} catch (\OCP\Files\StorageNotAvailableException $e) {
+			$this->setAvailability(false);
+			throw $e;
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function hasUpdated($path, $time) {
+		$this->checkAvailability();
+		try {
+			return parent::hasUpdated($path, $time);
+		} catch (\OCP\Files\StorageNotAvailableException $e) {
+			$this->setAvailability(false);
+			throw $e;
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function getOwner($path) {
+		try {
+			return parent::getOwner($path);
+		} catch (\OCP\Files\StorageNotAvailableException $e) {
+			$this->setAvailability(false);
+			throw $e;
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function getETag($path) {
+		$this->checkAvailability();
+		try {
+			return parent::getETag($path);
+		} catch (\OCP\Files\StorageNotAvailableException $e) {
+			$this->setAvailability(false);
+			throw $e;
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function getDirectDownload($path) {
+		$this->checkAvailability();
+		try {
+			return parent::getDirectDownload($path);
+		} catch (\OCP\Files\StorageNotAvailableException $e) {
+			$this->setAvailability(false);
+			throw $e;
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function copyFromStorage(\OCP\Files\Storage $sourceStorage, $sourceInternalPath, $targetInternalPath) {
+		$this->checkAvailability();
+		try {
+			return parent::copyFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath);
+		} catch (\OCP\Files\StorageNotAvailableException $e) {
+			$this->setAvailability(false);
+			throw $e;
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function moveFromStorage(\OCP\Files\Storage $sourceStorage, $sourceInternalPath, $targetInternalPath) {
+		$this->checkAvailability();
+		try {
+			return parent::moveFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath);
+		} catch (\OCP\Files\StorageNotAvailableException $e) {
+			$this->setAvailability(false);
+			throw $e;
+		}
+	}
+
+	/** {@inheritdoc} */
+	public function getMetaData($path) {
+		$this->checkAvailability();
+		try {
+			return parent::getMetaData($path);
+		} catch (\OCP\Files\StorageNotAvailableException $e) {
+			$this->setAvailability(false);
+			throw $e;
+		}
+	}
+}
diff --git a/lib/private/Files/Storage/Wrapper/Encryption.php b/lib/private/Files/Storage/Wrapper/Encryption.php
new file mode 100644
index 00000000000..02da978a700
--- /dev/null
+++ b/lib/private/Files/Storage/Wrapper/Encryption.php
@@ -0,0 +1,993 @@
+<?php
+/**
+ * @author Björn Schießle <schiessle@owncloud.com>
+ * @author Joas Schilling <nickvergessen@owncloud.com>
+ * @author Lukas Reschke <lukas@owncloud.com>
+ * @author Robin Appelman <icewind@owncloud.com>
+ * @author Thomas Müller <thomas.mueller@tmit.eu>
+ * @author Vincent Petry <pvince81@owncloud.com>
+ *
+ * @copyright Copyright (c) 2016, ownCloud, Inc.
+ * @license AGPL-3.0
+ *
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License, version 3,
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>
+ *
+ */
+
+namespace OC\Files\Storage\Wrapper;
+
+use OC\Encryption\Exceptions\ModuleDoesNotExistsException;
+use OC\Encryption\Update;
+use OC\Encryption\Util;
+use OC\Files\Cache\CacheEntry;
+use OC\Files\Filesystem;
+use OC\Files\Mount\Manager;
+use OC\Files\Storage\LocalTempFileTrait;
+use OC\Memcache\ArrayCache;
+use OCP\Encryption\Exceptions\GenericEncryptionException;
+use OCP\Encryption\IFile;
+use OCP\Encryption\IManager;
+use OCP\Encryption\Keys\IStorage;
+use OCP\Files\Mount\IMountPoint;
+use OCP\Files\Storage;
+use OCP\ILogger;
+use OCP\Files\Cache\ICacheEntry;
+
+class Encryption extends Wrapper {
+
+	use LocalTempFileTrait;
+
+	/** @var string */
+	private $mountPoint;
+
+	/** @var \OC\Encryption\Util */
+	private $util;
+
+	/** @var \OCP\Encryption\IManager */
+	private $encryptionManager;
+
+	/** @var \OCP\ILogger */
+	private $logger;
+
+	/** @var string */
+	private $uid;
+
+	/** @var array */
+	protected $unencryptedSize;
+
+	/** @var \OCP\Encryption\IFile */
+	private $fileHelper;
+
+	/** @var IMountPoint */
+	private $mount;
+
+	/** @var IStorage */
+	private $keyStorage;
+
+	/** @var Update */
+	private $update;
+
+	/** @var Manager */
+	private $mountManager;
+
+	/** @var array remember for which path we execute the repair step to avoid recursions */
+	private $fixUnencryptedSizeOf = array();
+
+	/** @var  ArrayCache */
+	private $arrayCache;
+
+	/**
+	 * @param array $parameters
+	 * @param IManager $encryptionManager
+	 * @param Util $util
+	 * @param ILogger $logger
+	 * @param IFile $fileHelper
+	 * @param string $uid
+	 * @param IStorage $keyStorage
+	 * @param Update $update
+	 * @param Manager $mountManager
+	 * @param ArrayCache $arrayCache
+	 */
+	public function __construct(
+			$parameters,
+			IManager $encryptionManager = null,
+			Util $util = null,
+			ILogger $logger = null,
+			IFile $fileHelper = null,
+			$uid = null,
+			IStorage $keyStorage = null,
+			Update $update = null,
+			Manager $mountManager = null,
+			ArrayCache $arrayCache = null
+		) {
+
+		$this->mountPoint = $parameters['mountPoint'];
+		$this->mount = $parameters['mount'];
+		$this->encryptionManager = $encryptionManager;
+		$this->util = $util;
+		$this->logger = $logger;
+		$this->uid = $uid;
+		$this->fileHelper = $fileHelper;
+		$this->keyStorage = $keyStorage;
+		$this->unencryptedSize = array();
+		$this->update = $update;
+		$this->mountManager = $mountManager;
+		$this->arrayCache = $arrayCache;
+		parent::__construct($parameters);
+	}
+
+	/**
+	 * 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) {
+		$fullPath = $this->getFullPath($path);
+
+		/** @var CacheEntry $info */
+		$info = $this->getCache()->get($path);
+		if (isset($this->unencryptedSize[$fullPath])) {
+			$size = $this->unencryptedSize[$fullPath];
+			// update file cache
+			if ($info instanceof ICacheEntry) {
+				$info = $info->getData();
+				$info['encrypted'] = $info['encryptedVersion'];
+			} else {
+				if (!is_array($info)) {
+					$info = [];
+				}
+				$info['encrypted'] = true;
+			}
+
+			$info['size'] = $size;
+			$this->getCache()->put($path, $info);
+
+			return $size;
+		}
+
+		if (isset($info['fileid']) && $info['encrypted']) {
+			return $this->verifyUnencryptedSize($path, $info['size']);
+		}
+
+		return $this->storage->filesize($path);
+	}
+
+	/**
+	 * @param string $path
+	 * @return array
+	 */
+	public function getMetaData($path) {
+		$data = $this->storage->getMetaData($path);
+		if (is_null($data)) {
+			return null;
+		}
+		$fullPath = $this->getFullPath($path);
+		$info = $this->getCache()->get($path);
+
+		if (isset($this->unencryptedSize[$fullPath])) {
+			$data['encrypted'] = true;
+			$data['size'] = $this->unencryptedSize[$fullPath];
+		} else {
+			if (isset($info['fileid']) && $info['encrypted']) {
+				$data['size'] = $this->verifyUnencryptedSize($path, $info['size']);
+				$data['encrypted'] = true;
+			}
+		}
+
+		if (isset($info['encryptedVersion']) && $info['encryptedVersion'] > 1) {
+			$data['encryptedVersion'] = $info['encryptedVersion'];
+		}
+
+		return $data;
+	}
+
+	/**
+	 * see http://php.net/manual/en/function.file_get_contents.php
+	 *
+	 * @param string $path
+	 * @return string
+	 */
+	public function file_get_contents($path) {
+
+		$encryptionModule = $this->getEncryptionModule($path);
+
+		if ($encryptionModule) {
+			$handle = $this->fopen($path, "r");
+			if (!$handle) {
+				return false;
+			}
+			$data = stream_get_contents($handle);
+			fclose($handle);
+			return $data;
+		}
+		return $this->storage->file_get_contents($path);
+	}
+
+	/**
+	 * 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) {
+		// file put content will always be translated to a stream write
+		$handle = $this->fopen($path, 'w');
+		if (is_resource($handle)) {
+			$written = fwrite($handle, $data);
+			fclose($handle);
+			return $written;
+		}
+
+		return false;
+	}
+
+	/**
+	 * see http://php.net/manual/en/function.unlink.php
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function unlink($path) {
+		$fullPath = $this->getFullPath($path);
+		if ($this->util->isExcluded($fullPath)) {
+			return $this->storage->unlink($path);
+		}
+
+		$encryptionModule = $this->getEncryptionModule($path);
+		if ($encryptionModule) {
+			$this->keyStorage->deleteAllFileKeys($this->getFullPath($path));
+		}
+
+		return $this->storage->unlink($path);
+	}
+
+	/**
+	 * see http://php.net/manual/en/function.rename.php
+	 *
+	 * @param string $path1
+	 * @param string $path2
+	 * @return bool
+	 */
+	public function rename($path1, $path2) {
+
+		$result = $this->storage->rename($path1, $path2);
+
+		if ($result &&
+			// versions always use the keys from the original file, so we can skip
+			// this step for versions
+			$this->isVersion($path2) === false &&
+			$this->encryptionManager->isEnabled()) {
+			$source = $this->getFullPath($path1);
+			if (!$this->util->isExcluded($source)) {
+				$target = $this->getFullPath($path2);
+				if (isset($this->unencryptedSize[$source])) {
+					$this->unencryptedSize[$target] = $this->unencryptedSize[$source];
+				}
+				$this->keyStorage->renameKeys($source, $target);
+				$module = $this->getEncryptionModule($path2);
+				if ($module) {
+					$module->update($target, $this->uid, []);
+				}
+			}
+		}
+
+		return $result;
+	}
+
+	/**
+	 * see http://php.net/manual/en/function.rmdir.php
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function rmdir($path) {
+		$result = $this->storage->rmdir($path);
+		$fullPath = $this->getFullPath($path);
+		if ($result &&
+			$this->util->isExcluded($fullPath) === false &&
+			$this->encryptionManager->isEnabled()
+		) {
+			$this->keyStorage->deleteAllFileKeys($fullPath);
+		}
+
+		return $result;
+	}
+
+	/**
+	 * check if a file can be read
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function isReadable($path) {
+
+		$isReadable = true;
+
+		$metaData = $this->getMetaData($path);
+		if (
+			!$this->is_dir($path) &&
+			isset($metaData['encrypted']) &&
+			$metaData['encrypted'] === true
+		) {
+			$fullPath = $this->getFullPath($path);
+			$module = $this->getEncryptionModule($path);
+			$isReadable = $module->isReadable($fullPath, $this->uid);
+		}
+
+		return $this->storage->isReadable($path) && $isReadable;
+	}
+
+	/**
+	 * see http://php.net/manual/en/function.copy.php
+	 *
+	 * @param string $path1
+	 * @param string $path2
+	 * @return bool
+	 */
+	public function copy($path1, $path2) {
+
+		$source = $this->getFullPath($path1);
+
+		if ($this->util->isExcluded($source)) {
+			return $this->storage->copy($path1, $path2);
+		}
+
+		// need to stream copy file by file in case we copy between a encrypted
+		// and a unencrypted storage
+		$this->unlink($path2);
+		$result = $this->copyFromStorage($this, $path1, $path2);
+
+		return $result;
+	}
+
+	/**
+	 * see http://php.net/manual/en/function.fopen.php
+	 *
+	 * @param string $path
+	 * @param string $mode
+	 * @return resource|bool
+	 * @throws GenericEncryptionException
+	 * @throws ModuleDoesNotExistsException
+	 */
+	public function fopen($path, $mode) {
+
+		// check if the file is stored in the array cache, this means that we
+		// copy a file over to the versions folder, in this case we don't want to
+		// decrypt it
+		if ($this->arrayCache->hasKey('encryption_copy_version_' . $path)) {
+			$this->arrayCache->remove('encryption_copy_version_' . $path);
+			return $this->storage->fopen($path, $mode);
+		}
+
+		$encryptionEnabled = $this->encryptionManager->isEnabled();
+		$shouldEncrypt = false;
+		$encryptionModule = null;
+		$header = $this->getHeader($path);
+		$signed = (isset($header['signed']) && $header['signed'] === 'true') ? true : false;
+		$fullPath = $this->getFullPath($path);
+		$encryptionModuleId = $this->util->getEncryptionModuleId($header);
+
+		if ($this->util->isExcluded($fullPath) === false) {
+
+			$size = $unencryptedSize = 0;
+			$realFile = $this->util->stripPartialFileExtension($path);
+			$targetExists = $this->file_exists($realFile) || $this->file_exists($path);
+			$targetIsEncrypted = false;
+			if ($targetExists) {
+				// in case the file exists we require the explicit module as
+				// specified in the file header - otherwise we need to fail hard to
+				// prevent data loss on client side
+				if (!empty($encryptionModuleId)) {
+					$targetIsEncrypted = true;
+					$encryptionModule = $this->encryptionManager->getEncryptionModule($encryptionModuleId);
+				}
+
+				if ($this->file_exists($path)) {
+					$size = $this->storage->filesize($path);
+					$unencryptedSize = $this->filesize($path);
+				} else {
+					$size = $unencryptedSize = 0;
+				}
+			}
+
+			try {
+
+				if (
+					$mode === 'w'
+					|| $mode === 'w+'
+					|| $mode === 'wb'
+					|| $mode === 'wb+'
+				) {
+					// don't overwrite encrypted files if encryption is not enabled
+					if ($targetIsEncrypted && $encryptionEnabled === false) {
+						throw new GenericEncryptionException('Tried to access encrypted file but encryption is not enabled');
+					}
+					if ($encryptionEnabled) {
+						// if $encryptionModuleId is empty, the default module will be used
+						$encryptionModule = $this->encryptionManager->getEncryptionModule($encryptionModuleId);
+						$shouldEncrypt = $encryptionModule->shouldEncrypt($fullPath);
+						$signed = true;
+					}
+				} else {
+					$info = $this->getCache()->get($path);
+					// only get encryption module if we found one in the header
+					// or if file should be encrypted according to the file cache
+					if (!empty($encryptionModuleId)) {
+						$encryptionModule = $this->encryptionManager->getEncryptionModule($encryptionModuleId);
+						$shouldEncrypt = true;
+					} else if (empty($encryptionModuleId) && $info['encrypted'] === true) {
+						// we come from a old installation. No header and/or no module defined
+						// but the file is encrypted. In this case we need to use the
+						// OC_DEFAULT_MODULE to read the file
+						$encryptionModule = $this->encryptionManager->getEncryptionModule('OC_DEFAULT_MODULE');
+						$shouldEncrypt = true;
+						$targetIsEncrypted = true;
+					}
+				}
+			} catch (ModuleDoesNotExistsException $e) {
+				$this->logger->warning('Encryption module "' . $encryptionModuleId .
+					'" not found, file will be stored unencrypted (' . $e->getMessage() . ')');
+			}
+
+			// encryption disabled on write of new file and write to existing unencrypted file -> don't encrypt
+			if (!$encryptionEnabled || !$this->mount->getOption('encrypt', true)) {
+				if (!$targetExists || !$targetIsEncrypted) {
+					$shouldEncrypt = false;
+				}
+			}
+
+			if ($shouldEncrypt === true && $encryptionModule !== null) {
+				$headerSize = $this->getHeaderSize($path);
+				$source = $this->storage->fopen($path, $mode);
+				if (!is_resource($source)) {
+					return false;
+				}
+				$handle = \OC\Files\Stream\Encryption::wrap($source, $path, $fullPath, $header,
+					$this->uid, $encryptionModule, $this->storage, $this, $this->util, $this->fileHelper, $mode,
+					$size, $unencryptedSize, $headerSize, $signed);
+				return $handle;
+			}
+
+		}
+
+		return $this->storage->fopen($path, $mode);
+	}
+
+
+	/**
+	 * perform some plausibility checks if the the unencrypted size is correct.
+	 * If not, we calculate the correct unencrypted size and return it
+	 *
+	 * @param string $path internal path relative to the storage root
+	 * @param int $unencryptedSize size of the unencrypted file
+	 *
+	 * @return int unencrypted size
+	 */
+	protected function verifyUnencryptedSize($path, $unencryptedSize) {
+
+		$size = $this->storage->filesize($path);
+		$result = $unencryptedSize;
+
+		if ($unencryptedSize < 0 ||
+			($size > 0 && $unencryptedSize === $size)
+		) {
+			// check if we already calculate the unencrypted size for the
+			// given path to avoid recursions
+			if (isset($this->fixUnencryptedSizeOf[$this->getFullPath($path)]) === false) {
+				$this->fixUnencryptedSizeOf[$this->getFullPath($path)] = true;
+				try {
+					$result = $this->fixUnencryptedSize($path, $size, $unencryptedSize);
+				} catch (\Exception $e) {
+					$this->logger->error('Couldn\'t re-calculate unencrypted size for '. $path);
+					$this->logger->logException($e);
+				}
+				unset($this->fixUnencryptedSizeOf[$this->getFullPath($path)]);
+			}
+		}
+
+		return $result;
+	}
+
+	/**
+	 * calculate the unencrypted size
+	 *
+	 * @param string $path internal path relative to the storage root
+	 * @param int $size size of the physical file
+	 * @param int $unencryptedSize size of the unencrypted file
+	 *
+	 * @return int calculated unencrypted size
+	 */
+	protected function fixUnencryptedSize($path, $size, $unencryptedSize) {
+
+		$headerSize = $this->getHeaderSize($path);
+		$header = $this->getHeader($path);
+		$encryptionModule = $this->getEncryptionModule($path);
+
+		$stream = $this->storage->fopen($path, 'r');
+
+		// if we couldn't open the file we return the old unencrypted size
+		if (!is_resource($stream)) {
+			$this->logger->error('Could not open ' . $path . '. Recalculation of unencrypted size aborted.');
+			return $unencryptedSize;
+		}
+
+		$newUnencryptedSize = 0;
+		$size -= $headerSize;
+		$blockSize = $this->util->getBlockSize();
+
+		// if a header exists we skip it
+		if ($headerSize > 0) {
+			fread($stream, $headerSize);
+		}
+
+		// fast path, else the calculation for $lastChunkNr is bogus
+		if ($size === 0) {
+			return 0;
+		}
+
+		$signed = (isset($header['signed']) && $header['signed'] === 'true') ? true : false;
+		$unencryptedBlockSize = $encryptionModule->getUnencryptedBlockSize($signed);
+
+		// calculate last chunk nr
+		// next highest is end of chunks, one subtracted is last one
+		// we have to read the last chunk, we can't just calculate it (because of padding etc)
+
+		$lastChunkNr = ceil($size/ $blockSize)-1;
+		// calculate last chunk position
+		$lastChunkPos = ($lastChunkNr * $blockSize);
+		// try to fseek to the last chunk, if it fails we have to read the whole file
+		if (@fseek($stream, $lastChunkPos, SEEK_CUR) === 0) {
+			$newUnencryptedSize += $lastChunkNr * $unencryptedBlockSize;
+		}
+
+		$lastChunkContentEncrypted='';
+		$count = $blockSize;
+
+		while ($count > 0) {
+			$data=fread($stream, $blockSize);
+			$count=strlen($data);
+			$lastChunkContentEncrypted .= $data;
+			if(strlen($lastChunkContentEncrypted) > $blockSize) {
+				$newUnencryptedSize += $unencryptedBlockSize;
+				$lastChunkContentEncrypted=substr($lastChunkContentEncrypted, $blockSize);
+			}
+		}
+
+		fclose($stream);
+
+		// we have to decrypt the last chunk to get it actual size
+		$encryptionModule->begin($this->getFullPath($path), $this->uid, 'r', $header, []);
+		$decryptedLastChunk = $encryptionModule->decrypt($lastChunkContentEncrypted, $lastChunkNr . 'end');
+		$decryptedLastChunk .= $encryptionModule->end($this->getFullPath($path), $lastChunkNr . 'end');
+
+		// calc the real file size with the size of the last chunk
+		$newUnencryptedSize += strlen($decryptedLastChunk);
+
+		$this->updateUnencryptedSize($this->getFullPath($path), $newUnencryptedSize);
+
+		// write to cache if applicable
+		$cache = $this->storage->getCache();
+		if ($cache) {
+			$entry = $cache->get($path);
+			$cache->update($entry['fileid'], ['size' => $newUnencryptedSize]);
+		}
+
+		return $newUnencryptedSize;
+	}
+
+	/**
+	 * @param Storage $sourceStorage
+	 * @param string $sourceInternalPath
+	 * @param string $targetInternalPath
+	 * @param bool $preserveMtime
+	 * @return bool
+	 */
+	public function moveFromStorage(Storage $sourceStorage, $sourceInternalPath, $targetInternalPath, $preserveMtime = true) {
+		if ($sourceStorage === $this) {
+			return $this->rename($sourceInternalPath, $targetInternalPath);
+		}
+
+		// TODO clean this up once the underlying moveFromStorage in OC\Files\Storage\Wrapper\Common is fixed:
+		// - call $this->storage->moveFromStorage() instead of $this->copyBetweenStorage
+		// - copy the file cache update from  $this->copyBetweenStorage to this method
+		// - copy the copyKeys() call from  $this->copyBetweenStorage to this method
+		// - remove $this->copyBetweenStorage
+
+		if (!$sourceStorage->isDeletable($sourceInternalPath)) {
+			return false;
+		}
+
+		$result = $this->copyBetweenStorage($sourceStorage, $sourceInternalPath, $targetInternalPath, $preserveMtime, true);
+		if ($result) {
+			if ($sourceStorage->is_dir($sourceInternalPath)) {
+				$result &= $sourceStorage->rmdir($sourceInternalPath);
+			} else {
+				$result &= $sourceStorage->unlink($sourceInternalPath);
+			}
+		}
+		return $result;
+	}
+
+
+	/**
+	 * @param Storage $sourceStorage
+	 * @param string $sourceInternalPath
+	 * @param string $targetInternalPath
+	 * @param bool $preserveMtime
+	 * @param bool $isRename
+	 * @return bool
+	 */
+	public function copyFromStorage(Storage $sourceStorage, $sourceInternalPath, $targetInternalPath, $preserveMtime = false, $isRename = false) {
+
+		// TODO clean this up once the underlying moveFromStorage in OC\Files\Storage\Wrapper\Common is fixed:
+		// - call $this->storage->copyFromStorage() instead of $this->copyBetweenStorage
+		// - copy the file cache update from  $this->copyBetweenStorage to this method
+		// - copy the copyKeys() call from  $this->copyBetweenStorage to this method
+		// - remove $this->copyBetweenStorage
+
+		return $this->copyBetweenStorage($sourceStorage, $sourceInternalPath, $targetInternalPath, $preserveMtime, $isRename);
+	}
+
+	/**
+	 * Update the encrypted cache version in the database
+	 *
+	 * @param Storage $sourceStorage
+	 * @param string $sourceInternalPath
+	 * @param string $targetInternalPath
+	 * @param bool $isRename
+	 */
+	private function updateEncryptedVersion(Storage $sourceStorage, $sourceInternalPath, $targetInternalPath, $isRename) {
+		$isEncrypted = $this->encryptionManager->isEnabled() && $this->mount->getOption('encrypt', true) ? 1 : 0;
+		$cacheInformation = [
+			'encrypted' => (bool)$isEncrypted,
+		];
+		if($isEncrypted === 1) {
+			$encryptedVersion = $sourceStorage->getCache()->get($sourceInternalPath)['encryptedVersion'];
+
+			// In case of a move operation from an unencrypted to an encrypted
+			// storage the old encrypted version would stay with "0" while the
+			// correct value would be "1". Thus we manually set the value to "1"
+			// for those cases.
+			// See also https://github.com/owncloud/core/issues/23078
+			if($encryptedVersion === 0) {
+				$encryptedVersion = 1;
+			}
+
+			$cacheInformation['encryptedVersion'] = $encryptedVersion;
+		}
+
+		// in case of a rename we need to manipulate the source cache because
+		// this information will be kept for the new target
+		if ($isRename) {
+			$sourceStorage->getCache()->put($sourceInternalPath, $cacheInformation);
+		} else {
+			$this->getCache()->put($targetInternalPath, $cacheInformation);
+		}
+	}
+
+	/**
+	 * copy file between two storages
+	 *
+	 * @param Storage $sourceStorage
+	 * @param string $sourceInternalPath
+	 * @param string $targetInternalPath
+	 * @param bool $preserveMtime
+	 * @param bool $isRename
+	 * @return bool
+	 * @throws \Exception
+	 */
+	private function copyBetweenStorage(Storage $sourceStorage, $sourceInternalPath, $targetInternalPath, $preserveMtime, $isRename) {
+
+		// for versions we have nothing to do, because versions should always use the
+		// key from the original file. Just create a 1:1 copy and done
+		if ($this->isVersion($targetInternalPath) ||
+			$this->isVersion($sourceInternalPath)) {
+			// remember that we try to create a version so that we can detect it during
+			// fopen($sourceInternalPath) and by-pass the encryption in order to
+			// create a 1:1 copy of the file
+			$this->arrayCache->set('encryption_copy_version_' . $sourceInternalPath, true);
+			$result = $this->storage->copyFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath);
+			$this->arrayCache->remove('encryption_copy_version_' . $sourceInternalPath);
+			if ($result) {
+				$info = $this->getCache('', $sourceStorage)->get($sourceInternalPath);
+				// make sure that we update the unencrypted size for the version
+				if (isset($info['encrypted']) && $info['encrypted'] === true) {
+					$this->updateUnencryptedSize(
+						$this->getFullPath($targetInternalPath),
+						$info['size']
+					);
+				}
+				$this->updateEncryptedVersion($sourceStorage, $sourceInternalPath, $targetInternalPath, $isRename);
+			}
+			return $result;
+		}
+
+		// first copy the keys that we reuse the existing file key on the target location
+		// and don't create a new one which would break versions for example.
+		$mount = $this->mountManager->findByStorageId($sourceStorage->getId());
+		if (count($mount) === 1) {
+			$mountPoint = $mount[0]->getMountPoint();
+			$source = $mountPoint . '/' . $sourceInternalPath;
+			$target = $this->getFullPath($targetInternalPath);
+			$this->copyKeys($source, $target);
+		} else {
+			$this->logger->error('Could not find mount point, can\'t keep encryption keys');
+		}
+
+		if ($sourceStorage->is_dir($sourceInternalPath)) {
+			$dh = $sourceStorage->opendir($sourceInternalPath);
+			$result = $this->mkdir($targetInternalPath);
+			if (is_resource($dh)) {
+				while ($result and ($file = readdir($dh)) !== false) {
+					if (!Filesystem::isIgnoredDir($file)) {
+						$result &= $this->copyFromStorage($sourceStorage, $sourceInternalPath . '/' . $file, $targetInternalPath . '/' . $file, false, $isRename);
+					}
+				}
+			}
+		} else {
+			try {
+				$source = $sourceStorage->fopen($sourceInternalPath, 'r');
+				$target = $this->fopen($targetInternalPath, 'w');
+				list(, $result) = \OC_Helper::streamCopy($source, $target);
+				fclose($source);
+				fclose($target);
+			} catch (\Exception $e) {
+				fclose($source);
+				fclose($target);
+				throw $e;
+			}
+			if($result) {
+				if ($preserveMtime) {
+					$this->touch($targetInternalPath, $sourceStorage->filemtime($sourceInternalPath));
+				}
+				$this->updateEncryptedVersion($sourceStorage, $sourceInternalPath, $targetInternalPath, $isRename);
+			} else {
+				// delete partially written target file
+				$this->unlink($targetInternalPath);
+				// delete cache entry that was created by fopen
+				$this->getCache()->remove($targetInternalPath);
+			}
+		}
+		return (bool)$result;
+
+	}
+
+	/**
+	 * 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) {
+		if ($this->encryptionManager->isEnabled()) {
+			$cachedFile = $this->getCachedFile($path);
+			if (is_string($cachedFile)) {
+				return $cachedFile;
+			}
+		}
+		return $this->storage->getLocalFile($path);
+	}
+
+	/**
+	 * Returns the wrapped storage's value for isLocal()
+	 *
+	 * @return bool wrapped storage's isLocal() value
+	 */
+	public function isLocal() {
+		if ($this->encryptionManager->isEnabled()) {
+			return false;
+		}
+		return $this->storage->isLocal();
+	}
+
+	/**
+	 * 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) {
+		$stat = $this->storage->stat($path);
+		$fileSize = $this->filesize($path);
+		$stat['size'] = $fileSize;
+		$stat[7] = $fileSize;
+		return $stat;
+	}
+
+	/**
+	 * 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) {
+		$fh = $this->fopen($path, 'rb');
+		$ctx = hash_init($type);
+		hash_update_stream($ctx, $fh);
+		fclose($fh);
+		return hash_final($ctx, $raw);
+	}
+
+	/**
+	 * return full path, including mount point
+	 *
+	 * @param string $path relative to mount point
+	 * @return string full path including mount point
+	 */
+	protected function getFullPath($path) {
+		return Filesystem::normalizePath($this->mountPoint . '/' . $path);
+	}
+
+	/**
+	 * read first block of encrypted file, typically this will contain the
+	 * encryption header
+	 *
+	 * @param string $path
+	 * @return string
+	 */
+	protected function readFirstBlock($path) {
+		$firstBlock = '';
+		if ($this->storage->file_exists($path)) {
+			$handle = $this->storage->fopen($path, 'r');
+			$firstBlock = fread($handle, $this->util->getHeaderSize());
+			fclose($handle);
+		}
+		return $firstBlock;
+	}
+
+	/**
+	 * return header size of given file
+	 *
+	 * @param string $path
+	 * @return int
+	 */
+	protected function getHeaderSize($path) {
+		$headerSize = 0;
+		$realFile = $this->util->stripPartialFileExtension($path);
+		if ($this->storage->file_exists($realFile)) {
+			$path = $realFile;
+		}
+		$firstBlock = $this->readFirstBlock($path);
+
+		if (substr($firstBlock, 0, strlen(Util::HEADER_START)) === Util::HEADER_START) {
+			$headerSize = $this->util->getHeaderSize();
+		}
+
+		return $headerSize;
+	}
+
+	/**
+	 * parse raw header to array
+	 *
+	 * @param string $rawHeader
+	 * @return array
+	 */
+	protected function parseRawHeader($rawHeader) {
+		$result = array();
+		if (substr($rawHeader, 0, strlen(Util::HEADER_START)) === Util::HEADER_START) {
+			$header = $rawHeader;
+			$endAt = strpos($header, Util::HEADER_END);
+			if ($endAt !== false) {
+				$header = substr($header, 0, $endAt + strlen(Util::HEADER_END));
+
+				// +1 to not start with an ':' which would result in empty element at the beginning
+				$exploded = explode(':', substr($header, strlen(Util::HEADER_START)+1));
+
+				$element = array_shift($exploded);
+				while ($element !== Util::HEADER_END) {
+					$result[$element] = array_shift($exploded);
+					$element = array_shift($exploded);
+				}
+			}
+		}
+
+		return $result;
+	}
+
+	/**
+	 * read header from file
+	 *
+	 * @param string $path
+	 * @return array
+	 */
+	protected function getHeader($path) {
+		$realFile = $this->util->stripPartialFileExtension($path);
+		if ($this->storage->file_exists($realFile)) {
+			$path = $realFile;
+		}
+
+		$firstBlock = $this->readFirstBlock($path);
+		$result = $this->parseRawHeader($firstBlock);
+
+		// if the header doesn't contain a encryption module we check if it is a
+		// legacy file. If true, we add the default encryption module
+		if (!isset($result[Util::HEADER_ENCRYPTION_MODULE_KEY])) {
+			if (!empty($result)) {
+				$result[Util::HEADER_ENCRYPTION_MODULE_KEY] = 'OC_DEFAULT_MODULE';
+			} else {
+				// if the header was empty we have to check first if it is a encrypted file at all
+				$info = $this->getCache()->get($path);
+				if (isset($info['encrypted']) && $info['encrypted'] === true) {
+					$result[Util::HEADER_ENCRYPTION_MODULE_KEY] = 'OC_DEFAULT_MODULE';
+				}
+			}
+		}
+
+		return $result;
+	}
+
+	/**
+	 * read encryption module needed to read/write the file located at $path
+	 *
+	 * @param string $path
+	 * @return null|\OCP\Encryption\IEncryptionModule
+	 * @throws ModuleDoesNotExistsException
+	 * @throws \Exception
+	 */
+	protected function getEncryptionModule($path) {
+		$encryptionModule = null;
+		$header = $this->getHeader($path);
+		$encryptionModuleId = $this->util->getEncryptionModuleId($header);
+		if (!empty($encryptionModuleId)) {
+			try {
+				$encryptionModule = $this->encryptionManager->getEncryptionModule($encryptionModuleId);
+			} catch (ModuleDoesNotExistsException $e) {
+				$this->logger->critical('Encryption module defined in "' . $path . '" not loaded!');
+				throw $e;
+			}
+		}
+		return $encryptionModule;
+	}
+
+	/**
+	 * @param string $path
+	 * @param int $unencryptedSize
+	 */
+	public function updateUnencryptedSize($path, $unencryptedSize) {
+		$this->unencryptedSize[$path] = $unencryptedSize;
+	}
+
+	/**
+	 * copy keys to new location
+	 *
+	 * @param string $source path relative to data/
+	 * @param string $target path relative to data/
+	 * @return bool
+	 */
+	protected function copyKeys($source, $target) {
+		if (!$this->util->isExcluded($source)) {
+			return $this->keyStorage->copyKeys($source, $target);
+		}
+
+		return false;
+	}
+
+	/**
+	 * check if path points to a files version
+	 *
+	 * @param $path
+	 * @return bool
+	 */
+	protected function isVersion($path) {
+		$normalized = Filesystem::normalizePath($path);
+		return substr($normalized, 0, strlen('/files_versions/')) === '/files_versions/';
+	}
+
+}
diff --git a/lib/private/Files/Storage/Wrapper/Jail.php b/lib/private/Files/Storage/Wrapper/Jail.php
new file mode 100644
index 00000000000..e8063f670c5
--- /dev/null
+++ b/lib/private/Files/Storage/Wrapper/Jail.php
@@ -0,0 +1,489 @@
+<?php
+/**
+ * @author Morris Jobke <hey@morrisjobke.de>
+ * @author Robin Appelman <icewind@owncloud.com>
+ *
+ * @copyright Copyright (c) 2016, ownCloud, Inc.
+ * @license AGPL-3.0
+ *
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License, version 3,
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>
+ *
+ */
+
+namespace OC\Files\Storage\Wrapper;
+
+use OC\Files\Cache\Wrapper\CacheJail;
+use OCP\Lock\ILockingProvider;
+
+/**
+ * Jail to a subdirectory of the wrapped storage
+ *
+ * This restricts access to a subfolder of the wrapped storage with the subfolder becoming the root folder new storage
+ */
+class Jail extends Wrapper {
+	/**
+	 * @var string
+	 */
+	protected $rootPath;
+
+	/**
+	 * @param array $arguments ['storage' => $storage, 'mask' => $root]
+	 *
+	 * $storage: The storage that will be wrapper
+	 * $root: The folder in the wrapped storage that will become the root folder of the wrapped storage
+	 */
+	public function __construct($arguments) {
+		parent::__construct($arguments);
+		$this->rootPath = $arguments['root'];
+	}
+
+	public function getSourcePath($path) {
+		if ($path === '') {
+			return $this->rootPath;
+		} else {
+			return $this->rootPath . '/' . $path;
+		}
+	}
+
+	public function getId() {
+		return 'link:' . parent::getId() . ':' . $this->rootPath;
+	}
+
+	/**
+	 * see http://php.net/manual/en/function.mkdir.php
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function mkdir($path) {
+		return $this->storage->mkdir($this->getSourcePath($path));
+	}
+
+	/**
+	 * see http://php.net/manual/en/function.rmdir.php
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function rmdir($path) {
+		return $this->storage->rmdir($this->getSourcePath($path));
+	}
+
+	/**
+	 * see http://php.net/manual/en/function.opendir.php
+	 *
+	 * @param string $path
+	 * @return resource
+	 */
+	public function opendir($path) {
+		return $this->storage->opendir($this->getSourcePath($path));
+	}
+
+	/**
+	 * see http://php.net/manual/en/function.is_dir.php
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function is_dir($path) {
+		return $this->storage->is_dir($this->getSourcePath($path));
+	}
+
+	/**
+	 * see http://php.net/manual/en/function.is_file.php
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function is_file($path) {
+		return $this->storage->is_file($this->getSourcePath($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) {
+		return $this->storage->stat($this->getSourcePath($path));
+	}
+
+	/**
+	 * see http://php.net/manual/en/function.filetype.php
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function filetype($path) {
+		return $this->storage->filetype($this->getSourcePath($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) {
+		return $this->storage->filesize($this->getSourcePath($path));
+	}
+
+	/**
+	 * check if a file can be created in $path
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function isCreatable($path) {
+		return $this->storage->isCreatable($this->getSourcePath($path));
+	}
+
+	/**
+	 * check if a file can be read
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function isReadable($path) {
+		return $this->storage->isReadable($this->getSourcePath($path));
+	}
+
+	/**
+	 * check if a file can be written to
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function isUpdatable($path) {
+		return $this->storage->isUpdatable($this->getSourcePath($path));
+	}
+
+	/**
+	 * check if a file can be deleted
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function isDeletable($path) {
+		return $this->storage->isDeletable($this->getSourcePath($path));
+	}
+
+	/**
+	 * check if a file can be shared
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function isSharable($path) {
+		return $this->storage->isSharable($this->getSourcePath($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) {
+		return $this->storage->getPermissions($this->getSourcePath($path));
+	}
+
+	/**
+	 * see http://php.net/manual/en/function.file_exists.php
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function file_exists($path) {
+		return $this->storage->file_exists($this->getSourcePath($path));
+	}
+
+	/**
+	 * see http://php.net/manual/en/function.filemtime.php
+	 *
+	 * @param string $path
+	 * @return int
+	 */
+	public function filemtime($path) {
+		return $this->storage->filemtime($this->getSourcePath($path));
+	}
+
+	/**
+	 * see http://php.net/manual/en/function.file_get_contents.php
+	 *
+	 * @param string $path
+	 * @return string
+	 */
+	public function file_get_contents($path) {
+		return $this->storage->file_get_contents($this->getSourcePath($path));
+	}
+
+	/**
+	 * 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) {
+		return $this->storage->file_put_contents($this->getSourcePath($path), $data);
+	}
+
+	/**
+	 * see http://php.net/manual/en/function.unlink.php
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function unlink($path) {
+		return $this->storage->unlink($this->getSourcePath($path));
+	}
+
+	/**
+	 * see http://php.net/manual/en/function.rename.php
+	 *
+	 * @param string $path1
+	 * @param string $path2
+	 * @return bool
+	 */
+	public function rename($path1, $path2) {
+		return $this->storage->rename($this->getSourcePath($path1), $this->getSourcePath($path2));
+	}
+
+	/**
+	 * see http://php.net/manual/en/function.copy.php
+	 *
+	 * @param string $path1
+	 * @param string $path2
+	 * @return bool
+	 */
+	public function copy($path1, $path2) {
+		return $this->storage->copy($this->getSourcePath($path1), $this->getSourcePath($path2));
+	}
+
+	/**
+	 * see http://php.net/manual/en/function.fopen.php
+	 *
+	 * @param string $path
+	 * @param string $mode
+	 * @return resource
+	 */
+	public function fopen($path, $mode) {
+		return $this->storage->fopen($this->getSourcePath($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) {
+		return $this->storage->getMimeType($this->getSourcePath($path));
+	}
+
+	/**
+	 * 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) {
+		return $this->storage->hash($type, $this->getSourcePath($path), $raw);
+	}
+
+	/**
+	 * see http://php.net/manual/en/function.free_space.php
+	 *
+	 * @param string $path
+	 * @return int
+	 */
+	public function free_space($path) {
+		return $this->storage->free_space($this->getSourcePath($path));
+	}
+
+	/**
+	 * search for occurrences of $query in file names
+	 *
+	 * @param string $query
+	 * @return array
+	 */
+	public function search($query) {
+		return $this->storage->search($query);
+	}
+
+	/**
+	 * 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) {
+		return $this->storage->touch($this->getSourcePath($path), $mtime);
+	}
+
+	/**
+	 * 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) {
+		return $this->storage->getLocalFile($this->getSourcePath($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) {
+		return $this->storage->hasUpdated($this->getSourcePath($path), $time);
+	}
+
+	/**
+	 * get a cache instance for the storage
+	 *
+	 * @param string $path
+	 * @param \OC\Files\Storage\Storage (optional) the storage to pass to the cache
+	 * @return \OC\Files\Cache\Cache
+	 */
+	public function getCache($path = '', $storage = null) {
+		if (!$storage) {
+			$storage = $this;
+		}
+		$sourceCache = $this->storage->getCache($this->getSourcePath($path), $storage);
+		return new CacheJail($sourceCache, $this->rootPath);
+	}
+
+	/**
+	 * get the user id of the owner of a file or folder
+	 *
+	 * @param string $path
+	 * @return string
+	 */
+	public function getOwner($path) {
+		return $this->storage->getOwner($this->getSourcePath($path));
+	}
+
+	/**
+	 * get a watcher instance for the cache
+	 *
+	 * @param string $path
+	 * @param \OC\Files\Storage\Storage (optional) the storage to pass to the watcher
+	 * @return \OC\Files\Cache\Watcher
+	 */
+	public function getWatcher($path = '', $storage = null) {
+		if (!$storage) {
+			$storage = $this;
+		}
+		return $this->storage->getWatcher($this->getSourcePath($path), $storage);
+	}
+
+	/**
+	 * get the ETag for a file or folder
+	 *
+	 * @param string $path
+	 * @return string
+	 */
+	public function getETag($path) {
+		return $this->storage->getETag($this->getSourcePath($path));
+	}
+
+	/**
+	 * @param string $path
+	 * @return array
+	 */
+	public function getMetaData($path) {
+		return $this->storage->getMetaData($this->getSourcePath($path));
+	}
+
+	/**
+	 * @param string $path
+	 * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
+	 * @param \OCP\Lock\ILockingProvider $provider
+	 * @throws \OCP\Lock\LockedException
+	 */
+	public function acquireLock($path, $type, ILockingProvider $provider) {
+		$this->storage->acquireLock($this->getSourcePath($path), $type, $provider);
+	}
+
+	/**
+	 * @param string $path
+	 * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
+	 * @param \OCP\Lock\ILockingProvider $provider
+	 */
+	public function releaseLock($path, $type, ILockingProvider $provider) {
+		$this->storage->releaseLock($this->getSourcePath($path), $type, $provider);
+	}
+
+	/**
+	 * @param string $path
+	 * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
+	 * @param \OCP\Lock\ILockingProvider $provider
+	 */
+	public function changeLock($path, $type, ILockingProvider $provider) {
+		$this->storage->changeLock($this->getSourcePath($path), $type, $provider);
+	}
+
+	/**
+	 * Resolve the path for the source of the share
+	 *
+	 * @param string $path
+	 * @return array
+	 */
+	public function resolvePath($path) {
+		return [$this->storage, $this->getSourcePath($path)];
+	}
+
+	/**
+	 * @param \OCP\Files\Storage $sourceStorage
+	 * @param string $sourceInternalPath
+	 * @param string $targetInternalPath
+	 * @return bool
+	 */
+	public function copyFromStorage(\OCP\Files\Storage $sourceStorage, $sourceInternalPath, $targetInternalPath) {
+		if ($sourceStorage === $this) {
+			return $this->copy($sourceInternalPath, $targetInternalPath);
+		}
+		return $this->storage->copyFromStorage($sourceStorage, $sourceInternalPath, $this->getSourcePath($targetInternalPath));
+	}
+
+	/**
+	 * @param \OCP\Files\Storage $sourceStorage
+	 * @param string $sourceInternalPath
+	 * @param string $targetInternalPath
+	 * @return bool
+	 */
+	public function moveFromStorage(\OCP\Files\Storage $sourceStorage, $sourceInternalPath, $targetInternalPath) {
+		if ($sourceStorage === $this) {
+			return $this->rename($sourceInternalPath, $targetInternalPath);
+		}
+		return $this->storage->moveFromStorage($sourceStorage, $sourceInternalPath, $this->getSourcePath($targetInternalPath));
+	}
+}
diff --git a/lib/private/Files/Storage/Wrapper/PermissionsMask.php b/lib/private/Files/Storage/Wrapper/PermissionsMask.php
new file mode 100644
index 00000000000..01dd78d418c
--- /dev/null
+++ b/lib/private/Files/Storage/Wrapper/PermissionsMask.php
@@ -0,0 +1,131 @@
+<?php
+/**
+ * @author Jörn Friedrich Dreyer <jfd@butonic.de>
+ * @author Morris Jobke <hey@morrisjobke.de>
+ * @author Robin Appelman <icewind@owncloud.com>
+ * @author Robin McCorkell <robin@mccorkell.me.uk>
+ *
+ * @copyright Copyright (c) 2016, ownCloud, Inc.
+ * @license AGPL-3.0
+ *
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License, version 3,
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>
+ *
+ */
+
+namespace OC\Files\Storage\Wrapper;
+
+use OC\Files\Cache\Wrapper\CachePermissionsMask;
+use OCP\Constants;
+
+/**
+ * Mask the permissions of a storage
+ *
+ * This can be used to restrict update, create, delete and/or share permissions of a storage
+ *
+ * Note that the read permissions can't be masked
+ */
+class PermissionsMask extends Wrapper {
+	/**
+	 * @var int the permissions bits we want to keep
+	 */
+	private $mask;
+
+	/**
+	 * @param array $arguments ['storage' => $storage, 'mask' => $mask]
+	 *
+	 * $storage: The storage the permissions mask should be applied on
+	 * $mask: The permission bits that should be kept, a combination of the \OCP\Constant::PERMISSION_ constants
+	 */
+	public function __construct($arguments) {
+		parent::__construct($arguments);
+		$this->mask = $arguments['mask'];
+	}
+
+	private function checkMask($permissions) {
+		return ($this->mask & $permissions) === $permissions;
+	}
+
+	public function isUpdatable($path) {
+		return $this->checkMask(Constants::PERMISSION_UPDATE) and parent::isUpdatable($path);
+	}
+
+	public function isCreatable($path) {
+		return $this->checkMask(Constants::PERMISSION_CREATE) and parent::isCreatable($path);
+	}
+
+	public function isDeletable($path) {
+		return $this->checkMask(Constants::PERMISSION_DELETE) and parent::isDeletable($path);
+	}
+
+	public function isSharable($path) {
+		return $this->checkMask(Constants::PERMISSION_SHARE) and parent::isSharable($path);
+	}
+
+	public function getPermissions($path) {
+		return $this->storage->getPermissions($path) & $this->mask;
+	}
+
+	public function rename($path1, $path2) {
+		return $this->checkMask(Constants::PERMISSION_UPDATE) and parent::rename($path1, $path2);
+	}
+
+	public function copy($path1, $path2) {
+		return $this->checkMask(Constants::PERMISSION_CREATE) and parent::copy($path1, $path2);
+	}
+
+	public function touch($path, $mtime = null) {
+		$permissions = $this->file_exists($path) ? Constants::PERMISSION_UPDATE : Constants::PERMISSION_CREATE;
+		return $this->checkMask($permissions) and parent::touch($path, $mtime);
+	}
+
+	public function mkdir($path) {
+		return $this->checkMask(Constants::PERMISSION_CREATE) and parent::mkdir($path);
+	}
+
+	public function rmdir($path) {
+		return $this->checkMask(Constants::PERMISSION_DELETE) and parent::rmdir($path);
+	}
+
+	public function unlink($path) {
+		return $this->checkMask(Constants::PERMISSION_DELETE) and parent::unlink($path);
+	}
+
+	public function file_put_contents($path, $data) {
+		$permissions = $this->file_exists($path) ? Constants::PERMISSION_UPDATE : Constants::PERMISSION_CREATE;
+		return $this->checkMask($permissions) and parent::file_put_contents($path, $data);
+	}
+
+	public function fopen($path, $mode) {
+		if ($mode === 'r' or $mode === 'rb') {
+			return parent::fopen($path, $mode);
+		} else {
+			$permissions = $this->file_exists($path) ? Constants::PERMISSION_UPDATE : Constants::PERMISSION_CREATE;
+			return $this->checkMask($permissions) ? parent::fopen($path, $mode) : false;
+		}
+	}
+
+	/**
+	 * get a cache instance for the storage
+	 *
+	 * @param string $path
+	 * @param \OC\Files\Storage\Storage (optional) the storage to pass to the cache
+	 * @return \OC\Files\Cache\Cache
+	 */
+	public function getCache($path = '', $storage = null) {
+		if (!$storage) {
+			$storage = $this;
+		}
+		$sourceCache = parent::getCache($path, $storage);
+		return new CachePermissionsMask($sourceCache, $this->mask);
+	}
+}
diff --git a/lib/private/Files/Storage/Wrapper/Quota.php b/lib/private/Files/Storage/Wrapper/Quota.php
new file mode 100644
index 00000000000..500677b092e
--- /dev/null
+++ b/lib/private/Files/Storage/Wrapper/Quota.php
@@ -0,0 +1,200 @@
+<?php
+/**
+ * @author Jörn Friedrich Dreyer <jfd@butonic.de>
+ * @author Morris Jobke <hey@morrisjobke.de>
+ * @author Robin Appelman <icewind@owncloud.com>
+ * @author Robin McCorkell <robin@mccorkell.me.uk>
+ * @author Vincent Petry <pvince81@owncloud.com>
+ *
+ * @copyright Copyright (c) 2016, ownCloud, Inc.
+ * @license AGPL-3.0
+ *
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License, version 3,
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>
+ *
+ */
+
+namespace OC\Files\Storage\Wrapper;
+
+use OCP\Files\Cache\ICacheEntry;
+
+class Quota extends Wrapper {
+
+	/**
+	 * @var int $quota
+	 */
+	protected $quota;
+
+	/**
+	 * @var string $sizeRoot
+	 */
+	protected $sizeRoot;
+
+	/**
+	 * @param array $parameters
+	 */
+	public function __construct($parameters) {
+		$this->storage = $parameters['storage'];
+		$this->quota = $parameters['quota'];
+		$this->sizeRoot = isset($parameters['root']) ? $parameters['root'] : '';
+	}
+
+	/**
+	 * @return int quota value
+	 */
+	public function getQuota() {
+		return $this->quota;
+	}
+
+	/**
+	 * @param string $path
+	 * @param \OC\Files\Storage\Storage $storage
+	 */
+	protected function getSize($path, $storage = null) {
+		if (is_null($storage)) {
+			$cache = $this->getCache();
+		} else {
+			$cache = $storage->getCache();
+		}
+		$data = $cache->get($path);
+		if ($data instanceof ICacheEntry and isset($data['size'])) {
+			return $data['size'];
+		} else {
+			return \OCP\Files\FileInfo::SPACE_NOT_COMPUTED;
+		}
+	}
+
+	/**
+	 * Get free space as limited by the quota
+	 *
+	 * @param string $path
+	 * @return int
+	 */
+	public function free_space($path) {
+		if ($this->quota < 0) {
+			return $this->storage->free_space($path);
+		} else {
+			$used = $this->getSize($this->sizeRoot);
+			if ($used < 0) {
+				return \OCP\Files\FileInfo::SPACE_NOT_COMPUTED;
+			} else {
+				$free = $this->storage->free_space($path);
+				$quotaFree = max($this->quota - $used, 0);
+				// if free space is known
+				if ($free >= 0) {
+					$free = min($free, $quotaFree);
+				} else {
+					$free = $quotaFree;
+				}
+				return $free;
+			}
+		}
+	}
+
+	/**
+	 * 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) {
+		$free = $this->free_space('');
+		if ($free < 0 or strlen($data) < $free) {
+			return $this->storage->file_put_contents($path, $data);
+		} else {
+			return false;
+		}
+	}
+
+	/**
+	 * see http://php.net/manual/en/function.copy.php
+	 *
+	 * @param string $source
+	 * @param string $target
+	 * @return bool
+	 */
+	public function copy($source, $target) {
+		$free = $this->free_space('');
+		if ($free < 0 or $this->getSize($source) < $free) {
+			return $this->storage->copy($source, $target);
+		} else {
+			return false;
+		}
+	}
+
+	/**
+	 * see http://php.net/manual/en/function.fopen.php
+	 *
+	 * @param string $path
+	 * @param string $mode
+	 * @return resource
+	 */
+	public function fopen($path, $mode) {
+		$source = $this->storage->fopen($path, $mode);
+
+		// don't apply quota for part files
+		if (!$this->isPartFile($path)) {
+			$free = $this->free_space('');
+			if ($source && $free >= 0 && $mode !== 'r' && $mode !== 'rb') {
+				// only apply quota for files, not metadata, trash or others
+				if (strpos(ltrim($path, '/'), 'files/') === 0) {
+					return \OC\Files\Stream\Quota::wrap($source, $free);
+				}
+			}
+		}
+		return $source;
+	}
+
+	/**
+	 * Checks whether the given path is a part file
+	 *
+	 * @param string $path Path that may identify a .part file
+	 * @return string File path without .part extension
+	 * @note this is needed for reusing keys
+	 */
+	private function isPartFile($path) {
+		$extension = pathinfo($path, PATHINFO_EXTENSION);
+
+		return ($extension === 'part');
+	}
+
+	/**
+	 * @param \OCP\Files\Storage $sourceStorage
+	 * @param string $sourceInternalPath
+	 * @param string $targetInternalPath
+	 * @return bool
+	 */
+	public function copyFromStorage(\OCP\Files\Storage $sourceStorage, $sourceInternalPath, $targetInternalPath) {
+		$free = $this->free_space('');
+		if ($free < 0 or $this->getSize($sourceInternalPath, $sourceStorage) < $free) {
+			return $this->storage->copyFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath);
+		} else {
+			return false;
+		}
+	}
+
+	/**
+	 * @param \OCP\Files\Storage $sourceStorage
+	 * @param string $sourceInternalPath
+	 * @param string $targetInternalPath
+	 * @return bool
+	 */
+	public function moveFromStorage(\OCP\Files\Storage $sourceStorage, $sourceInternalPath, $targetInternalPath) {
+		$free = $this->free_space('');
+		if ($free < 0 or $this->getSize($sourceInternalPath, $sourceStorage) < $free) {
+			return $this->storage->moveFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath);
+		} else {
+			return false;
+		}
+	}
+}
diff --git a/lib/private/Files/Storage/Wrapper/Wrapper.php b/lib/private/Files/Storage/Wrapper/Wrapper.php
new file mode 100644
index 00000000000..21d7db1099b
--- /dev/null
+++ b/lib/private/Files/Storage/Wrapper/Wrapper.php
@@ -0,0 +1,608 @@
+<?php
+/**
+ * @author Morris Jobke <hey@morrisjobke.de>
+ * @author Robin Appelman <icewind@owncloud.com>
+ * @author Robin McCorkell <robin@mccorkell.me.uk>
+ * @author Thomas Müller <thomas.mueller@tmit.eu>
+ * @author Vincent Petry <pvince81@owncloud.com>
+ *
+ * @copyright Copyright (c) 2016, ownCloud, Inc.
+ * @license AGPL-3.0
+ *
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License, version 3,
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>
+ *
+ */
+
+namespace OC\Files\Storage\Wrapper;
+
+use OCP\Files\InvalidPathException;
+use OCP\Files\Storage\ILockingStorage;
+use OCP\Lock\ILockingProvider;
+
+class Wrapper implements \OC\Files\Storage\Storage, ILockingStorage {
+	/**
+	 * @var \OC\Files\Storage\Storage $storage
+	 */
+	protected $storage;
+
+	public $cache;
+	public $scanner;
+	public $watcher;
+	public $propagator;
+	public $updater;
+
+	/**
+	 * @param array $parameters
+	 */
+	public function __construct($parameters) {
+		$this->storage = $parameters['storage'];
+	}
+
+	/**
+	 * @return \OC\Files\Storage\Storage
+	 */
+	public function getWrapperStorage() {
+		return $this->storage;
+	}
+
+	/**
+	 * 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() {
+		return $this->storage->getId();
+	}
+
+	/**
+	 * see http://php.net/manual/en/function.mkdir.php
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function mkdir($path) {
+		return $this->storage->mkdir($path);
+	}
+
+	/**
+	 * see http://php.net/manual/en/function.rmdir.php
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function rmdir($path) {
+		return $this->storage->rmdir($path);
+	}
+
+	/**
+	 * see http://php.net/manual/en/function.opendir.php
+	 *
+	 * @param string $path
+	 * @return resource
+	 */
+	public function opendir($path) {
+		return $this->storage->opendir($path);
+	}
+
+	/**
+	 * see http://php.net/manual/en/function.is_dir.php
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function is_dir($path) {
+		return $this->storage->is_dir($path);
+	}
+
+	/**
+	 * see http://php.net/manual/en/function.is_file.php
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function is_file($path) {
+		return $this->storage->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) {
+		return $this->storage->stat($path);
+	}
+
+	/**
+	 * see http://php.net/manual/en/function.filetype.php
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function filetype($path) {
+		return $this->storage->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) {
+		return $this->storage->filesize($path);
+	}
+
+	/**
+	 * check if a file can be created in $path
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function isCreatable($path) {
+		return $this->storage->isCreatable($path);
+	}
+
+	/**
+	 * check if a file can be read
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function isReadable($path) {
+		return $this->storage->isReadable($path);
+	}
+
+	/**
+	 * check if a file can be written to
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function isUpdatable($path) {
+		return $this->storage->isUpdatable($path);
+	}
+
+	/**
+	 * check if a file can be deleted
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function isDeletable($path) {
+		return $this->storage->isDeletable($path);
+	}
+
+	/**
+	 * check if a file can be shared
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function isSharable($path) {
+		return $this->storage->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) {
+		return $this->storage->getPermissions($path);
+	}
+
+	/**
+	 * see http://php.net/manual/en/function.file_exists.php
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function file_exists($path) {
+		return $this->storage->file_exists($path);
+	}
+
+	/**
+	 * see http://php.net/manual/en/function.filemtime.php
+	 *
+	 * @param string $path
+	 * @return int
+	 */
+	public function filemtime($path) {
+		return $this->storage->filemtime($path);
+	}
+
+	/**
+	 * see http://php.net/manual/en/function.file_get_contents.php
+	 *
+	 * @param string $path
+	 * @return string
+	 */
+	public function file_get_contents($path) {
+		return $this->storage->file_get_contents($path);
+	}
+
+	/**
+	 * 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) {
+		return $this->storage->file_put_contents($path, $data);
+	}
+
+	/**
+	 * see http://php.net/manual/en/function.unlink.php
+	 *
+	 * @param string $path
+	 * @return bool
+	 */
+	public function unlink($path) {
+		return $this->storage->unlink($path);
+	}
+
+	/**
+	 * see http://php.net/manual/en/function.rename.php
+	 *
+	 * @param string $path1
+	 * @param string $path2
+	 * @return bool
+	 */
+	public function rename($path1, $path2) {
+		return $this->storage->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) {
+		return $this->storage->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) {
+		return $this->storage->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) {
+		return $this->storage->getMimeType($path);
+	}
+
+	/**
+	 * 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) {
+		return $this->storage->hash($type, $path, $raw);
+	}
+
+	/**
+	 * see http://php.net/manual/en/function.free_space.php
+	 *
+	 * @param string $path
+	 * @return int
+	 */
+	public function free_space($path) {
+		return $this->storage->free_space($path);
+	}
+
+	/**
+	 * search for occurrences of $query in file names
+	 *
+	 * @param string $query
+	 * @return array
+	 */
+	public function search($query) {
+		return $this->storage->search($query);
+	}
+
+	/**
+	 * 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) {
+		return $this->storage->touch($path, $mtime);
+	}
+
+	/**
+	 * 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) {
+		return $this->storage->getLocalFile($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) {
+		return $this->storage->hasUpdated($path, $time);
+	}
+
+	/**
+	 * get a cache instance for the storage
+	 *
+	 * @param string $path
+	 * @param \OC\Files\Storage\Storage (optional) the storage to pass to the cache
+	 * @return \OC\Files\Cache\Cache
+	 */
+	public function getCache($path = '', $storage = null) {
+		if (!$storage) {
+			$storage = $this;
+		}
+		return $this->storage->getCache($path, $storage);
+	}
+
+	/**
+	 * get a scanner instance for the storage
+	 *
+	 * @param string $path
+	 * @param \OC\Files\Storage\Storage (optional) the storage to pass to the scanner
+	 * @return \OC\Files\Cache\Scanner
+	 */
+	public function getScanner($path = '', $storage = null) {
+		if (!$storage) {
+			$storage = $this;
+		}
+		return $this->storage->getScanner($path, $storage);
+	}
+
+
+	/**
+	 * get the user id of the owner of a file or folder
+	 *
+	 * @param string $path
+	 * @return string
+	 */
+	public function getOwner($path) {
+		return $this->storage->getOwner($path);
+	}
+
+	/**
+	 * get a watcher instance for the cache
+	 *
+	 * @param string $path
+	 * @param \OC\Files\Storage\Storage (optional) the storage to pass to the watcher
+	 * @return \OC\Files\Cache\Watcher
+	 */
+	public function getWatcher($path = '', $storage = null) {
+		if (!$storage) {
+			$storage = $this;
+		}
+		return $this->storage->getWatcher($path, $storage);
+	}
+
+	public function getPropagator($storage = null) {
+		if (!$storage) {
+			$storage = $this;
+		}
+		return $this->storage->getPropagator($storage);
+	}
+
+	public function getUpdater($storage = null) {
+		if (!$storage) {
+			$storage = $this;
+		}
+		return $this->storage->getUpdater($storage);
+	}
+
+	/**
+	 * @return \OC\Files\Cache\Storage
+	 */
+	public function getStorageCache() {
+		return $this->storage->getStorageCache();
+	}
+
+	/**
+	 * get the ETag for a file or folder
+	 *
+	 * @param string $path
+	 * @return string
+	 */
+	public function getETag($path) {
+		return $this->storage->getETag($path);
+	}
+
+	/**
+	 * Returns true
+	 *
+	 * @return true
+	 */
+	public function test() {
+		return $this->storage->test();
+	}
+
+	/**
+	 * Returns the wrapped storage's value for isLocal()
+	 *
+	 * @return bool wrapped storage's isLocal() value
+	 */
+	public function isLocal() {
+		return $this->storage->isLocal();
+	}
+
+	/**
+	 * Check if the storage is an instance of $class or is a wrapper for a storage that is an instance of $class
+	 *
+	 * @param string $class
+	 * @return bool
+	 */
+	public function instanceOfStorage($class) {
+		return is_a($this, $class) or $this->storage->instanceOfStorage($class);
+	}
+
+	/**
+	 * Pass any methods custom to specific storage implementations to the wrapped storage
+	 *
+	 * @param string $method
+	 * @param array $args
+	 * @return mixed
+	 */
+	public function __call($method, $args) {
+		return call_user_func_array(array($this->storage, $method), $args);
+	}
+
+	/**
+	 * A custom storage implementation can return an url for direct download of a give file.
+	 *
+	 * For now the returned array can hold the parameter url - in future more attributes might follow.
+	 *
+	 * @param string $path
+	 * @return array
+	 */
+	public function getDirectDownload($path) {
+		return $this->storage->getDirectDownload($path);
+	}
+
+	/**
+	 * Get availability of the storage
+	 *
+	 * @return array [ available, last_checked ]
+	 */
+	public function getAvailability() {
+		return $this->storage->getAvailability();
+	}
+
+	/**
+	 * Set availability of the storage
+	 *
+	 * @param bool $isAvailable
+	 */
+	public function setAvailability($isAvailable) {
+		$this->storage->setAvailability($isAvailable);
+	}
+
+	/**
+	 * @param string $path the path of the target folder
+	 * @param string $fileName the name of the file itself
+	 * @return void
+	 * @throws InvalidPathException
+	 */
+	public function verifyPath($path, $fileName) {
+		$this->storage->verifyPath($path, $fileName);
+	}
+
+	/**
+	 * @param \OCP\Files\Storage $sourceStorage
+	 * @param string $sourceInternalPath
+	 * @param string $targetInternalPath
+	 * @return bool
+	 */
+	public function copyFromStorage(\OCP\Files\Storage $sourceStorage, $sourceInternalPath, $targetInternalPath) {
+		if ($sourceStorage === $this) {
+			return $this->copy($sourceInternalPath, $targetInternalPath);
+		}
+
+		return $this->storage->copyFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath);
+	}
+
+	/**
+	 * @param \OCP\Files\Storage $sourceStorage
+	 * @param string $sourceInternalPath
+	 * @param string $targetInternalPath
+	 * @return bool
+	 */
+	public function moveFromStorage(\OCP\Files\Storage $sourceStorage, $sourceInternalPath, $targetInternalPath) {
+		if ($sourceStorage === $this) {
+			return $this->rename($sourceInternalPath, $targetInternalPath);
+		}
+
+		return $this->storage->moveFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath);
+	}
+
+	/**
+	 * @param string $path
+	 * @return array
+	 */
+	public function getMetaData($path) {
+		return $this->storage->getMetaData($path);
+	}
+
+	/**
+	 * @param string $path
+	 * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
+	 * @param \OCP\Lock\ILockingProvider $provider
+	 * @throws \OCP\Lock\LockedException
+	 */
+	public function acquireLock($path, $type, ILockingProvider $provider) {
+		if ($this->storage->instanceOfStorage('\OCP\Files\Storage\ILockingStorage')) {
+			$this->storage->acquireLock($path, $type, $provider);
+		}
+	}
+
+	/**
+	 * @param string $path
+	 * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
+	 * @param \OCP\Lock\ILockingProvider $provider
+	 */
+	public function releaseLock($path, $type, ILockingProvider $provider) {
+		if ($this->storage->instanceOfStorage('\OCP\Files\Storage\ILockingStorage')) {
+			$this->storage->releaseLock($path, $type, $provider);
+		}
+	}
+
+	/**
+	 * @param string $path
+	 * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
+	 * @param \OCP\Lock\ILockingProvider $provider
+	 */
+	public function changeLock($path, $type, ILockingProvider $provider) {
+		if ($this->storage->instanceOfStorage('\OCP\Files\Storage\ILockingStorage')) {
+			$this->storage->changeLock($path, $type, $provider);
+		}
+	}
+}