nextcloud / server

apps/dav/lib/Connector/Sabre/ShareTypeList.php

Doc Comments +1 added lines, -1 removed lines

@@ -61,7 +61,7 @@
 	 * The deserialize method is called during xml parsing.
 	 *
 	 * @param Reader $reader
-	 * @return mixed
+	 * @return null|ShareTypeList
 	 */
 	static function xmlDeserialize(Reader $reader) {
 		$shareTypes = [];

Indentation +51 added lines, -51 removed lines

@@ -32,61 +32,61 @@
  * This property contains multiple "share-type" elements, each containing a share type.
  */
 class ShareTypeList implements Element {
-	const NS_OWNCLOUD = 'http://owncloud.org/ns';
+    const NS_OWNCLOUD = 'http://owncloud.org/ns';
 
-	/**
-	 * Share types
-	 *
-	 * @var int[]
-	 */
-	private $shareTypes;
+    /**
+     * Share types
+     *
+     * @var int[]
+     */
+    private $shareTypes;
 
-	/**
-	 * @param int[] $shareTypes
-	 */
-	public function __construct($shareTypes) {
-		$this->shareTypes = $shareTypes;
-	}
+    /**
+     * @param int[] $shareTypes
+     */
+    public function __construct($shareTypes) {
+        $this->shareTypes = $shareTypes;
+    }
 
-	/**
-	 * Returns the share types
-	 *
-	 * @return int[]
-	 */
-	public function getShareTypes() {
-		return $this->shareTypes;
-	}
+    /**
+     * Returns the share types
+     *
+     * @return int[]
+     */
+    public function getShareTypes() {
+        return $this->shareTypes;
+    }
 
-	/**
-	 * The deserialize method is called during xml parsing.
-	 *
-	 * @param Reader $reader
-	 * @return mixed
-	 */
-	static function xmlDeserialize(Reader $reader) {
-		$shareTypes = [];
+    /**
+     * The deserialize method is called during xml parsing.
+     *
+     * @param Reader $reader
+     * @return mixed
+     */
+    static function xmlDeserialize(Reader $reader) {
+        $shareTypes = [];
 
-		$tree = $reader->parseInnerTree();
-		if ($tree === null) {
-			return null;
-		}
-		foreach ($tree as $elem) {
-			if ($elem['name'] === '{' . self::NS_OWNCLOUD . '}share-type') {
-				$shareTypes[] = (int)$elem['value'];
-			}
-		}
-		return new self($shareTypes);
-	}
+        $tree = $reader->parseInnerTree();
+        if ($tree === null) {
+            return null;
+        }
+        foreach ($tree as $elem) {
+            if ($elem['name'] === '{' . self::NS_OWNCLOUD . '}share-type') {
+                $shareTypes[] = (int)$elem['value'];
+            }
+        }
+        return new self($shareTypes);
+    }
 
-	/**
-	 * The xmlSerialize metod is called during xml writing.
-	 *
-	 * @param Writer $writer
-	 * @return void
-	 */
-	function xmlSerialize(Writer $writer) {
-		foreach ($this->shareTypes as $shareType) {
-			$writer->writeElement('{' . self::NS_OWNCLOUD . '}share-type', $shareType);
-		}
-	}
+    /**
+     * The xmlSerialize metod is called during xml writing.
+     *
+     * @param Writer $writer
+     * @return void
+     */
+    function xmlSerialize(Writer $writer) {
+        foreach ($this->shareTypes as $shareType) {
+            $writer->writeElement('{' . self::NS_OWNCLOUD . '}share-type', $shareType);
+        }
+    }
 }

Spacing +3 added lines, -3 removed lines

@@ -71,8 +71,8 @@ 
 			return null;
 		}
 		foreach ($tree as $elem) {
-			if ($elem['name'] === '{' . self::NS_OWNCLOUD . '}share-type') {
-				$shareTypes[] = (int)$elem['value'];
+			if ($elem['name'] === '{'.self::NS_OWNCLOUD.'}share-type') {
+				$shareTypes[] = (int) $elem['value'];
 			}
 		}
 		return new self($shareTypes);
@@ -86,7 +86,7 @@ 
 	 */
 	function xmlSerialize(Writer $writer) {
 		foreach ($this->shareTypes as $shareType) {
-			$writer->writeElement('{' . self::NS_OWNCLOUD . '}share-type', $shareType);
+			$writer->writeElement('{'.self::NS_OWNCLOUD.'}share-type', $shareType);
 		}
 	}
 }

apps/dav/lib/Connector/Sabre/TagList.php

Doc Comments +1 added lines, -1 removed lines

@@ -80,7 +80,7 @@
 	 * the next element.
 	 *
 	 * @param Reader $reader
-	 * @return mixed
+	 * @return null|TagList
 	 */
 	static function xmlDeserialize(Reader $reader) {
 		$tags = [];

Indentation +79 added lines, -79 removed lines

@@ -34,92 +34,92 @@
  * This property contains multiple "tag" elements, each containing a tag name.
  */
 class TagList implements Element {
-	const NS_OWNCLOUD = 'http://owncloud.org/ns';
+    const NS_OWNCLOUD = 'http://owncloud.org/ns';
 
-	/**
-	 * tags
-	 *
-	 * @var array
-	 */
-	private $tags;
+    /**
+     * tags
+     *
+     * @var array
+     */
+    private $tags;
 
-	/**
-	 * @param array $tags
-	 */
-	public function __construct(array $tags) {
-		$this->tags = $tags;
-	}
+    /**
+     * @param array $tags
+     */
+    public function __construct(array $tags) {
+        $this->tags = $tags;
+    }
 
-	/**
-	 * Returns the tags
-	 *
-	 * @return array
-	 */
-	public function getTags() {
+    /**
+     * Returns the tags
+     *
+     * @return array
+     */
+    public function getTags() {
 
-		return $this->tags;
+        return $this->tags;
 
-	}
+    }
 
-	/**
-	 * The deserialize method is called during xml parsing.
-	 *
-	 * This method is called statictly, this is because in theory this method
-	 * may be used as a type of constructor, or factory method.
-	 *
-	 * Often you want to return an instance of the current class, but you are
-	 * free to return other data as well.
-	 *
-	 * You are responsible for advancing the reader to the next element. Not
-	 * doing anything will result in a never-ending loop.
-	 *
-	 * If you just want to skip parsing for this element altogether, you can
-	 * just call $reader->next();
-	 *
-	 * $reader->parseInnerTree() will parse the entire sub-tree, and advance to
-	 * the next element.
-	 *
-	 * @param Reader $reader
-	 * @return mixed
-	 */
-	static function xmlDeserialize(Reader $reader) {
-		$tags = [];
+    /**
+     * The deserialize method is called during xml parsing.
+     *
+     * This method is called statictly, this is because in theory this method
+     * may be used as a type of constructor, or factory method.
+     *
+     * Often you want to return an instance of the current class, but you are
+     * free to return other data as well.
+     *
+     * You are responsible for advancing the reader to the next element. Not
+     * doing anything will result in a never-ending loop.
+     *
+     * If you just want to skip parsing for this element altogether, you can
+     * just call $reader->next();
+     *
+     * $reader->parseInnerTree() will parse the entire sub-tree, and advance to
+     * the next element.
+     *
+     * @param Reader $reader
+     * @return mixed
+     */
+    static function xmlDeserialize(Reader $reader) {
+        $tags = [];
 
-		$tree = $reader->parseInnerTree();
-		if ($tree === null) {
-			return null;
-		}
-		foreach ($tree as $elem) {
-			if ($elem['name'] === '{' . self::NS_OWNCLOUD . '}tag') {
-				$tags[] = $elem['value'];
-			}
-		}
-		return new self($tags);
-	}
+        $tree = $reader->parseInnerTree();
+        if ($tree === null) {
+            return null;
+        }
+        foreach ($tree as $elem) {
+            if ($elem['name'] === '{' . self::NS_OWNCLOUD . '}tag') {
+                $tags[] = $elem['value'];
+            }
+        }
+        return new self($tags);
+    }
 
-	/**
-	 * The xmlSerialize metod is called during xml writing.
-	 *
-	 * Use the $writer argument to write its own xml serialization.
-	 *
-	 * An important note: do _not_ create a parent element. Any element
-	 * implementing XmlSerializble should only ever write what's considered
-	 * its 'inner xml'.
-	 *
-	 * The parent of the current element is responsible for writing a
-	 * containing element.
-	 *
-	 * This allows serializers to be re-used for different element names.
-	 *
-	 * If you are opening new elements, you must also close them again.
-	 *
-	 * @param Writer $writer
-	 * @return void
-	 */
-	function xmlSerialize(Writer $writer) {
+    /**
+     * The xmlSerialize metod is called during xml writing.
+     *
+     * Use the $writer argument to write its own xml serialization.
+     *
+     * An important note: do _not_ create a parent element. Any element
+     * implementing XmlSerializble should only ever write what's considered
+     * its 'inner xml'.
+     *
+     * The parent of the current element is responsible for writing a
+     * containing element.
+     *
+     * This allows serializers to be re-used for different element names.
+     *
+     * If you are opening new elements, you must also close them again.
+     *
+     * @param Writer $writer
+     * @return void
+     */
+    function xmlSerialize(Writer $writer) {
 
-		foreach ($this->tags as $tag) {
-			$writer->writeElement('{' . self::NS_OWNCLOUD . '}tag', $tag);
-		}
-	}
+        foreach ($this->tags as $tag) {
+            $writer->writeElement('{' . self::NS_OWNCLOUD . '}tag', $tag);
+        }
+    }
 }

Spacing +2 added lines, -2 removed lines

@@ -90,7 +90,7 @@ 
 			return null;
 		}
 		foreach ($tree as $elem) {
-			if ($elem['name'] === '{' . self::NS_OWNCLOUD . '}tag') {
+			if ($elem['name'] === '{'.self::NS_OWNCLOUD.'}tag') {
 				$tags[] = $elem['value'];
 			}
 		}
@@ -119,7 +119,7 @@ 
 	function xmlSerialize(Writer $writer) {
 
 		foreach ($this->tags as $tag) {
-			$writer->writeElement('{' . self::NS_OWNCLOUD . '}tag', $tag);
+			$writer->writeElement('{'.self::NS_OWNCLOUD.'}tag', $tag);
 		}
 	}
 }

lib/private/L10N/Factory.php

Doc Comments +5 added lines

@@ -318,6 +318,11 @@
 	 */
 	// FIXME This method is only public, until OC_L10N does not need it anymore,
 	// FIXME This is also the reason, why it is not in the public interface
+
+	/**
+	 * @param string $app
+	 * @param string $lang
+	 */
 	public function getL10nFilesForApp($app, $lang) {
 		$languageFiles = [];
 

Spacing +24 added lines, -24 removed lines

@@ -143,7 +143,7 @@ 
 		 * @link https://github.com/owncloud/core/issues/21955
 		 */
 		if ($this->config->getSystemValue('installed', false)) {
-			$userId = !is_null($this->userSession->getUser()) ? $this->userSession->getUser()->getUID() :  null;
+			$userId = !is_null($this->userSession->getUser()) ? $this->userSession->getUser()->getUID() : null;
 			if (!is_null($userId)) {
 				$userLang = $this->config->getUserValue($userId, 'core', 'lang', null);
 			} else {
@@ -213,7 +213,7 @@ 
 		// merge with translations from theme
 		$theme = $this->config->getSystemValue('theme');
 		if (!empty($theme)) {
-			$themeDir = $this->serverRoot . '/themes/' . $theme . substr($dir, strlen($this->serverRoot));
+			$themeDir = $this->serverRoot.'/themes/'.$theme.substr($dir, strlen($this->serverRoot));
 
 			if (is_dir($themeDir)) {
 				$files = scandir($themeDir);
@@ -340,12 +340,12 @@ 
 		$languageFiles = [];
 
 		$i18nDir = $this->findL10nDir($app);
-		$transFile = strip_tags($i18nDir) . strip_tags($lang) . '.json';
+		$transFile = strip_tags($i18nDir).strip_tags($lang).'.json';
 
-		if (($this->isSubDirectory($transFile, $this->serverRoot . '/core/l10n/')
-				|| $this->isSubDirectory($transFile, $this->serverRoot . '/lib/l10n/')
-				|| $this->isSubDirectory($transFile, $this->serverRoot . '/settings/l10n/')
-				|| $this->isSubDirectory($transFile, \OC_App::getAppPath($app) . '/l10n/')
+		if (($this->isSubDirectory($transFile, $this->serverRoot.'/core/l10n/')
+				|| $this->isSubDirectory($transFile, $this->serverRoot.'/lib/l10n/')
+				|| $this->isSubDirectory($transFile, $this->serverRoot.'/settings/l10n/')
+				|| $this->isSubDirectory($transFile, \OC_App::getAppPath($app).'/l10n/')
 			)
 			&& file_exists($transFile)) {
 			// load the translations file
@@ -355,7 +355,7 @@ 
 		// merge with translations from theme
 		$theme = $this->config->getSystemValue('theme');
 		if (!empty($theme)) {
-			$transFile = $this->serverRoot . '/themes/' . $theme . substr($transFile, strlen($this->serverRoot));
+			$transFile = $this->serverRoot.'/themes/'.$theme.substr($transFile, strlen($this->serverRoot));
 			if (file_exists($transFile)) {
 				$languageFiles[] = $transFile;
 			}
@@ -372,14 +372,14 @@ 
 	 */
 	protected function findL10nDir($app = null) {
 		if (in_array($app, ['core', 'lib', 'settings'])) {
-			if (file_exists($this->serverRoot . '/' . $app . '/l10n/')) {
-				return $this->serverRoot . '/' . $app . '/l10n/';
+			if (file_exists($this->serverRoot.'/'.$app.'/l10n/')) {
+				return $this->serverRoot.'/'.$app.'/l10n/';
 			}
 		} else if ($app && \OC_App::getAppPath($app) !== false) {
 			// Check if the app is in the app folder
-			return \OC_App::getAppPath($app) . '/l10n/';
+			return \OC_App::getAppPath($app).'/l10n/';
 		}
-		return $this->serverRoot . '/core/l10n/';
+		return $this->serverRoot.'/core/l10n/';
 	}
 
 
@@ -396,15 +396,15 @@ 
 			return $this->pluralFunctions[$string];
 		}
 
-		if (preg_match( '/^\s*nplurals\s*=\s*(\d+)\s*;\s*plural=(.*)$/u', $string, $matches)) {
+		if (preg_match('/^\s*nplurals\s*=\s*(\d+)\s*;\s*plural=(.*)$/u', $string, $matches)) {
 			// sanitize
-			$nplurals = preg_replace( '/[^0-9]/', '', $matches[1] );
-			$plural = preg_replace( '#[^n0-9:\(\)\?\|\&=!<>+*/\%-]#', '', $matches[2] );
+			$nplurals = preg_replace('/[^0-9]/', '', $matches[1]);
+			$plural = preg_replace('#[^n0-9:\(\)\?\|\&=!<>+*/\%-]#', '', $matches[2]);
 
 			$body = str_replace(
-				array( 'plural', 'n', '$n$plurals', ),
-				array( '$plural', '$n', '$nplurals', ),
-				'nplurals='. $nplurals . '; plural=' . $plural
+				array('plural', 'n', '$n$plurals',),
+				array('$plural', '$n', '$nplurals',),
+				'nplurals='.$nplurals.'; plural='.$plural
 			);
 
 			// add parents
@@ -413,9 +413,9 @@ 
 			$res = '';
 			$p = 0;
 			$length = strlen($body);
-			for($i = 0; $i < $length; $i++) {
+			for ($i = 0; $i < $length; $i++) {
 				$ch = $body[$i];
-				switch ( $ch ) {
+				switch ($ch) {
 					case '?':
 						$res .= ' ? (';
 						$p++;
@@ -424,7 +424,7 @@ 
 						$res .= ') : (';
 						break;
 					case ';':
-						$res .= str_repeat( ')', $p ) . ';';
+						$res .= str_repeat(')', $p).';';
 						$p = 0;
 						break;
 					default:
@@ -432,7 +432,7 @@ 
 				}
 			}
 
-			$body = $res . 'return ($plural>=$nplurals?$nplurals-1:$plural);';
+			$body = $res.'return ($plural>=$nplurals?$nplurals-1:$plural);';
 			$function = create_function('$n', $body);
 			$this->pluralFunctions[$string] = $function;
 			return $function;
@@ -464,7 +464,7 @@ 
 		$commonLanguages = [];
 		$languages = [];
 
-		foreach($languageCodes as $lang) {
+		foreach ($languageCodes as $lang) {
 			$l = $this->get('lib', $lang);
 			// TRANSLATORS this is the language name for the language switcher in the personal settings and should be the localized version
 			$potentialName = (string) $l->t('__language_name__');
@@ -497,7 +497,7 @@ 
 		ksort($commonLanguages);
 
 		// sort now by displayed language not the iso-code
-		usort( $languages, function ($a, $b) {
+		usort($languages, function($a, $b) {
 			if ($a['code'] === $a['name'] && $b['code'] !== $b['name']) {
 				// If a doesn't have a name, but b does, list b before a
 				return 1;

Indentation +481 added lines, -481 removed lines

@@ -40,485 +40,485 @@
  */
 class Factory implements IFactory {
 
-	/** @var string */
-	protected $requestLanguage = '';
-
-	/**
-	 * cached instances
-	 * @var array Structure: Lang => App => \OCP\IL10N
-	 */
-	protected $instances = [];
-
-	/**
-	 * @var array Structure: App => string[]
-	 */
-	protected $availableLanguages = [];
-
-	/**
-	 * @var array Structure: string => callable
-	 */
-	protected $pluralFunctions = [];
-
-	const COMMON_LANGUAGE_CODES = [
-		'en', 'es', 'fr', 'de', 'de_DE', 'ja', 'ar', 'ru', 'nl', 'it',
-		'pt_BR', 'pt_PT', 'da', 'fi_FI', 'nb_NO', 'sv', 'tr', 'zh_CN', 'ko'
-	];
-
-	/** @var IConfig */
-	protected $config;
-
-	/** @var IRequest */
-	protected $request;
-
-	/** @var IUserSession */
-	protected $userSession;
-
-	/** @var string */
-	protected $serverRoot;
-
-	/**
-	 * @param IConfig $config
-	 * @param IRequest $request
-	 * @param IUserSession $userSession
-	 * @param string $serverRoot
-	 */
-	public function __construct(IConfig $config,
-								IRequest $request,
-								IUserSession $userSession,
-								$serverRoot) {
-		$this->config = $config;
-		$this->request = $request;
-		$this->userSession = $userSession;
-		$this->serverRoot = $serverRoot;
-	}
-
-	/**
-	 * Get a language instance
-	 *
-	 * @param string $app
-	 * @param string|null $lang
-	 * @return \OCP\IL10N
-	 */
-	public function get($app, $lang = null) {
-		$app = \OC_App::cleanAppId($app);
-		if ($lang !== null) {
-			$lang = str_replace(array('\0', '/', '\\', '..'), '', (string) $lang);
-		}
-
-		$forceLang = $this->config->getSystemValue('force_language', false);
-		if (is_string($forceLang)) {
-			$lang = $forceLang;
-		}
-
-		if ($lang === null || !$this->languageExists($app, $lang)) {
-			$lang = $this->findLanguage($app);
-		}
-
-		if (!isset($this->instances[$lang][$app])) {
-			$this->instances[$lang][$app] = new L10N(
-				$this, $app, $lang,
-				$this->getL10nFilesForApp($app, $lang)
-			);
-		}
-
-		return $this->instances[$lang][$app];
-	}
-
-	/**
-	 * Find the best language
-	 *
-	 * @param string|null $app App id or null for core
-	 * @return string language If nothing works it returns 'en'
-	 */
-	public function findLanguage($app = null) {
-		$forceLang = $this->config->getSystemValue('force_language', false);
-		if (is_string($forceLang)) {
-			$this->requestLanguage = $forceLang;
-		}
-
-		if ($this->requestLanguage !== '' && $this->languageExists($app, $this->requestLanguage)) {
-			return $this->requestLanguage;
-		}
-
-		/**
-		 * At this point Nextcloud might not yet be installed and thus the lookup
-		 * in the preferences table might fail. For this reason we need to check
-		 * whether the instance has already been installed
-		 *
-		 * @link https://github.com/owncloud/core/issues/21955
-		 */
-		if ($this->config->getSystemValue('installed', false)) {
-			$userId = !is_null($this->userSession->getUser()) ? $this->userSession->getUser()->getUID() :  null;
-			if (!is_null($userId)) {
-				$userLang = $this->config->getUserValue($userId, 'core', 'lang', null);
-			} else {
-				$userLang = null;
-			}
-		} else {
-			$userId = null;
-			$userLang = null;
-		}
-
-		if ($userLang) {
-			$this->requestLanguage = $userLang;
-			if ($this->languageExists($app, $userLang)) {
-				return $userLang;
-			}
-		}
-
-		try {
-			// Try to get the language from the Request
-			$lang = $this->getLanguageFromRequest($app);
-			if ($userId !== null && $app === null && !$userLang) {
-				$this->config->setUserValue($userId, 'core', 'lang', $lang);
-			}
-			return $lang;
-		} catch (LanguageNotFoundException $e) {
-			// Finding language from request failed fall back to default language
-			$defaultLanguage = $this->config->getSystemValue('default_language', false);
-			if ($defaultLanguage !== false && $this->languageExists($app, $defaultLanguage)) {
-				return $defaultLanguage;
-			}
-		}
-
-		// We could not find any language so fall back to english
-		return 'en';
-	}
-
-	/**
-	 * Find all available languages for an app
-	 *
-	 * @param string|null $app App id or null for core
-	 * @return array an array of available languages
-	 */
-	public function findAvailableLanguages($app = null) {
-		$key = $app;
-		if ($key === null) {
-			$key = 'null';
-		}
-
-		// also works with null as key
-		if (!empty($this->availableLanguages[$key])) {
-			return $this->availableLanguages[$key];
-		}
-
-		$available = ['en']; //english is always available
-		$dir = $this->findL10nDir($app);
-		if (is_dir($dir)) {
-			$files = scandir($dir);
-			if ($files !== false) {
-				foreach ($files as $file) {
-					if (substr($file, -5) === '.json' && substr($file, 0, 4) !== 'l10n') {
-						$available[] = substr($file, 0, -5);
-					}
-				}
-			}
-		}
-
-		// merge with translations from theme
-		$theme = $this->config->getSystemValue('theme');
-		if (!empty($theme)) {
-			$themeDir = $this->serverRoot . '/themes/' . $theme . substr($dir, strlen($this->serverRoot));
-
-			if (is_dir($themeDir)) {
-				$files = scandir($themeDir);
-				if ($files !== false) {
-					foreach ($files as $file) {
-						if (substr($file, -5) === '.json' && substr($file, 0, 4) !== 'l10n') {
-							$available[] = substr($file, 0, -5);
-						}
-					}
-				}
-			}
-		}
-
-		$this->availableLanguages[$key] = $available;
-		return $available;
-	}
-
-	/**
-	 * @param string|null $app App id or null for core
-	 * @param string $lang
-	 * @return bool
-	 */
-	public function languageExists($app, $lang) {
-		if ($lang === 'en') {//english is always available
-			return true;
-		}
-
-		$languages = $this->findAvailableLanguages($app);
-		return array_search($lang, $languages) !== false;
-	}
-
-	/**
-	 * @param string|null $app
-	 * @return string
-	 * @throws LanguageNotFoundException
-	 */
-	private function getLanguageFromRequest($app) {
-		$header = $this->request->getHeader('ACCEPT_LANGUAGE');
-		if ($header !== '') {
-			$available = $this->findAvailableLanguages($app);
-
-			// E.g. make sure that 'de' is before 'de_DE'.
-			sort($available);
-
-			$preferences = preg_split('/,\s*/', strtolower($header));
-			foreach ($preferences as $preference) {
-				list($preferred_language) = explode(';', $preference);
-				$preferred_language = str_replace('-', '_', $preferred_language);
-
-				foreach ($available as $available_language) {
-					if ($preferred_language === strtolower($available_language)) {
-						return $this->respectDefaultLanguage($app, $available_language);
-					}
-				}
-
-				// Fallback from de_De to de
-				foreach ($available as $available_language) {
-					if (substr($preferred_language, 0, 2) === $available_language) {
-						return $available_language;
-					}
-				}
-			}
-		}
-
-		throw new LanguageNotFoundException();
-	}
-
-	/**
-	 * if default language is set to de_DE (formal German) this should be
-	 * preferred to 'de' (non-formal German) if possible
-	 *
-	 * @param string|null $app
-	 * @param string $lang
-	 * @return string
-	 */
-	protected function respectDefaultLanguage($app, $lang) {
-		$result = $lang;
-		$defaultLanguage = $this->config->getSystemValue('default_language', false);
-
-		// use formal version of german ("Sie" instead of "Du") if the default
-		// language is set to 'de_DE' if possible
-		if (is_string($defaultLanguage) &&
-			strtolower($lang) === 'de' &&
-			strtolower($defaultLanguage) === 'de_de' &&
-			$this->languageExists($app, 'de_DE')
-		) {
-			$result = 'de_DE';
-		}
-
-		return $result;
-	}
-
-	/**
-	 * Checks if $sub is a subdirectory of $parent
-	 *
-	 * @param string $sub
-	 * @param string $parent
-	 * @return bool
-	 */
-	private function isSubDirectory($sub, $parent) {
-		// Check whether $sub contains no ".."
-		if (strpos($sub, '..') !== false) {
-			return false;
-		}
-
-		// Check whether $sub is a subdirectory of $parent
-		if (strpos($sub, $parent) === 0) {
-			return true;
-		}
-
-		return false;
-	}
-
-	/**
-	 * Get a list of language files that should be loaded
-	 *
-	 * @param string $app
-	 * @param string $lang
-	 * @return string[]
-	 */
-	// FIXME This method is only public, until OC_L10N does not need it anymore,
-	// FIXME This is also the reason, why it is not in the public interface
-	public function getL10nFilesForApp($app, $lang) {
-		$languageFiles = [];
-
-		$i18nDir = $this->findL10nDir($app);
-		$transFile = strip_tags($i18nDir) . strip_tags($lang) . '.json';
-
-		if (($this->isSubDirectory($transFile, $this->serverRoot . '/core/l10n/')
-				|| $this->isSubDirectory($transFile, $this->serverRoot . '/lib/l10n/')
-				|| $this->isSubDirectory($transFile, $this->serverRoot . '/settings/l10n/')
-				|| $this->isSubDirectory($transFile, \OC_App::getAppPath($app) . '/l10n/')
-			)
-			&& file_exists($transFile)) {
-			// load the translations file
-			$languageFiles[] = $transFile;
-		}
-
-		// merge with translations from theme
-		$theme = $this->config->getSystemValue('theme');
-		if (!empty($theme)) {
-			$transFile = $this->serverRoot . '/themes/' . $theme . substr($transFile, strlen($this->serverRoot));
-			if (file_exists($transFile)) {
-				$languageFiles[] = $transFile;
-			}
-		}
-
-		return $languageFiles;
-	}
-
-	/**
-	 * find the l10n directory
-	 *
-	 * @param string $app App id or empty string for core
-	 * @return string directory
-	 */
-	protected function findL10nDir($app = null) {
-		if (in_array($app, ['core', 'lib', 'settings'])) {
-			if (file_exists($this->serverRoot . '/' . $app . '/l10n/')) {
-				return $this->serverRoot . '/' . $app . '/l10n/';
-			}
-		} else if ($app && \OC_App::getAppPath($app) !== false) {
-			// Check if the app is in the app folder
-			return \OC_App::getAppPath($app) . '/l10n/';
-		}
-		return $this->serverRoot . '/core/l10n/';
-	}
-
-
-	/**
-	 * Creates a function from the plural string
-	 *
-	 * Parts of the code is copied from Habari:
-	 * https://github.com/habari/system/blob/master/classes/locale.php
-	 * @param string $string
-	 * @return string
-	 */
-	public function createPluralFunction($string) {
-		if (isset($this->pluralFunctions[$string])) {
-			return $this->pluralFunctions[$string];
-		}
-
-		if (preg_match( '/^\s*nplurals\s*=\s*(\d+)\s*;\s*plural=(.*)$/u', $string, $matches)) {
-			// sanitize
-			$nplurals = preg_replace( '/[^0-9]/', '', $matches[1] );
-			$plural = preg_replace( '#[^n0-9:\(\)\?\|\&=!<>+*/\%-]#', '', $matches[2] );
-
-			$body = str_replace(
-				array( 'plural', 'n', '$n$plurals', ),
-				array( '$plural', '$n', '$nplurals', ),
-				'nplurals='. $nplurals . '; plural=' . $plural
-			);
-
-			// add parents
-			// important since PHP's ternary evaluates from left to right
-			$body .= ';';
-			$res = '';
-			$p = 0;
-			$length = strlen($body);
-			for($i = 0; $i < $length; $i++) {
-				$ch = $body[$i];
-				switch ( $ch ) {
-					case '?':
-						$res .= ' ? (';
-						$p++;
-						break;
-					case ':':
-						$res .= ') : (';
-						break;
-					case ';':
-						$res .= str_repeat( ')', $p ) . ';';
-						$p = 0;
-						break;
-					default:
-						$res .= $ch;
-				}
-			}
-
-			$body = $res . 'return ($plural>=$nplurals?$nplurals-1:$plural);';
-			$function = create_function('$n', $body);
-			$this->pluralFunctions[$string] = $function;
-			return $function;
-		} else {
-			// default: one plural form for all cases but n==1 (english)
-			$function = create_function(
-				'$n',
-				'$nplurals=2;$plural=($n==1?0:1);return ($plural>=$nplurals?$nplurals-1:$plural);'
-			);
-			$this->pluralFunctions[$string] = $function;
-			return $function;
-		}
-	}
-
-	/**
-	 * returns the common language and other languages in an
-	 * associative array
-	 *
-	 * @return array
-	 */
-	public function getLanguages() {
-		$forceLanguage = $this->config->getSystemValue('force_language', false);
-		if ($forceLanguage !== false) {
-			return [];
-		}
-
-		$languageCodes = $this->findAvailableLanguages();
-
-		$commonLanguages = [];
-		$languages = [];
-
-		foreach($languageCodes as $lang) {
-			$l = $this->get('lib', $lang);
-			// TRANSLATORS this is the language name for the language switcher in the personal settings and should be the localized version
-			$potentialName = (string) $l->t('__language_name__');
-			if ($l->getLanguageCode() === $lang && $potentialName[0] !== '_') {//first check if the language name is in the translation file
-				$ln = array(
-					'code' => $lang,
-					'name' => $potentialName
-				);
-			} else if ($lang === 'en') {
-				$ln = array(
-					'code' => $lang,
-					'name' => 'English (US)'
-				);
-			} else {//fallback to language code
-				$ln = array(
-					'code' => $lang,
-					'name' => $lang
-				);
-			}
-
-			// put appropriate languages into appropriate arrays, to print them sorted
-			// common languages -> divider -> other languages
-			if (in_array($lang, self::COMMON_LANGUAGE_CODES)) {
-				$commonLanguages[array_search($lang, self::COMMON_LANGUAGE_CODES)] = $ln;
-			} else {
-				$languages[] = $ln;
-			}
-		}
-
-		ksort($commonLanguages);
-
-		// sort now by displayed language not the iso-code
-		usort( $languages, function ($a, $b) {
-			if ($a['code'] === $a['name'] && $b['code'] !== $b['name']) {
-				// If a doesn't have a name, but b does, list b before a
-				return 1;
-			}
-			if ($a['code'] !== $a['name'] && $b['code'] === $b['name']) {
-				// If a does have a name, but b doesn't, list a before b
-				return -1;
-			}
-			// Otherwise compare the names
-			return strcmp($a['name'], $b['name']);
-		});
-
-		return [
-			// reset indexes
-			'commonlanguages' => array_values($commonLanguages),
-			'languages' => $languages
-		];
-	}
+    /** @var string */
+    protected $requestLanguage = '';
+
+    /**
+     * cached instances
+     * @var array Structure: Lang => App => \OCP\IL10N
+     */
+    protected $instances = [];
+
+    /**
+     * @var array Structure: App => string[]
+     */
+    protected $availableLanguages = [];
+
+    /**
+     * @var array Structure: string => callable
+     */
+    protected $pluralFunctions = [];
+
+    const COMMON_LANGUAGE_CODES = [
+        'en', 'es', 'fr', 'de', 'de_DE', 'ja', 'ar', 'ru', 'nl', 'it',
+        'pt_BR', 'pt_PT', 'da', 'fi_FI', 'nb_NO', 'sv', 'tr', 'zh_CN', 'ko'
+    ];
+
+    /** @var IConfig */
+    protected $config;
+
+    /** @var IRequest */
+    protected $request;
+
+    /** @var IUserSession */
+    protected $userSession;
+
+    /** @var string */
+    protected $serverRoot;
+
+    /**
+     * @param IConfig $config
+     * @param IRequest $request
+     * @param IUserSession $userSession
+     * @param string $serverRoot
+     */
+    public function __construct(IConfig $config,
+                                IRequest $request,
+                                IUserSession $userSession,
+                                $serverRoot) {
+        $this->config = $config;
+        $this->request = $request;
+        $this->userSession = $userSession;
+        $this->serverRoot = $serverRoot;
+    }
+
+    /**
+     * Get a language instance
+     *
+     * @param string $app
+     * @param string|null $lang
+     * @return \OCP\IL10N
+     */
+    public function get($app, $lang = null) {
+        $app = \OC_App::cleanAppId($app);
+        if ($lang !== null) {
+            $lang = str_replace(array('\0', '/', '\\', '..'), '', (string) $lang);
+        }
+
+        $forceLang = $this->config->getSystemValue('force_language', false);
+        if (is_string($forceLang)) {
+            $lang = $forceLang;
+        }
+
+        if ($lang === null || !$this->languageExists($app, $lang)) {
+            $lang = $this->findLanguage($app);
+        }
+
+        if (!isset($this->instances[$lang][$app])) {
+            $this->instances[$lang][$app] = new L10N(
+                $this, $app, $lang,
+                $this->getL10nFilesForApp($app, $lang)
+            );
+        }
+
+        return $this->instances[$lang][$app];
+    }
+
+    /**
+     * Find the best language
+     *
+     * @param string|null $app App id or null for core
+     * @return string language If nothing works it returns 'en'
+     */
+    public function findLanguage($app = null) {
+        $forceLang = $this->config->getSystemValue('force_language', false);
+        if (is_string($forceLang)) {
+            $this->requestLanguage = $forceLang;
+        }
+
+        if ($this->requestLanguage !== '' && $this->languageExists($app, $this->requestLanguage)) {
+            return $this->requestLanguage;
+        }
+
+        /**
+         * At this point Nextcloud might not yet be installed and thus the lookup
+         * in the preferences table might fail. For this reason we need to check
+         * whether the instance has already been installed
+         *
+         * @link https://github.com/owncloud/core/issues/21955
+         */
+        if ($this->config->getSystemValue('installed', false)) {
+            $userId = !is_null($this->userSession->getUser()) ? $this->userSession->getUser()->getUID() :  null;
+            if (!is_null($userId)) {
+                $userLang = $this->config->getUserValue($userId, 'core', 'lang', null);
+            } else {
+                $userLang = null;
+            }
+        } else {
+            $userId = null;
+            $userLang = null;
+        }
+
+        if ($userLang) {
+            $this->requestLanguage = $userLang;
+            if ($this->languageExists($app, $userLang)) {
+                return $userLang;
+            }
+        }
+
+        try {
+            // Try to get the language from the Request
+            $lang = $this->getLanguageFromRequest($app);
+            if ($userId !== null && $app === null && !$userLang) {
+                $this->config->setUserValue($userId, 'core', 'lang', $lang);
+            }
+            return $lang;
+        } catch (LanguageNotFoundException $e) {
+            // Finding language from request failed fall back to default language
+            $defaultLanguage = $this->config->getSystemValue('default_language', false);
+            if ($defaultLanguage !== false && $this->languageExists($app, $defaultLanguage)) {
+                return $defaultLanguage;
+            }
+        }
+
+        // We could not find any language so fall back to english
+        return 'en';
+    }
+
+    /**
+     * Find all available languages for an app
+     *
+     * @param string|null $app App id or null for core
+     * @return array an array of available languages
+     */
+    public function findAvailableLanguages($app = null) {
+        $key = $app;
+        if ($key === null) {
+            $key = 'null';
+        }
+
+        // also works with null as key
+        if (!empty($this->availableLanguages[$key])) {
+            return $this->availableLanguages[$key];
+        }
+
+        $available = ['en']; //english is always available
+        $dir = $this->findL10nDir($app);
+        if (is_dir($dir)) {
+            $files = scandir($dir);
+            if ($files !== false) {
+                foreach ($files as $file) {
+                    if (substr($file, -5) === '.json' && substr($file, 0, 4) !== 'l10n') {
+                        $available[] = substr($file, 0, -5);
+                    }
+                }
+            }
+        }
+
+        // merge with translations from theme
+        $theme = $this->config->getSystemValue('theme');
+        if (!empty($theme)) {
+            $themeDir = $this->serverRoot . '/themes/' . $theme . substr($dir, strlen($this->serverRoot));
+
+            if (is_dir($themeDir)) {
+                $files = scandir($themeDir);
+                if ($files !== false) {
+                    foreach ($files as $file) {
+                        if (substr($file, -5) === '.json' && substr($file, 0, 4) !== 'l10n') {
+                            $available[] = substr($file, 0, -5);
+                        }
+                    }
+                }
+            }
+        }
+
+        $this->availableLanguages[$key] = $available;
+        return $available;
+    }
+
+    /**
+     * @param string|null $app App id or null for core
+     * @param string $lang
+     * @return bool
+     */
+    public function languageExists($app, $lang) {
+        if ($lang === 'en') {//english is always available
+            return true;
+        }
+
+        $languages = $this->findAvailableLanguages($app);
+        return array_search($lang, $languages) !== false;
+    }
+
+    /**
+     * @param string|null $app
+     * @return string
+     * @throws LanguageNotFoundException
+     */
+    private function getLanguageFromRequest($app) {
+        $header = $this->request->getHeader('ACCEPT_LANGUAGE');
+        if ($header !== '') {
+            $available = $this->findAvailableLanguages($app);
+
+            // E.g. make sure that 'de' is before 'de_DE'.
+            sort($available);
+
+            $preferences = preg_split('/,\s*/', strtolower($header));
+            foreach ($preferences as $preference) {
+                list($preferred_language) = explode(';', $preference);
+                $preferred_language = str_replace('-', '_', $preferred_language);
+
+                foreach ($available as $available_language) {
+                    if ($preferred_language === strtolower($available_language)) {
+                        return $this->respectDefaultLanguage($app, $available_language);
+                    }
+                }
+
+                // Fallback from de_De to de
+                foreach ($available as $available_language) {
+                    if (substr($preferred_language, 0, 2) === $available_language) {
+                        return $available_language;
+                    }
+                }
+            }
+        }
+
+        throw new LanguageNotFoundException();
+    }
+
+    /**
+     * if default language is set to de_DE (formal German) this should be
+     * preferred to 'de' (non-formal German) if possible
+     *
+     * @param string|null $app
+     * @param string $lang
+     * @return string
+     */
+    protected function respectDefaultLanguage($app, $lang) {
+        $result = $lang;
+        $defaultLanguage = $this->config->getSystemValue('default_language', false);
+
+        // use formal version of german ("Sie" instead of "Du") if the default
+        // language is set to 'de_DE' if possible
+        if (is_string($defaultLanguage) &&
+            strtolower($lang) === 'de' &&
+            strtolower($defaultLanguage) === 'de_de' &&
+            $this->languageExists($app, 'de_DE')
+        ) {
+            $result = 'de_DE';
+        }
+
+        return $result;
+    }
+
+    /**
+     * Checks if $sub is a subdirectory of $parent
+     *
+     * @param string $sub
+     * @param string $parent
+     * @return bool
+     */
+    private function isSubDirectory($sub, $parent) {
+        // Check whether $sub contains no ".."
+        if (strpos($sub, '..') !== false) {
+            return false;
+        }
+
+        // Check whether $sub is a subdirectory of $parent
+        if (strpos($sub, $parent) === 0) {
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * Get a list of language files that should be loaded
+     *
+     * @param string $app
+     * @param string $lang
+     * @return string[]
+     */
+    // FIXME This method is only public, until OC_L10N does not need it anymore,
+    // FIXME This is also the reason, why it is not in the public interface
+    public function getL10nFilesForApp($app, $lang) {
+        $languageFiles = [];
+
+        $i18nDir = $this->findL10nDir($app);
+        $transFile = strip_tags($i18nDir) . strip_tags($lang) . '.json';
+
+        if (($this->isSubDirectory($transFile, $this->serverRoot . '/core/l10n/')
+                || $this->isSubDirectory($transFile, $this->serverRoot . '/lib/l10n/')
+                || $this->isSubDirectory($transFile, $this->serverRoot . '/settings/l10n/')
+                || $this->isSubDirectory($transFile, \OC_App::getAppPath($app) . '/l10n/')
+            )
+            && file_exists($transFile)) {
+            // load the translations file
+            $languageFiles[] = $transFile;
+        }
+
+        // merge with translations from theme
+        $theme = $this->config->getSystemValue('theme');
+        if (!empty($theme)) {
+            $transFile = $this->serverRoot . '/themes/' . $theme . substr($transFile, strlen($this->serverRoot));
+            if (file_exists($transFile)) {
+                $languageFiles[] = $transFile;
+            }
+        }
+
+        return $languageFiles;
+    }
+
+    /**
+     * find the l10n directory
+     *
+     * @param string $app App id or empty string for core
+     * @return string directory
+     */
+    protected function findL10nDir($app = null) {
+        if (in_array($app, ['core', 'lib', 'settings'])) {
+            if (file_exists($this->serverRoot . '/' . $app . '/l10n/')) {
+                return $this->serverRoot . '/' . $app . '/l10n/';
+            }
+        } else if ($app && \OC_App::getAppPath($app) !== false) {
+            // Check if the app is in the app folder
+            return \OC_App::getAppPath($app) . '/l10n/';
+        }
+        return $this->serverRoot . '/core/l10n/';
+    }
+
+
+    /**
+     * Creates a function from the plural string
+     *
+     * Parts of the code is copied from Habari:
+     * https://github.com/habari/system/blob/master/classes/locale.php
+     * @param string $string
+     * @return string
+     */
+    public function createPluralFunction($string) {
+        if (isset($this->pluralFunctions[$string])) {
+            return $this->pluralFunctions[$string];
+        }
+
+        if (preg_match( '/^\s*nplurals\s*=\s*(\d+)\s*;\s*plural=(.*)$/u', $string, $matches)) {
+            // sanitize
+            $nplurals = preg_replace( '/[^0-9]/', '', $matches[1] );
+            $plural = preg_replace( '#[^n0-9:\(\)\?\|\&=!<>+*/\%-]#', '', $matches[2] );
+
+            $body = str_replace(
+                array( 'plural', 'n', '$n$plurals', ),
+                array( '$plural', '$n', '$nplurals', ),
+                'nplurals='. $nplurals . '; plural=' . $plural
+            );
+
+            // add parents
+            // important since PHP's ternary evaluates from left to right
+            $body .= ';';
+            $res = '';
+            $p = 0;
+            $length = strlen($body);
+            for($i = 0; $i < $length; $i++) {
+                $ch = $body[$i];
+                switch ( $ch ) {
+                    case '?':
+                        $res .= ' ? (';
+                        $p++;
+                        break;
+                    case ':':
+                        $res .= ') : (';
+                        break;
+                    case ';':
+                        $res .= str_repeat( ')', $p ) . ';';
+                        $p = 0;
+                        break;
+                    default:
+                        $res .= $ch;
+                }
+            }
+
+            $body = $res . 'return ($plural>=$nplurals?$nplurals-1:$plural);';
+            $function = create_function('$n', $body);
+            $this->pluralFunctions[$string] = $function;
+            return $function;
+        } else {
+            // default: one plural form for all cases but n==1 (english)
+            $function = create_function(
+                '$n',
+                '$nplurals=2;$plural=($n==1?0:1);return ($plural>=$nplurals?$nplurals-1:$plural);'
+            );
+            $this->pluralFunctions[$string] = $function;
+            return $function;
+        }
+    }
+
+    /**
+     * returns the common language and other languages in an
+     * associative array
+     *
+     * @return array
+     */
+    public function getLanguages() {
+        $forceLanguage = $this->config->getSystemValue('force_language', false);
+        if ($forceLanguage !== false) {
+            return [];
+        }
+
+        $languageCodes = $this->findAvailableLanguages();
+
+        $commonLanguages = [];
+        $languages = [];
+
+        foreach($languageCodes as $lang) {
+            $l = $this->get('lib', $lang);
+            // TRANSLATORS this is the language name for the language switcher in the personal settings and should be the localized version
+            $potentialName = (string) $l->t('__language_name__');
+            if ($l->getLanguageCode() === $lang && $potentialName[0] !== '_') {//first check if the language name is in the translation file
+                $ln = array(
+                    'code' => $lang,
+                    'name' => $potentialName
+                );
+            } else if ($lang === 'en') {
+                $ln = array(
+                    'code' => $lang,
+                    'name' => 'English (US)'
+                );
+            } else {//fallback to language code
+                $ln = array(
+                    'code' => $lang,
+                    'name' => $lang
+                );
+            }
+
+            // put appropriate languages into appropriate arrays, to print them sorted
+            // common languages -> divider -> other languages
+            if (in_array($lang, self::COMMON_LANGUAGE_CODES)) {
+                $commonLanguages[array_search($lang, self::COMMON_LANGUAGE_CODES)] = $ln;
+            } else {
+                $languages[] = $ln;
+            }
+        }
+
+        ksort($commonLanguages);
+
+        // sort now by displayed language not the iso-code
+        usort( $languages, function ($a, $b) {
+            if ($a['code'] === $a['name'] && $b['code'] !== $b['name']) {
+                // If a doesn't have a name, but b does, list b before a
+                return 1;
+            }
+            if ($a['code'] !== $a['name'] && $b['code'] === $b['name']) {
+                // If a does have a name, but b doesn't, list a before b
+                return -1;
+            }
+            // Otherwise compare the names
+            return strcmp($a['name'], $b['name']);
+        });
+
+        return [
+            // reset indexes
+            'commonlanguages' => array_values($commonLanguages),
+            'languages' => $languages
+        ];
+    }
 }

lib/private/Setup/MySQL.php

Doc Comments +1 added lines, -1 removed lines

@@ -101,7 +101,7 @@
 	}
 
 	/**
-	 * @param $username
+	 * @param string $username
 	 * @param IDBConnection $connection
 	 * @return array
 	 */

Indentation +139 added lines, -139 removed lines

@@ -34,143 +34,143 @@
 use OCP\ILogger;
 
 class MySQL extends AbstractDatabase {
-	public $dbprettyname = 'MySQL/MariaDB';
-
-	public function setupDatabase($username) {
-		//check if the database user has admin right
-		$connection = $this->connect(['dbname' => null]);
-
-		// detect mb4
-		$tools = new MySqlTools();
-		if ($tools->supports4ByteCharset($connection)) {
-			$this->config->setValue('mysql.utf8mb4', true);
-			$connection = $this->connect(['dbname' => null]);
-		}
-
-		$this->createSpecificUser($username, $connection);
-
-		//create the database
-		$this->createDatabase($connection);
-
-		//fill the database if needed
-		$query='select count(*) from information_schema.tables where table_schema=? AND table_name = ?';
-		$connection->executeQuery($query, [$this->dbName, $this->tablePrefix.'users']);
-	}
-
-	/**
-	 * @param \OC\DB\Connection $connection
-	 */
-	private function createDatabase($connection) {
-		try{
-			$name = $this->dbName;
-			$user = $this->dbUser;
-			//we can't use OC_DB functions here because we need to connect as the administrative user.
-			$characterSet = $this->config->getValue('mysql.utf8mb4', false) ? 'utf8mb4' : 'utf8';
-			$query = "CREATE DATABASE IF NOT EXISTS `$name` CHARACTER SET $characterSet COLLATE ${characterSet}_bin;";
-			$connection->executeUpdate($query);
-		} catch (\Exception $ex) {
-			$this->logger->logException($ex, [
-				'message' => 'Database creation failed.',
-				'level' => ILogger::ERROR,
-				'app' => 'mysql.setup',
-			]);
-			return;
-		}
-
-		try {
-			//this query will fail if there aren't the right permissions, ignore the error
-			$query="GRANT ALL PRIVILEGES ON `$name` . * TO '$user'";
-			$connection->executeUpdate($query);
-		} catch (\Exception $ex) {
-			$this->logger->logException($ex, [
-				'message' => 'Could not automatically grant privileges, this can be ignored if database user already had privileges.',
-				'level' => ILogger::DEBUG,
-				'app' => 'mysql.setup',
-			]);
-		}
-	}
-
-	/**
-	 * @param IDBConnection $connection
-	 * @throws \OC\DatabaseSetupException
-	 */
-	private function createDBUser($connection) {
-		try{
-			$name = $this->dbUser;
-			$password = $this->dbPassword;
-			// we need to create 2 accounts, one for global use and one for local user. if we don't specify the local one,
-			// the anonymous user would take precedence when there is one.
-			$query = "CREATE USER '$name'@'localhost' IDENTIFIED BY '$password'";
-			$connection->executeUpdate($query);
-			$query = "CREATE USER '$name'@'%' IDENTIFIED BY '$password'";
-			$connection->executeUpdate($query);
-		}
-		catch (\Exception $ex){
-			$this->logger->logException($ex, [
-				'message' => 'Database user creation failed.',
-				'level' => ILogger::ERROR,
-				'app' => 'mysql.setup',
-			]);
-		}
-	}
-
-	/**
-	 * @param $username
-	 * @param IDBConnection $connection
-	 * @return array
-	 */
-	private function createSpecificUser($username, $connection) {
-		try {
-			//user already specified in config
-			$oldUser = $this->config->getValue('dbuser', false);
-
-			//we don't have a dbuser specified in config
-			if ($this->dbUser !== $oldUser) {
-				//add prefix to the admin username to prevent collisions
-				$adminUser = substr('oc_' . $username, 0, 16);
-
-				$i = 1;
-				while (true) {
-					//this should be enough to check for admin rights in mysql
-					$query = 'SELECT user FROM mysql.user WHERE user=?';
-					$result = $connection->executeQuery($query, [$adminUser]);
-
-					//current dbuser has admin rights
-					if ($result) {
-						$data = $result->fetchAll();
-						//new dbuser does not exist
-						if (count($data) === 0) {
-							//use the admin login data for the new database user
-							$this->dbUser = $adminUser;
-
-							//create a random password so we don't need to store the admin password in the config file
-							$this->dbPassword =  $this->random->generate(30);
-
-							$this->createDBUser($connection);
-
-							break;
-						} else {
-							//repeat with different username
-							$length = strlen((string)$i);
-							$adminUser = substr('oc_' . $username, 0, 16 - $length) . $i;
-							$i++;
-						}
-					} else {
-						break;
-					}
-				}
-			}
-		} catch (\Exception $ex) {
-			$this->logger->logException($ex, [
-				'message' => 'Can not create a new MySQL user, will continue with the provided user.',
-				'level' => ILogger::INFO,
-				'app' => 'mysql.setup',
-			]);
-		}
-
-		$this->config->setValues([
-			'dbuser' => $this->dbUser,
-			'dbpassword' => $this->dbPassword,
-		]);
-	}
+    public $dbprettyname = 'MySQL/MariaDB';
+
+    public function setupDatabase($username) {
+        //check if the database user has admin right
+        $connection = $this->connect(['dbname' => null]);
+
+        // detect mb4
+        $tools = new MySqlTools();
+        if ($tools->supports4ByteCharset($connection)) {
+            $this->config->setValue('mysql.utf8mb4', true);
+            $connection = $this->connect(['dbname' => null]);
+        }
+
+        $this->createSpecificUser($username, $connection);
+
+        //create the database
+        $this->createDatabase($connection);
+
+        //fill the database if needed
+        $query='select count(*) from information_schema.tables where table_schema=? AND table_name = ?';
+        $connection->executeQuery($query, [$this->dbName, $this->tablePrefix.'users']);
+    }
+
+    /**
+     * @param \OC\DB\Connection $connection
+     */
+    private function createDatabase($connection) {
+        try{
+            $name = $this->dbName;
+            $user = $this->dbUser;
+            //we can't use OC_DB functions here because we need to connect as the administrative user.
+            $characterSet = $this->config->getValue('mysql.utf8mb4', false) ? 'utf8mb4' : 'utf8';
+            $query = "CREATE DATABASE IF NOT EXISTS `$name` CHARACTER SET $characterSet COLLATE ${characterSet}_bin;";
+            $connection->executeUpdate($query);
+        } catch (\Exception $ex) {
+            $this->logger->logException($ex, [
+                'message' => 'Database creation failed.',
+                'level' => ILogger::ERROR,
+                'app' => 'mysql.setup',
+            ]);
+            return;
+        }
+
+        try {
+            //this query will fail if there aren't the right permissions, ignore the error
+            $query="GRANT ALL PRIVILEGES ON `$name` . * TO '$user'";
+            $connection->executeUpdate($query);
+        } catch (\Exception $ex) {
+            $this->logger->logException($ex, [
+                'message' => 'Could not automatically grant privileges, this can be ignored if database user already had privileges.',
+                'level' => ILogger::DEBUG,
+                'app' => 'mysql.setup',
+            ]);
+        }
+    }
+
+    /**
+     * @param IDBConnection $connection
+     * @throws \OC\DatabaseSetupException
+     */
+    private function createDBUser($connection) {
+        try{
+            $name = $this->dbUser;
+            $password = $this->dbPassword;
+            // we need to create 2 accounts, one for global use and one for local user. if we don't specify the local one,
+            // the anonymous user would take precedence when there is one.
+            $query = "CREATE USER '$name'@'localhost' IDENTIFIED BY '$password'";
+            $connection->executeUpdate($query);
+            $query = "CREATE USER '$name'@'%' IDENTIFIED BY '$password'";
+            $connection->executeUpdate($query);
+        }
+        catch (\Exception $ex){
+            $this->logger->logException($ex, [
+                'message' => 'Database user creation failed.',
+                'level' => ILogger::ERROR,
+                'app' => 'mysql.setup',
+            ]);
+        }
+    }
+
+    /**
+     * @param $username
+     * @param IDBConnection $connection
+     * @return array
+     */
+    private function createSpecificUser($username, $connection) {
+        try {
+            //user already specified in config
+            $oldUser = $this->config->getValue('dbuser', false);
+
+            //we don't have a dbuser specified in config
+            if ($this->dbUser !== $oldUser) {
+                //add prefix to the admin username to prevent collisions
+                $adminUser = substr('oc_' . $username, 0, 16);
+
+                $i = 1;
+                while (true) {
+                    //this should be enough to check for admin rights in mysql
+                    $query = 'SELECT user FROM mysql.user WHERE user=?';
+                    $result = $connection->executeQuery($query, [$adminUser]);
+
+                    //current dbuser has admin rights
+                    if ($result) {
+                        $data = $result->fetchAll();
+                        //new dbuser does not exist
+                        if (count($data) === 0) {
+                            //use the admin login data for the new database user
+                            $this->dbUser = $adminUser;
+
+                            //create a random password so we don't need to store the admin password in the config file
+                            $this->dbPassword =  $this->random->generate(30);
+
+                            $this->createDBUser($connection);
+
+                            break;
+                        } else {
+                            //repeat with different username
+                            $length = strlen((string)$i);
+                            $adminUser = substr('oc_' . $username, 0, 16 - $length) . $i;
+                            $i++;
+                        }
+                    } else {
+                        break;
+                    }
+                }
+            }
+        } catch (\Exception $ex) {
+            $this->logger->logException($ex, [
+                'message' => 'Can not create a new MySQL user, will continue with the provided user.',
+                'level' => ILogger::INFO,
+                'app' => 'mysql.setup',
+            ]);
+        }
+
+        $this->config->setValues([
+            'dbuser' => $this->dbUser,
+            'dbpassword' => $this->dbPassword,
+        ]);
+    }
 }

Spacing +9 added lines, -9 removed lines

@@ -53,7 +53,7 @@ 
 		$this->createDatabase($connection);
 
 		//fill the database if needed
-		$query='select count(*) from information_schema.tables where table_schema=? AND table_name = ?';
+		$query = 'select count(*) from information_schema.tables where table_schema=? AND table_name = ?';
 		$connection->executeQuery($query, [$this->dbName, $this->tablePrefix.'users']);
 	}
 
@@ -61,7 +61,7 @@ 
 	 * @param \OC\DB\Connection $connection
 	 */
 	private function createDatabase($connection) {
-		try{
+		try {
 			$name = $this->dbName;
 			$user = $this->dbUser;
 			//we can't use OC_DB functions here because we need to connect as the administrative user.
@@ -79,7 +79,7 @@ 
 
 		try {
 			//this query will fail if there aren't the right permissions, ignore the error
-			$query="GRANT ALL PRIVILEGES ON `$name` . * TO '$user'";
+			$query = "GRANT ALL PRIVILEGES ON `$name` . * TO '$user'";
 			$connection->executeUpdate($query);
 		} catch (\Exception $ex) {
 			$this->logger->logException($ex, [
@@ -95,7 +95,7 @@ 
 	 * @throws \OC\DatabaseSetupException
 	 */
 	private function createDBUser($connection) {
-		try{
+		try {
 			$name = $this->dbUser;
 			$password = $this->dbPassword;
 			// we need to create 2 accounts, one for global use and one for local user. if we don't specify the local one,
@@ -105,7 +105,7 @@ 
 			$query = "CREATE USER '$name'@'%' IDENTIFIED BY '$password'";
 			$connection->executeUpdate($query);
 		}
-		catch (\Exception $ex){
+		catch (\Exception $ex) {
 			$this->logger->logException($ex, [
 				'message' => 'Database user creation failed.',
 				'level' => ILogger::ERROR,
@@ -127,7 +127,7 @@ 
 			//we don't have a dbuser specified in config
 			if ($this->dbUser !== $oldUser) {
 				//add prefix to the admin username to prevent collisions
-				$adminUser = substr('oc_' . $username, 0, 16);
+				$adminUser = substr('oc_'.$username, 0, 16);
 
 				$i = 1;
 				while (true) {
@@ -144,15 +144,15 @@ 
 							$this->dbUser = $adminUser;
 
 							//create a random password so we don't need to store the admin password in the config file
-							$this->dbPassword =  $this->random->generate(30);
+							$this->dbPassword = $this->random->generate(30);
 
 							$this->createDBUser($connection);
 
 							break;
 						} else {
 							//repeat with different username
-							$length = strlen((string)$i);
-							$adminUser = substr('oc_' . $username, 0, 16 - $length) . $i;
+							$length = strlen((string) $i);
+							$adminUser = substr('oc_'.$username, 0, 16 - $length).$i;
 							$i++;
 						}
 					} else {

Braces +1 added lines, -2 removed lines

@@ -104,8 +104,7 @@
 			$connection->executeUpdate($query);
 			$query = "CREATE USER '$name'@'%' IDENTIFIED BY '$password'";
 			$connection->executeUpdate($query);
-		}
-		catch (\Exception $ex){
+		} catch (\Exception $ex){
 			$this->logger->logException($ex, [
 				'message' => 'Database user creation failed.',
 				'level' => ILogger::ERROR,

lib/private/Files/Filesystem.php

Doc Comments +31 added lines, -2 removed lines

@@ -360,6 +360,9 @@ 
 		}
 	}
 
+	/**
+	 * @param string $root
+	 */
 	static public function init($user, $root) {
 		if (self::$defaultInstance) {
 			return false;
@@ -528,7 +531,7 @@ 
 	/**
 	 * mount an \OC\Files\Storage\Storage in our virtual filesystem
 	 *
-	 * @param \OC\Files\Storage\Storage|string $class
+	 * @param string $class
 	 * @param array $arguments
 	 * @param string $mountpoint
 	 */
@@ -660,6 +663,9 @@ 
 		return self::$defaultInstance->is_dir($path);
 	}
 
+	/**
+	 * @param string $path
+	 */
 	static public function is_file($path) {
 		return self::$defaultInstance->is_file($path);
 	}
@@ -672,6 +678,9 @@ 
 		return self::$defaultInstance->filetype($path);
 	}
 
+	/**
+	 * @param string $path
+	 */
 	static public function filesize($path) {
 		return self::$defaultInstance->filesize($path);
 	}
@@ -684,6 +693,9 @@ 
 		return self::$defaultInstance->isCreatable($path);
 	}
 
+	/**
+	 * @param string $path
+	 */
 	static public function isReadable($path) {
 		return self::$defaultInstance->isReadable($path);
 	}
@@ -696,6 +708,9 @@ 
 		return self::$defaultInstance->isDeletable($path);
 	}
 
+	/**
+	 * @param string $path
+	 */
 	static public function isSharable($path) {
 		return self::$defaultInstance->isSharable($path);
 	}
@@ -704,6 +719,9 @@ 
 		return self::$defaultInstance->file_exists($path);
 	}
 
+	/**
+	 * @param string $path
+	 */
 	static public function filemtime($path) {
 		return self::$defaultInstance->filemtime($path);
 	}
@@ -713,6 +731,7 @@ 
 	}
 
 	/**
+	 * @param string $path
 	 * @return string
 	 */
 	static public function file_get_contents($path) {
@@ -735,6 +754,10 @@ 
 		return self::$defaultInstance->copy($path1, $path2);
 	}
 
+	/**
+	 * @param string $path
+	 * @param string $mode
+	 */
 	static public function fopen($path, $mode) {
 		return self::$defaultInstance->fopen($path, $mode);
 	}
@@ -750,6 +773,9 @@ 
 		return self::$defaultInstance->fromTmpFile($tmpFile, $path);
 	}
 
+	/**
+	 * @param string $path
+	 */
 	static public function getMimeType($path) {
 		return self::$defaultInstance->getMimeType($path);
 	}
@@ -762,6 +788,9 @@ 
 		return self::$defaultInstance->free_space($path);
 	}
 
+	/**
+	 * @param string $query
+	 */
 	static public function search($query) {
 		return self::$defaultInstance->search($query);
 	}
@@ -870,7 +899,7 @@ 
 	 * @param string $path
 	 * @param boolean $includeMountPoints whether to add mountpoint sizes,
 	 * defaults to true
-	 * @return \OC\Files\FileInfo|bool False if file does not exist
+	 * @return \OCP\Files\FileInfo|null False if file does not exist
 	 */
 	public static function getFileInfo($path, $includeMountPoints = true) {
 		return self::$defaultInstance->getFileInfo($path, $includeMountPoints);

Indentation +853 added lines, -853 removed lines

@@ -70,857 +70,857 @@
 
 class Filesystem {
 
-	/**
-	 * @var Mount\Manager $mounts
-	 */
-	private static $mounts;
-
-	public static $loaded = false;
-	/**
-	 * @var \OC\Files\View $defaultInstance
-	 */
-	static private $defaultInstance;
-
-	static private $usersSetup = array();
-
-	static private $normalizedPathCache = null;
-
-	static private $listeningForProviders = false;
-
-	/**
-	 * classname which used for hooks handling
-	 * used as signalclass in OC_Hooks::emit()
-	 */
-	const CLASSNAME = 'OC_Filesystem';
-
-	/**
-	 * signalname emitted before file renaming
-	 *
-	 * @param string $oldpath
-	 * @param string $newpath
-	 */
-	const signal_rename = 'rename';
-
-	/**
-	 * signal emitted after file renaming
-	 *
-	 * @param string $oldpath
-	 * @param string $newpath
-	 */
-	const signal_post_rename = 'post_rename';
-
-	/**
-	 * signal emitted before file/dir creation
-	 *
-	 * @param string $path
-	 * @param bool $run changing this flag to false in hook handler will cancel event
-	 */
-	const signal_create = 'create';
-
-	/**
-	 * signal emitted after file/dir creation
-	 *
-	 * @param string $path
-	 * @param bool $run changing this flag to false in hook handler will cancel event
-	 */
-	const signal_post_create = 'post_create';
-
-	/**
-	 * signal emits before file/dir copy
-	 *
-	 * @param string $oldpath
-	 * @param string $newpath
-	 * @param bool $run changing this flag to false in hook handler will cancel event
-	 */
-	const signal_copy = 'copy';
-
-	/**
-	 * signal emits after file/dir copy
-	 *
-	 * @param string $oldpath
-	 * @param string $newpath
-	 */
-	const signal_post_copy = 'post_copy';
-
-	/**
-	 * signal emits before file/dir save
-	 *
-	 * @param string $path
-	 * @param bool $run changing this flag to false in hook handler will cancel event
-	 */
-	const signal_write = 'write';
-
-	/**
-	 * signal emits after file/dir save
-	 *
-	 * @param string $path
-	 */
-	const signal_post_write = 'post_write';
-
-	/**
-	 * signal emitted before file/dir update
-	 *
-	 * @param string $path
-	 * @param bool $run changing this flag to false in hook handler will cancel event
-	 */
-	const signal_update = 'update';
-
-	/**
-	 * signal emitted after file/dir update
-	 *
-	 * @param string $path
-	 * @param bool $run changing this flag to false in hook handler will cancel event
-	 */
-	const signal_post_update = 'post_update';
-
-	/**
-	 * signal emits when reading file/dir
-	 *
-	 * @param string $path
-	 */
-	const signal_read = 'read';
-
-	/**
-	 * signal emits when removing file/dir
-	 *
-	 * @param string $path
-	 */
-	const signal_delete = 'delete';
-
-	/**
-	 * parameters definitions for signals
-	 */
-	const signal_param_path = 'path';
-	const signal_param_oldpath = 'oldpath';
-	const signal_param_newpath = 'newpath';
-
-	/**
-	 * run - changing this flag to false in hook handler will cancel event
-	 */
-	const signal_param_run = 'run';
-
-	const signal_create_mount = 'create_mount';
-	const signal_delete_mount = 'delete_mount';
-	const signal_param_mount_type = 'mounttype';
-	const signal_param_users = 'users';
-
-	/**
-	 * @var \OC\Files\Storage\StorageFactory $loader
-	 */
-	private static $loader;
-
-	/** @var bool */
-	private static $logWarningWhenAddingStorageWrapper = true;
-
-	/**
-	 * @param bool $shouldLog
-	 * @return bool previous value
-	 * @internal
-	 */
-	public static function logWarningWhenAddingStorageWrapper($shouldLog) {
-		$previousValue = self::$logWarningWhenAddingStorageWrapper;
-		self::$logWarningWhenAddingStorageWrapper = (bool) $shouldLog;
-		return $previousValue;
-	}
-
-	/**
-	 * @param string $wrapperName
-	 * @param callable $wrapper
-	 * @param int $priority
-	 */
-	public static function addStorageWrapper($wrapperName, $wrapper, $priority = 50) {
-		if (self::$logWarningWhenAddingStorageWrapper) {
-			\OC::$server->getLogger()->warning("Storage wrapper '{wrapper}' was not registered via the 'OC_Filesystem - preSetup' hook which could cause potential problems.", [
-				'wrapper' => $wrapperName,
-				'app' => 'filesystem',
-			]);
-		}
-
-		$mounts = self::getMountManager()->getAll();
-		if (!self::getLoader()->addStorageWrapper($wrapperName, $wrapper, $priority, $mounts)) {
-			// do not re-wrap if storage with this name already existed
-			return;
-		}
-	}
-
-	/**
-	 * Returns the storage factory
-	 *
-	 * @return \OCP\Files\Storage\IStorageFactory
-	 */
-	public static function getLoader() {
-		if (!self::$loader) {
-			self::$loader = new StorageFactory();
-		}
-		return self::$loader;
-	}
-
-	/**
-	 * Returns the mount manager
-	 *
-	 * @return \OC\Files\Mount\Manager
-	 */
-	public static function getMountManager($user = '') {
-		if (!self::$mounts) {
-			\OC_Util::setupFS($user);
-		}
-		return self::$mounts;
-	}
-
-	/**
-	 * get the mountpoint of the storage object for a path
-	 * ( note: because a storage is not always mounted inside the fakeroot, the
-	 * returned mountpoint is relative to the absolute root of the filesystem
-	 * and doesn't take the chroot into account )
-	 *
-	 * @param string $path
-	 * @return string
-	 */
-	static public function getMountPoint($path) {
-		if (!self::$mounts) {
-			\OC_Util::setupFS();
-		}
-		$mount = self::$mounts->find($path);
-		if ($mount) {
-			return $mount->getMountPoint();
-		} else {
-			return '';
-		}
-	}
-
-	/**
-	 * get a list of all mount points in a directory
-	 *
-	 * @param string $path
-	 * @return string[]
-	 */
-	static public function getMountPoints($path) {
-		if (!self::$mounts) {
-			\OC_Util::setupFS();
-		}
-		$result = array();
-		$mounts = self::$mounts->findIn($path);
-		foreach ($mounts as $mount) {
-			$result[] = $mount->getMountPoint();
-		}
-		return $result;
-	}
-
-	/**
-	 * get the storage mounted at $mountPoint
-	 *
-	 * @param string $mountPoint
-	 * @return \OC\Files\Storage\Storage
-	 */
-	public static function getStorage($mountPoint) {
-		if (!self::$mounts) {
-			\OC_Util::setupFS();
-		}
-		$mount = self::$mounts->find($mountPoint);
-		return $mount->getStorage();
-	}
-
-	/**
-	 * @param string $id
-	 * @return Mount\MountPoint[]
-	 */
-	public static function getMountByStorageId($id) {
-		if (!self::$mounts) {
-			\OC_Util::setupFS();
-		}
-		return self::$mounts->findByStorageId($id);
-	}
-
-	/**
-	 * @param int $id
-	 * @return Mount\MountPoint[]
-	 */
-	public static function getMountByNumericId($id) {
-		if (!self::$mounts) {
-			\OC_Util::setupFS();
-		}
-		return self::$mounts->findByNumericId($id);
-	}
-
-	/**
-	 * resolve a path to a storage and internal path
-	 *
-	 * @param string $path
-	 * @return array an array consisting of the storage and the internal path
-	 */
-	static public function resolvePath($path) {
-		if (!self::$mounts) {
-			\OC_Util::setupFS();
-		}
-		$mount = self::$mounts->find($path);
-		if ($mount) {
-			return array($mount->getStorage(), rtrim($mount->getInternalPath($path), '/'));
-		} else {
-			return array(null, null);
-		}
-	}
-
-	static public function init($user, $root) {
-		if (self::$defaultInstance) {
-			return false;
-		}
-		self::getLoader();
-		self::$defaultInstance = new View($root);
-
-		if (!self::$mounts) {
-			self::$mounts = \OC::$server->getMountManager();
-		}
-
-		//load custom mount config
-		self::initMountPoints($user);
-
-		self::$loaded = true;
-
-		return true;
-	}
-
-	static public function initMountManager() {
-		if (!self::$mounts) {
-			self::$mounts = \OC::$server->getMountManager();
-		}
-	}
-
-	/**
-	 * Initialize system and personal mount points for a user
-	 *
-	 * @param string $user
-	 * @throws \OC\User\NoUserException if the user is not available
-	 */
-	public static function initMountPoints($user = '') {
-		if ($user == '') {
-			$user = \OC_User::getUser();
-		}
-		if ($user === null || $user === false || $user === '') {
-			throw new \OC\User\NoUserException('Attempted to initialize mount points for null user and no user in session');
-		}
-
-		if (isset(self::$usersSetup[$user])) {
-			return;
-		}
-
-		self::$usersSetup[$user] = true;
-
-		$userManager = \OC::$server->getUserManager();
-		$userObject = $userManager->get($user);
-
-		if (is_null($userObject)) {
-			\OCP\Util::writeLog('files', ' Backends provided no user object for ' . $user, ILogger::ERROR);
-			// reset flag, this will make it possible to rethrow the exception if called again
-			unset(self::$usersSetup[$user]);
-			throw new \OC\User\NoUserException('Backends provided no user object for ' . $user);
-		}
-
-		$realUid = $userObject->getUID();
-		// workaround in case of different casings
-		if ($user !== $realUid) {
-			$stack = json_encode(debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 50));
-			\OCP\Util::writeLog('files', 'initMountPoints() called with wrong user casing. This could be a bug. Expected: "' . $realUid . '" got "' . $user . '". Stack: ' . $stack, ILogger::WARN);
-			$user = $realUid;
-
-			// again with the correct casing
-			if (isset(self::$usersSetup[$user])) {
-				return;
-			}
-
-			self::$usersSetup[$user] = true;
-		}
-
-		if (\OC::$server->getLockdownManager()->canAccessFilesystem()) {
-			/** @var \OC\Files\Config\MountProviderCollection $mountConfigManager */
-			$mountConfigManager = \OC::$server->getMountProviderCollection();
-
-			// home mounts are handled seperate since we need to ensure this is mounted before we call the other mount providers
-			$homeMount = $mountConfigManager->getHomeMountForUser($userObject);
-
-			self::getMountManager()->addMount($homeMount);
-
-			\OC\Files\Filesystem::getStorage($user);
-
-			// Chance to mount for other storages
-			if ($userObject) {
-				$mounts = $mountConfigManager->addMountForUser($userObject, self::getMountManager());
-				$mounts[] = $homeMount;
-				$mountConfigManager->registerMounts($userObject, $mounts);
-			}
-
-			self::listenForNewMountProviders($mountConfigManager, $userManager);
-		} else {
-			self::getMountManager()->addMount(new MountPoint(
-				new NullStorage([]),
-				'/' . $user
-			));
-			self::getMountManager()->addMount(new MountPoint(
-				new NullStorage([]),
-				'/' . $user . '/files'
-			));
-		}
-		\OC_Hook::emit('OC_Filesystem', 'post_initMountPoints', array('user' => $user));
-	}
-
-	/**
-	 * Get mounts from mount providers that are registered after setup
-	 *
-	 * @param MountProviderCollection $mountConfigManager
-	 * @param IUserManager $userManager
-	 */
-	private static function listenForNewMountProviders(MountProviderCollection $mountConfigManager, IUserManager $userManager) {
-		if (!self::$listeningForProviders) {
-			self::$listeningForProviders = true;
-			$mountConfigManager->listen('\OC\Files\Config', 'registerMountProvider', function (IMountProvider $provider) use ($userManager) {
-				foreach (Filesystem::$usersSetup as $user => $setup) {
-					$userObject = $userManager->get($user);
-					if ($userObject) {
-						$mounts = $provider->getMountsForUser($userObject, Filesystem::getLoader());
-						array_walk($mounts, array(self::$mounts, 'addMount'));
-					}
-				}
-			});
-		}
-	}
-
-	/**
-	 * get the default filesystem view
-	 *
-	 * @return View
-	 */
-	static public function getView() {
-		return self::$defaultInstance;
-	}
-
-	/**
-	 * tear down the filesystem, removing all storage providers
-	 */
-	static public function tearDown() {
-		self::clearMounts();
-		self::$defaultInstance = null;
-	}
-
-	/**
-	 * get the relative path of the root data directory for the current user
-	 *
-	 * @return string
-	 *
-	 * Returns path like /admin/files
-	 */
-	static public function getRoot() {
-		if (!self::$defaultInstance) {
-			return null;
-		}
-		return self::$defaultInstance->getRoot();
-	}
-
-	/**
-	 * clear all mounts and storage backends
-	 */
-	public static function clearMounts() {
-		if (self::$mounts) {
-			self::$usersSetup = array();
-			self::$mounts->clear();
-		}
-	}
-
-	/**
-	 * mount an \OC\Files\Storage\Storage in our virtual filesystem
-	 *
-	 * @param \OC\Files\Storage\Storage|string $class
-	 * @param array $arguments
-	 * @param string $mountpoint
-	 */
-	static public function mount($class, $arguments, $mountpoint) {
-		if (!self::$mounts) {
-			\OC_Util::setupFS();
-		}
-		$mount = new Mount\MountPoint($class, $mountpoint, $arguments, self::getLoader());
-		self::$mounts->addMount($mount);
-	}
-
-	/**
-	 * return the path to a local version of the file
-	 * we need this because we can't know if a file is stored local or not from
-	 * outside the filestorage and for some purposes a local file is needed
-	 *
-	 * @param string $path
-	 * @return string
-	 */
-	static public function getLocalFile($path) {
-		return self::$defaultInstance->getLocalFile($path);
-	}
-
-	/**
-	 * @param string $path
-	 * @return string
-	 */
-	static public function getLocalFolder($path) {
-		return self::$defaultInstance->getLocalFolder($path);
-	}
-
-	/**
-	 * return path to file which reflects one visible in browser
-	 *
-	 * @param string $path
-	 * @return string
-	 */
-	static public function getLocalPath($path) {
-		$datadir = \OC_User::getHome(\OC_User::getUser()) . '/files';
-		$newpath = $path;
-		if (strncmp($newpath, $datadir, strlen($datadir)) == 0) {
-			$newpath = substr($path, strlen($datadir));
-		}
-		return $newpath;
-	}
-
-	/**
-	 * check if the requested path is valid
-	 *
-	 * @param string $path
-	 * @return bool
-	 */
-	static public function isValidPath($path) {
-		$path = self::normalizePath($path);
-		if (!$path || $path[0] !== '/') {
-			$path = '/' . $path;
-		}
-		if (strpos($path, '/../') !== false || strrchr($path, '/') === '/..') {
-			return false;
-		}
-		return true;
-	}
-
-	/**
-	 * checks if a file is blacklisted for storage in the filesystem
-	 * Listens to write and rename hooks
-	 *
-	 * @param array $data from hook
-	 */
-	static public function isBlacklisted($data) {
-		if (isset($data['path'])) {
-			$path = $data['path'];
-		} else if (isset($data['newpath'])) {
-			$path = $data['newpath'];
-		}
-		if (isset($path)) {
-			if (self::isFileBlacklisted($path)) {
-				$data['run'] = false;
-			}
-		}
-	}
-
-	/**
-	 * @param string $filename
-	 * @return bool
-	 */
-	static public function isFileBlacklisted($filename) {
-		$filename = self::normalizePath($filename);
-
-		$blacklist = \OC::$server->getConfig()->getSystemValue('blacklisted_files', array('.htaccess'));
-		$filename = strtolower(basename($filename));
-		return in_array($filename, $blacklist);
-	}
-
-	/**
-	 * check if the directory should be ignored when scanning
-	 * NOTE: the special directories . and .. would cause never ending recursion
-	 *
-	 * @param String $dir
-	 * @return boolean
-	 */
-	static public function isIgnoredDir($dir) {
-		if ($dir === '.' || $dir === '..') {
-			return true;
-		}
-		return false;
-	}
-
-	/**
-	 * following functions are equivalent to their php builtin equivalents for arguments/return values.
-	 */
-	static public function mkdir($path) {
-		return self::$defaultInstance->mkdir($path);
-	}
-
-	static public function rmdir($path) {
-		return self::$defaultInstance->rmdir($path);
-	}
-
-	static public function is_dir($path) {
-		return self::$defaultInstance->is_dir($path);
-	}
-
-	static public function is_file($path) {
-		return self::$defaultInstance->is_file($path);
-	}
-
-	static public function stat($path) {
-		return self::$defaultInstance->stat($path);
-	}
-
-	static public function filetype($path) {
-		return self::$defaultInstance->filetype($path);
-	}
-
-	static public function filesize($path) {
-		return self::$defaultInstance->filesize($path);
-	}
-
-	static public function readfile($path) {
-		return self::$defaultInstance->readfile($path);
-	}
-
-	static public function isCreatable($path) {
-		return self::$defaultInstance->isCreatable($path);
-	}
-
-	static public function isReadable($path) {
-		return self::$defaultInstance->isReadable($path);
-	}
-
-	static public function isUpdatable($path) {
-		return self::$defaultInstance->isUpdatable($path);
-	}
-
-	static public function isDeletable($path) {
-		return self::$defaultInstance->isDeletable($path);
-	}
-
-	static public function isSharable($path) {
-		return self::$defaultInstance->isSharable($path);
-	}
-
-	static public function file_exists($path) {
-		return self::$defaultInstance->file_exists($path);
-	}
-
-	static public function filemtime($path) {
-		return self::$defaultInstance->filemtime($path);
-	}
-
-	static public function touch($path, $mtime = null) {
-		return self::$defaultInstance->touch($path, $mtime);
-	}
-
-	/**
-	 * @return string
-	 */
-	static public function file_get_contents($path) {
-		return self::$defaultInstance->file_get_contents($path);
-	}
-
-	static public function file_put_contents($path, $data) {
-		return self::$defaultInstance->file_put_contents($path, $data);
-	}
-
-	static public function unlink($path) {
-		return self::$defaultInstance->unlink($path);
-	}
-
-	static public function rename($path1, $path2) {
-		return self::$defaultInstance->rename($path1, $path2);
-	}
-
-	static public function copy($path1, $path2) {
-		return self::$defaultInstance->copy($path1, $path2);
-	}
-
-	static public function fopen($path, $mode) {
-		return self::$defaultInstance->fopen($path, $mode);
-	}
-
-	/**
-	 * @return string
-	 */
-	static public function toTmpFile($path) {
-		return self::$defaultInstance->toTmpFile($path);
-	}
-
-	static public function fromTmpFile($tmpFile, $path) {
-		return self::$defaultInstance->fromTmpFile($tmpFile, $path);
-	}
-
-	static public function getMimeType($path) {
-		return self::$defaultInstance->getMimeType($path);
-	}
-
-	static public function hash($type, $path, $raw = false) {
-		return self::$defaultInstance->hash($type, $path, $raw);
-	}
-
-	static public function free_space($path = '/') {
-		return self::$defaultInstance->free_space($path);
-	}
-
-	static public function search($query) {
-		return self::$defaultInstance->search($query);
-	}
-
-	/**
-	 * @param string $query
-	 */
-	static public function searchByMime($query) {
-		return self::$defaultInstance->searchByMime($query);
-	}
-
-	/**
-	 * @param string|int $tag name or tag id
-	 * @param string $userId owner of the tags
-	 * @return FileInfo[] array or file info
-	 */
-	static public function searchByTag($tag, $userId) {
-		return self::$defaultInstance->searchByTag($tag, $userId);
-	}
-
-	/**
-	 * check if a file or folder has been updated since $time
-	 *
-	 * @param string $path
-	 * @param int $time
-	 * @return bool
-	 */
-	static public function hasUpdated($path, $time) {
-		return self::$defaultInstance->hasUpdated($path, $time);
-	}
-
-	/**
-	 * Fix common problems with a file path
-	 *
-	 * @param string $path
-	 * @param bool $stripTrailingSlash whether to strip the trailing slash
-	 * @param bool $isAbsolutePath whether the given path is absolute
-	 * @param bool $keepUnicode true to disable unicode normalization
-	 * @return string
-	 */
-	public static function normalizePath($path, $stripTrailingSlash = true, $isAbsolutePath = false, $keepUnicode = false) {
-		if (is_null(self::$normalizedPathCache)) {
-			self::$normalizedPathCache = new CappedMemoryCache(2048);
-		}
-
-		/**
-		 * FIXME: This is a workaround for existing classes and files which call
-		 *        this function with another type than a valid string. This
-		 *        conversion should get removed as soon as all existing
-		 *        function calls have been fixed.
-		 */
-		$path = (string)$path;
-
-		$cacheKey = json_encode([$path, $stripTrailingSlash, $isAbsolutePath, $keepUnicode]);
-
-		if (isset(self::$normalizedPathCache[$cacheKey])) {
-			return self::$normalizedPathCache[$cacheKey];
-		}
-
-		if ($path == '') {
-			return '/';
-		}
-
-		//normalize unicode if possible
-		if (!$keepUnicode) {
-			$path = \OC_Util::normalizeUnicode($path);
-		}
-
-		//no windows style slashes
-		$path = str_replace('\\', '/', $path);
-
-		//add leading slash
-		if ($path[0] !== '/') {
-			$path = '/' . $path;
-		}
-
-		// remove '/./'
-		// ugly, but str_replace() can't replace them all in one go
-		// as the replacement itself is part of the search string
-		// which will only be found during the next iteration
-		while (strpos($path, '/./') !== false) {
-			$path = str_replace('/./', '/', $path);
-		}
-		// remove sequences of slashes
-		$path = preg_replace('#/{2,}#', '/', $path);
-
-		//remove trailing slash
-		if ($stripTrailingSlash and strlen($path) > 1) {
-			$path = rtrim($path, '/');
-		}
-
-		// remove trailing '/.'
-		if (substr($path, -2) == '/.') {
-			$path = substr($path, 0, -2);
-		}
-
-		$normalizedPath = $path;
-		self::$normalizedPathCache[$cacheKey] = $normalizedPath;
-
-		return $normalizedPath;
-	}
-
-	/**
-	 * get the filesystem info
-	 *
-	 * @param string $path
-	 * @param boolean $includeMountPoints whether to add mountpoint sizes,
-	 * defaults to true
-	 * @return \OC\Files\FileInfo|bool False if file does not exist
-	 */
-	public static function getFileInfo($path, $includeMountPoints = true) {
-		return self::$defaultInstance->getFileInfo($path, $includeMountPoints);
-	}
-
-	/**
-	 * change file metadata
-	 *
-	 * @param string $path
-	 * @param array $data
-	 * @return int
-	 *
-	 * returns the fileid of the updated file
-	 */
-	public static function putFileInfo($path, $data) {
-		return self::$defaultInstance->putFileInfo($path, $data);
-	}
-
-	/**
-	 * get the content of a directory
-	 *
-	 * @param string $directory path under datadirectory
-	 * @param string $mimetype_filter limit returned content to this mimetype or mimepart
-	 * @return \OC\Files\FileInfo[]
-	 */
-	public static function getDirectoryContent($directory, $mimetype_filter = '') {
-		return self::$defaultInstance->getDirectoryContent($directory, $mimetype_filter);
-	}
-
-	/**
-	 * Get the path of a file by id
-	 *
-	 * Note that the resulting path is not guaranteed to be unique for the id, multiple paths can point to the same file
-	 *
-	 * @param int $id
-	 * @throws NotFoundException
-	 * @return string
-	 */
-	public static function getPath($id) {
-		return self::$defaultInstance->getPath($id);
-	}
-
-	/**
-	 * Get the owner for a file or folder
-	 *
-	 * @param string $path
-	 * @return string
-	 */
-	public static function getOwner($path) {
-		return self::$defaultInstance->getOwner($path);
-	}
-
-	/**
-	 * get the ETag for a file or folder
-	 *
-	 * @param string $path
-	 * @return string
-	 */
-	static public function getETag($path) {
-		return self::$defaultInstance->getETag($path);
-	}
+    /**
+     * @var Mount\Manager $mounts
+     */
+    private static $mounts;
+
+    public static $loaded = false;
+    /**
+     * @var \OC\Files\View $defaultInstance
+     */
+    static private $defaultInstance;
+
+    static private $usersSetup = array();
+
+    static private $normalizedPathCache = null;
+
+    static private $listeningForProviders = false;
+
+    /**
+     * classname which used for hooks handling
+     * used as signalclass in OC_Hooks::emit()
+     */
+    const CLASSNAME = 'OC_Filesystem';
+
+    /**
+     * signalname emitted before file renaming
+     *
+     * @param string $oldpath
+     * @param string $newpath
+     */
+    const signal_rename = 'rename';
+
+    /**
+     * signal emitted after file renaming
+     *
+     * @param string $oldpath
+     * @param string $newpath
+     */
+    const signal_post_rename = 'post_rename';
+
+    /**
+     * signal emitted before file/dir creation
+     *
+     * @param string $path
+     * @param bool $run changing this flag to false in hook handler will cancel event
+     */
+    const signal_create = 'create';
+
+    /**
+     * signal emitted after file/dir creation
+     *
+     * @param string $path
+     * @param bool $run changing this flag to false in hook handler will cancel event
+     */
+    const signal_post_create = 'post_create';
+
+    /**
+     * signal emits before file/dir copy
+     *
+     * @param string $oldpath
+     * @param string $newpath
+     * @param bool $run changing this flag to false in hook handler will cancel event
+     */
+    const signal_copy = 'copy';
+
+    /**
+     * signal emits after file/dir copy
+     *
+     * @param string $oldpath
+     * @param string $newpath
+     */
+    const signal_post_copy = 'post_copy';
+
+    /**
+     * signal emits before file/dir save
+     *
+     * @param string $path
+     * @param bool $run changing this flag to false in hook handler will cancel event
+     */
+    const signal_write = 'write';
+
+    /**
+     * signal emits after file/dir save
+     *
+     * @param string $path
+     */
+    const signal_post_write = 'post_write';
+
+    /**
+     * signal emitted before file/dir update
+     *
+     * @param string $path
+     * @param bool $run changing this flag to false in hook handler will cancel event
+     */
+    const signal_update = 'update';
+
+    /**
+     * signal emitted after file/dir update
+     *
+     * @param string $path
+     * @param bool $run changing this flag to false in hook handler will cancel event
+     */
+    const signal_post_update = 'post_update';
+
+    /**
+     * signal emits when reading file/dir
+     *
+     * @param string $path
+     */
+    const signal_read = 'read';
+
+    /**
+     * signal emits when removing file/dir
+     *
+     * @param string $path
+     */
+    const signal_delete = 'delete';
+
+    /**
+     * parameters definitions for signals
+     */
+    const signal_param_path = 'path';
+    const signal_param_oldpath = 'oldpath';
+    const signal_param_newpath = 'newpath';
+
+    /**
+     * run - changing this flag to false in hook handler will cancel event
+     */
+    const signal_param_run = 'run';
+
+    const signal_create_mount = 'create_mount';
+    const signal_delete_mount = 'delete_mount';
+    const signal_param_mount_type = 'mounttype';
+    const signal_param_users = 'users';
+
+    /**
+     * @var \OC\Files\Storage\StorageFactory $loader
+     */
+    private static $loader;
+
+    /** @var bool */
+    private static $logWarningWhenAddingStorageWrapper = true;
+
+    /**
+     * @param bool $shouldLog
+     * @return bool previous value
+     * @internal
+     */
+    public static function logWarningWhenAddingStorageWrapper($shouldLog) {
+        $previousValue = self::$logWarningWhenAddingStorageWrapper;
+        self::$logWarningWhenAddingStorageWrapper = (bool) $shouldLog;
+        return $previousValue;
+    }
+
+    /**
+     * @param string $wrapperName
+     * @param callable $wrapper
+     * @param int $priority
+     */
+    public static function addStorageWrapper($wrapperName, $wrapper, $priority = 50) {
+        if (self::$logWarningWhenAddingStorageWrapper) {
+            \OC::$server->getLogger()->warning("Storage wrapper '{wrapper}' was not registered via the 'OC_Filesystem - preSetup' hook which could cause potential problems.", [
+                'wrapper' => $wrapperName,
+                'app' => 'filesystem',
+            ]);
+        }
+
+        $mounts = self::getMountManager()->getAll();
+        if (!self::getLoader()->addStorageWrapper($wrapperName, $wrapper, $priority, $mounts)) {
+            // do not re-wrap if storage with this name already existed
+            return;
+        }
+    }
+
+    /**
+     * Returns the storage factory
+     *
+     * @return \OCP\Files\Storage\IStorageFactory
+     */
+    public static function getLoader() {
+        if (!self::$loader) {
+            self::$loader = new StorageFactory();
+        }
+        return self::$loader;
+    }
+
+    /**
+     * Returns the mount manager
+     *
+     * @return \OC\Files\Mount\Manager
+     */
+    public static function getMountManager($user = '') {
+        if (!self::$mounts) {
+            \OC_Util::setupFS($user);
+        }
+        return self::$mounts;
+    }
+
+    /**
+     * get the mountpoint of the storage object for a path
+     * ( note: because a storage is not always mounted inside the fakeroot, the
+     * returned mountpoint is relative to the absolute root of the filesystem
+     * and doesn't take the chroot into account )
+     *
+     * @param string $path
+     * @return string
+     */
+    static public function getMountPoint($path) {
+        if (!self::$mounts) {
+            \OC_Util::setupFS();
+        }
+        $mount = self::$mounts->find($path);
+        if ($mount) {
+            return $mount->getMountPoint();
+        } else {
+            return '';
+        }
+    }
+
+    /**
+     * get a list of all mount points in a directory
+     *
+     * @param string $path
+     * @return string[]
+     */
+    static public function getMountPoints($path) {
+        if (!self::$mounts) {
+            \OC_Util::setupFS();
+        }
+        $result = array();
+        $mounts = self::$mounts->findIn($path);
+        foreach ($mounts as $mount) {
+            $result[] = $mount->getMountPoint();
+        }
+        return $result;
+    }
+
+    /**
+     * get the storage mounted at $mountPoint
+     *
+     * @param string $mountPoint
+     * @return \OC\Files\Storage\Storage
+     */
+    public static function getStorage($mountPoint) {
+        if (!self::$mounts) {
+            \OC_Util::setupFS();
+        }
+        $mount = self::$mounts->find($mountPoint);
+        return $mount->getStorage();
+    }
+
+    /**
+     * @param string $id
+     * @return Mount\MountPoint[]
+     */
+    public static function getMountByStorageId($id) {
+        if (!self::$mounts) {
+            \OC_Util::setupFS();
+        }
+        return self::$mounts->findByStorageId($id);
+    }
+
+    /**
+     * @param int $id
+     * @return Mount\MountPoint[]
+     */
+    public static function getMountByNumericId($id) {
+        if (!self::$mounts) {
+            \OC_Util::setupFS();
+        }
+        return self::$mounts->findByNumericId($id);
+    }
+
+    /**
+     * resolve a path to a storage and internal path
+     *
+     * @param string $path
+     * @return array an array consisting of the storage and the internal path
+     */
+    static public function resolvePath($path) {
+        if (!self::$mounts) {
+            \OC_Util::setupFS();
+        }
+        $mount = self::$mounts->find($path);
+        if ($mount) {
+            return array($mount->getStorage(), rtrim($mount->getInternalPath($path), '/'));
+        } else {
+            return array(null, null);
+        }
+    }
+
+    static public function init($user, $root) {
+        if (self::$defaultInstance) {
+            return false;
+        }
+        self::getLoader();
+        self::$defaultInstance = new View($root);
+
+        if (!self::$mounts) {
+            self::$mounts = \OC::$server->getMountManager();
+        }
+
+        //load custom mount config
+        self::initMountPoints($user);
+
+        self::$loaded = true;
+
+        return true;
+    }
+
+    static public function initMountManager() {
+        if (!self::$mounts) {
+            self::$mounts = \OC::$server->getMountManager();
+        }
+    }
+
+    /**
+     * Initialize system and personal mount points for a user
+     *
+     * @param string $user
+     * @throws \OC\User\NoUserException if the user is not available
+     */
+    public static function initMountPoints($user = '') {
+        if ($user == '') {
+            $user = \OC_User::getUser();
+        }
+        if ($user === null || $user === false || $user === '') {
+            throw new \OC\User\NoUserException('Attempted to initialize mount points for null user and no user in session');
+        }
+
+        if (isset(self::$usersSetup[$user])) {
+            return;
+        }
+
+        self::$usersSetup[$user] = true;
+
+        $userManager = \OC::$server->getUserManager();
+        $userObject = $userManager->get($user);
+
+        if (is_null($userObject)) {
+            \OCP\Util::writeLog('files', ' Backends provided no user object for ' . $user, ILogger::ERROR);
+            // reset flag, this will make it possible to rethrow the exception if called again
+            unset(self::$usersSetup[$user]);
+            throw new \OC\User\NoUserException('Backends provided no user object for ' . $user);
+        }
+
+        $realUid = $userObject->getUID();
+        // workaround in case of different casings
+        if ($user !== $realUid) {
+            $stack = json_encode(debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 50));
+            \OCP\Util::writeLog('files', 'initMountPoints() called with wrong user casing. This could be a bug. Expected: "' . $realUid . '" got "' . $user . '". Stack: ' . $stack, ILogger::WARN);
+            $user = $realUid;
+
+            // again with the correct casing
+            if (isset(self::$usersSetup[$user])) {
+                return;
+            }
+
+            self::$usersSetup[$user] = true;
+        }
+
+        if (\OC::$server->getLockdownManager()->canAccessFilesystem()) {
+            /** @var \OC\Files\Config\MountProviderCollection $mountConfigManager */
+            $mountConfigManager = \OC::$server->getMountProviderCollection();
+
+            // home mounts are handled seperate since we need to ensure this is mounted before we call the other mount providers
+            $homeMount = $mountConfigManager->getHomeMountForUser($userObject);
+
+            self::getMountManager()->addMount($homeMount);
+
+            \OC\Files\Filesystem::getStorage($user);
+
+            // Chance to mount for other storages
+            if ($userObject) {
+                $mounts = $mountConfigManager->addMountForUser($userObject, self::getMountManager());
+                $mounts[] = $homeMount;
+                $mountConfigManager->registerMounts($userObject, $mounts);
+            }
+
+            self::listenForNewMountProviders($mountConfigManager, $userManager);
+        } else {
+            self::getMountManager()->addMount(new MountPoint(
+                new NullStorage([]),
+                '/' . $user
+            ));
+            self::getMountManager()->addMount(new MountPoint(
+                new NullStorage([]),
+                '/' . $user . '/files'
+            ));
+        }
+        \OC_Hook::emit('OC_Filesystem', 'post_initMountPoints', array('user' => $user));
+    }
+
+    /**
+     * Get mounts from mount providers that are registered after setup
+     *
+     * @param MountProviderCollection $mountConfigManager
+     * @param IUserManager $userManager
+     */
+    private static function listenForNewMountProviders(MountProviderCollection $mountConfigManager, IUserManager $userManager) {
+        if (!self::$listeningForProviders) {
+            self::$listeningForProviders = true;
+            $mountConfigManager->listen('\OC\Files\Config', 'registerMountProvider', function (IMountProvider $provider) use ($userManager) {
+                foreach (Filesystem::$usersSetup as $user => $setup) {
+                    $userObject = $userManager->get($user);
+                    if ($userObject) {
+                        $mounts = $provider->getMountsForUser($userObject, Filesystem::getLoader());
+                        array_walk($mounts, array(self::$mounts, 'addMount'));
+                    }
+                }
+            });
+        }
+    }
+
+    /**
+     * get the default filesystem view
+     *
+     * @return View
+     */
+    static public function getView() {
+        return self::$defaultInstance;
+    }
+
+    /**
+     * tear down the filesystem, removing all storage providers
+     */
+    static public function tearDown() {
+        self::clearMounts();
+        self::$defaultInstance = null;
+    }
+
+    /**
+     * get the relative path of the root data directory for the current user
+     *
+     * @return string
+     *
+     * Returns path like /admin/files
+     */
+    static public function getRoot() {
+        if (!self::$defaultInstance) {
+            return null;
+        }
+        return self::$defaultInstance->getRoot();
+    }
+
+    /**
+     * clear all mounts and storage backends
+     */
+    public static function clearMounts() {
+        if (self::$mounts) {
+            self::$usersSetup = array();
+            self::$mounts->clear();
+        }
+    }
+
+    /**
+     * mount an \OC\Files\Storage\Storage in our virtual filesystem
+     *
+     * @param \OC\Files\Storage\Storage|string $class
+     * @param array $arguments
+     * @param string $mountpoint
+     */
+    static public function mount($class, $arguments, $mountpoint) {
+        if (!self::$mounts) {
+            \OC_Util::setupFS();
+        }
+        $mount = new Mount\MountPoint($class, $mountpoint, $arguments, self::getLoader());
+        self::$mounts->addMount($mount);
+    }
+
+    /**
+     * return the path to a local version of the file
+     * we need this because we can't know if a file is stored local or not from
+     * outside the filestorage and for some purposes a local file is needed
+     *
+     * @param string $path
+     * @return string
+     */
+    static public function getLocalFile($path) {
+        return self::$defaultInstance->getLocalFile($path);
+    }
+
+    /**
+     * @param string $path
+     * @return string
+     */
+    static public function getLocalFolder($path) {
+        return self::$defaultInstance->getLocalFolder($path);
+    }
+
+    /**
+     * return path to file which reflects one visible in browser
+     *
+     * @param string $path
+     * @return string
+     */
+    static public function getLocalPath($path) {
+        $datadir = \OC_User::getHome(\OC_User::getUser()) . '/files';
+        $newpath = $path;
+        if (strncmp($newpath, $datadir, strlen($datadir)) == 0) {
+            $newpath = substr($path, strlen($datadir));
+        }
+        return $newpath;
+    }
+
+    /**
+     * check if the requested path is valid
+     *
+     * @param string $path
+     * @return bool
+     */
+    static public function isValidPath($path) {
+        $path = self::normalizePath($path);
+        if (!$path || $path[0] !== '/') {
+            $path = '/' . $path;
+        }
+        if (strpos($path, '/../') !== false || strrchr($path, '/') === '/..') {
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * checks if a file is blacklisted for storage in the filesystem
+     * Listens to write and rename hooks
+     *
+     * @param array $data from hook
+     */
+    static public function isBlacklisted($data) {
+        if (isset($data['path'])) {
+            $path = $data['path'];
+        } else if (isset($data['newpath'])) {
+            $path = $data['newpath'];
+        }
+        if (isset($path)) {
+            if (self::isFileBlacklisted($path)) {
+                $data['run'] = false;
+            }
+        }
+    }
+
+    /**
+     * @param string $filename
+     * @return bool
+     */
+    static public function isFileBlacklisted($filename) {
+        $filename = self::normalizePath($filename);
+
+        $blacklist = \OC::$server->getConfig()->getSystemValue('blacklisted_files', array('.htaccess'));
+        $filename = strtolower(basename($filename));
+        return in_array($filename, $blacklist);
+    }
+
+    /**
+     * check if the directory should be ignored when scanning
+     * NOTE: the special directories . and .. would cause never ending recursion
+     *
+     * @param String $dir
+     * @return boolean
+     */
+    static public function isIgnoredDir($dir) {
+        if ($dir === '.' || $dir === '..') {
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * following functions are equivalent to their php builtin equivalents for arguments/return values.
+     */
+    static public function mkdir($path) {
+        return self::$defaultInstance->mkdir($path);
+    }
+
+    static public function rmdir($path) {
+        return self::$defaultInstance->rmdir($path);
+    }
+
+    static public function is_dir($path) {
+        return self::$defaultInstance->is_dir($path);
+    }
+
+    static public function is_file($path) {
+        return self::$defaultInstance->is_file($path);
+    }
+
+    static public function stat($path) {
+        return self::$defaultInstance->stat($path);
+    }
+
+    static public function filetype($path) {
+        return self::$defaultInstance->filetype($path);
+    }
+
+    static public function filesize($path) {
+        return self::$defaultInstance->filesize($path);
+    }
+
+    static public function readfile($path) {
+        return self::$defaultInstance->readfile($path);
+    }
+
+    static public function isCreatable($path) {
+        return self::$defaultInstance->isCreatable($path);
+    }
+
+    static public function isReadable($path) {
+        return self::$defaultInstance->isReadable($path);
+    }
+
+    static public function isUpdatable($path) {
+        return self::$defaultInstance->isUpdatable($path);
+    }
+
+    static public function isDeletable($path) {
+        return self::$defaultInstance->isDeletable($path);
+    }
+
+    static public function isSharable($path) {
+        return self::$defaultInstance->isSharable($path);
+    }
+
+    static public function file_exists($path) {
+        return self::$defaultInstance->file_exists($path);
+    }
+
+    static public function filemtime($path) {
+        return self::$defaultInstance->filemtime($path);
+    }
+
+    static public function touch($path, $mtime = null) {
+        return self::$defaultInstance->touch($path, $mtime);
+    }
+
+    /**
+     * @return string
+     */
+    static public function file_get_contents($path) {
+        return self::$defaultInstance->file_get_contents($path);
+    }
+
+    static public function file_put_contents($path, $data) {
+        return self::$defaultInstance->file_put_contents($path, $data);
+    }
+
+    static public function unlink($path) {
+        return self::$defaultInstance->unlink($path);
+    }
+
+    static public function rename($path1, $path2) {
+        return self::$defaultInstance->rename($path1, $path2);
+    }
+
+    static public function copy($path1, $path2) {
+        return self::$defaultInstance->copy($path1, $path2);
+    }
+
+    static public function fopen($path, $mode) {
+        return self::$defaultInstance->fopen($path, $mode);
+    }
+
+    /**
+     * @return string
+     */
+    static public function toTmpFile($path) {
+        return self::$defaultInstance->toTmpFile($path);
+    }
+
+    static public function fromTmpFile($tmpFile, $path) {
+        return self::$defaultInstance->fromTmpFile($tmpFile, $path);
+    }
+
+    static public function getMimeType($path) {
+        return self::$defaultInstance->getMimeType($path);
+    }
+
+    static public function hash($type, $path, $raw = false) {
+        return self::$defaultInstance->hash($type, $path, $raw);
+    }
+
+    static public function free_space($path = '/') {
+        return self::$defaultInstance->free_space($path);
+    }
+
+    static public function search($query) {
+        return self::$defaultInstance->search($query);
+    }
+
+    /**
+     * @param string $query
+     */
+    static public function searchByMime($query) {
+        return self::$defaultInstance->searchByMime($query);
+    }
+
+    /**
+     * @param string|int $tag name or tag id
+     * @param string $userId owner of the tags
+     * @return FileInfo[] array or file info
+     */
+    static public function searchByTag($tag, $userId) {
+        return self::$defaultInstance->searchByTag($tag, $userId);
+    }
+
+    /**
+     * check if a file or folder has been updated since $time
+     *
+     * @param string $path
+     * @param int $time
+     * @return bool
+     */
+    static public function hasUpdated($path, $time) {
+        return self::$defaultInstance->hasUpdated($path, $time);
+    }
+
+    /**
+     * Fix common problems with a file path
+     *
+     * @param string $path
+     * @param bool $stripTrailingSlash whether to strip the trailing slash
+     * @param bool $isAbsolutePath whether the given path is absolute
+     * @param bool $keepUnicode true to disable unicode normalization
+     * @return string
+     */
+    public static function normalizePath($path, $stripTrailingSlash = true, $isAbsolutePath = false, $keepUnicode = false) {
+        if (is_null(self::$normalizedPathCache)) {
+            self::$normalizedPathCache = new CappedMemoryCache(2048);
+        }
+
+        /**
+         * FIXME: This is a workaround for existing classes and files which call
+         *        this function with another type than a valid string. This
+         *        conversion should get removed as soon as all existing
+         *        function calls have been fixed.
+         */
+        $path = (string)$path;
+
+        $cacheKey = json_encode([$path, $stripTrailingSlash, $isAbsolutePath, $keepUnicode]);
+
+        if (isset(self::$normalizedPathCache[$cacheKey])) {
+            return self::$normalizedPathCache[$cacheKey];
+        }
+
+        if ($path == '') {
+            return '/';
+        }
+
+        //normalize unicode if possible
+        if (!$keepUnicode) {
+            $path = \OC_Util::normalizeUnicode($path);
+        }
+
+        //no windows style slashes
+        $path = str_replace('\\', '/', $path);
+
+        //add leading slash
+        if ($path[0] !== '/') {
+            $path = '/' . $path;
+        }
+
+        // remove '/./'
+        // ugly, but str_replace() can't replace them all in one go
+        // as the replacement itself is part of the search string
+        // which will only be found during the next iteration
+        while (strpos($path, '/./') !== false) {
+            $path = str_replace('/./', '/', $path);
+        }
+        // remove sequences of slashes
+        $path = preg_replace('#/{2,}#', '/', $path);
+
+        //remove trailing slash
+        if ($stripTrailingSlash and strlen($path) > 1) {
+            $path = rtrim($path, '/');
+        }
+
+        // remove trailing '/.'
+        if (substr($path, -2) == '/.') {
+            $path = substr($path, 0, -2);
+        }
+
+        $normalizedPath = $path;
+        self::$normalizedPathCache[$cacheKey] = $normalizedPath;
+
+        return $normalizedPath;
+    }
+
+    /**
+     * get the filesystem info
+     *
+     * @param string $path
+     * @param boolean $includeMountPoints whether to add mountpoint sizes,
+     * defaults to true
+     * @return \OC\Files\FileInfo|bool False if file does not exist
+     */
+    public static function getFileInfo($path, $includeMountPoints = true) {
+        return self::$defaultInstance->getFileInfo($path, $includeMountPoints);
+    }
+
+    /**
+     * change file metadata
+     *
+     * @param string $path
+     * @param array $data
+     * @return int
+     *
+     * returns the fileid of the updated file
+     */
+    public static function putFileInfo($path, $data) {
+        return self::$defaultInstance->putFileInfo($path, $data);
+    }
+
+    /**
+     * get the content of a directory
+     *
+     * @param string $directory path under datadirectory
+     * @param string $mimetype_filter limit returned content to this mimetype or mimepart
+     * @return \OC\Files\FileInfo[]
+     */
+    public static function getDirectoryContent($directory, $mimetype_filter = '') {
+        return self::$defaultInstance->getDirectoryContent($directory, $mimetype_filter);
+    }
+
+    /**
+     * Get the path of a file by id
+     *
+     * Note that the resulting path is not guaranteed to be unique for the id, multiple paths can point to the same file
+     *
+     * @param int $id
+     * @throws NotFoundException
+     * @return string
+     */
+    public static function getPath($id) {
+        return self::$defaultInstance->getPath($id);
+    }
+
+    /**
+     * Get the owner for a file or folder
+     *
+     * @param string $path
+     * @return string
+     */
+    public static function getOwner($path) {
+        return self::$defaultInstance->getOwner($path);
+    }
+
+    /**
+     * get the ETag for a file or folder
+     *
+     * @param string $path
+     * @return string
+     */
+    static public function getETag($path) {
+        return self::$defaultInstance->getETag($path);
+    }
 }

Spacing +10 added lines, -10 removed lines

@@ -409,17 +409,17 @@ 
 		$userObject = $userManager->get($user);
 
 		if (is_null($userObject)) {
-			\OCP\Util::writeLog('files', ' Backends provided no user object for ' . $user, ILogger::ERROR);
+			\OCP\Util::writeLog('files', ' Backends provided no user object for '.$user, ILogger::ERROR);
 			// reset flag, this will make it possible to rethrow the exception if called again
 			unset(self::$usersSetup[$user]);
-			throw new \OC\User\NoUserException('Backends provided no user object for ' . $user);
+			throw new \OC\User\NoUserException('Backends provided no user object for '.$user);
 		}
 
 		$realUid = $userObject->getUID();
 		// workaround in case of different casings
 		if ($user !== $realUid) {
 			$stack = json_encode(debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 50));
-			\OCP\Util::writeLog('files', 'initMountPoints() called with wrong user casing. This could be a bug. Expected: "' . $realUid . '" got "' . $user . '". Stack: ' . $stack, ILogger::WARN);
+			\OCP\Util::writeLog('files', 'initMountPoints() called with wrong user casing. This could be a bug. Expected: "'.$realUid.'" got "'.$user.'". Stack: '.$stack, ILogger::WARN);
 			$user = $realUid;
 
 			// again with the correct casing
@@ -452,11 +452,11 @@ 
 		} else {
 			self::getMountManager()->addMount(new MountPoint(
 				new NullStorage([]),
-				'/' . $user
+				'/'.$user
 			));
 			self::getMountManager()->addMount(new MountPoint(
 				new NullStorage([]),
-				'/' . $user . '/files'
+				'/'.$user.'/files'
 			));
 		}
 		\OC_Hook::emit('OC_Filesystem', 'post_initMountPoints', array('user' => $user));
@@ -471,7 +471,7 @@ 
 	private static function listenForNewMountProviders(MountProviderCollection $mountConfigManager, IUserManager $userManager) {
 		if (!self::$listeningForProviders) {
 			self::$listeningForProviders = true;
-			$mountConfigManager->listen('\OC\Files\Config', 'registerMountProvider', function (IMountProvider $provider) use ($userManager) {
+			$mountConfigManager->listen('\OC\Files\Config', 'registerMountProvider', function(IMountProvider $provider) use ($userManager) {
 				foreach (Filesystem::$usersSetup as $user => $setup) {
 					$userObject = $userManager->get($user);
 					if ($userObject) {
@@ -566,7 +566,7 @@ 
 	 * @return string
 	 */
 	static public function getLocalPath($path) {
-		$datadir = \OC_User::getHome(\OC_User::getUser()) . '/files';
+		$datadir = \OC_User::getHome(\OC_User::getUser()).'/files';
 		$newpath = $path;
 		if (strncmp($newpath, $datadir, strlen($datadir)) == 0) {
 			$newpath = substr($path, strlen($datadir));
@@ -583,7 +583,7 @@ 
 	static public function isValidPath($path) {
 		$path = self::normalizePath($path);
 		if (!$path || $path[0] !== '/') {
-			$path = '/' . $path;
+			$path = '/'.$path;
 		}
 		if (strpos($path, '/../') !== false || strrchr($path, '/') === '/..') {
 			return false;
@@ -804,7 +804,7 @@ 
 		 *        conversion should get removed as soon as all existing
 		 *        function calls have been fixed.
 		 */
-		$path = (string)$path;
+		$path = (string) $path;
 
 		$cacheKey = json_encode([$path, $stripTrailingSlash, $isAbsolutePath, $keepUnicode]);
 
@@ -826,7 +826,7 @@ 
 
 		//add leading slash
 		if ($path[0] !== '/') {
-			$path = '/' . $path;
+			$path = '/'.$path;
 		}
 
 		// remove '/./'

lib/private/Files/Storage/Wrapper/Encryption.php

Doc Comments +2 added lines, -2 removed lines

@@ -984,7 +984,7 @@ 
 	/**
 	 * check if path points to a files version
 	 *
-	 * @param $path
+	 * @param string $path
 	 * @return bool
 	 */
 	protected function isVersion($path) {
@@ -995,7 +995,7 @@ 
 	/**
 	 * check if the given storage should be encrypted or not
 	 *
-	 * @param $path
+	 * @param string $path
 	 * @return bool
 	 */
 	protected function shouldEncrypt($path) {

Indentation +976 added lines, -976 removed lines

@@ -48,981 +48,981 @@
 
 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);
-		return $this->copyFromStorage($this, $path1, $path2);
-	}
-
-	/**
-	 * 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';
-		$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->logException($e, [
-					'message' => 'Encryption module "' . $encryptionModuleId . '" not found, file will be stored unencrypted',
-					'level' => ILogger::WARN,
-					'app' => 'core',
-				]);
-			}
-
-			// encryption disabled on write of new file and write to existing unencrypted file -> don't encrypt
-			if (!$encryptionEnabled || !$this->shouldEncrypt($path)) {
-				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';
-		$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\IStorage $sourceStorage
-	 * @param string $sourceInternalPath
-	 * @param string $targetInternalPath
-	 * @param bool $preserveMtime
-	 * @return bool
-	 */
-	public function moveFromStorage(Storage\IStorage $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\IStorage $sourceStorage
-	 * @param string $sourceInternalPath
-	 * @param string $targetInternalPath
-	 * @param bool $preserveMtime
-	 * @param bool $isRename
-	 * @return bool
-	 */
-	public function copyFromStorage(Storage\IStorage $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\IStorage $sourceStorage
-	 * @param string $sourceInternalPath
-	 * @param string $targetInternalPath
-	 * @param bool $isRename
-	 * @param bool $keepEncryptionVersion
-	 */
-	private function updateEncryptedVersion(Storage\IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath, $isRename, $keepEncryptionVersion) {
-		$isEncrypted = $this->encryptionManager->isEnabled() && $this->shouldEncrypt($targetInternalPath);
-		$cacheInformation = [
-			'encrypted' => $isEncrypted,
-		];
-		if($isEncrypted) {
-			$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 || !$keepEncryptionVersion) {
-				$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\IStorage $sourceStorage
-	 * @param string $sourceInternalPath
-	 * @param string $targetInternalPath
-	 * @param bool $preserveMtime
-	 * @param bool $isRename
-	 * @return bool
-	 * @throws \Exception
-	 */
-	private function copyBetweenStorage(Storage\IStorage $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, true);
-			}
-			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, false);
-			} 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);
-		$exists = $this->storage->file_exists($realFile);
-		if ($exists) {
-			$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 ($exists) {
-				// if the header was empty we have to check first if it is a encrypted file at all
-				// We would do query to filecache only if we know that entry in filecache exists
-				$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/';
-	}
-
-	/**
-	 * check if the given storage should be encrypted or not
-	 *
-	 * @param $path
-	 * @return bool
-	 */
-	protected function shouldEncrypt($path) {
-		$fullPath = $this->getFullPath($path);
-		$mountPointConfig = $this->mount->getOption('encrypt', true);
-		if ($mountPointConfig === false) {
-			return false;
-		}
-
-		try {
-			$encryptionModule = $this->getEncryptionModule($fullPath);
-		} catch (ModuleDoesNotExistsException $e) {
-			return false;
-		}
-
-		if ($encryptionModule === null) {
-			$encryptionModule = $this->encryptionManager->getEncryptionModule();
-		}
-
-		return $encryptionModule->shouldEncrypt($fullPath);
-
-	}
+    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);
+        return $this->copyFromStorage($this, $path1, $path2);
+    }
+
+    /**
+     * 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';
+        $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->logException($e, [
+                    'message' => 'Encryption module "' . $encryptionModuleId . '" not found, file will be stored unencrypted',
+                    'level' => ILogger::WARN,
+                    'app' => 'core',
+                ]);
+            }
+
+            // encryption disabled on write of new file and write to existing unencrypted file -> don't encrypt
+            if (!$encryptionEnabled || !$this->shouldEncrypt($path)) {
+                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';
+        $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\IStorage $sourceStorage
+     * @param string $sourceInternalPath
+     * @param string $targetInternalPath
+     * @param bool $preserveMtime
+     * @return bool
+     */
+    public function moveFromStorage(Storage\IStorage $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\IStorage $sourceStorage
+     * @param string $sourceInternalPath
+     * @param string $targetInternalPath
+     * @param bool $preserveMtime
+     * @param bool $isRename
+     * @return bool
+     */
+    public function copyFromStorage(Storage\IStorage $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\IStorage $sourceStorage
+     * @param string $sourceInternalPath
+     * @param string $targetInternalPath
+     * @param bool $isRename
+     * @param bool $keepEncryptionVersion
+     */
+    private function updateEncryptedVersion(Storage\IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath, $isRename, $keepEncryptionVersion) {
+        $isEncrypted = $this->encryptionManager->isEnabled() && $this->shouldEncrypt($targetInternalPath);
+        $cacheInformation = [
+            'encrypted' => $isEncrypted,
+        ];
+        if($isEncrypted) {
+            $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 || !$keepEncryptionVersion) {
+                $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\IStorage $sourceStorage
+     * @param string $sourceInternalPath
+     * @param string $targetInternalPath
+     * @param bool $preserveMtime
+     * @param bool $isRename
+     * @return bool
+     * @throws \Exception
+     */
+    private function copyBetweenStorage(Storage\IStorage $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, true);
+            }
+            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, false);
+            } 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);
+        $exists = $this->storage->file_exists($realFile);
+        if ($exists) {
+            $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 ($exists) {
+                // if the header was empty we have to check first if it is a encrypted file at all
+                // We would do query to filecache only if we know that entry in filecache exists
+                $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/';
+    }
+
+    /**
+     * check if the given storage should be encrypted or not
+     *
+     * @param $path
+     * @return bool
+     */
+    protected function shouldEncrypt($path) {
+        $fullPath = $this->getFullPath($path);
+        $mountPointConfig = $this->mount->getOption('encrypt', true);
+        if ($mountPointConfig === false) {
+            return false;
+        }
+
+        try {
+            $encryptionModule = $this->getEncryptionModule($fullPath);
+        } catch (ModuleDoesNotExistsException $e) {
+            return false;
+        }
+
+        if ($encryptionModule === null) {
+            $encryptionModule = $this->encryptionManager->getEncryptionModule();
+        }
+
+        return $encryptionModule->shouldEncrypt($fullPath);
+
+    }
 
 }

Spacing +24 added lines, -24 removed lines

@@ -368,8 +368,8 @@ 
 		// 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);
+		if ($this->arrayCache->hasKey('encryption_copy_version_'.$path)) {
+			$this->arrayCache->remove('encryption_copy_version_'.$path);
 			return $this->storage->fopen($path, $mode);
 		}
 
@@ -440,7 +440,7 @@ 
 				}
 			} catch (ModuleDoesNotExistsException $e) {
 				$this->logger->logException($e, [
-					'message' => 'Encryption module "' . $encryptionModuleId . '" not found, file will be stored unencrypted',
+					'message' => 'Encryption module "'.$encryptionModuleId.'" not found, file will be stored unencrypted',
 					'level' => ILogger::WARN,
 					'app' => 'core',
 				]);
@@ -495,7 +495,7 @@ 
 				try {
 					$result = $this->fixUnencryptedSize($path, $size, $unencryptedSize);
 				} catch (\Exception $e) {
-					$this->logger->error('Couldn\'t re-calculate unencrypted size for '. $path);
+					$this->logger->error('Couldn\'t re-calculate unencrypted size for '.$path);
 					$this->logger->logException($e);
 				}
 				unset($this->fixUnencryptedSizeOf[$this->getFullPath($path)]);
@@ -524,7 +524,7 @@ 
 
 		// 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.');
+			$this->logger->error('Could not open '.$path.'. Recalculation of unencrypted size aborted.');
 			return $unencryptedSize;
 		}
 
@@ -549,7 +549,7 @@ 
 		// 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;
+		$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
@@ -557,16 +557,16 @@ 
 			$newUnencryptedSize += $lastChunkNr * $unencryptedBlockSize;
 		}
 
-		$lastChunkContentEncrypted='';
+		$lastChunkContentEncrypted = '';
 		$count = $blockSize;
 
 		while ($count > 0) {
-			$data=fread($stream, $blockSize);
-			$count=strlen($data);
+			$data = fread($stream, $blockSize);
+			$count = strlen($data);
 			$lastChunkContentEncrypted .= $data;
-			if(strlen($lastChunkContentEncrypted) > $blockSize) {
+			if (strlen($lastChunkContentEncrypted) > $blockSize) {
 				$newUnencryptedSize += $unencryptedBlockSize;
-				$lastChunkContentEncrypted=substr($lastChunkContentEncrypted, $blockSize);
+				$lastChunkContentEncrypted = substr($lastChunkContentEncrypted, $blockSize);
 			}
 		}
 
@@ -574,8 +574,8 @@ 
 
 		// 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');
+		$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);
@@ -659,7 +659,7 @@ 
 		$cacheInformation = [
 			'encrypted' => $isEncrypted,
 		];
-		if($isEncrypted) {
+		if ($isEncrypted) {
 			$encryptedVersion = $sourceStorage->getCache()->get($sourceInternalPath)['encryptedVersion'];
 
 			// In case of a move operation from an unencrypted to an encrypted
@@ -667,7 +667,7 @@ 
 			// 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 || !$keepEncryptionVersion) {
+			if ($encryptedVersion === 0 || !$keepEncryptionVersion) {
 				$encryptedVersion = 1;
 			}
 
@@ -703,9 +703,9 @@ 
 			// 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);
+			$this->arrayCache->set('encryption_copy_version_'.$sourceInternalPath, true);
 			$result = $this->storage->copyFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath);
-			$this->arrayCache->remove('encryption_copy_version_' . $sourceInternalPath);
+			$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
@@ -725,7 +725,7 @@ 
 		$mount = $this->mountManager->findByStorageId($sourceStorage->getId());
 		if (count($mount) === 1) {
 			$mountPoint = $mount[0]->getMountPoint();
-			$source = $mountPoint . '/' . $sourceInternalPath;
+			$source = $mountPoint.'/'.$sourceInternalPath;
 			$target = $this->getFullPath($targetInternalPath);
 			$this->copyKeys($source, $target);
 		} else {
@@ -738,7 +738,7 @@ 
 			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);
+						$result &= $this->copyFromStorage($sourceStorage, $sourceInternalPath.'/'.$file, $targetInternalPath.'/'.$file, false, $isRename);
 					}
 				}
 			}
@@ -754,7 +754,7 @@ 
 				fclose($target);
 				throw $e;
 			}
-			if($result) {
+			if ($result) {
 				if ($preserveMtime) {
 					$this->touch($targetInternalPath, $sourceStorage->filemtime($sourceInternalPath));
 				}
@@ -766,7 +766,7 @@ 
 				$this->getCache()->remove($targetInternalPath);
 			}
 		}
-		return (bool)$result;
+		return (bool) $result;
 
 	}
 
@@ -837,7 +837,7 @@ 
 	 * @return string full path including mount point
 	 */
 	protected function getFullPath($path) {
-		return Filesystem::normalizePath($this->mountPoint . '/' . $path);
+		return Filesystem::normalizePath($this->mountPoint.'/'.$path);
 	}
 
 	/**
@@ -893,7 +893,7 @@ 
 				$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));
+				$exploded = explode(':', substr($header, strlen(Util::HEADER_START) + 1));
 
 				$element = array_shift($exploded);
 				while ($element !== Util::HEADER_END) {
@@ -956,7 +956,7 @@ 
 			try {
 				$encryptionModule = $this->encryptionManager->getEncryptionModule($encryptionModuleId);
 			} catch (ModuleDoesNotExistsException $e) {
-				$this->logger->critical('Encryption module defined in "' . $path . '" not loaded!');
+				$this->logger->critical('Encryption module defined in "'.$path.'" not loaded!');
 				throw $e;
 			}
 		}

lib/private/Files/ObjectStore/ObjectStoreStorage.php

Doc Comments +6 added lines

@@ -162,6 +162,9 @@ 
 		return true;
 	}
 
+	/**
+	 * @param string $path
+	 */
 	private function rmObjects($path) {
 		$children = $this->getCache()->getFolderContents($path);
 		foreach ($children as $child) {
@@ -364,6 +367,9 @@ 
 		return true;
 	}
 
+	/**
+	 * @param string $path
+	 */
 	public function writeBack($tmpFile, $path) {
 		$stat = $this->stat($path);
 		if (empty($stat)) {

Spacing +10 added lines, -10 removed lines

@@ -55,9 +55,9 @@ 
 			throw new \Exception('missing IObjectStore instance');
 		}
 		if (isset($params['storageid'])) {
-			$this->id = 'object::store:' . $params['storageid'];
+			$this->id = 'object::store:'.$params['storageid'];
 		} else {
-			$this->id = 'object::store:' . $this->objectStore->getStorageId();
+			$this->id = 'object::store:'.$this->objectStore->getStorageId();
 		}
 		if (isset($params['objectPrefix'])) {
 			$this->objectPrefix = $params['objectPrefix'];
@@ -191,7 +191,7 @@ 
 				if ($ex->getCode() !== 404) {
 					$this->logger->logException($ex, [
 						'app' => 'objectstore',
-						'message' => 'Could not delete object ' . $this->getURN($stat['fileid']) . ' for ' . $path,
+						'message' => 'Could not delete object '.$this->getURN($stat['fileid']).' for '.$path,
 					]);
 					return false;
 				}
@@ -223,7 +223,7 @@ 
 	 */
 	protected function getURN($fileId) {
 		if (is_numeric($fileId)) {
-			return $this->objectPrefix . $fileId;
+			return $this->objectPrefix.$fileId;
 		}
 		return null;
 	}
@@ -277,7 +277,7 @@ 
 					} catch (\Exception $ex) {
 						$this->logger->logException($ex, [
 							'app' => 'objectstore',
-							'message' => 'Count not get object ' . $this->getURN($stat['fileid']) . ' for file ' . $path,
+							'message' => 'Count not get object '.$this->getURN($stat['fileid']).' for file '.$path,
 						]);
 						return false;
 					}
@@ -290,7 +290,7 @@ 
 			case 'wb+':
 				$tmpFile = \OC::$server->getTempManager()->getTemporaryFile($ext);
 				$handle = fopen($tmpFile, $mode);
-				return CallbackWrapper::wrap($handle, null, null, function () use ($path, $tmpFile) {
+				return CallbackWrapper::wrap($handle, null, null, function() use ($path, $tmpFile) {
 					$this->writeBack($tmpFile, $path);
 				});
 			case 'a':
@@ -307,7 +307,7 @@ 
 					file_put_contents($tmpFile, $source);
 				}
 				$handle = fopen($tmpFile, $mode);
-				return CallbackWrapper::wrap($handle, null, null, function () use ($path, $tmpFile) {
+				return CallbackWrapper::wrap($handle, null, null, function() use ($path, $tmpFile) {
 					$this->writeBack($tmpFile, $path);
 				});
 		}
@@ -316,7 +316,7 @@ 
 
 	public function file_exists($path) {
 		$path = $this->normalizePath($path);
-		return (bool)$this->stat($path);
+		return (bool) $this->stat($path);
 	}
 
 	public function rename($source, $target) {
@@ -373,7 +373,7 @@ 
 			} catch (\Exception $ex) {
 				$this->logger->logException($ex, [
 					'app' => 'objectstore',
-					'message' => 'Could not create object for ' . $path,
+					'message' => 'Could not create object for '.$path,
 				]);
 				throw $ex;
 			}
@@ -413,7 +413,7 @@ 
 			$this->getCache()->remove($path);
 			$this->logger->logException($ex, [
 				'app' => 'objectstore',
-				'message' => 'Could not create object ' . $this->getURN($fileId) . ' for ' . $path,
+				'message' => 'Could not create object '.$this->getURN($fileId).' for '.$path,
 			]);
 			throw $ex; // make this bubble up
 		}

Indentation +402 added lines, -402 removed lines

@@ -31,406 +31,406 @@
 use OCP\Files\ObjectStore\IObjectStore;
 
 class ObjectStoreStorage extends \OC\Files\Storage\Common {
-	/**
-	 * @var \OCP\Files\ObjectStore\IObjectStore $objectStore
-	 */
-	protected $objectStore;
-	/**
-	 * @var string $id
-	 */
-	protected $id;
-	/**
-	 * @var \OC\User\User $user
-	 */
-	protected $user;
-
-	private $objectPrefix = 'urn:oid:';
-
-	private $logger;
-
-	public function __construct($params) {
-		if (isset($params['objectstore']) && $params['objectstore'] instanceof IObjectStore) {
-			$this->objectStore = $params['objectstore'];
-		} else {
-			throw new \Exception('missing IObjectStore instance');
-		}
-		if (isset($params['storageid'])) {
-			$this->id = 'object::store:' . $params['storageid'];
-		} else {
-			$this->id = 'object::store:' . $this->objectStore->getStorageId();
-		}
-		if (isset($params['objectPrefix'])) {
-			$this->objectPrefix = $params['objectPrefix'];
-		}
-		//initialize cache with root directory in cache
-		if (!$this->is_dir('/')) {
-			$this->mkdir('/');
-		}
-
-		$this->logger = \OC::$server->getLogger();
-	}
-
-	public function mkdir($path) {
-		$path = $this->normalizePath($path);
-
-		if ($this->file_exists($path)) {
-			return false;
-		}
-
-		$mTime = time();
-		$data = [
-			'mimetype' => 'httpd/unix-directory',
-			'size' => 0,
-			'mtime' => $mTime,
-			'storage_mtime' => $mTime,
-			'permissions' => \OCP\Constants::PERMISSION_ALL,
-		];
-		if ($path === '') {
-			//create root on the fly
-			$data['etag'] = $this->getETag('');
-			$this->getCache()->put('', $data);
-			return true;
-		} else {
-			// if parent does not exist, create it
-			$parent = $this->normalizePath(dirname($path));
-			$parentType = $this->filetype($parent);
-			if ($parentType === false) {
-				if (!$this->mkdir($parent)) {
-					// something went wrong
-					return false;
-				}
-			} else if ($parentType === 'file') {
-				// parent is a file
-				return false;
-			}
-			// finally create the new dir
-			$mTime = time(); // update mtime
-			$data['mtime'] = $mTime;
-			$data['storage_mtime'] = $mTime;
-			$data['etag'] = $this->getETag($path);
-			$this->getCache()->put($path, $data);
-			return true;
-		}
-	}
-
-	/**
-	 * @param string $path
-	 * @return string
-	 */
-	private function normalizePath($path) {
-		$path = trim($path, '/');
-		//FIXME why do we sometimes get a path like 'files//username'?
-		$path = str_replace('//', '/', $path);
-
-		// dirname('/folder') returns '.' but internally (in the cache) we store the root as ''
-		if (!$path || $path === '.') {
-			$path = '';
-		}
-
-		return $path;
-	}
-
-	/**
-	 * Object Stores use a NoopScanner because metadata is directly stored in
-	 * the file cache and cannot really scan the filesystem. The storage passed in is not used anywhere.
-	 *
-	 * @param string $path
-	 * @param \OC\Files\Storage\Storage (optional) the storage to pass to the scanner
-	 * @return \OC\Files\ObjectStore\NoopScanner
-	 */
-	public function getScanner($path = '', $storage = null) {
-		if (!$storage) {
-			$storage = $this;
-		}
-		if (!isset($this->scanner)) {
-			$this->scanner = new NoopScanner($storage);
-		}
-		return $this->scanner;
-	}
-
-	public function getId() {
-		return $this->id;
-	}
-
-	public function rmdir($path) {
-		$path = $this->normalizePath($path);
-
-		if (!$this->is_dir($path)) {
-			return false;
-		}
-
-		$this->rmObjects($path);
-
-		$this->getCache()->remove($path);
-
-		return true;
-	}
-
-	private function rmObjects($path) {
-		$children = $this->getCache()->getFolderContents($path);
-		foreach ($children as $child) {
-			if ($child['mimetype'] === 'httpd/unix-directory') {
-				$this->rmObjects($child['path']);
-			} else {
-				$this->unlink($child['path']);
-			}
-		}
-	}
-
-	public function unlink($path) {
-		$path = $this->normalizePath($path);
-		$stat = $this->stat($path);
-
-		if ($stat && isset($stat['fileid'])) {
-			if ($stat['mimetype'] === 'httpd/unix-directory') {
-				return $this->rmdir($path);
-			}
-			try {
-				$this->objectStore->deleteObject($this->getURN($stat['fileid']));
-			} catch (\Exception $ex) {
-				if ($ex->getCode() !== 404) {
-					$this->logger->logException($ex, [
-						'app' => 'objectstore',
-						'message' => 'Could not delete object ' . $this->getURN($stat['fileid']) . ' for ' . $path,
-					]);
-					return false;
-				}
-				//removing from cache is ok as it does not exist in the objectstore anyway
-			}
-			$this->getCache()->remove($path);
-			return true;
-		}
-		return false;
-	}
-
-	public function stat($path) {
-		$path = $this->normalizePath($path);
-		$cacheEntry = $this->getCache()->get($path);
-		if ($cacheEntry instanceof CacheEntry) {
-			return $cacheEntry->getData();
-		} else {
-			return false;
-		}
-	}
-
-	/**
-	 * Override this method if you need a different unique resource identifier for your object storage implementation.
-	 * The default implementations just appends the fileId to 'urn:oid:'. Make sure the URN is unique over all users.
-	 * You may need a mapping table to store your URN if it cannot be generated from the fileid.
-	 *
-	 * @param int $fileId the fileid
-	 * @return null|string the unified resource name used to identify the object
-	 */
-	protected function getURN($fileId) {
-		if (is_numeric($fileId)) {
-			return $this->objectPrefix . $fileId;
-		}
-		return null;
-	}
-
-	public function opendir($path) {
-		$path = $this->normalizePath($path);
-
-		try {
-			$files = array();
-			$folderContents = $this->getCache()->getFolderContents($path);
-			foreach ($folderContents as $file) {
-				$files[] = $file['name'];
-			}
-
-			return IteratorDirectory::wrap($files);
-		} catch (\Exception $e) {
-			$this->logger->logException($e);
-			return false;
-		}
-	}
-
-	public function filetype($path) {
-		$path = $this->normalizePath($path);
-		$stat = $this->stat($path);
-		if ($stat) {
-			if ($stat['mimetype'] === 'httpd/unix-directory') {
-				return 'dir';
-			}
-			return 'file';
-		} else {
-			return false;
-		}
-	}
-
-	public function fopen($path, $mode) {
-		$path = $this->normalizePath($path);
-
-		if (strrpos($path, '.') !== false) {
-			$ext = substr($path, strrpos($path, '.'));
-		} else {
-			$ext = '';
-		}
-
-		switch ($mode) {
-			case 'r':
-			case 'rb':
-				$stat = $this->stat($path);
-				if (is_array($stat)) {
-					try {
-						return $this->objectStore->readObject($this->getURN($stat['fileid']));
-					} catch (\Exception $ex) {
-						$this->logger->logException($ex, [
-							'app' => 'objectstore',
-							'message' => 'Count not get object ' . $this->getURN($stat['fileid']) . ' for file ' . $path,
-						]);
-						return false;
-					}
-				} else {
-					return false;
-				}
-			case 'w':
-			case 'wb':
-			case 'w+':
-			case 'wb+':
-				$tmpFile = \OC::$server->getTempManager()->getTemporaryFile($ext);
-				$handle = fopen($tmpFile, $mode);
-				return CallbackWrapper::wrap($handle, null, null, function () use ($path, $tmpFile) {
-					$this->writeBack($tmpFile, $path);
-				});
-			case 'a':
-			case 'ab':
-			case 'r+':
-			case 'a+':
-			case 'x':
-			case 'x+':
-			case 'c':
-			case 'c+':
-				$tmpFile = \OC::$server->getTempManager()->getTemporaryFile($ext);
-				if ($this->file_exists($path)) {
-					$source = $this->fopen($path, 'r');
-					file_put_contents($tmpFile, $source);
-				}
-				$handle = fopen($tmpFile, $mode);
-				return CallbackWrapper::wrap($handle, null, null, function () use ($path, $tmpFile) {
-					$this->writeBack($tmpFile, $path);
-				});
-		}
-		return false;
-	}
-
-	public function file_exists($path) {
-		$path = $this->normalizePath($path);
-		return (bool)$this->stat($path);
-	}
-
-	public function rename($source, $target) {
-		$source = $this->normalizePath($source);
-		$target = $this->normalizePath($target);
-		$this->remove($target);
-		$this->getCache()->move($source, $target);
-		$this->touch(dirname($target));
-		return true;
-	}
-
-	public function getMimeType($path) {
-		$path = $this->normalizePath($path);
-		$stat = $this->stat($path);
-		if (is_array($stat)) {
-			return $stat['mimetype'];
-		} else {
-			return false;
-		}
-	}
-
-	public function touch($path, $mtime = null) {
-		if (is_null($mtime)) {
-			$mtime = time();
-		}
-
-		$path = $this->normalizePath($path);
-		$dirName = dirname($path);
-		$parentExists = $this->is_dir($dirName);
-		if (!$parentExists) {
-			return false;
-		}
-
-		$stat = $this->stat($path);
-		if (is_array($stat)) {
-			// update existing mtime in db
-			$stat['mtime'] = $mtime;
-			$this->getCache()->update($stat['fileid'], $stat);
-		} else {
-			try {
-				//create a empty file, need to have at least on char to make it
-				// work with all object storage implementations
-				$this->file_put_contents($path, ' ');
-				$mimeType = \OC::$server->getMimeTypeDetector()->detectPath($path);
-				$stat = array(
-					'etag' => $this->getETag($path),
-					'mimetype' => $mimeType,
-					'size' => 0,
-					'mtime' => $mtime,
-					'storage_mtime' => $mtime,
-					'permissions' => \OCP\Constants::PERMISSION_ALL - \OCP\Constants::PERMISSION_CREATE,
-				);
-				$this->getCache()->put($path, $stat);
-			} catch (\Exception $ex) {
-				$this->logger->logException($ex, [
-					'app' => 'objectstore',
-					'message' => 'Could not create object for ' . $path,
-				]);
-				throw $ex;
-			}
-		}
-		return true;
-	}
-
-	public function writeBack($tmpFile, $path) {
-		$stat = $this->stat($path);
-		if (empty($stat)) {
-			// create new file
-			$stat = array(
-				'permissions' => \OCP\Constants::PERMISSION_ALL - \OCP\Constants::PERMISSION_CREATE,
-			);
-		}
-		// update stat with new data
-		$mTime = time();
-		$stat['size'] = filesize($tmpFile);
-		$stat['mtime'] = $mTime;
-		$stat['storage_mtime'] = $mTime;
-
-		// run path based detection first, to use file extension because $tmpFile is only a random string
-		$mimetypeDetector = \OC::$server->getMimeTypeDetector();
-		$mimetype = $mimetypeDetector->detectPath($path);
-		if ($mimetype === 'application/octet-stream') {
-			$mimetype = $mimetypeDetector->detect($tmpFile);
-		}
-
-		$stat['mimetype'] = $mimetype;
-		$stat['etag'] = $this->getETag($path);
-
-		$fileId = $this->getCache()->put($path, $stat);
-		try {
-			//upload to object storage
-			$this->objectStore->writeObject($this->getURN($fileId), fopen($tmpFile, 'r'));
-		} catch (\Exception $ex) {
-			$this->getCache()->remove($path);
-			$this->logger->logException($ex, [
-				'app' => 'objectstore',
-				'message' => 'Could not create object ' . $this->getURN($fileId) . ' for ' . $path,
-			]);
-			throw $ex; // make this bubble up
-		}
-	}
-
-	/**
-	 * external changes are not supported, exclusive access to the object storage is assumed
-	 *
-	 * @param string $path
-	 * @param int $time
-	 * @return false
-	 */
-	public function hasUpdated($path, $time) {
-		return false;
-	}
-
-	public function needsPartFile() {
-		return false;
-	}
+    /**
+     * @var \OCP\Files\ObjectStore\IObjectStore $objectStore
+     */
+    protected $objectStore;
+    /**
+     * @var string $id
+     */
+    protected $id;
+    /**
+     * @var \OC\User\User $user
+     */
+    protected $user;
+
+    private $objectPrefix = 'urn:oid:';
+
+    private $logger;
+
+    public function __construct($params) {
+        if (isset($params['objectstore']) && $params['objectstore'] instanceof IObjectStore) {
+            $this->objectStore = $params['objectstore'];
+        } else {
+            throw new \Exception('missing IObjectStore instance');
+        }
+        if (isset($params['storageid'])) {
+            $this->id = 'object::store:' . $params['storageid'];
+        } else {
+            $this->id = 'object::store:' . $this->objectStore->getStorageId();
+        }
+        if (isset($params['objectPrefix'])) {
+            $this->objectPrefix = $params['objectPrefix'];
+        }
+        //initialize cache with root directory in cache
+        if (!$this->is_dir('/')) {
+            $this->mkdir('/');
+        }
+
+        $this->logger = \OC::$server->getLogger();
+    }
+
+    public function mkdir($path) {
+        $path = $this->normalizePath($path);
+
+        if ($this->file_exists($path)) {
+            return false;
+        }
+
+        $mTime = time();
+        $data = [
+            'mimetype' => 'httpd/unix-directory',
+            'size' => 0,
+            'mtime' => $mTime,
+            'storage_mtime' => $mTime,
+            'permissions' => \OCP\Constants::PERMISSION_ALL,
+        ];
+        if ($path === '') {
+            //create root on the fly
+            $data['etag'] = $this->getETag('');
+            $this->getCache()->put('', $data);
+            return true;
+        } else {
+            // if parent does not exist, create it
+            $parent = $this->normalizePath(dirname($path));
+            $parentType = $this->filetype($parent);
+            if ($parentType === false) {
+                if (!$this->mkdir($parent)) {
+                    // something went wrong
+                    return false;
+                }
+            } else if ($parentType === 'file') {
+                // parent is a file
+                return false;
+            }
+            // finally create the new dir
+            $mTime = time(); // update mtime
+            $data['mtime'] = $mTime;
+            $data['storage_mtime'] = $mTime;
+            $data['etag'] = $this->getETag($path);
+            $this->getCache()->put($path, $data);
+            return true;
+        }
+    }
+
+    /**
+     * @param string $path
+     * @return string
+     */
+    private function normalizePath($path) {
+        $path = trim($path, '/');
+        //FIXME why do we sometimes get a path like 'files//username'?
+        $path = str_replace('//', '/', $path);
+
+        // dirname('/folder') returns '.' but internally (in the cache) we store the root as ''
+        if (!$path || $path === '.') {
+            $path = '';
+        }
+
+        return $path;
+    }
+
+    /**
+     * Object Stores use a NoopScanner because metadata is directly stored in
+     * the file cache and cannot really scan the filesystem. The storage passed in is not used anywhere.
+     *
+     * @param string $path
+     * @param \OC\Files\Storage\Storage (optional) the storage to pass to the scanner
+     * @return \OC\Files\ObjectStore\NoopScanner
+     */
+    public function getScanner($path = '', $storage = null) {
+        if (!$storage) {
+            $storage = $this;
+        }
+        if (!isset($this->scanner)) {
+            $this->scanner = new NoopScanner($storage);
+        }
+        return $this->scanner;
+    }
+
+    public function getId() {
+        return $this->id;
+    }
+
+    public function rmdir($path) {
+        $path = $this->normalizePath($path);
+
+        if (!$this->is_dir($path)) {
+            return false;
+        }
+
+        $this->rmObjects($path);
+
+        $this->getCache()->remove($path);
+
+        return true;
+    }
+
+    private function rmObjects($path) {
+        $children = $this->getCache()->getFolderContents($path);
+        foreach ($children as $child) {
+            if ($child['mimetype'] === 'httpd/unix-directory') {
+                $this->rmObjects($child['path']);
+            } else {
+                $this->unlink($child['path']);
+            }
+        }
+    }
+
+    public function unlink($path) {
+        $path = $this->normalizePath($path);
+        $stat = $this->stat($path);
+
+        if ($stat && isset($stat['fileid'])) {
+            if ($stat['mimetype'] === 'httpd/unix-directory') {
+                return $this->rmdir($path);
+            }
+            try {
+                $this->objectStore->deleteObject($this->getURN($stat['fileid']));
+            } catch (\Exception $ex) {
+                if ($ex->getCode() !== 404) {
+                    $this->logger->logException($ex, [
+                        'app' => 'objectstore',
+                        'message' => 'Could not delete object ' . $this->getURN($stat['fileid']) . ' for ' . $path,
+                    ]);
+                    return false;
+                }
+                //removing from cache is ok as it does not exist in the objectstore anyway
+            }
+            $this->getCache()->remove($path);
+            return true;
+        }
+        return false;
+    }
+
+    public function stat($path) {
+        $path = $this->normalizePath($path);
+        $cacheEntry = $this->getCache()->get($path);
+        if ($cacheEntry instanceof CacheEntry) {
+            return $cacheEntry->getData();
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * Override this method if you need a different unique resource identifier for your object storage implementation.
+     * The default implementations just appends the fileId to 'urn:oid:'. Make sure the URN is unique over all users.
+     * You may need a mapping table to store your URN if it cannot be generated from the fileid.
+     *
+     * @param int $fileId the fileid
+     * @return null|string the unified resource name used to identify the object
+     */
+    protected function getURN($fileId) {
+        if (is_numeric($fileId)) {
+            return $this->objectPrefix . $fileId;
+        }
+        return null;
+    }
+
+    public function opendir($path) {
+        $path = $this->normalizePath($path);
+
+        try {
+            $files = array();
+            $folderContents = $this->getCache()->getFolderContents($path);
+            foreach ($folderContents as $file) {
+                $files[] = $file['name'];
+            }
+
+            return IteratorDirectory::wrap($files);
+        } catch (\Exception $e) {
+            $this->logger->logException($e);
+            return false;
+        }
+    }
+
+    public function filetype($path) {
+        $path = $this->normalizePath($path);
+        $stat = $this->stat($path);
+        if ($stat) {
+            if ($stat['mimetype'] === 'httpd/unix-directory') {
+                return 'dir';
+            }
+            return 'file';
+        } else {
+            return false;
+        }
+    }
+
+    public function fopen($path, $mode) {
+        $path = $this->normalizePath($path);
+
+        if (strrpos($path, '.') !== false) {
+            $ext = substr($path, strrpos($path, '.'));
+        } else {
+            $ext = '';
+        }
+
+        switch ($mode) {
+            case 'r':
+            case 'rb':
+                $stat = $this->stat($path);
+                if (is_array($stat)) {
+                    try {
+                        return $this->objectStore->readObject($this->getURN($stat['fileid']));
+                    } catch (\Exception $ex) {
+                        $this->logger->logException($ex, [
+                            'app' => 'objectstore',
+                            'message' => 'Count not get object ' . $this->getURN($stat['fileid']) . ' for file ' . $path,
+                        ]);
+                        return false;
+                    }
+                } else {
+                    return false;
+                }
+            case 'w':
+            case 'wb':
+            case 'w+':
+            case 'wb+':
+                $tmpFile = \OC::$server->getTempManager()->getTemporaryFile($ext);
+                $handle = fopen($tmpFile, $mode);
+                return CallbackWrapper::wrap($handle, null, null, function () use ($path, $tmpFile) {
+                    $this->writeBack($tmpFile, $path);
+                });
+            case 'a':
+            case 'ab':
+            case 'r+':
+            case 'a+':
+            case 'x':
+            case 'x+':
+            case 'c':
+            case 'c+':
+                $tmpFile = \OC::$server->getTempManager()->getTemporaryFile($ext);
+                if ($this->file_exists($path)) {
+                    $source = $this->fopen($path, 'r');
+                    file_put_contents($tmpFile, $source);
+                }
+                $handle = fopen($tmpFile, $mode);
+                return CallbackWrapper::wrap($handle, null, null, function () use ($path, $tmpFile) {
+                    $this->writeBack($tmpFile, $path);
+                });
+        }
+        return false;
+    }
+
+    public function file_exists($path) {
+        $path = $this->normalizePath($path);
+        return (bool)$this->stat($path);
+    }
+
+    public function rename($source, $target) {
+        $source = $this->normalizePath($source);
+        $target = $this->normalizePath($target);
+        $this->remove($target);
+        $this->getCache()->move($source, $target);
+        $this->touch(dirname($target));
+        return true;
+    }
+
+    public function getMimeType($path) {
+        $path = $this->normalizePath($path);
+        $stat = $this->stat($path);
+        if (is_array($stat)) {
+            return $stat['mimetype'];
+        } else {
+            return false;
+        }
+    }
+
+    public function touch($path, $mtime = null) {
+        if (is_null($mtime)) {
+            $mtime = time();
+        }
+
+        $path = $this->normalizePath($path);
+        $dirName = dirname($path);
+        $parentExists = $this->is_dir($dirName);
+        if (!$parentExists) {
+            return false;
+        }
+
+        $stat = $this->stat($path);
+        if (is_array($stat)) {
+            // update existing mtime in db
+            $stat['mtime'] = $mtime;
+            $this->getCache()->update($stat['fileid'], $stat);
+        } else {
+            try {
+                //create a empty file, need to have at least on char to make it
+                // work with all object storage implementations
+                $this->file_put_contents($path, ' ');
+                $mimeType = \OC::$server->getMimeTypeDetector()->detectPath($path);
+                $stat = array(
+                    'etag' => $this->getETag($path),
+                    'mimetype' => $mimeType,
+                    'size' => 0,
+                    'mtime' => $mtime,
+                    'storage_mtime' => $mtime,
+                    'permissions' => \OCP\Constants::PERMISSION_ALL - \OCP\Constants::PERMISSION_CREATE,
+                );
+                $this->getCache()->put($path, $stat);
+            } catch (\Exception $ex) {
+                $this->logger->logException($ex, [
+                    'app' => 'objectstore',
+                    'message' => 'Could not create object for ' . $path,
+                ]);
+                throw $ex;
+            }
+        }
+        return true;
+    }
+
+    public function writeBack($tmpFile, $path) {
+        $stat = $this->stat($path);
+        if (empty($stat)) {
+            // create new file
+            $stat = array(
+                'permissions' => \OCP\Constants::PERMISSION_ALL - \OCP\Constants::PERMISSION_CREATE,
+            );
+        }
+        // update stat with new data
+        $mTime = time();
+        $stat['size'] = filesize($tmpFile);
+        $stat['mtime'] = $mTime;
+        $stat['storage_mtime'] = $mTime;
+
+        // run path based detection first, to use file extension because $tmpFile is only a random string
+        $mimetypeDetector = \OC::$server->getMimeTypeDetector();
+        $mimetype = $mimetypeDetector->detectPath($path);
+        if ($mimetype === 'application/octet-stream') {
+            $mimetype = $mimetypeDetector->detect($tmpFile);
+        }
+
+        $stat['mimetype'] = $mimetype;
+        $stat['etag'] = $this->getETag($path);
+
+        $fileId = $this->getCache()->put($path, $stat);
+        try {
+            //upload to object storage
+            $this->objectStore->writeObject($this->getURN($fileId), fopen($tmpFile, 'r'));
+        } catch (\Exception $ex) {
+            $this->getCache()->remove($path);
+            $this->logger->logException($ex, [
+                'app' => 'objectstore',
+                'message' => 'Could not create object ' . $this->getURN($fileId) . ' for ' . $path,
+            ]);
+            throw $ex; // make this bubble up
+        }
+    }
+
+    /**
+     * external changes are not supported, exclusive access to the object storage is assumed
+     *
+     * @param string $path
+     * @param int $time
+     * @return false
+     */
+    public function hasUpdated($path, $time) {
+        return false;
+    }
+
+    public function needsPartFile() {
+        return false;
+    }
 }

apps/files_external/lib/Lib/Notify/SMBNotifyHandler.php

Doc Comments +1 added lines, -1 removed lines

@@ -102,7 +102,7 @@
 
 	/**
 	 * @param \Icewind\SMB\Change $change
-	 * @return IChange|null
+	 * @return null|Change
 	 */
 	private function mapChange(\Icewind\SMB\Change $change) {
 		$path = $this->relativePath($change->getPath());

Indentation +109 added lines, -109 removed lines

@@ -29,122 +29,122 @@
 use OCP\Files\Notify\INotifyHandler;
 
 class SMBNotifyHandler implements INotifyHandler {
-	/**
-	 * @var \Icewind\SMB\INotifyHandler
-	 */
-	private $shareNotifyHandler;
+    /**
+     * @var \Icewind\SMB\INotifyHandler
+     */
+    private $shareNotifyHandler;
 
-	/**
-	 * @var string
-	 */
-	private $root;
+    /**
+     * @var string
+     */
+    private $root;
 
-	private $oldRenamePath = null;
+    private $oldRenamePath = null;
 
-	/**
-	 * SMBNotifyHandler constructor.
-	 *
-	 * @param \Icewind\SMB\INotifyHandler $shareNotifyHandler
-	 * @param string $root
-	 */
-	public function __construct(\Icewind\SMB\INotifyHandler $shareNotifyHandler, $root) {
-		$this->shareNotifyHandler = $shareNotifyHandler;
-		$this->root = $root;
-	}
+    /**
+     * SMBNotifyHandler constructor.
+     *
+     * @param \Icewind\SMB\INotifyHandler $shareNotifyHandler
+     * @param string $root
+     */
+    public function __construct(\Icewind\SMB\INotifyHandler $shareNotifyHandler, $root) {
+        $this->shareNotifyHandler = $shareNotifyHandler;
+        $this->root = $root;
+    }
 
-	private function relativePath($fullPath) {
-		if ($fullPath === $this->root) {
-			return '';
-		} else if (substr($fullPath, 0, strlen($this->root)) === $this->root) {
-			return substr($fullPath, strlen($this->root));
-		} else {
-			return null;
-		}
-	}
+    private function relativePath($fullPath) {
+        if ($fullPath === $this->root) {
+            return '';
+        } else if (substr($fullPath, 0, strlen($this->root)) === $this->root) {
+            return substr($fullPath, strlen($this->root));
+        } else {
+            return null;
+        }
+    }
 
-	public function listen(callable $callback) {
-		$oldRenamePath = null;
-		$this->shareNotifyHandler->listen(function (\Icewind\SMB\Change $shareChange) use ($callback) {
-			$change = $this->mapChange($shareChange);
-			if (!is_null($change)) {
-				return $callback($change);
-			} else {
-				return true;
-			}
-		});
-	}
+    public function listen(callable $callback) {
+        $oldRenamePath = null;
+        $this->shareNotifyHandler->listen(function (\Icewind\SMB\Change $shareChange) use ($callback) {
+            $change = $this->mapChange($shareChange);
+            if (!is_null($change)) {
+                return $callback($change);
+            } else {
+                return true;
+            }
+        });
+    }
 
-	/**
-	 * Get all changes detected since the start of the notify process or the last call to getChanges
-	 *
-	 * @return IChange[]
-	 */
-	public function getChanges() {
-		$shareChanges = $this->shareNotifyHandler->getChanges();
-		$changes = [];
-		foreach ($shareChanges as $shareChange) {
-			$change = $this->mapChange($shareChange);
-			if ($change) {
-				$changes[] = $change;
-			}
-		}
-		return $changes;
-	}
+    /**
+     * Get all changes detected since the start of the notify process or the last call to getChanges
+     *
+     * @return IChange[]
+     */
+    public function getChanges() {
+        $shareChanges = $this->shareNotifyHandler->getChanges();
+        $changes = [];
+        foreach ($shareChanges as $shareChange) {
+            $change = $this->mapChange($shareChange);
+            if ($change) {
+                $changes[] = $change;
+            }
+        }
+        return $changes;
+    }
 
-	/**
-	 * Stop listening for changes
-	 *
-	 * Note that any pending changes will be discarded
-	 */
-	public function stop() {
-		$this->shareNotifyHandler->stop();
-	}
+    /**
+     * Stop listening for changes
+     *
+     * Note that any pending changes will be discarded
+     */
+    public function stop() {
+        $this->shareNotifyHandler->stop();
+    }
 
-	/**
-	 * @param \Icewind\SMB\Change $change
-	 * @return IChange|null
-	 */
-	private function mapChange(\Icewind\SMB\Change $change) {
-		$path = $this->relativePath($change->getPath());
-		if (is_null($path)) {
-			return null;
-		}
-		if ($change->getCode() === \Icewind\SMB\INotifyHandler::NOTIFY_RENAMED_OLD) {
-			$this->oldRenamePath = $path;
-			return null;
-		}
-		$type = $this->mapNotifyType($change->getCode());
-		if (is_null($type)) {
-			return null;
-		}
-		if ($type === IChange::RENAMED) {
-			if (!is_null($this->oldRenamePath)) {
-				$result = new RenameChange($type, $this->oldRenamePath, $path);
-				$this->oldRenamePath = null;
-			} else {
-				$result = null;
-			}
-		} else {
-			$result = new Change($type, $path);
-		}
-		return $result;
-	}
+    /**
+     * @param \Icewind\SMB\Change $change
+     * @return IChange|null
+     */
+    private function mapChange(\Icewind\SMB\Change $change) {
+        $path = $this->relativePath($change->getPath());
+        if (is_null($path)) {
+            return null;
+        }
+        if ($change->getCode() === \Icewind\SMB\INotifyHandler::NOTIFY_RENAMED_OLD) {
+            $this->oldRenamePath = $path;
+            return null;
+        }
+        $type = $this->mapNotifyType($change->getCode());
+        if (is_null($type)) {
+            return null;
+        }
+        if ($type === IChange::RENAMED) {
+            if (!is_null($this->oldRenamePath)) {
+                $result = new RenameChange($type, $this->oldRenamePath, $path);
+                $this->oldRenamePath = null;
+            } else {
+                $result = null;
+            }
+        } else {
+            $result = new Change($type, $path);
+        }
+        return $result;
+    }
 
-	private function mapNotifyType($smbType) {
-		switch ($smbType) {
-			case \Icewind\SMB\INotifyHandler::NOTIFY_ADDED:
-				return IChange::ADDED;
-			case \Icewind\SMB\INotifyHandler::NOTIFY_REMOVED:
-				return IChange::REMOVED;
-			case \Icewind\SMB\INotifyHandler::NOTIFY_MODIFIED:
-			case \Icewind\SMB\INotifyHandler::NOTIFY_ADDED_STREAM:
-			case \Icewind\SMB\INotifyHandler::NOTIFY_MODIFIED_STREAM:
-			case \Icewind\SMB\INotifyHandler::NOTIFY_REMOVED_STREAM:
-				return IChange::MODIFIED;
-			case \Icewind\SMB\INotifyHandler::NOTIFY_RENAMED_NEW:
-				return IChange::RENAMED;
-			default:
-				return null;
-		}
-	}
+    private function mapNotifyType($smbType) {
+        switch ($smbType) {
+            case \Icewind\SMB\INotifyHandler::NOTIFY_ADDED:
+                return IChange::ADDED;
+            case \Icewind\SMB\INotifyHandler::NOTIFY_REMOVED:
+                return IChange::REMOVED;
+            case \Icewind\SMB\INotifyHandler::NOTIFY_MODIFIED:
+            case \Icewind\SMB\INotifyHandler::NOTIFY_ADDED_STREAM:
+            case \Icewind\SMB\INotifyHandler::NOTIFY_MODIFIED_STREAM:
+            case \Icewind\SMB\INotifyHandler::NOTIFY_REMOVED_STREAM:
+                return IChange::MODIFIED;
+            case \Icewind\SMB\INotifyHandler::NOTIFY_RENAMED_NEW:
+                return IChange::RENAMED;
+            default:
+                return null;
+        }
+    }
 }

Spacing +1 added lines, -1 removed lines

@@ -64,7 +64,7 @@
 
 	public function listen(callable $callback) {
 		$oldRenamePath = null;
-		$this->shareNotifyHandler->listen(function (\Icewind\SMB\Change $shareChange) use ($callback) {
+		$this->shareNotifyHandler->listen(function(\Icewind\SMB\Change $shareChange) use ($callback) {
 			$change = $this->mapChange($shareChange);
 			if (!is_null($change)) {
 				return $callback($change);

lib/private/Files/Node/File.php

Doc Comments +1 added lines, -1 removed lines

@@ -31,7 +31,7 @@
 	 * Creates a Folder that represents a non-existing path
 	 *
 	 * @param string $path path
-	 * @return string non-existing node class
+	 * @return NonExistingFile non-existing node class
 	 */
 	protected function createNonExistingNode($path) {
 		return new NonExistingFile($this->root, $this->view, $path);

Indentation +105 added lines, -105 removed lines

@@ -30,116 +30,116 @@
 use OCP\Files\NotPermittedException;
 
 class File extends Node implements \OCP\Files\File {
-	/**
-	 * Creates a Folder that represents a non-existing path
-	 *
-	 * @param string $path path
-	 * @return string non-existing node class
-	 */
-	protected function createNonExistingNode($path) {
-		return new NonExistingFile($this->root, $this->view, $path);
-	}
+    /**
+     * Creates a Folder that represents a non-existing path
+     *
+     * @param string $path path
+     * @return string non-existing node class
+     */
+    protected function createNonExistingNode($path) {
+        return new NonExistingFile($this->root, $this->view, $path);
+    }
 
-	/**
-	 * @return string
-	 * @throws \OCP\Files\NotPermittedException
-	 */
-	public function getContent() {
-		if ($this->checkPermissions(\OCP\Constants::PERMISSION_READ)) {
-			/**
-			 * @var \OC\Files\Storage\Storage $storage;
-			 */
-			return $this->view->file_get_contents($this->path);
-		} else {
-			throw new NotPermittedException();
-		}
-	}
+    /**
+     * @return string
+     * @throws \OCP\Files\NotPermittedException
+     */
+    public function getContent() {
+        if ($this->checkPermissions(\OCP\Constants::PERMISSION_READ)) {
+            /**
+             * @var \OC\Files\Storage\Storage $storage;
+             */
+            return $this->view->file_get_contents($this->path);
+        } else {
+            throw new NotPermittedException();
+        }
+    }
 
-	/**
-	 * @param string $data
-	 * @throws \OCP\Files\NotPermittedException
-	 * @throws \OCP\Files\GenericFileException
-	 */
-	public function putContent($data) {
-		if ($this->checkPermissions(\OCP\Constants::PERMISSION_UPDATE)) {
-			$this->sendHooks(array('preWrite'));
-			if ($this->view->file_put_contents($this->path, $data) === false) {
-				throw new GenericFileException('file_put_contents failed');
-			}
-			$this->fileInfo = null;
-			$this->sendHooks(array('postWrite'));
-		} else {
-			throw new NotPermittedException();
-		}
-	}
+    /**
+     * @param string $data
+     * @throws \OCP\Files\NotPermittedException
+     * @throws \OCP\Files\GenericFileException
+     */
+    public function putContent($data) {
+        if ($this->checkPermissions(\OCP\Constants::PERMISSION_UPDATE)) {
+            $this->sendHooks(array('preWrite'));
+            if ($this->view->file_put_contents($this->path, $data) === false) {
+                throw new GenericFileException('file_put_contents failed');
+            }
+            $this->fileInfo = null;
+            $this->sendHooks(array('postWrite'));
+        } else {
+            throw new NotPermittedException();
+        }
+    }
 
-	/**
-	 * @param string $mode
-	 * @return resource
-	 * @throws \OCP\Files\NotPermittedException
-	 */
-	public function fopen($mode) {
-		$preHooks = array();
-		$postHooks = array();
-		$requiredPermissions = \OCP\Constants::PERMISSION_READ;
-		switch ($mode) {
-			case 'r+':
-			case 'rb+':
-			case 'w+':
-			case 'wb+':
-			case 'x+':
-			case 'xb+':
-			case 'a+':
-			case 'ab+':
-			case 'w':
-			case 'wb':
-			case 'x':
-			case 'xb':
-			case 'a':
-			case 'ab':
-				$preHooks[] = 'preWrite';
-				$postHooks[] = 'postWrite';
-				$requiredPermissions |= \OCP\Constants::PERMISSION_UPDATE;
-				break;
-		}
+    /**
+     * @param string $mode
+     * @return resource
+     * @throws \OCP\Files\NotPermittedException
+     */
+    public function fopen($mode) {
+        $preHooks = array();
+        $postHooks = array();
+        $requiredPermissions = \OCP\Constants::PERMISSION_READ;
+        switch ($mode) {
+            case 'r+':
+            case 'rb+':
+            case 'w+':
+            case 'wb+':
+            case 'x+':
+            case 'xb+':
+            case 'a+':
+            case 'ab+':
+            case 'w':
+            case 'wb':
+            case 'x':
+            case 'xb':
+            case 'a':
+            case 'ab':
+                $preHooks[] = 'preWrite';
+                $postHooks[] = 'postWrite';
+                $requiredPermissions |= \OCP\Constants::PERMISSION_UPDATE;
+                break;
+        }
 
-		if ($this->checkPermissions($requiredPermissions)) {
-			$this->sendHooks($preHooks);
-			$result = $this->view->fopen($this->path, $mode);
-			$this->sendHooks($postHooks);
-			return $result;
-		} else {
-			throw new NotPermittedException();
-		}
-	}
+        if ($this->checkPermissions($requiredPermissions)) {
+            $this->sendHooks($preHooks);
+            $result = $this->view->fopen($this->path, $mode);
+            $this->sendHooks($postHooks);
+            return $result;
+        } else {
+            throw new NotPermittedException();
+        }
+    }
 
-	public function delete() {
-		if ($this->checkPermissions(\OCP\Constants::PERMISSION_DELETE)) {
-			$this->sendHooks(array('preDelete'));
-			$fileInfo = $this->getFileInfo();
-			$this->view->unlink($this->path);
-			$nonExisting = new NonExistingFile($this->root, $this->view, $this->path, $fileInfo);
-			$this->root->emit('\OC\Files', 'postDelete', array($nonExisting));
-			$this->exists = false;
-			$this->fileInfo = null;
-		} else {
-			throw new NotPermittedException();
-		}
-	}
+    public function delete() {
+        if ($this->checkPermissions(\OCP\Constants::PERMISSION_DELETE)) {
+            $this->sendHooks(array('preDelete'));
+            $fileInfo = $this->getFileInfo();
+            $this->view->unlink($this->path);
+            $nonExisting = new NonExistingFile($this->root, $this->view, $this->path, $fileInfo);
+            $this->root->emit('\OC\Files', 'postDelete', array($nonExisting));
+            $this->exists = false;
+            $this->fileInfo = null;
+        } else {
+            throw new NotPermittedException();
+        }
+    }
 
-	/**
-	 * @param string $type
-	 * @param bool $raw
-	 * @return string
-	 */
-	public function hash($type, $raw = false) {
-		return $this->view->hash($type, $this->path, $raw);
-	}
+    /**
+     * @param string $type
+     * @param bool $raw
+     * @return string
+     */
+    public function hash($type, $raw = false) {
+        return $this->view->hash($type, $this->path, $raw);
+    }
 
-	/**
-	 * @inheritdoc
-	 */
-	public function getChecksum() {
-		return $this->getFileInfo()->getChecksum();
-	}
+    /**
+     * @inheritdoc
+     */
+    public function getChecksum() {
+        return $this->getFileInfo()->getChecksum();
+    }
 }