nextcloud / server

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 +25 added lines, -25 removed lines

@@ -131,9 +131,9 @@ 
 		 *
 		 * @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)) {
+		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;
@@ -202,7 +202,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);
@@ -297,7 +297,7 @@ 
 	 */
 	private function isSubDirectory($sub, $parent) {
 		// Check whether $sub contains no ".."
-		if(strpos($sub, '..') !== false) {
+		if (strpos($sub, '..') !== false) {
 			return false;
 		}
 
@@ -322,12 +322,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
@@ -337,7 +337,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;
 			}
@@ -354,14 +354,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/';
 	}
 
 
@@ -378,15 +378,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
@@ -394,9 +394,9 @@ 
 			$body .= ';';
 			$res = '';
 			$p = 0;
-			for($i = 0; $i < strlen($body); $i++) {
+			for ($i = 0; $i < strlen($body); $i++) {
 				$ch = $body[$i];
-				switch ( $ch ) {
+				switch ($ch) {
 					case '?':
 						$res .= ' ? (';
 						$p++;
@@ -405,7 +405,7 @@ 
 						$res .= ') : (';
 						break;
 					case ';':
-						$res .= str_repeat( ')', $p ) . ';';
+						$res .= str_repeat(')', $p).';';
 						$p = 0;
 						break;
 					default:
@@ -413,7 +413,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;

Indentation +405 added lines, -405 removed lines

@@ -40,409 +40,409 @@
  */
 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 = [];
-
-	/** @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;
-			for($i = 0; $i < strlen($body); $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;
-		}
-	}
+    /** @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 = [];
+
+    /** @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;
+            for($i = 0; $i < strlen($body); $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;
+        }
+    }
 }

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);

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, \OCP\Util::ERROR);
+			\OCP\Util::writeLog('files', ' Backends provided no user object for '.$user, \OCP\Util::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, \OCP\Util::WARN);
+			\OCP\Util::writeLog('files', 'initMountPoints() called with wrong user casing. This could be a bug. Expected: "'.$realUid.'" got "'.$user.'". Stack: '.$stack, \OCP\Util::WARN);
 			$user = $realUid;
 
 			// again with the correct casing
@@ -453,11 +453,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));
@@ -472,7 +472,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) {
@@ -567,7 +567,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));
@@ -584,7 +584,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;
@@ -813,7 +813,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]);
 
@@ -835,7 +835,7 @@ 
 
 		//add leading slash
 		if ($path[0] !== '/') {
-			$path = '/' . $path;
+			$path = '/'.$path;
 		}
 
 		// remove '/./'

Indentation +853 added lines, -853 removed lines

@@ -69,857 +69,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, \OCP\Util::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, \OCP\Util::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();
-		}
-
-		/**
-		 * 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 and substr($path, -1, 1) === '/') {
-			$path = substr($path, 0, -1);
-		}
-
-		// 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, \OCP\Util::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, \OCP\Util::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();
+        }
+
+        /**
+         * 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 and substr($path, -1, 1) === '/') {
+            $path = substr($path, 0, -1);
+        }
+
+        // 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);
+    }
 }

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) {

Spacing +25 added lines, -25 removed lines

@@ -370,8 +370,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);
 		}
 
@@ -441,8 +441,8 @@ 
 					}
 				}
 			} catch (ModuleDoesNotExistsException $e) {
-				$this->logger->warning('Encryption module "' . $encryptionModuleId .
-					'" not found, file will be stored unencrypted (' . $e->getMessage() . ')');
+				$this->logger->warning('Encryption module "'.$encryptionModuleId.
+					'" not found, file will be stored unencrypted ('.$e->getMessage().')');
 			}
 
 			// encryption disabled on write of new file and write to existing unencrypted file -> don't encrypt
@@ -494,7 +494,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)]);
@@ -523,7 +523,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;
 		}
 
@@ -548,7 +548,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
@@ -556,16 +556,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);
 			}
 		}
 
@@ -573,8 +573,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);
@@ -658,7 +658,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
@@ -666,7 +666,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;
 			}
 
@@ -702,9 +702,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
@@ -724,7 +724,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 {
@@ -737,7 +737,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);
 					}
 				}
 			}
@@ -753,7 +753,7 @@ 
 				fclose($target);
 				throw $e;
 			}
-			if($result) {
+			if ($result) {
 				if ($preserveMtime) {
 					$this->touch($targetInternalPath, $sourceStorage->filemtime($sourceInternalPath));
 				}
@@ -765,7 +765,7 @@ 
 				$this->getCache()->remove($targetInternalPath);
 			}
 		}
-		return (bool)$result;
+		return (bool) $result;
 
 	}
 
@@ -836,7 +836,7 @@ 
 	 * @return string full path including mount point
 	 */
 	protected function getFullPath($path) {
-		return Filesystem::normalizePath($this->mountPoint . '/' . $path);
+		return Filesystem::normalizePath($this->mountPoint.'/'.$path);
 	}
 
 	/**
@@ -892,7 +892,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) {
@@ -955,7 +955,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;
 			}
 		}

Indentation +979 added lines, -979 removed lines

@@ -48,984 +48,984 @@
 
 class Encryption extends Wrapper {
 
-	use LocalTempFileTrait;
-
-	/** @var string */
-	private $mountPoint;
-
-	/** @var \OC\Encryption\Util */
-	private $util;
-
-	/** @var \OCP\Encryption\IManager */
-	private $encryptionManager;
-
-	/** @var \OCP\ILogger */
-	private $logger;
-
-	/** @var string */
-	private $uid;
-
-	/** @var array */
-	protected $unencryptedSize;
-
-	/** @var \OCP\Encryption\IFile */
-	private $fileHelper;
-
-	/** @var IMountPoint */
-	private $mount;
-
-	/** @var IStorage */
-	private $keyStorage;
-
-	/** @var Update */
-	private $update;
-
-	/** @var Manager */
-	private $mountManager;
-
-	/** @var array remember for which path we execute the repair step to avoid recursions */
-	private $fixUnencryptedSizeOf = array();
-
-	/** @var  ArrayCache */
-	private $arrayCache;
-
-	/**
-	 * @param array $parameters
-	 * @param IManager $encryptionManager
-	 * @param Util $util
-	 * @param ILogger $logger
-	 * @param IFile $fileHelper
-	 * @param string $uid
-	 * @param IStorage $keyStorage
-	 * @param Update $update
-	 * @param Manager $mountManager
-	 * @param ArrayCache $arrayCache
-	 */
-	public function __construct(
-			$parameters,
-			IManager $encryptionManager = null,
-			Util $util = null,
-			ILogger $logger = null,
-			IFile $fileHelper = null,
-			$uid = null,
-			IStorage $keyStorage = null,
-			Update $update = null,
-			Manager $mountManager = null,
-			ArrayCache $arrayCache = null
-		) {
-
-		$this->mountPoint = $parameters['mountPoint'];
-		$this->mount = $parameters['mount'];
-		$this->encryptionManager = $encryptionManager;
-		$this->util = $util;
-		$this->logger = $logger;
-		$this->uid = $uid;
-		$this->fileHelper = $fileHelper;
-		$this->keyStorage = $keyStorage;
-		$this->unencryptedSize = array();
-		$this->update = $update;
-		$this->mountManager = $mountManager;
-		$this->arrayCache = $arrayCache;
-		parent::__construct($parameters);
-	}
-
-	/**
-	 * see http://php.net/manual/en/function.filesize.php
-	 * The result for filesize when called on a folder is required to be 0
-	 *
-	 * @param string $path
-	 * @return int
-	 */
-	public function filesize($path) {
-		$fullPath = $this->getFullPath($path);
-
-		/** @var CacheEntry $info */
-		$info = $this->getCache()->get($path);
-		if (isset($this->unencryptedSize[$fullPath])) {
-			$size = $this->unencryptedSize[$fullPath];
-			// update file cache
-			if ($info instanceof ICacheEntry) {
-				$info = $info->getData();
-				$info['encrypted'] = $info['encryptedVersion'];
-			} else {
-				if (!is_array($info)) {
-					$info = [];
-				}
-				$info['encrypted'] = true;
-			}
-
-			$info['size'] = $size;
-			$this->getCache()->put($path, $info);
-
-			return $size;
-		}
-
-		if (isset($info['fileid']) && $info['encrypted']) {
-			return $this->verifyUnencryptedSize($path, $info['size']);
-		}
-
-		return $this->storage->filesize($path);
-	}
-
-	/**
-	 * @param string $path
-	 * @return array
-	 */
-	public function getMetaData($path) {
-		$data = $this->storage->getMetaData($path);
-		if (is_null($data)) {
-			return null;
-		}
-		$fullPath = $this->getFullPath($path);
-		$info = $this->getCache()->get($path);
-
-		if (isset($this->unencryptedSize[$fullPath])) {
-			$data['encrypted'] = true;
-			$data['size'] = $this->unencryptedSize[$fullPath];
-		} else {
-			if (isset($info['fileid']) && $info['encrypted']) {
-				$data['size'] = $this->verifyUnencryptedSize($path, $info['size']);
-				$data['encrypted'] = true;
-			}
-		}
-
-		if (isset($info['encryptedVersion']) && $info['encryptedVersion'] > 1) {
-			$data['encryptedVersion'] = $info['encryptedVersion'];
-		}
-
-		return $data;
-	}
-
-	/**
-	 * see http://php.net/manual/en/function.file_get_contents.php
-	 *
-	 * @param string $path
-	 * @return string
-	 */
-	public function file_get_contents($path) {
-
-		$encryptionModule = $this->getEncryptionModule($path);
-
-		if ($encryptionModule) {
-			$handle = $this->fopen($path, "r");
-			if (!$handle) {
-				return false;
-			}
-			$data = stream_get_contents($handle);
-			fclose($handle);
-			return $data;
-		}
-		return $this->storage->file_get_contents($path);
-	}
-
-	/**
-	 * see http://php.net/manual/en/function.file_put_contents.php
-	 *
-	 * @param string $path
-	 * @param string $data
-	 * @return bool
-	 */
-	public function file_put_contents($path, $data) {
-		// file put content will always be translated to a stream write
-		$handle = $this->fopen($path, 'w');
-		if (is_resource($handle)) {
-			$written = fwrite($handle, $data);
-			fclose($handle);
-			return $written;
-		}
-
-		return false;
-	}
-
-	/**
-	 * see http://php.net/manual/en/function.unlink.php
-	 *
-	 * @param string $path
-	 * @return bool
-	 */
-	public function unlink($path) {
-		$fullPath = $this->getFullPath($path);
-		if ($this->util->isExcluded($fullPath)) {
-			return $this->storage->unlink($path);
-		}
-
-		$encryptionModule = $this->getEncryptionModule($path);
-		if ($encryptionModule) {
-			$this->keyStorage->deleteAllFileKeys($this->getFullPath($path));
-		}
-
-		return $this->storage->unlink($path);
-	}
-
-	/**
-	 * see http://php.net/manual/en/function.rename.php
-	 *
-	 * @param string $path1
-	 * @param string $path2
-	 * @return bool
-	 */
-	public function rename($path1, $path2) {
-
-		$result = $this->storage->rename($path1, $path2);
-
-		if ($result &&
-			// versions always use the keys from the original file, so we can skip
-			// this step for versions
-			$this->isVersion($path2) === false &&
-			$this->encryptionManager->isEnabled()) {
-			$source = $this->getFullPath($path1);
-			if (!$this->util->isExcluded($source)) {
-				$target = $this->getFullPath($path2);
-				if (isset($this->unencryptedSize[$source])) {
-					$this->unencryptedSize[$target] = $this->unencryptedSize[$source];
-				}
-				$this->keyStorage->renameKeys($source, $target);
-				$module = $this->getEncryptionModule($path2);
-				if ($module) {
-					$module->update($target, $this->uid, []);
-				}
-			}
-		}
-
-		return $result;
-	}
-
-	/**
-	 * see http://php.net/manual/en/function.rmdir.php
-	 *
-	 * @param string $path
-	 * @return bool
-	 */
-	public function rmdir($path) {
-		$result = $this->storage->rmdir($path);
-		$fullPath = $this->getFullPath($path);
-		if ($result &&
-			$this->util->isExcluded($fullPath) === false &&
-			$this->encryptionManager->isEnabled()
-		) {
-			$this->keyStorage->deleteAllFileKeys($fullPath);
-		}
-
-		return $result;
-	}
-
-	/**
-	 * check if a file can be read
-	 *
-	 * @param string $path
-	 * @return bool
-	 */
-	public function isReadable($path) {
-
-		$isReadable = true;
-
-		$metaData = $this->getMetaData($path);
-		if (
-			!$this->is_dir($path) &&
-			isset($metaData['encrypted']) &&
-			$metaData['encrypted'] === true
-		) {
-			$fullPath = $this->getFullPath($path);
-			$module = $this->getEncryptionModule($path);
-			$isReadable = $module->isReadable($fullPath, $this->uid);
-		}
-
-		return $this->storage->isReadable($path) && $isReadable;
-	}
-
-	/**
-	 * see http://php.net/manual/en/function.copy.php
-	 *
-	 * @param string $path1
-	 * @param string $path2
-	 * @return bool
-	 */
-	public function copy($path1, $path2) {
-
-		$source = $this->getFullPath($path1);
-
-		if ($this->util->isExcluded($source)) {
-			return $this->storage->copy($path1, $path2);
-		}
-
-		// need to stream copy file by file in case we copy between a encrypted
-		// and a unencrypted storage
-		$this->unlink($path2);
-		$result = $this->copyFromStorage($this, $path1, $path2);
-
-		return $result;
-	}
-
-	/**
-	 * see http://php.net/manual/en/function.fopen.php
-	 *
-	 * @param string $path
-	 * @param string $mode
-	 * @return resource|bool
-	 * @throws GenericEncryptionException
-	 * @throws ModuleDoesNotExistsException
-	 */
-	public function fopen($path, $mode) {
-
-		// check if the file is stored in the array cache, this means that we
-		// copy a file over to the versions folder, in this case we don't want to
-		// decrypt it
-		if ($this->arrayCache->hasKey('encryption_copy_version_' . $path)) {
-			$this->arrayCache->remove('encryption_copy_version_' . $path);
-			return $this->storage->fopen($path, $mode);
-		}
-
-		$encryptionEnabled = $this->encryptionManager->isEnabled();
-		$shouldEncrypt = false;
-		$encryptionModule = null;
-		$header = $this->getHeader($path);
-		$signed = (isset($header['signed']) && $header['signed'] === 'true') ? true : false;
-		$fullPath = $this->getFullPath($path);
-		$encryptionModuleId = $this->util->getEncryptionModuleId($header);
-
-		if ($this->util->isExcluded($fullPath) === false) {
-
-			$size = $unencryptedSize = 0;
-			$realFile = $this->util->stripPartialFileExtension($path);
-			$targetExists = $this->file_exists($realFile) || $this->file_exists($path);
-			$targetIsEncrypted = false;
-			if ($targetExists) {
-				// in case the file exists we require the explicit module as
-				// specified in the file header - otherwise we need to fail hard to
-				// prevent data loss on client side
-				if (!empty($encryptionModuleId)) {
-					$targetIsEncrypted = true;
-					$encryptionModule = $this->encryptionManager->getEncryptionModule($encryptionModuleId);
-				}
-
-				if ($this->file_exists($path)) {
-					$size = $this->storage->filesize($path);
-					$unencryptedSize = $this->filesize($path);
-				} else {
-					$size = $unencryptedSize = 0;
-				}
-			}
-
-			try {
-
-				if (
-					$mode === 'w'
-					|| $mode === 'w+'
-					|| $mode === 'wb'
-					|| $mode === 'wb+'
-				) {
-					// if we update a encrypted file with a un-encrypted one we change the db flag
-					if ($targetIsEncrypted && $encryptionEnabled === false) {
-						$cache = $this->storage->getCache();
-						if ($cache) {
-							$entry = $cache->get($path);
-							$cache->update($entry->getId(), ['encrypted' => 0]);
-						}
-					}
-					if ($encryptionEnabled) {
-						// if $encryptionModuleId is empty, the default module will be used
-						$encryptionModule = $this->encryptionManager->getEncryptionModule($encryptionModuleId);
-						$shouldEncrypt = $encryptionModule->shouldEncrypt($fullPath);
-						$signed = true;
-					}
-				} else {
-					$info = $this->getCache()->get($path);
-					// only get encryption module if we found one in the header
-					// or if file should be encrypted according to the file cache
-					if (!empty($encryptionModuleId)) {
-						$encryptionModule = $this->encryptionManager->getEncryptionModule($encryptionModuleId);
-						$shouldEncrypt = true;
-					} else if (empty($encryptionModuleId) && $info['encrypted'] === true) {
-						// we come from a old installation. No header and/or no module defined
-						// but the file is encrypted. In this case we need to use the
-						// OC_DEFAULT_MODULE to read the file
-						$encryptionModule = $this->encryptionManager->getEncryptionModule('OC_DEFAULT_MODULE');
-						$shouldEncrypt = true;
-						$targetIsEncrypted = true;
-					}
-				}
-			} catch (ModuleDoesNotExistsException $e) {
-				$this->logger->warning('Encryption module "' . $encryptionModuleId .
-					'" not found, file will be stored unencrypted (' . $e->getMessage() . ')');
-			}
-
-			// encryption disabled on write of new file and write to existing unencrypted file -> don't encrypt
-			if (!$encryptionEnabled || !$this->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') ? true : false;
-		$unencryptedBlockSize = $encryptionModule->getUnencryptedBlockSize($signed);
-
-		// calculate last chunk nr
-		// next highest is end of chunks, one subtracted is last one
-		// we have to read the last chunk, we can't just calculate it (because of padding etc)
-
-		$lastChunkNr = ceil($size/ $blockSize)-1;
-		// calculate last chunk position
-		$lastChunkPos = ($lastChunkNr * $blockSize);
-		// try to fseek to the last chunk, if it fails we have to read the whole file
-		if (@fseek($stream, $lastChunkPos, SEEK_CUR) === 0) {
-			$newUnencryptedSize += $lastChunkNr * $unencryptedBlockSize;
-		}
-
-		$lastChunkContentEncrypted='';
-		$count = $blockSize;
-
-		while ($count > 0) {
-			$data=fread($stream, $blockSize);
-			$count=strlen($data);
-			$lastChunkContentEncrypted .= $data;
-			if(strlen($lastChunkContentEncrypted) > $blockSize) {
-				$newUnencryptedSize += $unencryptedBlockSize;
-				$lastChunkContentEncrypted=substr($lastChunkContentEncrypted, $blockSize);
-			}
-		}
-
-		fclose($stream);
-
-		// we have to decrypt the last chunk to get it actual size
-		$encryptionModule->begin($this->getFullPath($path), $this->uid, 'r', $header, []);
-		$decryptedLastChunk = $encryptionModule->decrypt($lastChunkContentEncrypted, $lastChunkNr . 'end');
-		$decryptedLastChunk .= $encryptionModule->end($this->getFullPath($path), $lastChunkNr . 'end');
-
-		// calc the real file size with the size of the last chunk
-		$newUnencryptedSize += strlen($decryptedLastChunk);
-
-		$this->updateUnencryptedSize($this->getFullPath($path), $newUnencryptedSize);
-
-		// write to cache if applicable
-		$cache = $this->storage->getCache();
-		if ($cache) {
-			$entry = $cache->get($path);
-			$cache->update($entry['fileid'], ['size' => $newUnencryptedSize]);
-		}
-
-		return $newUnencryptedSize;
-	}
-
-	/**
-	 * @param Storage\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);
+        $result = $this->copyFromStorage($this, $path1, $path2);
+
+        return $result;
+    }
+
+    /**
+     * see http://php.net/manual/en/function.fopen.php
+     *
+     * @param string $path
+     * @param string $mode
+     * @return resource|bool
+     * @throws GenericEncryptionException
+     * @throws ModuleDoesNotExistsException
+     */
+    public function fopen($path, $mode) {
+
+        // check if the file is stored in the array cache, this means that we
+        // copy a file over to the versions folder, in this case we don't want to
+        // decrypt it
+        if ($this->arrayCache->hasKey('encryption_copy_version_' . $path)) {
+            $this->arrayCache->remove('encryption_copy_version_' . $path);
+            return $this->storage->fopen($path, $mode);
+        }
+
+        $encryptionEnabled = $this->encryptionManager->isEnabled();
+        $shouldEncrypt = false;
+        $encryptionModule = null;
+        $header = $this->getHeader($path);
+        $signed = (isset($header['signed']) && $header['signed'] === 'true') ? true : false;
+        $fullPath = $this->getFullPath($path);
+        $encryptionModuleId = $this->util->getEncryptionModuleId($header);
+
+        if ($this->util->isExcluded($fullPath) === false) {
+
+            $size = $unencryptedSize = 0;
+            $realFile = $this->util->stripPartialFileExtension($path);
+            $targetExists = $this->file_exists($realFile) || $this->file_exists($path);
+            $targetIsEncrypted = false;
+            if ($targetExists) {
+                // in case the file exists we require the explicit module as
+                // specified in the file header - otherwise we need to fail hard to
+                // prevent data loss on client side
+                if (!empty($encryptionModuleId)) {
+                    $targetIsEncrypted = true;
+                    $encryptionModule = $this->encryptionManager->getEncryptionModule($encryptionModuleId);
+                }
+
+                if ($this->file_exists($path)) {
+                    $size = $this->storage->filesize($path);
+                    $unencryptedSize = $this->filesize($path);
+                } else {
+                    $size = $unencryptedSize = 0;
+                }
+            }
+
+            try {
+
+                if (
+                    $mode === 'w'
+                    || $mode === 'w+'
+                    || $mode === 'wb'
+                    || $mode === 'wb+'
+                ) {
+                    // if we update a encrypted file with a un-encrypted one we change the db flag
+                    if ($targetIsEncrypted && $encryptionEnabled === false) {
+                        $cache = $this->storage->getCache();
+                        if ($cache) {
+                            $entry = $cache->get($path);
+                            $cache->update($entry->getId(), ['encrypted' => 0]);
+                        }
+                    }
+                    if ($encryptionEnabled) {
+                        // if $encryptionModuleId is empty, the default module will be used
+                        $encryptionModule = $this->encryptionManager->getEncryptionModule($encryptionModuleId);
+                        $shouldEncrypt = $encryptionModule->shouldEncrypt($fullPath);
+                        $signed = true;
+                    }
+                } else {
+                    $info = $this->getCache()->get($path);
+                    // only get encryption module if we found one in the header
+                    // or if file should be encrypted according to the file cache
+                    if (!empty($encryptionModuleId)) {
+                        $encryptionModule = $this->encryptionManager->getEncryptionModule($encryptionModuleId);
+                        $shouldEncrypt = true;
+                    } else if (empty($encryptionModuleId) && $info['encrypted'] === true) {
+                        // we come from a old installation. No header and/or no module defined
+                        // but the file is encrypted. In this case we need to use the
+                        // OC_DEFAULT_MODULE to read the file
+                        $encryptionModule = $this->encryptionManager->getEncryptionModule('OC_DEFAULT_MODULE');
+                        $shouldEncrypt = true;
+                        $targetIsEncrypted = true;
+                    }
+                }
+            } catch (ModuleDoesNotExistsException $e) {
+                $this->logger->warning('Encryption module "' . $encryptionModuleId .
+                    '" not found, file will be stored unencrypted (' . $e->getMessage() . ')');
+            }
+
+            // encryption disabled on write of new file and write to existing unencrypted file -> don't encrypt
+            if (!$encryptionEnabled || !$this->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') ? true : false;
+        $unencryptedBlockSize = $encryptionModule->getUnencryptedBlockSize($signed);
+
+        // calculate last chunk nr
+        // next highest is end of chunks, one subtracted is last one
+        // we have to read the last chunk, we can't just calculate it (because of padding etc)
+
+        $lastChunkNr = ceil($size/ $blockSize)-1;
+        // calculate last chunk position
+        $lastChunkPos = ($lastChunkNr * $blockSize);
+        // try to fseek to the last chunk, if it fails we have to read the whole file
+        if (@fseek($stream, $lastChunkPos, SEEK_CUR) === 0) {
+            $newUnencryptedSize += $lastChunkNr * $unencryptedBlockSize;
+        }
+
+        $lastChunkContentEncrypted='';
+        $count = $blockSize;
+
+        while ($count > 0) {
+            $data=fread($stream, $blockSize);
+            $count=strlen($data);
+            $lastChunkContentEncrypted .= $data;
+            if(strlen($lastChunkContentEncrypted) > $blockSize) {
+                $newUnencryptedSize += $unencryptedBlockSize;
+                $lastChunkContentEncrypted=substr($lastChunkContentEncrypted, $blockSize);
+            }
+        }
+
+        fclose($stream);
+
+        // we have to decrypt the last chunk to get it actual size
+        $encryptionModule->begin($this->getFullPath($path), $this->uid, 'r', $header, []);
+        $decryptedLastChunk = $encryptionModule->decrypt($lastChunkContentEncrypted, $lastChunkNr . 'end');
+        $decryptedLastChunk .= $encryptionModule->end($this->getFullPath($path), $lastChunkNr . 'end');
+
+        // calc the real file size with the size of the last chunk
+        $newUnencryptedSize += strlen($decryptedLastChunk);
+
+        $this->updateUnencryptedSize($this->getFullPath($path), $newUnencryptedSize);
+
+        // write to cache if applicable
+        $cache = $this->storage->getCache();
+        if ($cache) {
+            $entry = $cache->get($path);
+            $cache->update($entry['fileid'], ['size' => $newUnencryptedSize]);
+        }
+
+        return $newUnencryptedSize;
+    }
+
+    /**
+     * @param Storage\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);
+
+    }
 
 }

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)) {

Unused Use Statements -1 removed lines

@@ -28,7 +28,6 @@
 use Icewind\Streams\CallbackWrapper;
 use Icewind\Streams\IteratorDirectory;
 use OC\Files\Cache\CacheEntry;
-use OC\Files\Stream\CountReadStream;
 use OCP\Files\NotFoundException;
 use OCP\Files\ObjectStore\IObjectStore;
 

Indentation +403 added lines, -403 removed lines

@@ -33,407 +33,407 @@
 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;
-				} else {
-					//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);
-
-		switch ($mode) {
-			case 'r':
-			case 'rb':
-				$stat = $this->stat($path);
-				if (is_array($stat)) {
-					try {
-						return $this->objectStore->readObject($this->getURN($stat['fileid']));
-					} catch (NotFoundException $e) {
-						$this->logger->logException($e, [
-							'app' => 'objectstore',
-							'message' => 'Could not get object ' . $this->getURN($stat['fileid']) . ' for file ' . $path,
-						]);
-						throw $e;
-					} catch (\Exception $ex) {
-						$this->logger->logException($ex, [
-							'app' => 'objectstore',
-							'message' => 'Could not get object ' . $this->getURN($stat['fileid']) . ' for file ' . $path,
-						]);
-						return false;
-					}
-				} else {
-					return false;
-				}
-			case 'w':
-			case 'wb':
-			case 'a':
-			case 'ab':
-			case 'r+':
-			case 'w+':
-			case 'wb+':
-			case 'a+':
-			case 'x':
-			case 'x+':
-			case 'c':
-			case 'c+':
-				if (strrpos($path, '.') !== false) {
-					$ext = substr($path, strrpos($path, '.'));
-				} else {
-					$ext = '';
-				}
-				$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,
-				]);
-				return false;
-			}
-		}
-		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;
+                } else {
+                    //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);
+
+        switch ($mode) {
+            case 'r':
+            case 'rb':
+                $stat = $this->stat($path);
+                if (is_array($stat)) {
+                    try {
+                        return $this->objectStore->readObject($this->getURN($stat['fileid']));
+                    } catch (NotFoundException $e) {
+                        $this->logger->logException($e, [
+                            'app' => 'objectstore',
+                            'message' => 'Could not get object ' . $this->getURN($stat['fileid']) . ' for file ' . $path,
+                        ]);
+                        throw $e;
+                    } catch (\Exception $ex) {
+                        $this->logger->logException($ex, [
+                            'app' => 'objectstore',
+                            'message' => 'Could not get object ' . $this->getURN($stat['fileid']) . ' for file ' . $path,
+                        ]);
+                        return false;
+                    }
+                } else {
+                    return false;
+                }
+            case 'w':
+            case 'wb':
+            case 'a':
+            case 'ab':
+            case 'r+':
+            case 'w+':
+            case 'wb+':
+            case 'a+':
+            case 'x':
+            case 'x+':
+            case 'c':
+            case 'c+':
+                if (strrpos($path, '.') !== false) {
+                    $ext = substr($path, strrpos($path, '.'));
+                } else {
+                    $ext = '';
+                }
+                $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,
+                ]);
+                return false;
+            }
+        }
+        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;
+    }
 }

Spacing +10 added lines, -10 removed lines

@@ -57,9 +57,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'];
@@ -193,7 +193,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;
 				} else {
@@ -226,7 +226,7 @@ 
 	 */
 	protected function getURN($fileId) {
 		if (is_numeric($fileId)) {
-			return $this->objectPrefix . $fileId;
+			return $this->objectPrefix.$fileId;
 		}
 		return null;
 	}
@@ -274,13 +274,13 @@ 
 					} catch (NotFoundException $e) {
 						$this->logger->logException($e, [
 							'app' => 'objectstore',
-							'message' => 'Could not get object ' . $this->getURN($stat['fileid']) . ' for file ' . $path,
+							'message' => 'Could not get object '.$this->getURN($stat['fileid']).' for file '.$path,
 						]);
 						throw $e;
 					} catch (\Exception $ex) {
 						$this->logger->logException($ex, [
 							'app' => 'objectstore',
-							'message' => 'Could not get object ' . $this->getURN($stat['fileid']) . ' for file ' . $path,
+							'message' => 'Could not get object '.$this->getURN($stat['fileid']).' for file '.$path,
 						]);
 						return false;
 					}
@@ -310,7 +310,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);
 				});
 		}
@@ -319,7 +319,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) {
@@ -376,7 +376,7 @@ 
 			} catch (\Exception $ex) {
 				$this->logger->logException($ex, [
 					'app' => 'objectstore',
-					'message' => 'Could not create object for ' . $path,
+					'message' => 'Could not create object for '.$path,
 				]);
 				return false;
 			}
@@ -416,7 +416,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
 		}

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 +102 added lines, -102 removed lines

@@ -29,113 +29,113 @@
 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
-	 */
-	public function putContent($data) {
-		if ($this->checkPermissions(\OCP\Constants::PERMISSION_UPDATE)) {
-			$this->sendHooks(array('preWrite'));
-			$this->view->file_put_contents($this->path, $data);
-			$this->fileInfo = null;
-			$this->sendHooks(array('postWrite'));
-		} else {
-			throw new NotPermittedException();
-		}
-	}
+    /**
+     * @param string $data
+     * @throws \OCP\Files\NotPermittedException
+     */
+    public function putContent($data) {
+        if ($this->checkPermissions(\OCP\Constants::PERMISSION_UPDATE)) {
+            $this->sendHooks(array('preWrite'));
+            $this->view->file_put_contents($this->path, $data);
+            $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();
+    }
 }

lib/private/Files/Node/Folder.php

Doc Comments +1 added lines, -1 removed lines

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

Indentation +394 added lines, -394 removed lines

@@ -36,398 +36,398 @@
 use OCP\Files\Search\ISearchOperator;
 
 class Folder extends Node implements \OCP\Files\Folder {
-	/**
-	 * 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 NonExistingFolder($this->root, $this->view, $path);
-	}
-
-	/**
-	 * @param string $path path relative to the folder
-	 * @return string
-	 * @throws \OCP\Files\NotPermittedException
-	 */
-	public function getFullPath($path) {
-		if (!$this->isValidPath($path)) {
-			throw new NotPermittedException('Invalid path');
-		}
-		return $this->path . $this->normalizePath($path);
-	}
-
-	/**
-	 * @param string $path
-	 * @return string
-	 */
-	public function getRelativePath($path) {
-		if ($this->path === '' or $this->path === '/') {
-			return $this->normalizePath($path);
-		}
-		if ($path === $this->path) {
-			return '/';
-		} else if (strpos($path, $this->path . '/') !== 0) {
-			return null;
-		} else {
-			$path = substr($path, strlen($this->path));
-			return $this->normalizePath($path);
-		}
-	}
-
-	/**
-	 * check if a node is a (grand-)child of the folder
-	 *
-	 * @param \OC\Files\Node\Node $node
-	 * @return bool
-	 */
-	public function isSubNode($node) {
-		return strpos($node->getPath(), $this->path . '/') === 0;
-	}
-
-	/**
-	 * get the content of this directory
-	 *
-	 * @throws \OCP\Files\NotFoundException
-	 * @return Node[]
-	 */
-	public function getDirectoryListing() {
-		$folderContent = $this->view->getDirectoryContent($this->path);
-
-		return array_map(function (FileInfo $info) {
-			if ($info->getMimetype() === 'httpd/unix-directory') {
-				return new Folder($this->root, $this->view, $info->getPath(), $info);
-			} else {
-				return new File($this->root, $this->view, $info->getPath(), $info);
-			}
-		}, $folderContent);
-	}
-
-	/**
-	 * @param string $path
-	 * @param FileInfo $info
-	 * @return File|Folder
-	 */
-	protected function createNode($path, FileInfo $info = null) {
-		if (is_null($info)) {
-			$isDir = $this->view->is_dir($path);
-		} else {
-			$isDir = $info->getType() === FileInfo::TYPE_FOLDER;
-		}
-		if ($isDir) {
-			return new Folder($this->root, $this->view, $path, $info);
-		} else {
-			return new File($this->root, $this->view, $path, $info);
-		}
-	}
-
-	/**
-	 * Get the node at $path
-	 *
-	 * @param string $path
-	 * @return \OC\Files\Node\Node
-	 * @throws \OCP\Files\NotFoundException
-	 */
-	public function get($path) {
-		return $this->root->get($this->getFullPath($path));
-	}
-
-	/**
-	 * @param string $path
-	 * @return bool
-	 */
-	public function nodeExists($path) {
-		try {
-			$this->get($path);
-			return true;
-		} catch (NotFoundException $e) {
-			return false;
-		}
-	}
-
-	/**
-	 * @param string $path
-	 * @return \OC\Files\Node\Folder
-	 * @throws \OCP\Files\NotPermittedException
-	 */
-	public function newFolder($path) {
-		if ($this->checkPermissions(\OCP\Constants::PERMISSION_CREATE)) {
-			$fullPath = $this->getFullPath($path);
-			$nonExisting = new NonExistingFolder($this->root, $this->view, $fullPath);
-			$this->root->emit('\OC\Files', 'preWrite', array($nonExisting));
-			$this->root->emit('\OC\Files', 'preCreate', array($nonExisting));
-			$this->view->mkdir($fullPath);
-			$node = new Folder($this->root, $this->view, $fullPath);
-			$this->root->emit('\OC\Files', 'postWrite', array($node));
-			$this->root->emit('\OC\Files', 'postCreate', array($node));
-			return $node;
-		} else {
-			throw new NotPermittedException('No create permission for folder');
-		}
-	}
-
-	/**
-	 * @param string $path
-	 * @return \OC\Files\Node\File
-	 * @throws \OCP\Files\NotPermittedException
-	 */
-	public function newFile($path) {
-		if ($this->checkPermissions(\OCP\Constants::PERMISSION_CREATE)) {
-			$fullPath = $this->getFullPath($path);
-			$nonExisting = new NonExistingFile($this->root, $this->view, $fullPath);
-			$this->root->emit('\OC\Files', 'preWrite', array($nonExisting));
-			$this->root->emit('\OC\Files', 'preCreate', array($nonExisting));
-			$this->view->touch($fullPath);
-			$node = new File($this->root, $this->view, $fullPath);
-			$this->root->emit('\OC\Files', 'postWrite', array($node));
-			$this->root->emit('\OC\Files', 'postCreate', array($node));
-			return $node;
-		} else {
-			throw new NotPermittedException('No create permission for path');
-		}
-	}
-
-	/**
-	 * search for files with the name matching $query
-	 *
-	 * @param string|ISearchOperator $query
-	 * @return \OC\Files\Node\Node[]
-	 */
-	public function search($query) {
-		if (is_string($query)) {
-			return $this->searchCommon('search', array('%' . $query . '%'));
-		} else {
-			return $this->searchCommon('searchQuery', array($query));
-		}
-	}
-
-	/**
-	 * search for files by mimetype
-	 *
-	 * @param string $mimetype
-	 * @return Node[]
-	 */
-	public function searchByMime($mimetype) {
-		return $this->searchCommon('searchByMime', array($mimetype));
-	}
-
-	/**
-	 * search for files by tag
-	 *
-	 * @param string|int $tag name or tag id
-	 * @param string $userId owner of the tags
-	 * @return Node[]
-	 */
-	public function searchByTag($tag, $userId) {
-		return $this->searchCommon('searchByTag', array($tag, $userId));
-	}
-
-	/**
-	 * @param string $method cache method
-	 * @param array $args call args
-	 * @return \OC\Files\Node\Node[]
-	 */
-	private function searchCommon($method, $args) {
-		$files = array();
-		$rootLength = strlen($this->path);
-		$mount = $this->root->getMount($this->path);
-		$storage = $mount->getStorage();
-		$internalPath = $mount->getInternalPath($this->path);
-		$internalPath = rtrim($internalPath, '/');
-		if ($internalPath !== '') {
-			$internalPath = $internalPath . '/';
-		}
-		$internalRootLength = strlen($internalPath);
-
-		$cache = $storage->getCache('');
-
-		$results = call_user_func_array(array($cache, $method), $args);
-		foreach ($results as $result) {
-			if ($internalRootLength === 0 or substr($result['path'], 0, $internalRootLength) === $internalPath) {
-				$result['internalPath'] = $result['path'];
-				$result['path'] = substr($result['path'], $internalRootLength);
-				$result['storage'] = $storage;
-				$files[] = new \OC\Files\FileInfo($this->path . '/' . $result['path'], $storage, $result['internalPath'], $result, $mount);
-			}
-		}
-
-		$mounts = $this->root->getMountsIn($this->path);
-		foreach ($mounts as $mount) {
-			$storage = $mount->getStorage();
-			if ($storage) {
-				$cache = $storage->getCache('');
-
-				$relativeMountPoint = substr($mount->getMountPoint(), $rootLength);
-				$results = call_user_func_array(array($cache, $method), $args);
-				foreach ($results as $result) {
-					$result['internalPath'] = $result['path'];
-					$result['path'] = $relativeMountPoint . $result['path'];
-					$result['storage'] = $storage;
-					$files[] = new \OC\Files\FileInfo($this->path . '/' . $result['path'], $storage, $result['internalPath'], $result, $mount);
-				}
-			}
-		}
-
-		return array_map(function (FileInfo $file) {
-			return $this->createNode($file->getPath(), $file);
-		}, $files);
-	}
-
-	/**
-	 * @param int $id
-	 * @return \OC\Files\Node\Node[]
-	 */
-	public function getById($id) {
-		$mountCache = $this->root->getUserMountCache();
-		if (strpos($this->getPath(), '/', 1) > 0) {
-			list(, $user) = explode('/', $this->getPath());
-		} else {
-			$user = null;
-		}
-		$mountsContainingFile = $mountCache->getMountsForFileId((int)$id, $user);
-		$mounts = $this->root->getMountsIn($this->path);
-		$mounts[] = $this->root->getMount($this->path);
-		/** @var IMountPoint[] $folderMounts */
-		$folderMounts = array_combine(array_map(function (IMountPoint $mountPoint) {
-			return $mountPoint->getMountPoint();
-		}, $mounts), $mounts);
-
-		/** @var ICachedMountInfo[] $mountsContainingFile */
-		$mountsContainingFile = array_values(array_filter($mountsContainingFile, function (ICachedMountInfo $cachedMountInfo) use ($folderMounts) {
-			return isset($folderMounts[$cachedMountInfo->getMountPoint()]);
-		}));
-
-		if (count($mountsContainingFile) === 0) {
-			return [];
-		}
-
-		$nodes = array_map(function (ICachedMountInfo $cachedMountInfo) use ($folderMounts, $id) {
-			$mount = $folderMounts[$cachedMountInfo->getMountPoint()];
-			$cacheEntry = $mount->getStorage()->getCache()->get((int)$id);
-			if (!$cacheEntry) {
-				return null;
-			}
-
-			// cache jails will hide the "true" internal path
-			$internalPath = ltrim($cachedMountInfo->getRootInternalPath() . '/' . $cacheEntry->getPath(), '/');
-			$pathRelativeToMount = substr($internalPath, strlen($cachedMountInfo->getRootInternalPath()));
-			$pathRelativeToMount = ltrim($pathRelativeToMount, '/');
-			$absolutePath = $cachedMountInfo->getMountPoint() . $pathRelativeToMount;
-			return $this->root->createNode($absolutePath, new \OC\Files\FileInfo(
-				$absolutePath, $mount->getStorage(), $cacheEntry->getPath(), $cacheEntry, $mount,
-				\OC::$server->getUserManager()->get($mount->getStorage()->getOwner($pathRelativeToMount))
-			));
-		}, $mountsContainingFile);
-
-		$nodes = array_filter($nodes);
-
-		return array_filter($nodes, function (Node $node) {
-			return $this->getRelativePath($node->getPath());
-		});
-	}
-
-	public function getFreeSpace() {
-		return $this->view->free_space($this->path);
-	}
-
-	public function delete() {
-		if ($this->checkPermissions(\OCP\Constants::PERMISSION_DELETE)) {
-			$this->sendHooks(array('preDelete'));
-			$fileInfo = $this->getFileInfo();
-			$this->view->rmdir($this->path);
-			$nonExisting = new NonExistingFolder($this->root, $this->view, $this->path, $fileInfo);
-			$this->root->emit('\OC\Files', 'postDelete', array($nonExisting));
-			$this->exists = false;
-		} else {
-			throw new NotPermittedException('No delete permission for path');
-		}
-	}
-
-	/**
-	 * Add a suffix to the name in case the file exists
-	 *
-	 * @param string $name
-	 * @return string
-	 * @throws NotPermittedException
-	 */
-	public function getNonExistingName($name) {
-		$uniqueName = \OC_Helper::buildNotExistingFileNameForView($this->getPath(), $name, $this->view);
-		return trim($this->getRelativePath($uniqueName), '/');
-	}
-
-	/**
-	 * @param int $limit
-	 * @param int $offset
-	 * @return \OCP\Files\Node[]
-	 */
-	public function getRecent($limit, $offset = 0) {
-		$mimetypeLoader = \OC::$server->getMimeTypeLoader();
-		$mounts = $this->root->getMountsIn($this->path);
-		$mounts[] = $this->getMountPoint();
-
-		$mounts = array_filter($mounts, function (IMountPoint $mount) {
-			return $mount->getStorage();
-		});
-		$storageIds = array_map(function (IMountPoint $mount) {
-			return $mount->getStorage()->getCache()->getNumericStorageId();
-		}, $mounts);
-		/** @var IMountPoint[] $mountMap */
-		$mountMap = array_combine($storageIds, $mounts);
-		$folderMimetype = $mimetypeLoader->getId(FileInfo::MIMETYPE_FOLDER);
-
-		//todo look into options of filtering path based on storage id (only search in files/ for home storage, filter by share root for shared, etc)
-
-		$builder = \OC::$server->getDatabaseConnection()->getQueryBuilder();
-		$query = $builder
-			->select('f.*')
-			->from('filecache', 'f')
-			->andWhere($builder->expr()->in('f.storage', $builder->createNamedParameter($storageIds, IQueryBuilder::PARAM_INT_ARRAY)))
-			->andWhere($builder->expr()->orX(
-			// handle non empty folders separate
-				$builder->expr()->neq('f.mimetype', $builder->createNamedParameter($folderMimetype, IQueryBuilder::PARAM_INT)),
-				$builder->expr()->eq('f.size', new Literal(0))
-			))
-			->orderBy('f.mtime', 'DESC')
-			->setMaxResults($limit)
-			->setFirstResult($offset);
-
-		$result = $query->execute()->fetchAll();
-
-		$files = array_filter(array_map(function (array $entry) use ($mountMap, $mimetypeLoader) {
-			$mount = $mountMap[$entry['storage']];
-			$entry['internalPath'] = $entry['path'];
-			$entry['mimetype'] = $mimetypeLoader->getMimetypeById($entry['mimetype']);
-			$entry['mimepart'] = $mimetypeLoader->getMimetypeById($entry['mimepart']);
-			$path = $this->getAbsolutePath($mount, $entry['path']);
-			if (is_null($path)) {
-				return null;
-			}
-			$fileInfo = new \OC\Files\FileInfo($path, $mount->getStorage(), $entry['internalPath'], $entry, $mount);
-			return $this->root->createNode($fileInfo->getPath(), $fileInfo);
-		}, $result));
-
-		return array_values(array_filter($files, function (Node $node) {
-			$relative = $this->getRelativePath($node->getPath());
-			return $relative !== null && $relative !== '/';
-		}));
-	}
-
-	private function getAbsolutePath(IMountPoint $mount, $path) {
-		$storage = $mount->getStorage();
-		if ($storage->instanceOfStorage('\OC\Files\Storage\Wrapper\Jail')) {
-			/** @var \OC\Files\Storage\Wrapper\Jail $storage */
-			$jailRoot = $storage->getUnjailedPath('');
-			$rootLength = strlen($jailRoot) + 1;
-			if ($path === $jailRoot) {
-				return $mount->getMountPoint();
-			} else if (substr($path, 0, $rootLength) === $jailRoot . '/') {
-				return $mount->getMountPoint() . substr($path, $rootLength);
-			} else {
-				return null;
-			}
-		} else {
-			return $mount->getMountPoint() . $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 NonExistingFolder($this->root, $this->view, $path);
+    }
+
+    /**
+     * @param string $path path relative to the folder
+     * @return string
+     * @throws \OCP\Files\NotPermittedException
+     */
+    public function getFullPath($path) {
+        if (!$this->isValidPath($path)) {
+            throw new NotPermittedException('Invalid path');
+        }
+        return $this->path . $this->normalizePath($path);
+    }
+
+    /**
+     * @param string $path
+     * @return string
+     */
+    public function getRelativePath($path) {
+        if ($this->path === '' or $this->path === '/') {
+            return $this->normalizePath($path);
+        }
+        if ($path === $this->path) {
+            return '/';
+        } else if (strpos($path, $this->path . '/') !== 0) {
+            return null;
+        } else {
+            $path = substr($path, strlen($this->path));
+            return $this->normalizePath($path);
+        }
+    }
+
+    /**
+     * check if a node is a (grand-)child of the folder
+     *
+     * @param \OC\Files\Node\Node $node
+     * @return bool
+     */
+    public function isSubNode($node) {
+        return strpos($node->getPath(), $this->path . '/') === 0;
+    }
+
+    /**
+     * get the content of this directory
+     *
+     * @throws \OCP\Files\NotFoundException
+     * @return Node[]
+     */
+    public function getDirectoryListing() {
+        $folderContent = $this->view->getDirectoryContent($this->path);
+
+        return array_map(function (FileInfo $info) {
+            if ($info->getMimetype() === 'httpd/unix-directory') {
+                return new Folder($this->root, $this->view, $info->getPath(), $info);
+            } else {
+                return new File($this->root, $this->view, $info->getPath(), $info);
+            }
+        }, $folderContent);
+    }
+
+    /**
+     * @param string $path
+     * @param FileInfo $info
+     * @return File|Folder
+     */
+    protected function createNode($path, FileInfo $info = null) {
+        if (is_null($info)) {
+            $isDir = $this->view->is_dir($path);
+        } else {
+            $isDir = $info->getType() === FileInfo::TYPE_FOLDER;
+        }
+        if ($isDir) {
+            return new Folder($this->root, $this->view, $path, $info);
+        } else {
+            return new File($this->root, $this->view, $path, $info);
+        }
+    }
+
+    /**
+     * Get the node at $path
+     *
+     * @param string $path
+     * @return \OC\Files\Node\Node
+     * @throws \OCP\Files\NotFoundException
+     */
+    public function get($path) {
+        return $this->root->get($this->getFullPath($path));
+    }
+
+    /**
+     * @param string $path
+     * @return bool
+     */
+    public function nodeExists($path) {
+        try {
+            $this->get($path);
+            return true;
+        } catch (NotFoundException $e) {
+            return false;
+        }
+    }
+
+    /**
+     * @param string $path
+     * @return \OC\Files\Node\Folder
+     * @throws \OCP\Files\NotPermittedException
+     */
+    public function newFolder($path) {
+        if ($this->checkPermissions(\OCP\Constants::PERMISSION_CREATE)) {
+            $fullPath = $this->getFullPath($path);
+            $nonExisting = new NonExistingFolder($this->root, $this->view, $fullPath);
+            $this->root->emit('\OC\Files', 'preWrite', array($nonExisting));
+            $this->root->emit('\OC\Files', 'preCreate', array($nonExisting));
+            $this->view->mkdir($fullPath);
+            $node = new Folder($this->root, $this->view, $fullPath);
+            $this->root->emit('\OC\Files', 'postWrite', array($node));
+            $this->root->emit('\OC\Files', 'postCreate', array($node));
+            return $node;
+        } else {
+            throw new NotPermittedException('No create permission for folder');
+        }
+    }
+
+    /**
+     * @param string $path
+     * @return \OC\Files\Node\File
+     * @throws \OCP\Files\NotPermittedException
+     */
+    public function newFile($path) {
+        if ($this->checkPermissions(\OCP\Constants::PERMISSION_CREATE)) {
+            $fullPath = $this->getFullPath($path);
+            $nonExisting = new NonExistingFile($this->root, $this->view, $fullPath);
+            $this->root->emit('\OC\Files', 'preWrite', array($nonExisting));
+            $this->root->emit('\OC\Files', 'preCreate', array($nonExisting));
+            $this->view->touch($fullPath);
+            $node = new File($this->root, $this->view, $fullPath);
+            $this->root->emit('\OC\Files', 'postWrite', array($node));
+            $this->root->emit('\OC\Files', 'postCreate', array($node));
+            return $node;
+        } else {
+            throw new NotPermittedException('No create permission for path');
+        }
+    }
+
+    /**
+     * search for files with the name matching $query
+     *
+     * @param string|ISearchOperator $query
+     * @return \OC\Files\Node\Node[]
+     */
+    public function search($query) {
+        if (is_string($query)) {
+            return $this->searchCommon('search', array('%' . $query . '%'));
+        } else {
+            return $this->searchCommon('searchQuery', array($query));
+        }
+    }
+
+    /**
+     * search for files by mimetype
+     *
+     * @param string $mimetype
+     * @return Node[]
+     */
+    public function searchByMime($mimetype) {
+        return $this->searchCommon('searchByMime', array($mimetype));
+    }
+
+    /**
+     * search for files by tag
+     *
+     * @param string|int $tag name or tag id
+     * @param string $userId owner of the tags
+     * @return Node[]
+     */
+    public function searchByTag($tag, $userId) {
+        return $this->searchCommon('searchByTag', array($tag, $userId));
+    }
+
+    /**
+     * @param string $method cache method
+     * @param array $args call args
+     * @return \OC\Files\Node\Node[]
+     */
+    private function searchCommon($method, $args) {
+        $files = array();
+        $rootLength = strlen($this->path);
+        $mount = $this->root->getMount($this->path);
+        $storage = $mount->getStorage();
+        $internalPath = $mount->getInternalPath($this->path);
+        $internalPath = rtrim($internalPath, '/');
+        if ($internalPath !== '') {
+            $internalPath = $internalPath . '/';
+        }
+        $internalRootLength = strlen($internalPath);
+
+        $cache = $storage->getCache('');
+
+        $results = call_user_func_array(array($cache, $method), $args);
+        foreach ($results as $result) {
+            if ($internalRootLength === 0 or substr($result['path'], 0, $internalRootLength) === $internalPath) {
+                $result['internalPath'] = $result['path'];
+                $result['path'] = substr($result['path'], $internalRootLength);
+                $result['storage'] = $storage;
+                $files[] = new \OC\Files\FileInfo($this->path . '/' . $result['path'], $storage, $result['internalPath'], $result, $mount);
+            }
+        }
+
+        $mounts = $this->root->getMountsIn($this->path);
+        foreach ($mounts as $mount) {
+            $storage = $mount->getStorage();
+            if ($storage) {
+                $cache = $storage->getCache('');
+
+                $relativeMountPoint = substr($mount->getMountPoint(), $rootLength);
+                $results = call_user_func_array(array($cache, $method), $args);
+                foreach ($results as $result) {
+                    $result['internalPath'] = $result['path'];
+                    $result['path'] = $relativeMountPoint . $result['path'];
+                    $result['storage'] = $storage;
+                    $files[] = new \OC\Files\FileInfo($this->path . '/' . $result['path'], $storage, $result['internalPath'], $result, $mount);
+                }
+            }
+        }
+
+        return array_map(function (FileInfo $file) {
+            return $this->createNode($file->getPath(), $file);
+        }, $files);
+    }
+
+    /**
+     * @param int $id
+     * @return \OC\Files\Node\Node[]
+     */
+    public function getById($id) {
+        $mountCache = $this->root->getUserMountCache();
+        if (strpos($this->getPath(), '/', 1) > 0) {
+            list(, $user) = explode('/', $this->getPath());
+        } else {
+            $user = null;
+        }
+        $mountsContainingFile = $mountCache->getMountsForFileId((int)$id, $user);
+        $mounts = $this->root->getMountsIn($this->path);
+        $mounts[] = $this->root->getMount($this->path);
+        /** @var IMountPoint[] $folderMounts */
+        $folderMounts = array_combine(array_map(function (IMountPoint $mountPoint) {
+            return $mountPoint->getMountPoint();
+        }, $mounts), $mounts);
+
+        /** @var ICachedMountInfo[] $mountsContainingFile */
+        $mountsContainingFile = array_values(array_filter($mountsContainingFile, function (ICachedMountInfo $cachedMountInfo) use ($folderMounts) {
+            return isset($folderMounts[$cachedMountInfo->getMountPoint()]);
+        }));
+
+        if (count($mountsContainingFile) === 0) {
+            return [];
+        }
+
+        $nodes = array_map(function (ICachedMountInfo $cachedMountInfo) use ($folderMounts, $id) {
+            $mount = $folderMounts[$cachedMountInfo->getMountPoint()];
+            $cacheEntry = $mount->getStorage()->getCache()->get((int)$id);
+            if (!$cacheEntry) {
+                return null;
+            }
+
+            // cache jails will hide the "true" internal path
+            $internalPath = ltrim($cachedMountInfo->getRootInternalPath() . '/' . $cacheEntry->getPath(), '/');
+            $pathRelativeToMount = substr($internalPath, strlen($cachedMountInfo->getRootInternalPath()));
+            $pathRelativeToMount = ltrim($pathRelativeToMount, '/');
+            $absolutePath = $cachedMountInfo->getMountPoint() . $pathRelativeToMount;
+            return $this->root->createNode($absolutePath, new \OC\Files\FileInfo(
+                $absolutePath, $mount->getStorage(), $cacheEntry->getPath(), $cacheEntry, $mount,
+                \OC::$server->getUserManager()->get($mount->getStorage()->getOwner($pathRelativeToMount))
+            ));
+        }, $mountsContainingFile);
+
+        $nodes = array_filter($nodes);
+
+        return array_filter($nodes, function (Node $node) {
+            return $this->getRelativePath($node->getPath());
+        });
+    }
+
+    public function getFreeSpace() {
+        return $this->view->free_space($this->path);
+    }
+
+    public function delete() {
+        if ($this->checkPermissions(\OCP\Constants::PERMISSION_DELETE)) {
+            $this->sendHooks(array('preDelete'));
+            $fileInfo = $this->getFileInfo();
+            $this->view->rmdir($this->path);
+            $nonExisting = new NonExistingFolder($this->root, $this->view, $this->path, $fileInfo);
+            $this->root->emit('\OC\Files', 'postDelete', array($nonExisting));
+            $this->exists = false;
+        } else {
+            throw new NotPermittedException('No delete permission for path');
+        }
+    }
+
+    /**
+     * Add a suffix to the name in case the file exists
+     *
+     * @param string $name
+     * @return string
+     * @throws NotPermittedException
+     */
+    public function getNonExistingName($name) {
+        $uniqueName = \OC_Helper::buildNotExistingFileNameForView($this->getPath(), $name, $this->view);
+        return trim($this->getRelativePath($uniqueName), '/');
+    }
+
+    /**
+     * @param int $limit
+     * @param int $offset
+     * @return \OCP\Files\Node[]
+     */
+    public function getRecent($limit, $offset = 0) {
+        $mimetypeLoader = \OC::$server->getMimeTypeLoader();
+        $mounts = $this->root->getMountsIn($this->path);
+        $mounts[] = $this->getMountPoint();
+
+        $mounts = array_filter($mounts, function (IMountPoint $mount) {
+            return $mount->getStorage();
+        });
+        $storageIds = array_map(function (IMountPoint $mount) {
+            return $mount->getStorage()->getCache()->getNumericStorageId();
+        }, $mounts);
+        /** @var IMountPoint[] $mountMap */
+        $mountMap = array_combine($storageIds, $mounts);
+        $folderMimetype = $mimetypeLoader->getId(FileInfo::MIMETYPE_FOLDER);
+
+        //todo look into options of filtering path based on storage id (only search in files/ for home storage, filter by share root for shared, etc)
+
+        $builder = \OC::$server->getDatabaseConnection()->getQueryBuilder();
+        $query = $builder
+            ->select('f.*')
+            ->from('filecache', 'f')
+            ->andWhere($builder->expr()->in('f.storage', $builder->createNamedParameter($storageIds, IQueryBuilder::PARAM_INT_ARRAY)))
+            ->andWhere($builder->expr()->orX(
+            // handle non empty folders separate
+                $builder->expr()->neq('f.mimetype', $builder->createNamedParameter($folderMimetype, IQueryBuilder::PARAM_INT)),
+                $builder->expr()->eq('f.size', new Literal(0))
+            ))
+            ->orderBy('f.mtime', 'DESC')
+            ->setMaxResults($limit)
+            ->setFirstResult($offset);
+
+        $result = $query->execute()->fetchAll();
+
+        $files = array_filter(array_map(function (array $entry) use ($mountMap, $mimetypeLoader) {
+            $mount = $mountMap[$entry['storage']];
+            $entry['internalPath'] = $entry['path'];
+            $entry['mimetype'] = $mimetypeLoader->getMimetypeById($entry['mimetype']);
+            $entry['mimepart'] = $mimetypeLoader->getMimetypeById($entry['mimepart']);
+            $path = $this->getAbsolutePath($mount, $entry['path']);
+            if (is_null($path)) {
+                return null;
+            }
+            $fileInfo = new \OC\Files\FileInfo($path, $mount->getStorage(), $entry['internalPath'], $entry, $mount);
+            return $this->root->createNode($fileInfo->getPath(), $fileInfo);
+        }, $result));
+
+        return array_values(array_filter($files, function (Node $node) {
+            $relative = $this->getRelativePath($node->getPath());
+            return $relative !== null && $relative !== '/';
+        }));
+    }
+
+    private function getAbsolutePath(IMountPoint $mount, $path) {
+        $storage = $mount->getStorage();
+        if ($storage->instanceOfStorage('\OC\Files\Storage\Wrapper\Jail')) {
+            /** @var \OC\Files\Storage\Wrapper\Jail $storage */
+            $jailRoot = $storage->getUnjailedPath('');
+            $rootLength = strlen($jailRoot) + 1;
+            if ($path === $jailRoot) {
+                return $mount->getMountPoint();
+            } else if (substr($path, 0, $rootLength) === $jailRoot . '/') {
+                return $mount->getMountPoint() . substr($path, $rootLength);
+            } else {
+                return null;
+            }
+        } else {
+            return $mount->getMountPoint() . $path;
+        }
+    }
 }

Spacing +25 added lines, -25 removed lines

@@ -55,7 +55,7 @@ 
 		if (!$this->isValidPath($path)) {
 			throw new NotPermittedException('Invalid path');
 		}
-		return $this->path . $this->normalizePath($path);
+		return $this->path.$this->normalizePath($path);
 	}
 
 	/**
@@ -68,7 +68,7 @@ 
 		}
 		if ($path === $this->path) {
 			return '/';
-		} else if (strpos($path, $this->path . '/') !== 0) {
+		} else if (strpos($path, $this->path.'/') !== 0) {
 			return null;
 		} else {
 			$path = substr($path, strlen($this->path));
@@ -83,7 +83,7 @@ 
 	 * @return bool
 	 */
 	public function isSubNode($node) {
-		return strpos($node->getPath(), $this->path . '/') === 0;
+		return strpos($node->getPath(), $this->path.'/') === 0;
 	}
 
 	/**
@@ -95,7 +95,7 @@ 
 	public function getDirectoryListing() {
 		$folderContent = $this->view->getDirectoryContent($this->path);
 
-		return array_map(function (FileInfo $info) {
+		return array_map(function(FileInfo $info) {
 			if ($info->getMimetype() === 'httpd/unix-directory') {
 				return new Folder($this->root, $this->view, $info->getPath(), $info);
 			} else {
@@ -196,7 +196,7 @@ 
 	 */
 	public function search($query) {
 		if (is_string($query)) {
-			return $this->searchCommon('search', array('%' . $query . '%'));
+			return $this->searchCommon('search', array('%'.$query.'%'));
 		} else {
 			return $this->searchCommon('searchQuery', array($query));
 		}
@@ -236,7 +236,7 @@ 
 		$internalPath = $mount->getInternalPath($this->path);
 		$internalPath = rtrim($internalPath, '/');
 		if ($internalPath !== '') {
-			$internalPath = $internalPath . '/';
+			$internalPath = $internalPath.'/';
 		}
 		$internalRootLength = strlen($internalPath);
 
@@ -248,7 +248,7 @@ 
 				$result['internalPath'] = $result['path'];
 				$result['path'] = substr($result['path'], $internalRootLength);
 				$result['storage'] = $storage;
-				$files[] = new \OC\Files\FileInfo($this->path . '/' . $result['path'], $storage, $result['internalPath'], $result, $mount);
+				$files[] = new \OC\Files\FileInfo($this->path.'/'.$result['path'], $storage, $result['internalPath'], $result, $mount);
 			}
 		}
 
@@ -262,14 +262,14 @@ 
 				$results = call_user_func_array(array($cache, $method), $args);
 				foreach ($results as $result) {
 					$result['internalPath'] = $result['path'];
-					$result['path'] = $relativeMountPoint . $result['path'];
+					$result['path'] = $relativeMountPoint.$result['path'];
 					$result['storage'] = $storage;
-					$files[] = new \OC\Files\FileInfo($this->path . '/' . $result['path'], $storage, $result['internalPath'], $result, $mount);
+					$files[] = new \OC\Files\FileInfo($this->path.'/'.$result['path'], $storage, $result['internalPath'], $result, $mount);
 				}
 			}
 		}
 
-		return array_map(function (FileInfo $file) {
+		return array_map(function(FileInfo $file) {
 			return $this->createNode($file->getPath(), $file);
 		}, $files);
 	}
@@ -285,16 +285,16 @@ 
 		} else {
 			$user = null;
 		}
-		$mountsContainingFile = $mountCache->getMountsForFileId((int)$id, $user);
+		$mountsContainingFile = $mountCache->getMountsForFileId((int) $id, $user);
 		$mounts = $this->root->getMountsIn($this->path);
 		$mounts[] = $this->root->getMount($this->path);
 		/** @var IMountPoint[] $folderMounts */
-		$folderMounts = array_combine(array_map(function (IMountPoint $mountPoint) {
+		$folderMounts = array_combine(array_map(function(IMountPoint $mountPoint) {
 			return $mountPoint->getMountPoint();
 		}, $mounts), $mounts);
 
 		/** @var ICachedMountInfo[] $mountsContainingFile */
-		$mountsContainingFile = array_values(array_filter($mountsContainingFile, function (ICachedMountInfo $cachedMountInfo) use ($folderMounts) {
+		$mountsContainingFile = array_values(array_filter($mountsContainingFile, function(ICachedMountInfo $cachedMountInfo) use ($folderMounts) {
 			return isset($folderMounts[$cachedMountInfo->getMountPoint()]);
 		}));
 
@@ -302,18 +302,18 @@ 
 			return [];
 		}
 
-		$nodes = array_map(function (ICachedMountInfo $cachedMountInfo) use ($folderMounts, $id) {
+		$nodes = array_map(function(ICachedMountInfo $cachedMountInfo) use ($folderMounts, $id) {
 			$mount = $folderMounts[$cachedMountInfo->getMountPoint()];
-			$cacheEntry = $mount->getStorage()->getCache()->get((int)$id);
+			$cacheEntry = $mount->getStorage()->getCache()->get((int) $id);
 			if (!$cacheEntry) {
 				return null;
 			}
 
 			// cache jails will hide the "true" internal path
-			$internalPath = ltrim($cachedMountInfo->getRootInternalPath() . '/' . $cacheEntry->getPath(), '/');
+			$internalPath = ltrim($cachedMountInfo->getRootInternalPath().'/'.$cacheEntry->getPath(), '/');
 			$pathRelativeToMount = substr($internalPath, strlen($cachedMountInfo->getRootInternalPath()));
 			$pathRelativeToMount = ltrim($pathRelativeToMount, '/');
-			$absolutePath = $cachedMountInfo->getMountPoint() . $pathRelativeToMount;
+			$absolutePath = $cachedMountInfo->getMountPoint().$pathRelativeToMount;
 			return $this->root->createNode($absolutePath, new \OC\Files\FileInfo(
 				$absolutePath, $mount->getStorage(), $cacheEntry->getPath(), $cacheEntry, $mount,
 				\OC::$server->getUserManager()->get($mount->getStorage()->getOwner($pathRelativeToMount))
@@ -322,7 +322,7 @@ 
 
 		$nodes = array_filter($nodes);
 
-		return array_filter($nodes, function (Node $node) {
+		return array_filter($nodes, function(Node $node) {
 			return $this->getRelativePath($node->getPath());
 		});
 	}
@@ -366,10 +366,10 @@ 
 		$mounts = $this->root->getMountsIn($this->path);
 		$mounts[] = $this->getMountPoint();
 
-		$mounts = array_filter($mounts, function (IMountPoint $mount) {
+		$mounts = array_filter($mounts, function(IMountPoint $mount) {
 			return $mount->getStorage();
 		});
-		$storageIds = array_map(function (IMountPoint $mount) {
+		$storageIds = array_map(function(IMountPoint $mount) {
 			return $mount->getStorage()->getCache()->getNumericStorageId();
 		}, $mounts);
 		/** @var IMountPoint[] $mountMap */
@@ -394,7 +394,7 @@ 
 
 		$result = $query->execute()->fetchAll();
 
-		$files = array_filter(array_map(function (array $entry) use ($mountMap, $mimetypeLoader) {
+		$files = array_filter(array_map(function(array $entry) use ($mountMap, $mimetypeLoader) {
 			$mount = $mountMap[$entry['storage']];
 			$entry['internalPath'] = $entry['path'];
 			$entry['mimetype'] = $mimetypeLoader->getMimetypeById($entry['mimetype']);
@@ -407,7 +407,7 @@ 
 			return $this->root->createNode($fileInfo->getPath(), $fileInfo);
 		}, $result));
 
-		return array_values(array_filter($files, function (Node $node) {
+		return array_values(array_filter($files, function(Node $node) {
 			$relative = $this->getRelativePath($node->getPath());
 			return $relative !== null && $relative !== '/';
 		}));
@@ -421,13 +421,13 @@ 
 			$rootLength = strlen($jailRoot) + 1;
 			if ($path === $jailRoot) {
 				return $mount->getMountPoint();
-			} else if (substr($path, 0, $rootLength) === $jailRoot . '/') {
-				return $mount->getMountPoint() . substr($path, $rootLength);
+			} else if (substr($path, 0, $rootLength) === $jailRoot.'/') {
+				return $mount->getMountPoint().substr($path, $rootLength);
 			} else {
 				return null;
 			}
 		} else {
-			return $mount->getMountPoint() . $path;
+			return $mount->getMountPoint().$path;
 		}
 	}
 }

lib/public/Settings/IIconSection.php

Doc Comments +1 added lines

@@ -33,6 +33,7 @@
 	 *
 	 * @returns string
 	 * @since 12
+	 * @return string
 	 */
 	public function getIcon();
 }

Indentation +8 added lines, -8 removed lines

@@ -27,12 +27,12 @@
  * @since 12
  */
 interface IIconSection extends ISection {
-	/**
-	 * returns the relative path to an 16*16 icon describing the section.
-	 * e.g. '/core/img/places/files.svg'
-	 *
-	 * @returns string
-	 * @since 12
-	 */
-	public function getIcon();
+    /**
+     * returns the relative path to an 16*16 icon describing the section.
+     * e.g. '/core/img/places/files.svg'
+     *
+     * @returns string
+     * @since 12
+     */
+    public function getIcon();
 }

apps/files_external/lib/Lib/Storage/FTP.php

Doc Comments +3 added lines

@@ -139,6 +139,9 @@
 		return false;
 	}
 
+	/**
+	 * @param string $path
+	 */
 	public function writeBack($tmpFile, $path) {
 		$this->uploadFile($tmpFile, $path);
 		unlink($tmpFile);

Braces +1 added lines, -2 removed lines

@@ -93,8 +93,7 @@
 	public function unlink($path) {
 		if ($this->is_dir($path)) {
 			return $this->rmdir($path);
-		}
-		else {
+		} else {
 			$url = $this->constructUrl($path);
 			$result = unlink($url);
 			clearstatcache(true, $url);

Indentation +109 added lines, -109 removed lines

@@ -37,122 +37,122 @@
 use Icewind\Streams\RetryWrapper;
 
 class FTP extends StreamWrapper{
-	private $password;
-	private $user;
-	private $host;
-	private $secure;
-	private $root;
+    private $password;
+    private $user;
+    private $host;
+    private $secure;
+    private $root;
 
-	private static $tempFiles=array();
+    private static $tempFiles=array();
 
-	public function __construct($params) {
-		if (isset($params['host']) && isset($params['user']) && isset($params['password'])) {
-			$this->host=$params['host'];
-			$this->user=$params['user'];
-			$this->password=$params['password'];
-			if (isset($params['secure'])) {
-				$this->secure = $params['secure'];
-			} else {
-				$this->secure = false;
-			}
-			$this->root=isset($params['root'])?$params['root']:'/';
-			if ( ! $this->root || $this->root[0]!=='/') {
-				$this->root='/'.$this->root;
-			}
-			if (substr($this->root, -1) !== '/') {
-				$this->root .= '/';
-			}
-		} else {
-			throw new \Exception('Creating FTP storage failed');
-		}
+    public function __construct($params) {
+        if (isset($params['host']) && isset($params['user']) && isset($params['password'])) {
+            $this->host=$params['host'];
+            $this->user=$params['user'];
+            $this->password=$params['password'];
+            if (isset($params['secure'])) {
+                $this->secure = $params['secure'];
+            } else {
+                $this->secure = false;
+            }
+            $this->root=isset($params['root'])?$params['root']:'/';
+            if ( ! $this->root || $this->root[0]!=='/') {
+                $this->root='/'.$this->root;
+            }
+            if (substr($this->root, -1) !== '/') {
+                $this->root .= '/';
+            }
+        } else {
+            throw new \Exception('Creating FTP storage failed');
+        }
 		
-	}
+    }
 
-	public function getId(){
-		return 'ftp::' . $this->user . '@' . $this->host . '/' . $this->root;
-	}
+    public function getId(){
+        return 'ftp::' . $this->user . '@' . $this->host . '/' . $this->root;
+    }
 
-	/**
-	 * construct the ftp url
-	 * @param string $path
-	 * @return string
-	 */
-	public function constructUrl($path) {
-		$url='ftp';
-		if ($this->secure) {
-			$url.='s';
-		}
-		$url.='://'.urlencode($this->user).':'.urlencode($this->password).'@'.$this->host.$this->root.$path;
-		return $url;
-	}
+    /**
+     * construct the ftp url
+     * @param string $path
+     * @return string
+     */
+    public function constructUrl($path) {
+        $url='ftp';
+        if ($this->secure) {
+            $url.='s';
+        }
+        $url.='://'.urlencode($this->user).':'.urlencode($this->password).'@'.$this->host.$this->root.$path;
+        return $url;
+    }
 
-	/**
-	 * Unlinks file or directory
-	 * @param string $path
-	 */
-	public function unlink($path) {
-		if ($this->is_dir($path)) {
-			return $this->rmdir($path);
-		}
-		else {
-			$url = $this->constructUrl($path);
-			$result = unlink($url);
-			clearstatcache(true, $url);
-			return $result;
-		}
-	}
-	public function fopen($path,$mode) {
-		switch($mode) {
-			case 'r':
-			case 'rb':
-			case 'w':
-			case 'wb':
-			case 'a':
-			case 'ab':
-				//these are supported by the wrapper
-				$context = stream_context_create(array('ftp' => array('overwrite' => true)));
-				$handle = fopen($this->constructUrl($path), $mode, false, $context);
-				return RetryWrapper::wrap($handle);
-			case 'r+':
-			case 'w+':
-			case 'wb+':
-			case 'a+':
-			case 'x':
-			case 'x+':
-			case 'c':
-			case 'c+':
-				//emulate these
-				if (strrpos($path, '.')!==false) {
-					$ext=substr($path, strrpos($path, '.'));
-				} else {
-					$ext='';
-				}
-				$tmpFile=\OCP\Files::tmpFile($ext);
-				if ($this->file_exists($path)) {
-					$this->getFile($path, $tmpFile);
-				}
-				$handle = fopen($tmpFile, $mode);
-				return CallbackWrapper::wrap($handle, null, null, function () use ($path, $tmpFile) {
-					$this->writeBack($tmpFile, $path);
-				});
-		}
-		return false;
-	}
+    /**
+     * Unlinks file or directory
+     * @param string $path
+     */
+    public function unlink($path) {
+        if ($this->is_dir($path)) {
+            return $this->rmdir($path);
+        }
+        else {
+            $url = $this->constructUrl($path);
+            $result = unlink($url);
+            clearstatcache(true, $url);
+            return $result;
+        }
+    }
+    public function fopen($path,$mode) {
+        switch($mode) {
+            case 'r':
+            case 'rb':
+            case 'w':
+            case 'wb':
+            case 'a':
+            case 'ab':
+                //these are supported by the wrapper
+                $context = stream_context_create(array('ftp' => array('overwrite' => true)));
+                $handle = fopen($this->constructUrl($path), $mode, false, $context);
+                return RetryWrapper::wrap($handle);
+            case 'r+':
+            case 'w+':
+            case 'wb+':
+            case 'a+':
+            case 'x':
+            case 'x+':
+            case 'c':
+            case 'c+':
+                //emulate these
+                if (strrpos($path, '.')!==false) {
+                    $ext=substr($path, strrpos($path, '.'));
+                } else {
+                    $ext='';
+                }
+                $tmpFile=\OCP\Files::tmpFile($ext);
+                if ($this->file_exists($path)) {
+                    $this->getFile($path, $tmpFile);
+                }
+                $handle = fopen($tmpFile, $mode);
+                return CallbackWrapper::wrap($handle, null, null, function () use ($path, $tmpFile) {
+                    $this->writeBack($tmpFile, $path);
+                });
+        }
+        return false;
+    }
 
-	public function writeBack($tmpFile, $path) {
-		$this->uploadFile($tmpFile, $path);
-		unlink($tmpFile);
-	}
+    public function writeBack($tmpFile, $path) {
+        $this->uploadFile($tmpFile, $path);
+        unlink($tmpFile);
+    }
 
-	/**
-	 * check if php-ftp is installed
-	 */
-	public static function checkDependencies() {
-		if (function_exists('ftp_login')) {
-			return(true);
-		} else {
-			return array('ftp');
-		}
-	}
+    /**
+     * check if php-ftp is installed
+     */
+    public static function checkDependencies() {
+        if (function_exists('ftp_login')) {
+            return(true);
+        } else {
+            return array('ftp');
+        }
+    }
 
 }

Spacing +20 added lines, -20 removed lines

@@ -36,28 +36,28 @@ 
 use Icewind\Streams\CallbackWrapper;
 use Icewind\Streams\RetryWrapper;
 
-class FTP extends StreamWrapper{
+class FTP extends StreamWrapper {
 	private $password;
 	private $user;
 	private $host;
 	private $secure;
 	private $root;
 
-	private static $tempFiles=array();
+	private static $tempFiles = array();
 
 	public function __construct($params) {
 		if (isset($params['host']) && isset($params['user']) && isset($params['password'])) {
-			$this->host=$params['host'];
-			$this->user=$params['user'];
-			$this->password=$params['password'];
+			$this->host = $params['host'];
+			$this->user = $params['user'];
+			$this->password = $params['password'];
 			if (isset($params['secure'])) {
 				$this->secure = $params['secure'];
 			} else {
 				$this->secure = false;
 			}
-			$this->root=isset($params['root'])?$params['root']:'/';
-			if ( ! $this->root || $this->root[0]!=='/') {
-				$this->root='/'.$this->root;
+			$this->root = isset($params['root']) ? $params['root'] : '/';
+			if (!$this->root || $this->root[0] !== '/') {
+				$this->root = '/'.$this->root;
 			}
 			if (substr($this->root, -1) !== '/') {
 				$this->root .= '/';
@@ -68,8 +68,8 @@ 
 		
 	}
 
-	public function getId(){
-		return 'ftp::' . $this->user . '@' . $this->host . '/' . $this->root;
+	public function getId() {
+		return 'ftp::'.$this->user.'@'.$this->host.'/'.$this->root;
 	}
 
 	/**
@@ -78,11 +78,11 @@ 
 	 * @return string
 	 */
 	public function constructUrl($path) {
-		$url='ftp';
+		$url = 'ftp';
 		if ($this->secure) {
-			$url.='s';
+			$url .= 's';
 		}
-		$url.='://'.urlencode($this->user).':'.urlencode($this->password).'@'.$this->host.$this->root.$path;
+		$url .= '://'.urlencode($this->user).':'.urlencode($this->password).'@'.$this->host.$this->root.$path;
 		return $url;
 	}
 
@@ -101,8 +101,8 @@ 
 			return $result;
 		}
 	}
-	public function fopen($path,$mode) {
-		switch($mode) {
+	public function fopen($path, $mode) {
+		switch ($mode) {
 			case 'r':
 			case 'rb':
 			case 'w':
@@ -122,17 +122,17 @@ 
 			case 'c':
 			case 'c+':
 				//emulate these
-				if (strrpos($path, '.')!==false) {
-					$ext=substr($path, strrpos($path, '.'));
+				if (strrpos($path, '.') !== false) {
+					$ext = substr($path, strrpos($path, '.'));
 				} else {
-					$ext='';
+					$ext = '';
 				}
-				$tmpFile=\OCP\Files::tmpFile($ext);
+				$tmpFile = \OCP\Files::tmpFile($ext);
 				if ($this->file_exists($path)) {
 					$this->getFile($path, $tmpFile);
 				}
 				$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);
 				});
 		}