View GitHub Repository server

Schedule Inspection
Subscribe
Completed
Pull Request — master (#9293)
by Blizzz
31:50 queued 12:06
created
Status
Category
Toggle Patches
lib/private/App/AppStore/Fetcher/AppFetcher.php 1 patch
Indentation   +106 added lines, -106 removed lines patch added patch discarded remove patch 
@@ -37,119 +37,119 @@
 
 block discarded – undo
37 37
38 38 
 class AppFetcher extends Fetcher {
39 39
40 
-	/** @var CompareVersion */
41 
-	private $compareVersion;
40 
+    /** @var CompareVersion */
41 
+    private $compareVersion;
42 42
43 
-	/**
44 
-	 * @param Factory $appDataFactory
45 
-	 * @param IClientService $clientService
46 
-	 * @param ITimeFactory $timeFactory
47 
-	 * @param IConfig $config
48 
-	 * @param CompareVersion $compareVersion
49 
-	 * @param ILogger $logger
50 
-	 */
51 
-	public function __construct(Factory $appDataFactory,
52 
-								IClientService $clientService,
53 
-								ITimeFactory $timeFactory,
54 
-								IConfig $config,
55 
-								CompareVersion $compareVersion,
56 
-								ILogger $logger) {
57 
-		parent::__construct(
58 
-			$appDataFactory,
59 
-			$clientService,
60 
-			$timeFactory,
61 
-			$config,
62 
-			$logger
63 
-		);
43 
+    /**
44 
+     * @param Factory $appDataFactory
45 
+     * @param IClientService $clientService
46 
+     * @param ITimeFactory $timeFactory
47 
+     * @param IConfig $config
48 
+     * @param CompareVersion $compareVersion
49 
+     * @param ILogger $logger
50 
+     */
51 
+    public function __construct(Factory $appDataFactory,
52 
+                                IClientService $clientService,
53 
+                                ITimeFactory $timeFactory,
54 
+                                IConfig $config,
55 
+                                CompareVersion $compareVersion,
56 
+                                ILogger $logger) {
57 
+        parent::__construct(
58 
+            $appDataFactory,
59 
+            $clientService,
60 
+            $timeFactory,
61 
+            $config,
62 
+            $logger
63 
+        );
64 64
65 
-		$this->fileName = 'apps.json';
66 
-		$this->setEndpoint();
67 
-		$this->compareVersion = $compareVersion;
68 
-	}
65 
+        $this->fileName = 'apps.json';
66 
+        $this->setEndpoint();
67 
+        $this->compareVersion = $compareVersion;
68 
+    }
69 69
70 
-	/**
71 
-	 * Only returns the latest compatible app release in the releases array
72 
-	 *
73 
-	 * @param string $ETag
74 
-	 * @param string $content
75 
-	 *
76 
-	 * @return array
77 
-	 */
78 
-	protected function fetch($ETag, $content) {
79 
-		/** @var mixed[] $response */
80 
-		$response = parent::fetch($ETag, $content);
70 
+    /**
71 
+     * Only returns the latest compatible app release in the releases array
72 
+     *
73 
+     * @param string $ETag
74 
+     * @param string $content
75 
+     *
76 
+     * @return array
77 
+     */
78 
+    protected function fetch($ETag, $content) {
79 
+        /** @var mixed[] $response */
80 
+        $response = parent::fetch($ETag, $content);
81 81
82 
-		foreach($response['data'] as $dataKey => $app) {
83 
-			$releases = [];
82 
+        foreach($response['data'] as $dataKey => $app) {
83 
+            $releases = [];
84 84
85 
-			// Filter all compatible releases
86 
-			foreach($app['releases'] as $release) {
87 
-				// Exclude all nightly and pre-releases
88 
-				if($release['isNightly'] === false
89 
-					&& strpos($release['version'], '-') === false) {
90 
-					// Exclude all versions not compatible with the current version
91 
-					try {
92 
-						$versionParser = new VersionParser();
93 
-						$version = $versionParser->getVersion($release['rawPlatformVersionSpec']);
94 
-						$ncVersion = $this->getVersion();
95 
-						$min = $version->getMinimumVersion();
96 
-						$max = $version->getMaximumVersion();
97 
-						$minFulfilled = $this->compareVersion->isCompatible($ncVersion, $min, '>=');
98 
-						$maxFulfilled = $max !== '' &&
99 
-							$this->compareVersion->isCompatible($ncVersion, $max, '<=');
100 
-						if ($minFulfilled && $maxFulfilled) {
101 
-							$releases[] = $release;
102 
-						}
103 
-					} catch (\InvalidArgumentException $e) {
104 
-						$this->logger->logException($e, ['app' => 'appstoreFetcher', 'level' => ILogger::WARN]);
105 
-					}
106 
-				}
107 
-			}
85 
+            // Filter all compatible releases
86 
+            foreach($app['releases'] as $release) {
87 
+                // Exclude all nightly and pre-releases
88 
+                if($release['isNightly'] === false
89 
+                    && strpos($release['version'], '-') === false) {
90 
+                    // Exclude all versions not compatible with the current version
91 
+                    try {
92 
+                        $versionParser = new VersionParser();
93 
+                        $version = $versionParser->getVersion($release['rawPlatformVersionSpec']);
94 
+                        $ncVersion = $this->getVersion();
95 
+                        $min = $version->getMinimumVersion();
96 
+                        $max = $version->getMaximumVersion();
97 
+                        $minFulfilled = $this->compareVersion->isCompatible($ncVersion, $min, '>=');
98 
+                        $maxFulfilled = $max !== '' &&
99 
+                            $this->compareVersion->isCompatible($ncVersion, $max, '<=');
100 
+                        if ($minFulfilled && $maxFulfilled) {
101 
+                            $releases[] = $release;
102 
+                        }
103 
+                    } catch (\InvalidArgumentException $e) {
104 
+                        $this->logger->logException($e, ['app' => 'appstoreFetcher', 'level' => ILogger::WARN]);
105 
+                    }
106 
+                }
107 
+            }
108 108
109 
-			// Get the highest version
110 
-			$versions = [];
111 
-			foreach($releases as $release) {
112 
-				$versions[] = $release['version'];
113 
-			}
114 
-			usort($versions, 'version_compare');
115 
-			$versions = array_reverse($versions);
116 
-			$compatible = false;
117 
-			if(isset($versions[0])) {
118 
-				$highestVersion = $versions[0];
119 
-				foreach ($releases as $release) {
120 
-					if ((string)$release['version'] === (string)$highestVersion) {
121 
-						$compatible = true;
122 
-						$response['data'][$dataKey]['releases'] = [$release];
123 
-						break;
124 
-					}
125 
-				}
126 
-			}
127 
-			if(!$compatible) {
128 
-				unset($response['data'][$dataKey]);
129 
-			}
130 
-		}
109 
+            // Get the highest version
110 
+            $versions = [];
111 
+            foreach($releases as $release) {
112 
+                $versions[] = $release['version'];
113 
+            }
114 
+            usort($versions, 'version_compare');
115 
+            $versions = array_reverse($versions);
116 
+            $compatible = false;
117 
+            if(isset($versions[0])) {
118 
+                $highestVersion = $versions[0];
119 
+                foreach ($releases as $release) {
120 
+                    if ((string)$release['version'] === (string)$highestVersion) {
121 
+                        $compatible = true;
122 
+                        $response['data'][$dataKey]['releases'] = [$release];
123 
+                        break;
124 
+                    }
125 
+                }
126 
+            }
127 
+            if(!$compatible) {
128 
+                unset($response['data'][$dataKey]);
129 
+            }
130 
+        }
131 131
132 
-		$response['data'] = array_values($response['data']);
133 
-		return $response;
134 
-	}
132 
+        $response['data'] = array_values($response['data']);
133 
+        return $response;
134 
+    }
135 135
136 
-	private function setEndpoint() {
137 
-		$versionArray = explode('.', $this->getVersion());
138 
-		$this->endpointUrl = sprintf(
139 
-			'https://apps.nextcloud.com/api/v1/platform/%d.%d.%d/apps.json',
140 
-			$versionArray[0],
141 
-			$versionArray[1],
142 
-			$versionArray[2]
143 
-		);
144 
-	}
136 
+    private function setEndpoint() {
137 
+        $versionArray = explode('.', $this->getVersion());
138 
+        $this->endpointUrl = sprintf(
139 
+            'https://apps.nextcloud.com/api/v1/platform/%d.%d.%d/apps.json',
140 
+            $versionArray[0],
141 
+            $versionArray[1],
142 
+            $versionArray[2]
143 
+        );
144 
+    }
145 145
146 
-	/**
147 
-	 * @param string $version
148 
-	 * @param string $fileName
149 
-	 */
150 
-	public function setVersion(string $version, string $fileName = 'apps.json') {
151 
-		parent::setVersion($version);
152 
-		$this->fileName = $fileName;
153 
-		$this->setEndpoint();
154 
-	}
146 
+    /**
147 
+     * @param string $version
148 
+     * @param string $fileName
149 
+     */
150 
+    public function setVersion(string $version, string $fileName = 'apps.json') {
151 
+        parent::setVersion($version);
152 
+        $this->fileName = $fileName;
153 
+        $this->setEndpoint();
154 
+    }
155 155 
 }
Please login to merge, or discard this patch.
lib/private/CapabilitiesManager.php 1 patch
Indentation   +47 added lines, -47 removed lines patch added patch discarded remove patch 
@@ -32,58 +32,58 @@
 
 block discarded – undo
32 32
33 33 
 class CapabilitiesManager {
34 34
35 
-	/** @var \Closure[] */
36 
-	private $capabilities = array();
35 
+    /** @var \Closure[] */
36 
+    private $capabilities = array();
37 37
38 
-	/** @var ILogger */
39 
-	private $logger;
38 
+    /** @var ILogger */
39 
+    private $logger;
40 40
41 
-	public function __construct(ILogger $logger) {
42 
-		$this->logger = $logger;
43 
-	}
41 
+    public function __construct(ILogger $logger) {
42 
+        $this->logger = $logger;
43 
+    }
44 44
45 
-	/**
46 
-	 * Get an array of al the capabilities that are registered at this manager
45 
+    /**
46 
+     * Get an array of al the capabilities that are registered at this manager
47 47 
      *
48 
-	 * @param bool $public get public capabilities only
49 
-	 * @throws \InvalidArgumentException
50 
-	 * @return array
51 
-	 */
52 
-	public function getCapabilities(bool $public = false) : array {
53 
-		$capabilities = [];
54 
-		foreach($this->capabilities as $capability) {
55 
-			try {
56 
-				$c = $capability();
57 
-			} catch (QueryException $e) {
58 
-				$this->logger->logException($e, [
59 
-					'message' => 'CapabilitiesManager',
60 
-					'level' => ILogger::ERROR,
61 
-					'app' => 'core',
62 
-				]);
63 
-				continue;
64 
-			}
48 
+     * @param bool $public get public capabilities only
49 
+     * @throws \InvalidArgumentException
50 
+     * @return array
51 
+     */
52 
+    public function getCapabilities(bool $public = false) : array {
53 
+        $capabilities = [];
54 
+        foreach($this->capabilities as $capability) {
55 
+            try {
56 
+                $c = $capability();
57 
+            } catch (QueryException $e) {
58 
+                $this->logger->logException($e, [
59 
+                    'message' => 'CapabilitiesManager',
60 
+                    'level' => ILogger::ERROR,
61 
+                    'app' => 'core',
62 
+                ]);
63 
+                continue;
64 
+            }
65 65
66 
-			if ($c instanceof ICapability) {
67 
-				if(!$public || $c instanceof IPublicCapability) {
68 
-					$capabilities = array_replace_recursive($capabilities, $c->getCapabilities());
69 
-				}
70 
-			} else {
71 
-				throw new \InvalidArgumentException('The given Capability (' . get_class($c) . ') does not implement the ICapability interface');
72 
-			}
73 
-		}
66 
+            if ($c instanceof ICapability) {
67 
+                if(!$public || $c instanceof IPublicCapability) {
68 
+                    $capabilities = array_replace_recursive($capabilities, $c->getCapabilities());
69 
+                }
70 
+            } else {
71 
+                throw new \InvalidArgumentException('The given Capability (' . get_class($c) . ') does not implement the ICapability interface');
72 
+            }
73 
+        }
74 74
75 
-		return $capabilities;
76 
-	}
75 
+        return $capabilities;
76 
+    }
77 77
78 
-	/**
79 
-	 * In order to improve lazy loading a closure can be registered which will be called in case
80 
-	 * capabilities are actually requested
81 
-	 *
82 
-	 * $callable has to return an instance of OCP\Capabilities\ICapability
83 
-	 *
84 
-	 * @param \Closure $callable
85 
-	 */
86 
-	public function registerCapability(\Closure $callable) {
87 
-		$this->capabilities[] = $callable;
88 
-	}
78 
+    /**
79 
+     * In order to improve lazy loading a closure can be registered which will be called in case
80 
+     * capabilities are actually requested
81 
+     *
82 
+     * $callable has to return an instance of OCP\Capabilities\ICapability
83 
+     *
84 
+     * @param \Closure $callable
85 
+     */
86 
+    public function registerCapability(\Closure $callable) {
87 
+        $this->capabilities[] = $callable;
88 
+    }
89 89 
 }
Please login to merge, or discard this patch.
lib/private/Files/ObjectStore/S3ConnectionTrait.php 2 patches
Indentation   +112 added lines, -112 removed lines patch added patch discarded remove patch 
@@ -30,116 +30,116 @@
 
 block discarded – undo
30 30 
 use OCP\ILogger;
31 31
32 32 
 trait S3ConnectionTrait {
33 
-	/** @var array */
34 
-	protected $params;
35 
-
36 
-	/** @var S3Client */
37 
-	protected $connection;
38 
-
39 
-	/** @var string */
40 
-	protected $id;
41 
-
42 
-	/** @var string */
43 
-	protected $bucket;
44 
-
45 
-	/** @var int */
46 
-	protected $timeout;
47 
-
48 
-	protected $test;
49 
-
50 
-	protected function parseParams($params) {
51 
-		if (empty($params['key']) || empty($params['secret']) || empty($params['bucket'])) {
52 
-			throw new \Exception("Access Key, Secret and Bucket have to be configured.");
53 
-		}
54 
-
55 
-		$this->id = 'amazon::' . $params['bucket'];
56 
-
57 
-		$this->test = isset($params['test']);
58 
-		$this->bucket = $params['bucket'];
59 
-		$this->timeout = !isset($params['timeout']) ? 15 : $params['timeout'];
60 
-		$params['region'] = empty($params['region']) ? 'eu-west-1' : $params['region'];
61 
-		$params['hostname'] = empty($params['hostname']) ? 's3.' . $params['region'] . '.amazonaws.com' : $params['hostname'];
62 
-		if (!isset($params['port']) || $params['port'] === '') {
63 
-			$params['port'] = (isset($params['use_ssl']) && $params['use_ssl'] === false) ? 80 : 443;
64 
-		}
65 
-		$this->params = $params;
66 
-	}
67 
-
68 
-
69 
-	/**
70 
-	 * Returns the connection
71 
-	 *
72 
-	 * @return S3Client connected client
73 
-	 * @throws \Exception if connection could not be made
74 
-	 */
75 
-	protected function getConnection() {
76 
-		if (!is_null($this->connection)) {
77 
-			return $this->connection;
78 
-		}
79 
-
80 
-		$scheme = (isset($this->params['use_ssl']) && $this->params['use_ssl'] === false) ? 'http' : 'https';
81 
-		$base_url = $scheme . '://' . $this->params['hostname'] . ':' . $this->params['port'] . '/';
82 
-
83 
-		$options = [
84 
-			'version' => isset($this->params['version']) ? $this->params['version'] : 'latest',
85 
-			'credentials' => [
86 
-				'key' => $this->params['key'],
87 
-				'secret' => $this->params['secret'],
88 
-			],
89 
-			'endpoint' => $base_url,
90 
-			'region' => $this->params['region'],
91 
-			'use_path_style_endpoint' => isset($this->params['use_path_style']) ? $this->params['use_path_style'] : false,
92 
-			'signature_provider' => \Aws\or_chain([self::class, 'legacySignatureProvider'], ClientResolver::_default_signature_provider())
93 
-		];
94 
-		if (isset($this->params['proxy'])) {
95 
-			$options['request.options'] = ['proxy' => $this->params['proxy']];
96 
-		}
97 
-		if (isset($this->params['legacy_auth']) && $this->params['legacy_auth']) {
98 
-			$options['signature_version'] = 'v2';
99 
-		}
100 
-		$this->connection = new S3Client($options);
101 
-
102 
-		if (!$this->connection->isBucketDnsCompatible($this->bucket)) {
103 
-			throw new \Exception("The configured bucket name is invalid: " . $this->bucket);
104 
-		}
105 
-
106 
-		if (!$this->connection->doesBucketExist($this->bucket)) {
107 
-			$logger = \OC::$server->getLogger();
108 
-			try {
109 
-				$logger->info('Bucket "' . $this->bucket . '" does not exist - creating it.', ['app' => 'objectstore']);
110 
-				$this->connection->createBucket(array(
111 
-					'Bucket' => $this->bucket
112 
-				));
113 
-				$this->testTimeout();
114 
-			} catch (S3Exception $e) {
115 
-				$logger->logException($e, [
116 
-					'message' => 'Invalid remote storage.',
117 
-					'level' => ILogger::DEBUG,
118 
-					'app' => 'objectstore',
119 
-				]);
120 
-				throw new \Exception('Creation of bucket "' . $this->bucket . '" failed. ' . $e->getMessage());
121 
-			}
122 
-		}
123 
-
124 
-		return $this->connection;
125 
-	}
126 
-
127 
-	/**
128 
-	 * when running the tests wait to let the buckets catch up
129 
-	 */
130 
-	private function testTimeout() {
131 
-		if ($this->test) {
132 
-			sleep($this->timeout);
133 
-		}
134 
-	}
135 
-
136 
-	public static function legacySignatureProvider($version, $service, $region) {
137 
-		switch ($version) {
138 
-			case 'v2':
139 
-			case 's3':
140 
-				return new S3Signature();
141 
-			default:
142 
-				return null;
143 
-		}
144 
-	}
33 
+    /** @var array */
34 
+    protected $params;
35 
+
36 
+    /** @var S3Client */
37 
+    protected $connection;
38 
+
39 
+    /** @var string */
40 
+    protected $id;
41 
+
42 
+    /** @var string */
43 
+    protected $bucket;
44 
+
45 
+    /** @var int */
46 
+    protected $timeout;
47 
+
48 
+    protected $test;
49 
+
50 
+    protected function parseParams($params) {
51 
+        if (empty($params['key']) || empty($params['secret']) || empty($params['bucket'])) {
52 
+            throw new \Exception("Access Key, Secret and Bucket have to be configured.");
53 
+        }
54 
+
55 
+        $this->id = 'amazon::' . $params['bucket'];
56 
+
57 
+        $this->test = isset($params['test']);
58 
+        $this->bucket = $params['bucket'];
59 
+        $this->timeout = !isset($params['timeout']) ? 15 : $params['timeout'];
60 
+        $params['region'] = empty($params['region']) ? 'eu-west-1' : $params['region'];
61 
+        $params['hostname'] = empty($params['hostname']) ? 's3.' . $params['region'] . '.amazonaws.com' : $params['hostname'];
62 
+        if (!isset($params['port']) || $params['port'] === '') {
63 
+            $params['port'] = (isset($params['use_ssl']) && $params['use_ssl'] === false) ? 80 : 443;
64 
+        }
65 
+        $this->params = $params;
66 
+    }
67 
+
68 
+
69 
+    /**
70 
+     * Returns the connection
71 
+     *
72 
+     * @return S3Client connected client
73 
+     * @throws \Exception if connection could not be made
74 
+     */
75 
+    protected function getConnection() {
76 
+        if (!is_null($this->connection)) {
77 
+            return $this->connection;
78 
+        }
79 
+
80 
+        $scheme = (isset($this->params['use_ssl']) && $this->params['use_ssl'] === false) ? 'http' : 'https';
81 
+        $base_url = $scheme . '://' . $this->params['hostname'] . ':' . $this->params['port'] . '/';
82 
+
83 
+        $options = [
84 
+            'version' => isset($this->params['version']) ? $this->params['version'] : 'latest',
85 
+            'credentials' => [
86 
+                'key' => $this->params['key'],
87 
+                'secret' => $this->params['secret'],
88 
+            ],
89 
+            'endpoint' => $base_url,
90 
+            'region' => $this->params['region'],
91 
+            'use_path_style_endpoint' => isset($this->params['use_path_style']) ? $this->params['use_path_style'] : false,
92 
+            'signature_provider' => \Aws\or_chain([self::class, 'legacySignatureProvider'], ClientResolver::_default_signature_provider())
93 
+        ];
94 
+        if (isset($this->params['proxy'])) {
95 
+            $options['request.options'] = ['proxy' => $this->params['proxy']];
96 
+        }
97 
+        if (isset($this->params['legacy_auth']) && $this->params['legacy_auth']) {
98 
+            $options['signature_version'] = 'v2';
99 
+        }
100 
+        $this->connection = new S3Client($options);
101 
+
102 
+        if (!$this->connection->isBucketDnsCompatible($this->bucket)) {
103 
+            throw new \Exception("The configured bucket name is invalid: " . $this->bucket);
104 
+        }
105 
+
106 
+        if (!$this->connection->doesBucketExist($this->bucket)) {
107 
+            $logger = \OC::$server->getLogger();
108 
+            try {
109 
+                $logger->info('Bucket "' . $this->bucket . '" does not exist - creating it.', ['app' => 'objectstore']);
110 
+                $this->connection->createBucket(array(
111 
+                    'Bucket' => $this->bucket
112 
+                ));
113 
+                $this->testTimeout();
114 
+            } catch (S3Exception $e) {
115 
+                $logger->logException($e, [
116 
+                    'message' => 'Invalid remote storage.',
117 
+                    'level' => ILogger::DEBUG,
118 
+                    'app' => 'objectstore',
119 
+                ]);
120 
+                throw new \Exception('Creation of bucket "' . $this->bucket . '" failed. ' . $e->getMessage());
121 
+            }
122 
+        }
123 
+
124 
+        return $this->connection;
125 
+    }
126 
+
127 
+    /**
128 
+     * when running the tests wait to let the buckets catch up
129 
+     */
130 
+    private function testTimeout() {
131 
+        if ($this->test) {
132 
+            sleep($this->timeout);
133 
+        }
134 
+    }
135 
+
136 
+    public static function legacySignatureProvider($version, $service, $region) {
137 
+        switch ($version) {
138 
+            case 'v2':
139 
+            case 's3':
140 
+                return new S3Signature();
141 
+            default:
142 
+                return null;
143 
+        }
144 
+    }
145 145 
 }
Please login to merge, or discard this patch.
Spacing   +6 added lines, -6 removed lines patch added patch discarded remove patch 
@@ -52,13 +52,13 @@  discard block
 
 block discarded – undo
52 52 
 			throw new \Exception("Access Key, Secret and Bucket have to be configured.");
53 53 
 		}
54 54
55 
-		$this->id = 'amazon::' . $params['bucket'];
55 
+		$this->id = 'amazon::'.$params['bucket'];
56 56
57 57 
 		$this->test = isset($params['test']);
58 58 
 		$this->bucket = $params['bucket'];
59 59 
 		$this->timeout = !isset($params['timeout']) ? 15 : $params['timeout'];
60 60 
 		$params['region'] = empty($params['region']) ? 'eu-west-1' : $params['region'];
61 
-		$params['hostname'] = empty($params['hostname']) ? 's3.' . $params['region'] . '.amazonaws.com' : $params['hostname'];
61 
+		$params['hostname'] = empty($params['hostname']) ? 's3.'.$params['region'].'.amazonaws.com' : $params['hostname'];
62 62 
 		if (!isset($params['port']) || $params['port'] === '') {
63 63 
 			$params['port'] = (isset($params['use_ssl']) && $params['use_ssl'] === false) ? 80 : 443;
64 64 
 		}
 
@@ -78,7 +78,7 @@  discard block
 
 block discarded – undo
78 78 
 		}
79 79
80 80 
 		$scheme = (isset($this->params['use_ssl']) && $this->params['use_ssl'] === false) ? 'http' : 'https';
81 
-		$base_url = $scheme . '://' . $this->params['hostname'] . ':' . $this->params['port'] . '/';
81 
+		$base_url = $scheme.'://'.$this->params['hostname'].':'.$this->params['port'].'/';
82 82
83 83 
 		$options = [
84 84 
 			'version' => isset($this->params['version']) ? $this->params['version'] : 'latest',
 
@@ -100,13 +100,13 @@  discard block
 
 block discarded – undo
100 100 
 		$this->connection = new S3Client($options);
101 101
102 102 
 		if (!$this->connection->isBucketDnsCompatible($this->bucket)) {
103 
-			throw new \Exception("The configured bucket name is invalid: " . $this->bucket);
103 
+			throw new \Exception("The configured bucket name is invalid: ".$this->bucket);
104 104 
 		}
105 105
106 106 
 		if (!$this->connection->doesBucketExist($this->bucket)) {
107 107 
 			$logger = \OC::$server->getLogger();
108 108 
 			try {
109 
-				$logger->info('Bucket "' . $this->bucket . '" does not exist - creating it.', ['app' => 'objectstore']);
109 
+				$logger->info('Bucket "'.$this->bucket.'" does not exist - creating it.', ['app' => 'objectstore']);
110 110 
 				$this->connection->createBucket(array(
111 111 
 					'Bucket' => $this->bucket
112 112 
 				));
 
@@ -117,7 +117,7 @@  discard block
 
 block discarded – undo
117 117 
 					'level' => ILogger::DEBUG,
118 118 
 					'app' => 'objectstore',
119 119 
 				]);
120 
-				throw new \Exception('Creation of bucket "' . $this->bucket . '" failed. ' . $e->getMessage());
120 
+				throw new \Exception('Creation of bucket "'.$this->bucket.'" failed. '.$e->getMessage());
121 121 
 			}
122 122 
 		}
123 123
Please login to merge, or discard this patch.
lib/private/Files/Filesystem.php 2 patches
Indentation   +853 added lines, -853 removed lines patch added patch discarded remove patch 
@@ -70,857 +70,857 @@
 
 block discarded – undo
70 70
71 71 
 class Filesystem {
72 72
73 
-	/**
74 
-	 * @var Mount\Manager $mounts
75 
-	 */
76 
-	private static $mounts;
77 
-
78 
-	public static $loaded = false;
79 
-	/**
80 
-	 * @var \OC\Files\View $defaultInstance
81 
-	 */
82 
-	static private $defaultInstance;
83 
-
84 
-	static private $usersSetup = array();
85 
-
86 
-	static private $normalizedPathCache = null;
87 
-
88 
-	static private $listeningForProviders = false;
89 
-
90 
-	/**
91 
-	 * classname which used for hooks handling
92 
-	 * used as signalclass in OC_Hooks::emit()
93 
-	 */
94 
-	const CLASSNAME = 'OC_Filesystem';
95 
-
96 
-	/**
97 
-	 * signalname emitted before file renaming
98 
-	 *
99 
-	 * @param string $oldpath
100 
-	 * @param string $newpath
101 
-	 */
102 
-	const signal_rename = 'rename';
103 
-
104 
-	/**
105 
-	 * signal emitted after file renaming
106 
-	 *
107 
-	 * @param string $oldpath
108 
-	 * @param string $newpath
109 
-	 */
110 
-	const signal_post_rename = 'post_rename';
111 
-
112 
-	/**
113 
-	 * signal emitted before file/dir creation
114 
-	 *
115 
-	 * @param string $path
116 
-	 * @param bool $run changing this flag to false in hook handler will cancel event
117 
-	 */
118 
-	const signal_create = 'create';
119 
-
120 
-	/**
121 
-	 * signal emitted after file/dir creation
122 
-	 *
123 
-	 * @param string $path
124 
-	 * @param bool $run changing this flag to false in hook handler will cancel event
125 
-	 */
126 
-	const signal_post_create = 'post_create';
127 
-
128 
-	/**
129 
-	 * signal emits before file/dir copy
130 
-	 *
131 
-	 * @param string $oldpath
132 
-	 * @param string $newpath
133 
-	 * @param bool $run changing this flag to false in hook handler will cancel event
134 
-	 */
135 
-	const signal_copy = 'copy';
136 
-
137 
-	/**
138 
-	 * signal emits after file/dir copy
139 
-	 *
140 
-	 * @param string $oldpath
141 
-	 * @param string $newpath
142 
-	 */
143 
-	const signal_post_copy = 'post_copy';
144 
-
145 
-	/**
146 
-	 * signal emits before file/dir save
147 
-	 *
148 
-	 * @param string $path
149 
-	 * @param bool $run changing this flag to false in hook handler will cancel event
150 
-	 */
151 
-	const signal_write = 'write';
152 
-
153 
-	/**
154 
-	 * signal emits after file/dir save
155 
-	 *
156 
-	 * @param string $path
157 
-	 */
158 
-	const signal_post_write = 'post_write';
159 
-
160 
-	/**
161 
-	 * signal emitted before file/dir update
162 
-	 *
163 
-	 * @param string $path
164 
-	 * @param bool $run changing this flag to false in hook handler will cancel event
165 
-	 */
166 
-	const signal_update = 'update';
167 
-
168 
-	/**
169 
-	 * signal emitted after file/dir update
170 
-	 *
171 
-	 * @param string $path
172 
-	 * @param bool $run changing this flag to false in hook handler will cancel event
173 
-	 */
174 
-	const signal_post_update = 'post_update';
175 
-
176 
-	/**
177 
-	 * signal emits when reading file/dir
178 
-	 *
179 
-	 * @param string $path
180 
-	 */
181 
-	const signal_read = 'read';
182 
-
183 
-	/**
184 
-	 * signal emits when removing file/dir
185 
-	 *
186 
-	 * @param string $path
187 
-	 */
188 
-	const signal_delete = 'delete';
189 
-
190 
-	/**
191 
-	 * parameters definitions for signals
192 
-	 */
193 
-	const signal_param_path = 'path';
194 
-	const signal_param_oldpath = 'oldpath';
195 
-	const signal_param_newpath = 'newpath';
196 
-
197 
-	/**
198 
-	 * run - changing this flag to false in hook handler will cancel event
199 
-	 */
200 
-	const signal_param_run = 'run';
201 
-
202 
-	const signal_create_mount = 'create_mount';
203 
-	const signal_delete_mount = 'delete_mount';
204 
-	const signal_param_mount_type = 'mounttype';
205 
-	const signal_param_users = 'users';
206 
-
207 
-	/**
208 
-	 * @var \OC\Files\Storage\StorageFactory $loader
209 
-	 */
210 
-	private static $loader;
211 
-
212 
-	/** @var bool */
213 
-	private static $logWarningWhenAddingStorageWrapper = true;
214 
-
215 
-	/**
216 
-	 * @param bool $shouldLog
217 
-	 * @return bool previous value
218 
-	 * @internal
219 
-	 */
220 
-	public static function logWarningWhenAddingStorageWrapper($shouldLog) {
221 
-		$previousValue = self::$logWarningWhenAddingStorageWrapper;
222 
-		self::$logWarningWhenAddingStorageWrapper = (bool) $shouldLog;
223 
-		return $previousValue;
224 
-	}
225 
-
226 
-	/**
227 
-	 * @param string $wrapperName
228 
-	 * @param callable $wrapper
229 
-	 * @param int $priority
230 
-	 */
231 
-	public static function addStorageWrapper($wrapperName, $wrapper, $priority = 50) {
232 
-		if (self::$logWarningWhenAddingStorageWrapper) {
233 
-			\OC::$server->getLogger()->warning("Storage wrapper '{wrapper}' was not registered via the 'OC_Filesystem - preSetup' hook which could cause potential problems.", [
234 
-				'wrapper' => $wrapperName,
235 
-				'app' => 'filesystem',
236 
-			]);
237 
-		}
238 
-
239 
-		$mounts = self::getMountManager()->getAll();
240 
-		if (!self::getLoader()->addStorageWrapper($wrapperName, $wrapper, $priority, $mounts)) {
241 
-			// do not re-wrap if storage with this name already existed
242 
-			return;
243 
-		}
244 
-	}
245 
-
246 
-	/**
247 
-	 * Returns the storage factory
248 
-	 *
249 
-	 * @return \OCP\Files\Storage\IStorageFactory
250 
-	 */
251 
-	public static function getLoader() {
252 
-		if (!self::$loader) {
253 
-			self::$loader = new StorageFactory();
254 
-		}
255 
-		return self::$loader;
256 
-	}
257 
-
258 
-	/**
259 
-	 * Returns the mount manager
260 
-	 *
261 
-	 * @return \OC\Files\Mount\Manager
262 
-	 */
263 
-	public static function getMountManager($user = '') {
264 
-		if (!self::$mounts) {
265 
-			\OC_Util::setupFS($user);
266 
-		}
267 
-		return self::$mounts;
268 
-	}
269 
-
270 
-	/**
271 
-	 * get the mountpoint of the storage object for a path
272 
-	 * ( note: because a storage is not always mounted inside the fakeroot, the
273 
-	 * returned mountpoint is relative to the absolute root of the filesystem
274 
-	 * and doesn't take the chroot into account )
275 
-	 *
276 
-	 * @param string $path
277 
-	 * @return string
278 
-	 */
279 
-	static public function getMountPoint($path) {
280 
-		if (!self::$mounts) {
281 
-			\OC_Util::setupFS();
282 
-		}
283 
-		$mount = self::$mounts->find($path);
284 
-		if ($mount) {
285 
-			return $mount->getMountPoint();
286 
-		} else {
287 
-			return '';
288 
-		}
289 
-	}
290 
-
291 
-	/**
292 
-	 * get a list of all mount points in a directory
293 
-	 *
294 
-	 * @param string $path
295 
-	 * @return string[]
296 
-	 */
297 
-	static public function getMountPoints($path) {
298 
-		if (!self::$mounts) {
299 
-			\OC_Util::setupFS();
300 
-		}
301 
-		$result = array();
302 
-		$mounts = self::$mounts->findIn($path);
303 
-		foreach ($mounts as $mount) {
304 
-			$result[] = $mount->getMountPoint();
305 
-		}
306 
-		return $result;
307 
-	}
308 
-
309 
-	/**
310 
-	 * get the storage mounted at $mountPoint
311 
-	 *
312 
-	 * @param string $mountPoint
313 
-	 * @return \OC\Files\Storage\Storage
314 
-	 */
315 
-	public static function getStorage($mountPoint) {
316 
-		if (!self::$mounts) {
317 
-			\OC_Util::setupFS();
318 
-		}
319 
-		$mount = self::$mounts->find($mountPoint);
320 
-		return $mount->getStorage();
321 
-	}
322 
-
323 
-	/**
324 
-	 * @param string $id
325 
-	 * @return Mount\MountPoint[]
326 
-	 */
327 
-	public static function getMountByStorageId($id) {
328 
-		if (!self::$mounts) {
329 
-			\OC_Util::setupFS();
330 
-		}
331 
-		return self::$mounts->findByStorageId($id);
332 
-	}
333 
-
334 
-	/**
335 
-	 * @param int $id
336 
-	 * @return Mount\MountPoint[]
337 
-	 */
338 
-	public static function getMountByNumericId($id) {
339 
-		if (!self::$mounts) {
340 
-			\OC_Util::setupFS();
341 
-		}
342 
-		return self::$mounts->findByNumericId($id);
343 
-	}
344 
-
345 
-	/**
346 
-	 * resolve a path to a storage and internal path
347 
-	 *
348 
-	 * @param string $path
349 
-	 * @return array an array consisting of the storage and the internal path
350 
-	 */
351 
-	static public function resolvePath($path) {
352 
-		if (!self::$mounts) {
353 
-			\OC_Util::setupFS();
354 
-		}
355 
-		$mount = self::$mounts->find($path);
356 
-		if ($mount) {
357 
-			return array($mount->getStorage(), rtrim($mount->getInternalPath($path), '/'));
358 
-		} else {
359 
-			return array(null, null);
360 
-		}
361 
-	}
362 
-
363 
-	static public function init($user, $root) {
364 
-		if (self::$defaultInstance) {
365 
-			return false;
366 
-		}
367 
-		self::getLoader();
368 
-		self::$defaultInstance = new View($root);
369 
-
370 
-		if (!self::$mounts) {
371 
-			self::$mounts = \OC::$server->getMountManager();
372 
-		}
373 
-
374 
-		//load custom mount config
375 
-		self::initMountPoints($user);
376 
-
377 
-		self::$loaded = true;
378 
-
379 
-		return true;
380 
-	}
381 
-
382 
-	static public function initMountManager() {
383 
-		if (!self::$mounts) {
384 
-			self::$mounts = \OC::$server->getMountManager();
385 
-		}
386 
-	}
387 
-
388 
-	/**
389 
-	 * Initialize system and personal mount points for a user
390 
-	 *
391 
-	 * @param string $user
392 
-	 * @throws \OC\User\NoUserException if the user is not available
393 
-	 */
394 
-	public static function initMountPoints($user = '') {
395 
-		if ($user == '') {
396 
-			$user = \OC_User::getUser();
397 
-		}
398 
-		if ($user === null || $user === false || $user === '') {
399 
-			throw new \OC\User\NoUserException('Attempted to initialize mount points for null user and no user in session');
400 
-		}
401 
-
402 
-		if (isset(self::$usersSetup[$user])) {
403 
-			return;
404 
-		}
405 
-
406 
-		self::$usersSetup[$user] = true;
407 
-
408 
-		$userManager = \OC::$server->getUserManager();
409 
-		$userObject = $userManager->get($user);
410 
-
411 
-		if (is_null($userObject)) {
412 
-			\OCP\Util::writeLog('files', ' Backends provided no user object for ' . $user, ILogger::ERROR);
413 
-			// reset flag, this will make it possible to rethrow the exception if called again
414 
-			unset(self::$usersSetup[$user]);
415 
-			throw new \OC\User\NoUserException('Backends provided no user object for ' . $user);
416 
-		}
417 
-
418 
-		$realUid = $userObject->getUID();
419 
-		// workaround in case of different casings
420 
-		if ($user !== $realUid) {
421 
-			$stack = json_encode(debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 50));
422 
-			\OCP\Util::writeLog('files', 'initMountPoints() called with wrong user casing. This could be a bug. Expected: "' . $realUid . '" got "' . $user . '". Stack: ' . $stack, ILogger::WARN);
423 
-			$user = $realUid;
424 
-
425 
-			// again with the correct casing
426 
-			if (isset(self::$usersSetup[$user])) {
427 
-				return;
428 
-			}
429 
-
430 
-			self::$usersSetup[$user] = true;
431 
-		}
432 
-
433 
-		if (\OC::$server->getLockdownManager()->canAccessFilesystem()) {
434 
-			/** @var \OC\Files\Config\MountProviderCollection $mountConfigManager */
435 
-			$mountConfigManager = \OC::$server->getMountProviderCollection();
436 
-
437 
-			// home mounts are handled seperate since we need to ensure this is mounted before we call the other mount providers
438 
-			$homeMount = $mountConfigManager->getHomeMountForUser($userObject);
439 
-
440 
-			self::getMountManager()->addMount($homeMount);
441 
-
442 
-			\OC\Files\Filesystem::getStorage($user);
443 
-
444 
-			// Chance to mount for other storages
445 
-			if ($userObject) {
446 
-				$mounts = $mountConfigManager->addMountForUser($userObject, self::getMountManager());
447 
-				$mounts[] = $homeMount;
448 
-				$mountConfigManager->registerMounts($userObject, $mounts);
449 
-			}
450 
-
451 
-			self::listenForNewMountProviders($mountConfigManager, $userManager);
452 
-		} else {
453 
-			self::getMountManager()->addMount(new MountPoint(
454 
-				new NullStorage([]),
455 
-				'/' . $user
456 
-			));
457 
-			self::getMountManager()->addMount(new MountPoint(
458 
-				new NullStorage([]),
459 
-				'/' . $user . '/files'
460 
-			));
461 
-		}
462 
-		\OC_Hook::emit('OC_Filesystem', 'post_initMountPoints', array('user' => $user));
463 
-	}
464 
-
465 
-	/**
466 
-	 * Get mounts from mount providers that are registered after setup
467 
-	 *
468 
-	 * @param MountProviderCollection $mountConfigManager
469 
-	 * @param IUserManager $userManager
470 
-	 */
471 
-	private static function listenForNewMountProviders(MountProviderCollection $mountConfigManager, IUserManager $userManager) {
472 
-		if (!self::$listeningForProviders) {
473 
-			self::$listeningForProviders = true;
474 
-			$mountConfigManager->listen('\OC\Files\Config', 'registerMountProvider', function (IMountProvider $provider) use ($userManager) {
475 
-				foreach (Filesystem::$usersSetup as $user => $setup) {
476 
-					$userObject = $userManager->get($user);
477 
-					if ($userObject) {
478 
-						$mounts = $provider->getMountsForUser($userObject, Filesystem::getLoader());
479 
-						array_walk($mounts, array(self::$mounts, 'addMount'));
480 
-					}
481 
-				}
482 
-			});
483 
-		}
484 
-	}
485 
-
486 
-	/**
487 
-	 * get the default filesystem view
488 
-	 *
489 
-	 * @return View
490 
-	 */
491 
-	static public function getView() {
492 
-		return self::$defaultInstance;
493 
-	}
494 
-
495 
-	/**
496 
-	 * tear down the filesystem, removing all storage providers
497 
-	 */
498 
-	static public function tearDown() {
499 
-		self::clearMounts();
500 
-		self::$defaultInstance = null;
501 
-	}
502 
-
503 
-	/**
504 
-	 * get the relative path of the root data directory for the current user
505 
-	 *
506 
-	 * @return string
507 
-	 *
508 
-	 * Returns path like /admin/files
509 
-	 */
510 
-	static public function getRoot() {
511 
-		if (!self::$defaultInstance) {
512 
-			return null;
513 
-		}
514 
-		return self::$defaultInstance->getRoot();
515 
-	}
516 
-
517 
-	/**
518 
-	 * clear all mounts and storage backends
519 
-	 */
520 
-	public static function clearMounts() {
521 
-		if (self::$mounts) {
522 
-			self::$usersSetup = array();
523 
-			self::$mounts->clear();
524 
-		}
525 
-	}
526 
-
527 
-	/**
528 
-	 * mount an \OC\Files\Storage\Storage in our virtual filesystem
529 
-	 *
530 
-	 * @param \OC\Files\Storage\Storage|string $class
531 
-	 * @param array $arguments
532 
-	 * @param string $mountpoint
533 
-	 */
534 
-	static public function mount($class, $arguments, $mountpoint) {
535 
-		if (!self::$mounts) {
536 
-			\OC_Util::setupFS();
537 
-		}
538 
-		$mount = new Mount\MountPoint($class, $mountpoint, $arguments, self::getLoader());
539 
-		self::$mounts->addMount($mount);
540 
-	}
541 
-
542 
-	/**
543 
-	 * return the path to a local version of the file
544 
-	 * we need this because we can't know if a file is stored local or not from
545 
-	 * outside the filestorage and for some purposes a local file is needed
546 
-	 *
547 
-	 * @param string $path
548 
-	 * @return string
549 
-	 */
550 
-	static public function getLocalFile($path) {
551 
-		return self::$defaultInstance->getLocalFile($path);
552 
-	}
553 
-
554 
-	/**
555 
-	 * @param string $path
556 
-	 * @return string
557 
-	 */
558 
-	static public function getLocalFolder($path) {
559 
-		return self::$defaultInstance->getLocalFolder($path);
560 
-	}
561 
-
562 
-	/**
563 
-	 * return path to file which reflects one visible in browser
564 
-	 *
565 
-	 * @param string $path
566 
-	 * @return string
567 
-	 */
568 
-	static public function getLocalPath($path) {
569 
-		$datadir = \OC_User::getHome(\OC_User::getUser()) . '/files';
570 
-		$newpath = $path;
571 
-		if (strncmp($newpath, $datadir, strlen($datadir)) == 0) {
572 
-			$newpath = substr($path, strlen($datadir));
573 
-		}
574 
-		return $newpath;
575 
-	}
576 
-
577 
-	/**
578 
-	 * check if the requested path is valid
579 
-	 *
580 
-	 * @param string $path
581 
-	 * @return bool
582 
-	 */
583 
-	static public function isValidPath($path) {
584 
-		$path = self::normalizePath($path);
585 
-		if (!$path || $path[0] !== '/') {
586 
-			$path = '/' . $path;
587 
-		}
588 
-		if (strpos($path, '/../') !== false || strrchr($path, '/') === '/..') {
589 
-			return false;
590 
-		}
591 
-		return true;
592 
-	}
593 
-
594 
-	/**
595 
-	 * checks if a file is blacklisted for storage in the filesystem
596 
-	 * Listens to write and rename hooks
597 
-	 *
598 
-	 * @param array $data from hook
599 
-	 */
600 
-	static public function isBlacklisted($data) {
601 
-		if (isset($data['path'])) {
602 
-			$path = $data['path'];
603 
-		} else if (isset($data['newpath'])) {
604 
-			$path = $data['newpath'];
605 
-		}
606 
-		if (isset($path)) {
607 
-			if (self::isFileBlacklisted($path)) {
608 
-				$data['run'] = false;
609 
-			}
610 
-		}
611 
-	}
612 
-
613 
-	/**
614 
-	 * @param string $filename
615 
-	 * @return bool
616 
-	 */
617 
-	static public function isFileBlacklisted($filename) {
618 
-		$filename = self::normalizePath($filename);
619 
-
620 
-		$blacklist = \OC::$server->getConfig()->getSystemValue('blacklisted_files', array('.htaccess'));
621 
-		$filename = strtolower(basename($filename));
622 
-		return in_array($filename, $blacklist);
623 
-	}
624 
-
625 
-	/**
626 
-	 * check if the directory should be ignored when scanning
627 
-	 * NOTE: the special directories . and .. would cause never ending recursion
628 
-	 *
629 
-	 * @param String $dir
630 
-	 * @return boolean
631 
-	 */
632 
-	static public function isIgnoredDir($dir) {
633 
-		if ($dir === '.' || $dir === '..') {
634 
-			return true;
635 
-		}
636 
-		return false;
637 
-	}
638 
-
639 
-	/**
640 
-	 * following functions are equivalent to their php builtin equivalents for arguments/return values.
641 
-	 */
642 
-	static public function mkdir($path) {
643 
-		return self::$defaultInstance->mkdir($path);
644 
-	}
645 
-
646 
-	static public function rmdir($path) {
647 
-		return self::$defaultInstance->rmdir($path);
648 
-	}
649 
-
650 
-	static public function is_dir($path) {
651 
-		return self::$defaultInstance->is_dir($path);
652 
-	}
653 
-
654 
-	static public function is_file($path) {
655 
-		return self::$defaultInstance->is_file($path);
656 
-	}
657 
-
658 
-	static public function stat($path) {
659 
-		return self::$defaultInstance->stat($path);
660 
-	}
661 
-
662 
-	static public function filetype($path) {
663 
-		return self::$defaultInstance->filetype($path);
664 
-	}
665 
-
666 
-	static public function filesize($path) {
667 
-		return self::$defaultInstance->filesize($path);
668 
-	}
669 
-
670 
-	static public function readfile($path) {
671 
-		return self::$defaultInstance->readfile($path);
672 
-	}
673 
-
674 
-	static public function isCreatable($path) {
675 
-		return self::$defaultInstance->isCreatable($path);
676 
-	}
677 
-
678 
-	static public function isReadable($path) {
679 
-		return self::$defaultInstance->isReadable($path);
680 
-	}
681 
-
682 
-	static public function isUpdatable($path) {
683 
-		return self::$defaultInstance->isUpdatable($path);
684 
-	}
685 
-
686 
-	static public function isDeletable($path) {
687 
-		return self::$defaultInstance->isDeletable($path);
688 
-	}
689 
-
690 
-	static public function isSharable($path) {
691 
-		return self::$defaultInstance->isSharable($path);
692 
-	}
693 
-
694 
-	static public function file_exists($path) {
695 
-		return self::$defaultInstance->file_exists($path);
696 
-	}
697 
-
698 
-	static public function filemtime($path) {
699 
-		return self::$defaultInstance->filemtime($path);
700 
-	}
701 
-
702 
-	static public function touch($path, $mtime = null) {
703 
-		return self::$defaultInstance->touch($path, $mtime);
704 
-	}
705 
-
706 
-	/**
707 
-	 * @return string
708 
-	 */
709 
-	static public function file_get_contents($path) {
710 
-		return self::$defaultInstance->file_get_contents($path);
711 
-	}
712 
-
713 
-	static public function file_put_contents($path, $data) {
714 
-		return self::$defaultInstance->file_put_contents($path, $data);
715 
-	}
716 
-
717 
-	static public function unlink($path) {
718 
-		return self::$defaultInstance->unlink($path);
719 
-	}
720 
-
721 
-	static public function rename($path1, $path2) {
722 
-		return self::$defaultInstance->rename($path1, $path2);
723 
-	}
724 
-
725 
-	static public function copy($path1, $path2) {
726 
-		return self::$defaultInstance->copy($path1, $path2);
727 
-	}
728 
-
729 
-	static public function fopen($path, $mode) {
730 
-		return self::$defaultInstance->fopen($path, $mode);
731 
-	}
732 
-
733 
-	/**
734 
-	 * @return string
735 
-	 */
736 
-	static public function toTmpFile($path) {
737 
-		return self::$defaultInstance->toTmpFile($path);
738 
-	}
739 
-
740 
-	static public function fromTmpFile($tmpFile, $path) {
741 
-		return self::$defaultInstance->fromTmpFile($tmpFile, $path);
742 
-	}
743 
-
744 
-	static public function getMimeType($path) {
745 
-		return self::$defaultInstance->getMimeType($path);
746 
-	}
747 
-
748 
-	static public function hash($type, $path, $raw = false) {
749 
-		return self::$defaultInstance->hash($type, $path, $raw);
750 
-	}
751 
-
752 
-	static public function free_space($path = '/') {
753 
-		return self::$defaultInstance->free_space($path);
754 
-	}
755 
-
756 
-	static public function search($query) {
757 
-		return self::$defaultInstance->search($query);
758 
-	}
759 
-
760 
-	/**
761 
-	 * @param string $query
762 
-	 */
763 
-	static public function searchByMime($query) {
764 
-		return self::$defaultInstance->searchByMime($query);
765 
-	}
766 
-
767 
-	/**
768 
-	 * @param string|int $tag name or tag id
769 
-	 * @param string $userId owner of the tags
770 
-	 * @return FileInfo[] array or file info
771 
-	 */
772 
-	static public function searchByTag($tag, $userId) {
773 
-		return self::$defaultInstance->searchByTag($tag, $userId);
774 
-	}
775 
-
776 
-	/**
777 
-	 * check if a file or folder has been updated since $time
778 
-	 *
779 
-	 * @param string $path
780 
-	 * @param int $time
781 
-	 * @return bool
782 
-	 */
783 
-	static public function hasUpdated($path, $time) {
784 
-		return self::$defaultInstance->hasUpdated($path, $time);
785 
-	}
786 
-
787 
-	/**
788 
-	 * Fix common problems with a file path
789 
-	 *
790 
-	 * @param string $path
791 
-	 * @param bool $stripTrailingSlash whether to strip the trailing slash
792 
-	 * @param bool $isAbsolutePath whether the given path is absolute
793 
-	 * @param bool $keepUnicode true to disable unicode normalization
794 
-	 * @return string
795 
-	 */
796 
-	public static function normalizePath($path, $stripTrailingSlash = true, $isAbsolutePath = false, $keepUnicode = false) {
797 
-		if (is_null(self::$normalizedPathCache)) {
798 
-			self::$normalizedPathCache = new CappedMemoryCache(2048);
799 
-		}
800 
-
801 
-		/**
802 
-		 * FIXME: This is a workaround for existing classes and files which call
803 
-		 *        this function with another type than a valid string. This
804 
-		 *        conversion should get removed as soon as all existing
805 
-		 *        function calls have been fixed.
806 
-		 */
807 
-		$path = (string)$path;
808 
-
809 
-		$cacheKey = json_encode([$path, $stripTrailingSlash, $isAbsolutePath, $keepUnicode]);
810 
-
811 
-		if (isset(self::$normalizedPathCache[$cacheKey])) {
812 
-			return self::$normalizedPathCache[$cacheKey];
813 
-		}
814 
-
815 
-		if ($path == '') {
816 
-			return '/';
817 
-		}
818 
-
819 
-		//normalize unicode if possible
820 
-		if (!$keepUnicode) {
821 
-			$path = \OC_Util::normalizeUnicode($path);
822 
-		}
823 
-
824 
-		//no windows style slashes
825 
-		$path = str_replace('\\', '/', $path);
826 
-
827 
-		//add leading slash
828 
-		if ($path[0] !== '/') {
829 
-			$path = '/' . $path;
830 
-		}
831 
-
832 
-		// remove '/./'
833 
-		// ugly, but str_replace() can't replace them all in one go
834 
-		// as the replacement itself is part of the search string
835 
-		// which will only be found during the next iteration
836 
-		while (strpos($path, '/./') !== false) {
837 
-			$path = str_replace('/./', '/', $path);
838 
-		}
839 
-		// remove sequences of slashes
840 
-		$path = preg_replace('#/{2,}#', '/', $path);
841 
-
842 
-		//remove trailing slash
843 
-		if ($stripTrailingSlash and strlen($path) > 1) {
844 
-			$path = rtrim($path, '/');
845 
-		}
846 
-
847 
-		// remove trailing '/.'
848 
-		if (substr($path, -2) == '/.') {
849 
-			$path = substr($path, 0, -2);
850 
-		}
851 
-
852 
-		$normalizedPath = $path;
853 
-		self::$normalizedPathCache[$cacheKey] = $normalizedPath;
854 
-
855 
-		return $normalizedPath;
856 
-	}
857 
-
858 
-	/**
859 
-	 * get the filesystem info
860 
-	 *
861 
-	 * @param string $path
862 
-	 * @param boolean $includeMountPoints whether to add mountpoint sizes,
863 
-	 * defaults to true
864 
-	 * @return \OC\Files\FileInfo|bool False if file does not exist
865 
-	 */
866 
-	public static function getFileInfo($path, $includeMountPoints = true) {
867 
-		return self::$defaultInstance->getFileInfo($path, $includeMountPoints);
868 
-	}
869 
-
870 
-	/**
871 
-	 * change file metadata
872 
-	 *
873 
-	 * @param string $path
874 
-	 * @param array $data
875 
-	 * @return int
876 
-	 *
877 
-	 * returns the fileid of the updated file
878 
-	 */
879 
-	public static function putFileInfo($path, $data) {
880 
-		return self::$defaultInstance->putFileInfo($path, $data);
881 
-	}
882 
-
883 
-	/**
884 
-	 * get the content of a directory
885 
-	 *
886 
-	 * @param string $directory path under datadirectory
887 
-	 * @param string $mimetype_filter limit returned content to this mimetype or mimepart
888 
-	 * @return \OC\Files\FileInfo[]
889 
-	 */
890 
-	public static function getDirectoryContent($directory, $mimetype_filter = '') {
891 
-		return self::$defaultInstance->getDirectoryContent($directory, $mimetype_filter);
892 
-	}
893 
-
894 
-	/**
895 
-	 * Get the path of a file by id
896 
-	 *
897 
-	 * Note that the resulting path is not guaranteed to be unique for the id, multiple paths can point to the same file
898 
-	 *
899 
-	 * @param int $id
900 
-	 * @throws NotFoundException
901 
-	 * @return string
902 
-	 */
903 
-	public static function getPath($id) {
904 
-		return self::$defaultInstance->getPath($id);
905 
-	}
906 
-
907 
-	/**
908 
-	 * Get the owner for a file or folder
909 
-	 *
910 
-	 * @param string $path
911 
-	 * @return string
912 
-	 */
913 
-	public static function getOwner($path) {
914 
-		return self::$defaultInstance->getOwner($path);
915 
-	}
916 
-
917 
-	/**
918 
-	 * get the ETag for a file or folder
919 
-	 *
920 
-	 * @param string $path
921 
-	 * @return string
922 
-	 */
923 
-	static public function getETag($path) {
924 
-		return self::$defaultInstance->getETag($path);
925 
-	}
73 
+    /**
74 
+     * @var Mount\Manager $mounts
75 
+     */
76 
+    private static $mounts;
77 
+
78 
+    public static $loaded = false;
79 
+    /**
80 
+     * @var \OC\Files\View $defaultInstance
81 
+     */
82 
+    static private $defaultInstance;
83 
+
84 
+    static private $usersSetup = array();
85 
+
86 
+    static private $normalizedPathCache = null;
87 
+
88 
+    static private $listeningForProviders = false;
89 
+
90 
+    /**
91 
+     * classname which used for hooks handling
92 
+     * used as signalclass in OC_Hooks::emit()
93 
+     */
94 
+    const CLASSNAME = 'OC_Filesystem';
95 
+
96 
+    /**
97 
+     * signalname emitted before file renaming
98 
+     *
99 
+     * @param string $oldpath
100 
+     * @param string $newpath
101 
+     */
102 
+    const signal_rename = 'rename';
103 
+
104 
+    /**
105 
+     * signal emitted after file renaming
106 
+     *
107 
+     * @param string $oldpath
108 
+     * @param string $newpath
109 
+     */
110 
+    const signal_post_rename = 'post_rename';
111 
+
112 
+    /**
113 
+     * signal emitted before file/dir creation
114 
+     *
115 
+     * @param string $path
116 
+     * @param bool $run changing this flag to false in hook handler will cancel event
117 
+     */
118 
+    const signal_create = 'create';
119 
+
120 
+    /**
121 
+     * signal emitted after file/dir creation
122 
+     *
123 
+     * @param string $path
124 
+     * @param bool $run changing this flag to false in hook handler will cancel event
125 
+     */
126 
+    const signal_post_create = 'post_create';
127 
+
128 
+    /**
129 
+     * signal emits before file/dir copy
130 
+     *
131 
+     * @param string $oldpath
132 
+     * @param string $newpath
133 
+     * @param bool $run changing this flag to false in hook handler will cancel event
134 
+     */
135 
+    const signal_copy = 'copy';
136 
+
137 
+    /**
138 
+     * signal emits after file/dir copy
139 
+     *
140 
+     * @param string $oldpath
141 
+     * @param string $newpath
142 
+     */
143 
+    const signal_post_copy = 'post_copy';
144 
+
145 
+    /**
146 
+     * signal emits before file/dir save
147 
+     *
148 
+     * @param string $path
149 
+     * @param bool $run changing this flag to false in hook handler will cancel event
150 
+     */
151 
+    const signal_write = 'write';
152 
+
153 
+    /**
154 
+     * signal emits after file/dir save
155 
+     *
156 
+     * @param string $path
157 
+     */
158 
+    const signal_post_write = 'post_write';
159 
+
160 
+    /**
161 
+     * signal emitted before file/dir update
162 
+     *
163 
+     * @param string $path
164 
+     * @param bool $run changing this flag to false in hook handler will cancel event
165 
+     */
166 
+    const signal_update = 'update';
167 
+
168 
+    /**
169 
+     * signal emitted after file/dir update
170 
+     *
171 
+     * @param string $path
172 
+     * @param bool $run changing this flag to false in hook handler will cancel event
173 
+     */
174 
+    const signal_post_update = 'post_update';
175 
+
176 
+    /**
177 
+     * signal emits when reading file/dir
178 
+     *
179 
+     * @param string $path
180 
+     */
181 
+    const signal_read = 'read';
182 
+
183 
+    /**
184 
+     * signal emits when removing file/dir
185 
+     *
186 
+     * @param string $path
187 
+     */
188 
+    const signal_delete = 'delete';
189 
+
190 
+    /**
191 
+     * parameters definitions for signals
192 
+     */
193 
+    const signal_param_path = 'path';
194 
+    const signal_param_oldpath = 'oldpath';
195 
+    const signal_param_newpath = 'newpath';
196 
+
197 
+    /**
198 
+     * run - changing this flag to false in hook handler will cancel event
199 
+     */
200 
+    const signal_param_run = 'run';
201 
+
202 
+    const signal_create_mount = 'create_mount';
203 
+    const signal_delete_mount = 'delete_mount';
204 
+    const signal_param_mount_type = 'mounttype';
205 
+    const signal_param_users = 'users';
206 
+
207 
+    /**
208 
+     * @var \OC\Files\Storage\StorageFactory $loader
209 
+     */
210 
+    private static $loader;
211 
+
212 
+    /** @var bool */
213 
+    private static $logWarningWhenAddingStorageWrapper = true;
214 
+
215 
+    /**
216 
+     * @param bool $shouldLog
217 
+     * @return bool previous value
218 
+     * @internal
219 
+     */
220 
+    public static function logWarningWhenAddingStorageWrapper($shouldLog) {
221 
+        $previousValue = self::$logWarningWhenAddingStorageWrapper;
222 
+        self::$logWarningWhenAddingStorageWrapper = (bool) $shouldLog;
223 
+        return $previousValue;
224 
+    }
225 
+
226 
+    /**
227 
+     * @param string $wrapperName
228 
+     * @param callable $wrapper
229 
+     * @param int $priority
230 
+     */
231 
+    public static function addStorageWrapper($wrapperName, $wrapper, $priority = 50) {
232 
+        if (self::$logWarningWhenAddingStorageWrapper) {
233 
+            \OC::$server->getLogger()->warning("Storage wrapper '{wrapper}' was not registered via the 'OC_Filesystem - preSetup' hook which could cause potential problems.", [
234 
+                'wrapper' => $wrapperName,
235 
+                'app' => 'filesystem',
236 
+            ]);
237 
+        }
238 
+
239 
+        $mounts = self::getMountManager()->getAll();
240 
+        if (!self::getLoader()->addStorageWrapper($wrapperName, $wrapper, $priority, $mounts)) {
241 
+            // do not re-wrap if storage with this name already existed
242 
+            return;
243 
+        }
244 
+    }
245 
+
246 
+    /**
247 
+     * Returns the storage factory
248 
+     *
249 
+     * @return \OCP\Files\Storage\IStorageFactory
250 
+     */
251 
+    public static function getLoader() {
252 
+        if (!self::$loader) {
253 
+            self::$loader = new StorageFactory();
254 
+        }
255 
+        return self::$loader;
256 
+    }
257 
+
258 
+    /**
259 
+     * Returns the mount manager
260 
+     *
261 
+     * @return \OC\Files\Mount\Manager
262 
+     */
263 
+    public static function getMountManager($user = '') {
264 
+        if (!self::$mounts) {
265 
+            \OC_Util::setupFS($user);
266 
+        }
267 
+        return self::$mounts;
268 
+    }
269 
+
270 
+    /**
271 
+     * get the mountpoint of the storage object for a path
272 
+     * ( note: because a storage is not always mounted inside the fakeroot, the
273 
+     * returned mountpoint is relative to the absolute root of the filesystem
274 
+     * and doesn't take the chroot into account )
275 
+     *
276 
+     * @param string $path
277 
+     * @return string
278 
+     */
279 
+    static public function getMountPoint($path) {
280 
+        if (!self::$mounts) {
281 
+            \OC_Util::setupFS();
282 
+        }
283 
+        $mount = self::$mounts->find($path);
284 
+        if ($mount) {
285 
+            return $mount->getMountPoint();
286 
+        } else {
287 
+            return '';
288 
+        }
289 
+    }
290 
+
291 
+    /**
292 
+     * get a list of all mount points in a directory
293 
+     *
294 
+     * @param string $path
295 
+     * @return string[]
296 
+     */
297 
+    static public function getMountPoints($path) {
298 
+        if (!self::$mounts) {
299 
+            \OC_Util::setupFS();
300 
+        }
301 
+        $result = array();
302 
+        $mounts = self::$mounts->findIn($path);
303 
+        foreach ($mounts as $mount) {
304 
+            $result[] = $mount->getMountPoint();
305 
+        }
306 
+        return $result;
307 
+    }
308 
+
309 
+    /**
310 
+     * get the storage mounted at $mountPoint
311 
+     *
312 
+     * @param string $mountPoint
313 
+     * @return \OC\Files\Storage\Storage
314 
+     */
315 
+    public static function getStorage($mountPoint) {
316 
+        if (!self::$mounts) {
317 
+            \OC_Util::setupFS();
318 
+        }
319 
+        $mount = self::$mounts->find($mountPoint);
320 
+        return $mount->getStorage();
321 
+    }
322 
+
323 
+    /**
324 
+     * @param string $id
325 
+     * @return Mount\MountPoint[]
326 
+     */
327 
+    public static function getMountByStorageId($id) {
328 
+        if (!self::$mounts) {
329 
+            \OC_Util::setupFS();
330 
+        }
331 
+        return self::$mounts->findByStorageId($id);
332 
+    }
333 
+
334 
+    /**
335 
+     * @param int $id
336 
+     * @return Mount\MountPoint[]
337 
+     */
338 
+    public static function getMountByNumericId($id) {
339 
+        if (!self::$mounts) {
340 
+            \OC_Util::setupFS();
341 
+        }
342 
+        return self::$mounts->findByNumericId($id);
343 
+    }
344 
+
345 
+    /**
346 
+     * resolve a path to a storage and internal path
347 
+     *
348 
+     * @param string $path
349 
+     * @return array an array consisting of the storage and the internal path
350 
+     */
351 
+    static public function resolvePath($path) {
352 
+        if (!self::$mounts) {
353 
+            \OC_Util::setupFS();
354 
+        }
355 
+        $mount = self::$mounts->find($path);
356 
+        if ($mount) {
357 
+            return array($mount->getStorage(), rtrim($mount->getInternalPath($path), '/'));
358 
+        } else {
359 
+            return array(null, null);
360 
+        }
361 
+    }
362 
+
363 
+    static public function init($user, $root) {
364 
+        if (self::$defaultInstance) {
365 
+            return false;
366 
+        }
367 
+        self::getLoader();
368 
+        self::$defaultInstance = new View($root);
369 
+
370 
+        if (!self::$mounts) {
371 
+            self::$mounts = \OC::$server->getMountManager();
372 
+        }
373 
+
374 
+        //load custom mount config
375 
+        self::initMountPoints($user);
376 
+
377 
+        self::$loaded = true;
378 
+
379 
+        return true;
380 
+    }
381 
+
382 
+    static public function initMountManager() {
383 
+        if (!self::$mounts) {
384 
+            self::$mounts = \OC::$server->getMountManager();
385 
+        }
386 
+    }
387 
+
388 
+    /**
389 
+     * Initialize system and personal mount points for a user
390 
+     *
391 
+     * @param string $user
392 
+     * @throws \OC\User\NoUserException if the user is not available
393 
+     */
394 
+    public static function initMountPoints($user = '') {
395 
+        if ($user == '') {
396 
+            $user = \OC_User::getUser();
397 
+        }
398 
+        if ($user === null || $user === false || $user === '') {
399 
+            throw new \OC\User\NoUserException('Attempted to initialize mount points for null user and no user in session');
400 
+        }
401 
+
402 
+        if (isset(self::$usersSetup[$user])) {
403 
+            return;
404 
+        }
405 
+
406 
+        self::$usersSetup[$user] = true;
407 
+
408 
+        $userManager = \OC::$server->getUserManager();
409 
+        $userObject = $userManager->get($user);
410 
+
411 
+        if (is_null($userObject)) {
412 
+            \OCP\Util::writeLog('files', ' Backends provided no user object for ' . $user, ILogger::ERROR);
413 
+            // reset flag, this will make it possible to rethrow the exception if called again
414 
+            unset(self::$usersSetup[$user]);
415 
+            throw new \OC\User\NoUserException('Backends provided no user object for ' . $user);
416 
+        }
417 
+
418 
+        $realUid = $userObject->getUID();
419 
+        // workaround in case of different casings
420 
+        if ($user !== $realUid) {
421 
+            $stack = json_encode(debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 50));
422 
+            \OCP\Util::writeLog('files', 'initMountPoints() called with wrong user casing. This could be a bug. Expected: "' . $realUid . '" got "' . $user . '". Stack: ' . $stack, ILogger::WARN);
423 
+            $user = $realUid;
424 
+
425 
+            // again with the correct casing
426 
+            if (isset(self::$usersSetup[$user])) {
427 
+                return;
428 
+            }
429 
+
430 
+            self::$usersSetup[$user] = true;
431 
+        }
432 
+
433 
+        if (\OC::$server->getLockdownManager()->canAccessFilesystem()) {
434 
+            /** @var \OC\Files\Config\MountProviderCollection $mountConfigManager */
435 
+            $mountConfigManager = \OC::$server->getMountProviderCollection();
436 
+
437 
+            // home mounts are handled seperate since we need to ensure this is mounted before we call the other mount providers
438 
+            $homeMount = $mountConfigManager->getHomeMountForUser($userObject);
439 
+
440 
+            self::getMountManager()->addMount($homeMount);
441 
+
442 
+            \OC\Files\Filesystem::getStorage($user);
443 
+
444 
+            // Chance to mount for other storages
445 
+            if ($userObject) {
446 
+                $mounts = $mountConfigManager->addMountForUser($userObject, self::getMountManager());
447 
+                $mounts[] = $homeMount;
448 
+                $mountConfigManager->registerMounts($userObject, $mounts);
449 
+            }
450 
+
451 
+            self::listenForNewMountProviders($mountConfigManager, $userManager);
452 
+        } else {
453 
+            self::getMountManager()->addMount(new MountPoint(
454 
+                new NullStorage([]),
455 
+                '/' . $user
456 
+            ));
457 
+            self::getMountManager()->addMount(new MountPoint(
458 
+                new NullStorage([]),
459 
+                '/' . $user . '/files'
460 
+            ));
461 
+        }
462 
+        \OC_Hook::emit('OC_Filesystem', 'post_initMountPoints', array('user' => $user));
463 
+    }
464 
+
465 
+    /**
466 
+     * Get mounts from mount providers that are registered after setup
467 
+     *
468 
+     * @param MountProviderCollection $mountConfigManager
469 
+     * @param IUserManager $userManager
470 
+     */
471 
+    private static function listenForNewMountProviders(MountProviderCollection $mountConfigManager, IUserManager $userManager) {
472 
+        if (!self::$listeningForProviders) {
473 
+            self::$listeningForProviders = true;
474 
+            $mountConfigManager->listen('\OC\Files\Config', 'registerMountProvider', function (IMountProvider $provider) use ($userManager) {
475 
+                foreach (Filesystem::$usersSetup as $user => $setup) {
476 
+                    $userObject = $userManager->get($user);
477 
+                    if ($userObject) {
478 
+                        $mounts = $provider->getMountsForUser($userObject, Filesystem::getLoader());
479 
+                        array_walk($mounts, array(self::$mounts, 'addMount'));
480 
+                    }
481 
+                }
482 
+            });
483 
+        }
484 
+    }
485 
+
486 
+    /**
487 
+     * get the default filesystem view
488 
+     *
489 
+     * @return View
490 
+     */
491 
+    static public function getView() {
492 
+        return self::$defaultInstance;
493 
+    }
494 
+
495 
+    /**
496 
+     * tear down the filesystem, removing all storage providers
497 
+     */
498 
+    static public function tearDown() {
499 
+        self::clearMounts();
500 
+        self::$defaultInstance = null;
501 
+    }
502 
+
503 
+    /**
504 
+     * get the relative path of the root data directory for the current user
505 
+     *
506 
+     * @return string
507 
+     *
508 
+     * Returns path like /admin/files
509 
+     */
510 
+    static public function getRoot() {
511 
+        if (!self::$defaultInstance) {
512 
+            return null;
513 
+        }
514 
+        return self::$defaultInstance->getRoot();
515 
+    }
516 
+
517 
+    /**
518 
+     * clear all mounts and storage backends
519 
+     */
520 
+    public static function clearMounts() {
521 
+        if (self::$mounts) {
522 
+            self::$usersSetup = array();
523 
+            self::$mounts->clear();
524 
+        }
525 
+    }
526 
+
527 
+    /**
528 
+     * mount an \OC\Files\Storage\Storage in our virtual filesystem
529 
+     *
530 
+     * @param \OC\Files\Storage\Storage|string $class
531 
+     * @param array $arguments
532 
+     * @param string $mountpoint
533 
+     */
534 
+    static public function mount($class, $arguments, $mountpoint) {
535 
+        if (!self::$mounts) {
536 
+            \OC_Util::setupFS();
537 
+        }
538 
+        $mount = new Mount\MountPoint($class, $mountpoint, $arguments, self::getLoader());
539 
+        self::$mounts->addMount($mount);
540 
+    }
541 
+
542 
+    /**
543 
+     * return the path to a local version of the file
544 
+     * we need this because we can't know if a file is stored local or not from
545 
+     * outside the filestorage and for some purposes a local file is needed
546 
+     *
547 
+     * @param string $path
548 
+     * @return string
549 
+     */
550 
+    static public function getLocalFile($path) {
551 
+        return self::$defaultInstance->getLocalFile($path);
552 
+    }
553 
+
554 
+    /**
555 
+     * @param string $path
556 
+     * @return string
557 
+     */
558 
+    static public function getLocalFolder($path) {
559 
+        return self::$defaultInstance->getLocalFolder($path);
560 
+    }
561 
+
562 
+    /**
563 
+     * return path to file which reflects one visible in browser
564 
+     *
565 
+     * @param string $path
566 
+     * @return string
567 
+     */
568 
+    static public function getLocalPath($path) {
569 
+        $datadir = \OC_User::getHome(\OC_User::getUser()) . '/files';
570 
+        $newpath = $path;
571 
+        if (strncmp($newpath, $datadir, strlen($datadir)) == 0) {
572 
+            $newpath = substr($path, strlen($datadir));
573 
+        }
574 
+        return $newpath;
575 
+    }
576 
+
577 
+    /**
578 
+     * check if the requested path is valid
579 
+     *
580 
+     * @param string $path
581 
+     * @return bool
582 
+     */
583 
+    static public function isValidPath($path) {
584 
+        $path = self::normalizePath($path);
585 
+        if (!$path || $path[0] !== '/') {
586 
+            $path = '/' . $path;
587 
+        }
588 
+        if (strpos($path, '/../') !== false || strrchr($path, '/') === '/..') {
589 
+            return false;
590 
+        }
591 
+        return true;
592 
+    }
593 
+
594 
+    /**
595 
+     * checks if a file is blacklisted for storage in the filesystem
596 
+     * Listens to write and rename hooks
597 
+     *
598 
+     * @param array $data from hook
599 
+     */
600 
+    static public function isBlacklisted($data) {
601 
+        if (isset($data['path'])) {
602 
+            $path = $data['path'];
603 
+        } else if (isset($data['newpath'])) {
604 
+            $path = $data['newpath'];
605 
+        }
606 
+        if (isset($path)) {
607 
+            if (self::isFileBlacklisted($path)) {
608 
+                $data['run'] = false;
609 
+            }
610 
+        }
611 
+    }
612 
+
613 
+    /**
614 
+     * @param string $filename
615 
+     * @return bool
616 
+     */
617 
+    static public function isFileBlacklisted($filename) {
618 
+        $filename = self::normalizePath($filename);
619 
+
620 
+        $blacklist = \OC::$server->getConfig()->getSystemValue('blacklisted_files', array('.htaccess'));
621 
+        $filename = strtolower(basename($filename));
622 
+        return in_array($filename, $blacklist);
623 
+    }
624 
+
625 
+    /**
626 
+     * check if the directory should be ignored when scanning
627 
+     * NOTE: the special directories . and .. would cause never ending recursion
628 
+     *
629 
+     * @param String $dir
630 
+     * @return boolean
631 
+     */
632 
+    static public function isIgnoredDir($dir) {
633 
+        if ($dir === '.' || $dir === '..') {
634 
+            return true;
635 
+        }
636 
+        return false;
637 
+    }
638 
+
639 
+    /**
640 
+     * following functions are equivalent to their php builtin equivalents for arguments/return values.
641 
+     */
642 
+    static public function mkdir($path) {
643 
+        return self::$defaultInstance->mkdir($path);
644 
+    }
645 
+
646 
+    static public function rmdir($path) {
647 
+        return self::$defaultInstance->rmdir($path);
648 
+    }
649 
+
650 
+    static public function is_dir($path) {
651 
+        return self::$defaultInstance->is_dir($path);
652 
+    }
653 
+
654 
+    static public function is_file($path) {
655 
+        return self::$defaultInstance->is_file($path);
656 
+    }
657 
+
658 
+    static public function stat($path) {
659 
+        return self::$defaultInstance->stat($path);
660 
+    }
661 
+
662 
+    static public function filetype($path) {
663 
+        return self::$defaultInstance->filetype($path);
664 
+    }
665 
+
666 
+    static public function filesize($path) {
667 
+        return self::$defaultInstance->filesize($path);
668 
+    }
669 
+
670 
+    static public function readfile($path) {
671 
+        return self::$defaultInstance->readfile($path);
672 
+    }
673 
+
674 
+    static public function isCreatable($path) {
675 
+        return self::$defaultInstance->isCreatable($path);
676 
+    }
677 
+
678 
+    static public function isReadable($path) {
679 
+        return self::$defaultInstance->isReadable($path);
680 
+    }
681 
+
682 
+    static public function isUpdatable($path) {
683 
+        return self::$defaultInstance->isUpdatable($path);
684 
+    }
685 
+
686 
+    static public function isDeletable($path) {
687 
+        return self::$defaultInstance->isDeletable($path);
688 
+    }
689 
+
690 
+    static public function isSharable($path) {
691 
+        return self::$defaultInstance->isSharable($path);
692 
+    }
693 
+
694 
+    static public function file_exists($path) {
695 
+        return self::$defaultInstance->file_exists($path);
696 
+    }
697 
+
698 
+    static public function filemtime($path) {
699 
+        return self::$defaultInstance->filemtime($path);
700 
+    }
701 
+
702 
+    static public function touch($path, $mtime = null) {
703 
+        return self::$defaultInstance->touch($path, $mtime);
704 
+    }
705 
+
706 
+    /**
707 
+     * @return string
708 
+     */
709 
+    static public function file_get_contents($path) {
710 
+        return self::$defaultInstance->file_get_contents($path);
711 
+    }
712 
+
713 
+    static public function file_put_contents($path, $data) {
714 
+        return self::$defaultInstance->file_put_contents($path, $data);
715 
+    }
716 
+
717 
+    static public function unlink($path) {
718 
+        return self::$defaultInstance->unlink($path);
719 
+    }
720 
+
721 
+    static public function rename($path1, $path2) {
722 
+        return self::$defaultInstance->rename($path1, $path2);
723 
+    }
724 
+
725 
+    static public function copy($path1, $path2) {
726 
+        return self::$defaultInstance->copy($path1, $path2);
727 
+    }
728 
+
729 
+    static public function fopen($path, $mode) {
730 
+        return self::$defaultInstance->fopen($path, $mode);
731 
+    }
732 
+
733 
+    /**
734 
+     * @return string
735 
+     */
736 
+    static public function toTmpFile($path) {
737 
+        return self::$defaultInstance->toTmpFile($path);
738 
+    }
739 
+
740 
+    static public function fromTmpFile($tmpFile, $path) {
741 
+        return self::$defaultInstance->fromTmpFile($tmpFile, $path);
742 
+    }
743 
+
744 
+    static public function getMimeType($path) {
745 
+        return self::$defaultInstance->getMimeType($path);
746 
+    }
747 
+
748 
+    static public function hash($type, $path, $raw = false) {
749 
+        return self::$defaultInstance->hash($type, $path, $raw);
750 
+    }
751 
+
752 
+    static public function free_space($path = '/') {
753 
+        return self::$defaultInstance->free_space($path);
754 
+    }
755 
+
756 
+    static public function search($query) {
757 
+        return self::$defaultInstance->search($query);
758 
+    }
759 
+
760 
+    /**
761 
+     * @param string $query
762 
+     */
763 
+    static public function searchByMime($query) {
764 
+        return self::$defaultInstance->searchByMime($query);
765 
+    }
766 
+
767 
+    /**
768 
+     * @param string|int $tag name or tag id
769 
+     * @param string $userId owner of the tags
770 
+     * @return FileInfo[] array or file info
771 
+     */
772 
+    static public function searchByTag($tag, $userId) {
773 
+        return self::$defaultInstance->searchByTag($tag, $userId);
774 
+    }
775 
+
776 
+    /**
777 
+     * check if a file or folder has been updated since $time
778 
+     *
779 
+     * @param string $path
780 
+     * @param int $time
781 
+     * @return bool
782 
+     */
783 
+    static public function hasUpdated($path, $time) {
784 
+        return self::$defaultInstance->hasUpdated($path, $time);
785 
+    }
786 
+
787 
+    /**
788 
+     * Fix common problems with a file path
789 
+     *
790 
+     * @param string $path
791 
+     * @param bool $stripTrailingSlash whether to strip the trailing slash
792 
+     * @param bool $isAbsolutePath whether the given path is absolute
793 
+     * @param bool $keepUnicode true to disable unicode normalization
794 
+     * @return string
795 
+     */
796 
+    public static function normalizePath($path, $stripTrailingSlash = true, $isAbsolutePath = false, $keepUnicode = false) {
797 
+        if (is_null(self::$normalizedPathCache)) {
798 
+            self::$normalizedPathCache = new CappedMemoryCache(2048);
799 
+        }
800 
+
801 
+        /**
802 
+         * FIXME: This is a workaround for existing classes and files which call
803 
+         *        this function with another type than a valid string. This
804 
+         *        conversion should get removed as soon as all existing
805 
+         *        function calls have been fixed.
806 
+         */
807 
+        $path = (string)$path;
808 
+
809 
+        $cacheKey = json_encode([$path, $stripTrailingSlash, $isAbsolutePath, $keepUnicode]);
810 
+
811 
+        if (isset(self::$normalizedPathCache[$cacheKey])) {
812 
+            return self::$normalizedPathCache[$cacheKey];
813 
+        }
814 
+
815 
+        if ($path == '') {
816 
+            return '/';
817 
+        }
818 
+
819 
+        //normalize unicode if possible
820 
+        if (!$keepUnicode) {
821 
+            $path = \OC_Util::normalizeUnicode($path);
822 
+        }
823 
+
824 
+        //no windows style slashes
825 
+        $path = str_replace('\\', '/', $path);
826 
+
827 
+        //add leading slash
828 
+        if ($path[0] !== '/') {
829 
+            $path = '/' . $path;
830 
+        }
831 
+
832 
+        // remove '/./'
833 
+        // ugly, but str_replace() can't replace them all in one go
834 
+        // as the replacement itself is part of the search string
835 
+        // which will only be found during the next iteration
836 
+        while (strpos($path, '/./') !== false) {
837 
+            $path = str_replace('/./', '/', $path);
838 
+        }
839 
+        // remove sequences of slashes
840 
+        $path = preg_replace('#/{2,}#', '/', $path);
841 
+
842 
+        //remove trailing slash
843 
+        if ($stripTrailingSlash and strlen($path) > 1) {
844 
+            $path = rtrim($path, '/');
845 
+        }
846 
+
847 
+        // remove trailing '/.'
848 
+        if (substr($path, -2) == '/.') {
849 
+            $path = substr($path, 0, -2);
850 
+        }
851 
+
852 
+        $normalizedPath = $path;
853 
+        self::$normalizedPathCache[$cacheKey] = $normalizedPath;
854 
+
855 
+        return $normalizedPath;
856 
+    }
857 
+
858 
+    /**
859 
+     * get the filesystem info
860 
+     *
861 
+     * @param string $path
862 
+     * @param boolean $includeMountPoints whether to add mountpoint sizes,
863 
+     * defaults to true
864 
+     * @return \OC\Files\FileInfo|bool False if file does not exist
865 
+     */
866 
+    public static function getFileInfo($path, $includeMountPoints = true) {
867 
+        return self::$defaultInstance->getFileInfo($path, $includeMountPoints);
868 
+    }
869 
+
870 
+    /**
871 
+     * change file metadata
872 
+     *
873 
+     * @param string $path
874 
+     * @param array $data
875 
+     * @return int
876 
+     *
877 
+     * returns the fileid of the updated file
878 
+     */
879 
+    public static function putFileInfo($path, $data) {
880 
+        return self::$defaultInstance->putFileInfo($path, $data);
881 
+    }
882 
+
883 
+    /**
884 
+     * get the content of a directory
885 
+     *
886 
+     * @param string $directory path under datadirectory
887 
+     * @param string $mimetype_filter limit returned content to this mimetype or mimepart
888 
+     * @return \OC\Files\FileInfo[]
889 
+     */
890 
+    public static function getDirectoryContent($directory, $mimetype_filter = '') {
891 
+        return self::$defaultInstance->getDirectoryContent($directory, $mimetype_filter);
892 
+    }
893 
+
894 
+    /**
895 
+     * Get the path of a file by id
896 
+     *
897 
+     * Note that the resulting path is not guaranteed to be unique for the id, multiple paths can point to the same file
898 
+     *
899 
+     * @param int $id
900 
+     * @throws NotFoundException
901 
+     * @return string
902 
+     */
903 
+    public static function getPath($id) {
904 
+        return self::$defaultInstance->getPath($id);
905 
+    }
906 
+
907 
+    /**
908 
+     * Get the owner for a file or folder
909 
+     *
910 
+     * @param string $path
911 
+     * @return string
912 
+     */
913 
+    public static function getOwner($path) {
914 
+        return self::$defaultInstance->getOwner($path);
915 
+    }
916 
+
917 
+    /**
918 
+     * get the ETag for a file or folder
919 
+     *
920 
+     * @param string $path
921 
+     * @return string
922 
+     */
923 
+    static public function getETag($path) {
924 
+        return self::$defaultInstance->getETag($path);
925 
+    }
926 926 
 }
Please login to merge, or discard this patch.
Spacing   +10 added lines, -10 removed lines patch added patch discarded remove patch 
@@ -409,17 +409,17 @@  discard block
 
 block discarded – undo
409 409 
 		$userObject = $userManager->get($user);
410 410
411 411 
 		if (is_null($userObject)) {
412 
-			\OCP\Util::writeLog('files', ' Backends provided no user object for ' . $user, ILogger::ERROR);
412 
+			\OCP\Util::writeLog('files', ' Backends provided no user object for '.$user, ILogger::ERROR);
413 413 
 			// reset flag, this will make it possible to rethrow the exception if called again
414 414 
 			unset(self::$usersSetup[$user]);
415 
-			throw new \OC\User\NoUserException('Backends provided no user object for ' . $user);
415 
+			throw new \OC\User\NoUserException('Backends provided no user object for '.$user);
416 416 
 		}
417 417
418 418 
 		$realUid = $userObject->getUID();
419 419 
 		// workaround in case of different casings
420 420 
 		if ($user !== $realUid) {
421 421 
 			$stack = json_encode(debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 50));
422 
-			\OCP\Util::writeLog('files', 'initMountPoints() called with wrong user casing. This could be a bug. Expected: "' . $realUid . '" got "' . $user . '". Stack: ' . $stack, ILogger::WARN);
422 
+			\OCP\Util::writeLog('files', 'initMountPoints() called with wrong user casing. This could be a bug. Expected: "'.$realUid.'" got "'.$user.'". Stack: '.$stack, ILogger::WARN);
423 423 
 			$user = $realUid;
424 424
425 425 
 			// again with the correct casing
 
@@ -452,11 +452,11 @@  discard block
 
 block discarded – undo
452 452 
 		} else {
453 453 
 			self::getMountManager()->addMount(new MountPoint(
454 454 
 				new NullStorage([]),
455 
-				'/' . $user
455 
+				'/'.$user
456 456 
 			));
457 457 
 			self::getMountManager()->addMount(new MountPoint(
458 458 
 				new NullStorage([]),
459 
-				'/' . $user . '/files'
459 
+				'/'.$user.'/files'
460 460 
 			));
461 461 
 		}
462 462 
 		\OC_Hook::emit('OC_Filesystem', 'post_initMountPoints', array('user' => $user));
 
@@ -471,7 +471,7 @@  discard block
 
 block discarded – undo
471 471 
 	private static function listenForNewMountProviders(MountProviderCollection $mountConfigManager, IUserManager $userManager) {
472 472 
 		if (!self::$listeningForProviders) {
473 473 
 			self::$listeningForProviders = true;
474 
-			$mountConfigManager->listen('\OC\Files\Config', 'registerMountProvider', function (IMountProvider $provider) use ($userManager) {
474 
+			$mountConfigManager->listen('\OC\Files\Config', 'registerMountProvider', function(IMountProvider $provider) use ($userManager) {
475 475 
 				foreach (Filesystem::$usersSetup as $user => $setup) {
476 476 
 					$userObject = $userManager->get($user);
477 477 
 					if ($userObject) {
 
@@ -566,7 +566,7 @@  discard block
 
 block discarded – undo
566 566 
 	 * @return string
567 567 
 	 */
568 568 
 	static public function getLocalPath($path) {
569 
-		$datadir = \OC_User::getHome(\OC_User::getUser()) . '/files';
569 
+		$datadir = \OC_User::getHome(\OC_User::getUser()).'/files';
570 570 
 		$newpath = $path;
571 571 
 		if (strncmp($newpath, $datadir, strlen($datadir)) == 0) {
572 572 
 			$newpath = substr($path, strlen($datadir));
 
@@ -583,7 +583,7 @@  discard block
 
 block discarded – undo
583 583 
 	static public function isValidPath($path) {
584 584 
 		$path = self::normalizePath($path);
585 585 
 		if (!$path || $path[0] !== '/') {
586 
-			$path = '/' . $path;
586 
+			$path = '/'.$path;
587 587 
 		}
588 588 
 		if (strpos($path, '/../') !== false || strrchr($path, '/') === '/..') {
589 589 
 			return false;
 
@@ -804,7 +804,7 @@  discard block
 
 block discarded – undo
804 804 
 		 *        conversion should get removed as soon as all existing
805 805 
 		 *        function calls have been fixed.
806 806 
 		 */
807 
-		$path = (string)$path;
807 
+		$path = (string) $path;
808 808
809 809 
 		$cacheKey = json_encode([$path, $stripTrailingSlash, $isAbsolutePath, $keepUnicode]);
810 810 
 
@@ -826,7 +826,7 @@  discard block
 
 block discarded – undo
826 826
827 827 
 		//add leading slash
828 828 
 		if ($path[0] !== '/') {
829 
-			$path = '/' . $path;
829 
+			$path = '/'.$path;
830 830 
 		}
831 831
832 832 
 		// remove '/./'
Please login to merge, or discard this patch.
lib/private/Files/View.php 2 patches
Indentation   +2080 added lines, -2080 removed lines patch added patch discarded remove patch 
@@ -81,2084 +81,2084 @@
 
 block discarded – undo
81 81 
  * \OC\Files\Storage\Storage object
82 82 
  */
83 83 
 class View {
84 
-	/** @var string */
85 
-	private $fakeRoot = '';
86 
-
87 
-	/**
88 
-	 * @var \OCP\Lock\ILockingProvider
89 
-	 */
90 
-	protected $lockingProvider;
91 
-
92 
-	private $lockingEnabled;
93 
-
94 
-	private $updaterEnabled = true;
95 
-
96 
-	/** @var \OC\User\Manager */
97 
-	private $userManager;
98 
-
99 
-	/** @var \OCP\ILogger */
100 
-	private $logger;
101 
-
102 
-	/**
103 
-	 * @param string $root
104 
-	 * @throws \Exception If $root contains an invalid path
105 
-	 */
106 
-	public function __construct($root = '') {
107 
-		if (is_null($root)) {
108 
-			throw new \InvalidArgumentException('Root can\'t be null');
109 
-		}
110 
-		if (!Filesystem::isValidPath($root)) {
111 
-			throw new \Exception();
112 
-		}
113 
-
114 
-		$this->fakeRoot = $root;
115 
-		$this->lockingProvider = \OC::$server->getLockingProvider();
116 
-		$this->lockingEnabled = !($this->lockingProvider instanceof \OC\Lock\NoopLockingProvider);
117 
-		$this->userManager = \OC::$server->getUserManager();
118 
-		$this->logger = \OC::$server->getLogger();
119 
-	}
120 
-
121 
-	public function getAbsolutePath($path = '/') {
122 
-		if ($path === null) {
123 
-			return null;
124 
-		}
125 
-		$this->assertPathLength($path);
126 
-		if ($path === '') {
127 
-			$path = '/';
128 
-		}
129 
-		if ($path[0] !== '/') {
130 
-			$path = '/' . $path;
131 
-		}
132 
-		return $this->fakeRoot . $path;
133 
-	}
134 
-
135 
-	/**
136 
-	 * change the root to a fake root
137 
-	 *
138 
-	 * @param string $fakeRoot
139 
-	 * @return boolean|null
140 
-	 */
141 
-	public function chroot($fakeRoot) {
142 
-		if (!$fakeRoot == '') {
143 
-			if ($fakeRoot[0] !== '/') {
144 
-				$fakeRoot = '/' . $fakeRoot;
145 
-			}
146 
-		}
147 
-		$this->fakeRoot = $fakeRoot;
148 
-	}
149 
-
150 
-	/**
151 
-	 * get the fake root
152 
-	 *
153 
-	 * @return string
154 
-	 */
155 
-	public function getRoot() {
156 
-		return $this->fakeRoot;
157 
-	}
158 
-
159 
-	/**
160 
-	 * get path relative to the root of the view
161 
-	 *
162 
-	 * @param string $path
163 
-	 * @return string
164 
-	 */
165 
-	public function getRelativePath($path) {
166 
-		$this->assertPathLength($path);
167 
-		if ($this->fakeRoot == '') {
168 
-			return $path;
169 
-		}
170 
-
171 
-		if (rtrim($path, '/') === rtrim($this->fakeRoot, '/')) {
172 
-			return '/';
173 
-		}
174 
-
175 
-		// missing slashes can cause wrong matches!
176 
-		$root = rtrim($this->fakeRoot, '/') . '/';
177 
-
178 
-		if (strpos($path, $root) !== 0) {
179 
-			return null;
180 
-		} else {
181 
-			$path = substr($path, strlen($this->fakeRoot));
182 
-			if (strlen($path) === 0) {
183 
-				return '/';
184 
-			} else {
185 
-				return $path;
186 
-			}
187 
-		}
188 
-	}
189 
-
190 
-	/**
191 
-	 * get the mountpoint of the storage object for a path
192 
-	 * ( note: because a storage is not always mounted inside the fakeroot, the
193 
-	 * returned mountpoint is relative to the absolute root of the filesystem
194 
-	 * and does not take the chroot into account )
195 
-	 *
196 
-	 * @param string $path
197 
-	 * @return string
198 
-	 */
199 
-	public function getMountPoint($path) {
200 
-		return Filesystem::getMountPoint($this->getAbsolutePath($path));
201 
-	}
202 
-
203 
-	/**
204 
-	 * get the mountpoint of the storage object for a path
205 
-	 * ( note: because a storage is not always mounted inside the fakeroot, the
206 
-	 * returned mountpoint is relative to the absolute root of the filesystem
207 
-	 * and does not take the chroot into account )
208 
-	 *
209 
-	 * @param string $path
210 
-	 * @return \OCP\Files\Mount\IMountPoint
211 
-	 */
212 
-	public function getMount($path) {
213 
-		return Filesystem::getMountManager()->find($this->getAbsolutePath($path));
214 
-	}
215 
-
216 
-	/**
217 
-	 * resolve a path to a storage and internal path
218 
-	 *
219 
-	 * @param string $path
220 
-	 * @return array an array consisting of the storage and the internal path
221 
-	 */
222 
-	public function resolvePath($path) {
223 
-		$a = $this->getAbsolutePath($path);
224 
-		$p = Filesystem::normalizePath($a);
225 
-		return Filesystem::resolvePath($p);
226 
-	}
227 
-
228 
-	/**
229 
-	 * return the path to a local version of the file
230 
-	 * we need this because we can't know if a file is stored local or not from
231 
-	 * outside the filestorage and for some purposes a local file is needed
232 
-	 *
233 
-	 * @param string $path
234 
-	 * @return string
235 
-	 */
236 
-	public function getLocalFile($path) {
237 
-		$parent = substr($path, 0, strrpos($path, '/'));
238 
-		$path = $this->getAbsolutePath($path);
239 
-		list($storage, $internalPath) = Filesystem::resolvePath($path);
240 
-		if (Filesystem::isValidPath($parent) and $storage) {
241 
-			return $storage->getLocalFile($internalPath);
242 
-		} else {
243 
-			return null;
244 
-		}
245 
-	}
246 
-
247 
-	/**
248 
-	 * @param string $path
249 
-	 * @return string
250 
-	 */
251 
-	public function getLocalFolder($path) {
252 
-		$parent = substr($path, 0, strrpos($path, '/'));
253 
-		$path = $this->getAbsolutePath($path);
254 
-		list($storage, $internalPath) = Filesystem::resolvePath($path);
255 
-		if (Filesystem::isValidPath($parent) and $storage) {
256 
-			return $storage->getLocalFolder($internalPath);
257 
-		} else {
258 
-			return null;
259 
-		}
260 
-	}
261 
-
262 
-	/**
263 
-	 * the following functions operate with arguments and return values identical
264 
-	 * to those of their PHP built-in equivalents. Mostly they are merely wrappers
265 
-	 * for \OC\Files\Storage\Storage via basicOperation().
266 
-	 */
267 
-	public function mkdir($path) {
268 
-		return $this->basicOperation('mkdir', $path, array('create', 'write'));
269 
-	}
270 
-
271 
-	/**
272 
-	 * remove mount point
273 
-	 *
274 
-	 * @param \OC\Files\Mount\MoveableMount $mount
275 
-	 * @param string $path relative to data/
276 
-	 * @return boolean
277 
-	 */
278 
-	protected function removeMount($mount, $path) {
279 
-		if ($mount instanceof MoveableMount) {
280 
-			// cut of /user/files to get the relative path to data/user/files
281 
-			$pathParts = explode('/', $path, 4);
282 
-			$relPath = '/' . $pathParts[3];
283 
-			$this->lockFile($relPath, ILockingProvider::LOCK_SHARED, true);
284 
-			\OC_Hook::emit(
285 
-				Filesystem::CLASSNAME, "umount",
286 
-				array(Filesystem::signal_param_path => $relPath)
287 
-			);
288 
-			$this->changeLock($relPath, ILockingProvider::LOCK_EXCLUSIVE, true);
289 
-			$result = $mount->removeMount();
290 
-			$this->changeLock($relPath, ILockingProvider::LOCK_SHARED, true);
291 
-			if ($result) {
292 
-				\OC_Hook::emit(
293 
-					Filesystem::CLASSNAME, "post_umount",
294 
-					array(Filesystem::signal_param_path => $relPath)
295 
-				);
296 
-			}
297 
-			$this->unlockFile($relPath, ILockingProvider::LOCK_SHARED, true);
298 
-			return $result;
299 
-		} else {
300 
-			// do not allow deleting the storage's root / the mount point
301 
-			// because for some storages it might delete the whole contents
302 
-			// but isn't supposed to work that way
303 
-			return false;
304 
-		}
305 
-	}
306 
-
307 
-	public function disableCacheUpdate() {
308 
-		$this->updaterEnabled = false;
309 
-	}
310 
-
311 
-	public function enableCacheUpdate() {
312 
-		$this->updaterEnabled = true;
313 
-	}
314 
-
315 
-	protected function writeUpdate(Storage $storage, $internalPath, $time = null) {
316 
-		if ($this->updaterEnabled) {
317 
-			if (is_null($time)) {
318 
-				$time = time();
319 
-			}
320 
-			$storage->getUpdater()->update($internalPath, $time);
321 
-		}
322 
-	}
323 
-
324 
-	protected function removeUpdate(Storage $storage, $internalPath) {
325 
-		if ($this->updaterEnabled) {
326 
-			$storage->getUpdater()->remove($internalPath);
327 
-		}
328 
-	}
329 
-
330 
-	protected function renameUpdate(Storage $sourceStorage, Storage $targetStorage, $sourceInternalPath, $targetInternalPath) {
331 
-		if ($this->updaterEnabled) {
332 
-			$targetStorage->getUpdater()->renameFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath);
333 
-		}
334 
-	}
335 
-
336 
-	/**
337 
-	 * @param string $path
338 
-	 * @return bool|mixed
339 
-	 */
340 
-	public function rmdir($path) {
341 
-		$absolutePath = $this->getAbsolutePath($path);
342 
-		$mount = Filesystem::getMountManager()->find($absolutePath);
343 
-		if ($mount->getInternalPath($absolutePath) === '') {
344 
-			return $this->removeMount($mount, $absolutePath);
345 
-		}
346 
-		if ($this->is_dir($path)) {
347 
-			$result = $this->basicOperation('rmdir', $path, array('delete'));
348 
-		} else {
349 
-			$result = false;
350 
-		}
351 
-
352 
-		if (!$result && !$this->file_exists($path)) { //clear ghost files from the cache on delete
353 
-			$storage = $mount->getStorage();
354 
-			$internalPath = $mount->getInternalPath($absolutePath);
355 
-			$storage->getUpdater()->remove($internalPath);
356 
-		}
357 
-		return $result;
358 
-	}
359 
-
360 
-	/**
361 
-	 * @param string $path
362 
-	 * @return resource
363 
-	 */
364 
-	public function opendir($path) {
365 
-		return $this->basicOperation('opendir', $path, array('read'));
366 
-	}
367 
-
368 
-	/**
369 
-	 * @param string $path
370 
-	 * @return bool|mixed
371 
-	 */
372 
-	public function is_dir($path) {
373 
-		if ($path == '/') {
374 
-			return true;
375 
-		}
376 
-		return $this->basicOperation('is_dir', $path);
377 
-	}
378 
-
379 
-	/**
380 
-	 * @param string $path
381 
-	 * @return bool|mixed
382 
-	 */
383 
-	public function is_file($path) {
384 
-		if ($path == '/') {
385 
-			return false;
386 
-		}
387 
-		return $this->basicOperation('is_file', $path);
388 
-	}
389 
-
390 
-	/**
391 
-	 * @param string $path
392 
-	 * @return mixed
393 
-	 */
394 
-	public function stat($path) {
395 
-		return $this->basicOperation('stat', $path);
396 
-	}
397 
-
398 
-	/**
399 
-	 * @param string $path
400 
-	 * @return mixed
401 
-	 */
402 
-	public function filetype($path) {
403 
-		return $this->basicOperation('filetype', $path);
404 
-	}
405 
-
406 
-	/**
407 
-	 * @param string $path
408 
-	 * @return mixed
409 
-	 */
410 
-	public function filesize($path) {
411 
-		return $this->basicOperation('filesize', $path);
412 
-	}
413 
-
414 
-	/**
415 
-	 * @param string $path
416 
-	 * @return bool|mixed
417 
-	 * @throws \OCP\Files\InvalidPathException
418 
-	 */
419 
-	public function readfile($path) {
420 
-		$this->assertPathLength($path);
421 
-		@ob_end_clean();
422 
-		$handle = $this->fopen($path, 'rb');
423 
-		if ($handle) {
424 
-			$chunkSize = 8192; // 8 kB chunks
425 
-			while (!feof($handle)) {
426 
-				echo fread($handle, $chunkSize);
427 
-				flush();
428 
-			}
429 
-			fclose($handle);
430 
-			return $this->filesize($path);
431 
-		}
432 
-		return false;
433 
-	}
434 
-
435 
-	/**
436 
-	 * @param string $path
437 
-	 * @param int $from
438 
-	 * @param int $to
439 
-	 * @return bool|mixed
440 
-	 * @throws \OCP\Files\InvalidPathException
441 
-	 * @throws \OCP\Files\UnseekableException
442 
-	 */
443 
-	public function readfilePart($path, $from, $to) {
444 
-		$this->assertPathLength($path);
445 
-		@ob_end_clean();
446 
-		$handle = $this->fopen($path, 'rb');
447 
-		if ($handle) {
448 
-			$chunkSize = 8192; // 8 kB chunks
449 
-			$startReading = true;
450 
-
451 
-			if ($from !== 0 && $from !== '0' && fseek($handle, $from) !== 0) {
452 
-				// forward file handle via chunked fread because fseek seem to have failed
453 
-
454 
-				$end = $from + 1;
455 
-				while (!feof($handle) && ftell($handle) < $end) {
456 
-					$len = $from - ftell($handle);
457 
-					if ($len > $chunkSize) {
458 
-						$len = $chunkSize;
459 
-					}
460 
-					$result = fread($handle, $len);
461 
-
462 
-					if ($result === false) {
463 
-						$startReading = false;
464 
-						break;
465 
-					}
466 
-				}
467 
-			}
468 
-
469 
-			if ($startReading) {
470 
-				$end = $to + 1;
471 
-				while (!feof($handle) && ftell($handle) < $end) {
472 
-					$len = $end - ftell($handle);
473 
-					if ($len > $chunkSize) {
474 
-						$len = $chunkSize;
475 
-					}
476 
-					echo fread($handle, $len);
477 
-					flush();
478 
-				}
479 
-				return ftell($handle) - $from;
480 
-			}
481 
-
482 
-			throw new \OCP\Files\UnseekableException('fseek error');
483 
-		}
484 
-		return false;
485 
-	}
486 
-
487 
-	/**
488 
-	 * @param string $path
489 
-	 * @return mixed
490 
-	 */
491 
-	public function isCreatable($path) {
492 
-		return $this->basicOperation('isCreatable', $path);
493 
-	}
494 
-
495 
-	/**
496 
-	 * @param string $path
497 
-	 * @return mixed
498 
-	 */
499 
-	public function isReadable($path) {
500 
-		return $this->basicOperation('isReadable', $path);
501 
-	}
502 
-
503 
-	/**
504 
-	 * @param string $path
505 
-	 * @return mixed
506 
-	 */
507 
-	public function isUpdatable($path) {
508 
-		return $this->basicOperation('isUpdatable', $path);
509 
-	}
510 
-
511 
-	/**
512 
-	 * @param string $path
513 
-	 * @return bool|mixed
514 
-	 */
515 
-	public function isDeletable($path) {
516 
-		$absolutePath = $this->getAbsolutePath($path);
517 
-		$mount = Filesystem::getMountManager()->find($absolutePath);
518 
-		if ($mount->getInternalPath($absolutePath) === '') {
519 
-			return $mount instanceof MoveableMount;
520 
-		}
521 
-		return $this->basicOperation('isDeletable', $path);
522 
-	}
523 
-
524 
-	/**
525 
-	 * @param string $path
526 
-	 * @return mixed
527 
-	 */
528 
-	public function isSharable($path) {
529 
-		return $this->basicOperation('isSharable', $path);
530 
-	}
531 
-
532 
-	/**
533 
-	 * @param string $path
534 
-	 * @return bool|mixed
535 
-	 */
536 
-	public function file_exists($path) {
537 
-		if ($path == '/') {
538 
-			return true;
539 
-		}
540 
-		return $this->basicOperation('file_exists', $path);
541 
-	}
542 
-
543 
-	/**
544 
-	 * @param string $path
545 
-	 * @return mixed
546 
-	 */
547 
-	public function filemtime($path) {
548 
-		return $this->basicOperation('filemtime', $path);
549 
-	}
550 
-
551 
-	/**
552 
-	 * @param string $path
553 
-	 * @param int|string $mtime
554 
-	 * @return bool
555 
-	 */
556 
-	public function touch($path, $mtime = null) {
557 
-		if (!is_null($mtime) and !is_numeric($mtime)) {
558 
-			$mtime = strtotime($mtime);
559 
-		}
560 
-
561 
-		$hooks = array('touch');
562 
-
563 
-		if (!$this->file_exists($path)) {
564 
-			$hooks[] = 'create';
565 
-			$hooks[] = 'write';
566 
-		}
567 
-		$result = $this->basicOperation('touch', $path, $hooks, $mtime);
568 
-		if (!$result) {
569 
-			// If create file fails because of permissions on external storage like SMB folders,
570 
-			// check file exists and return false if not.
571 
-			if (!$this->file_exists($path)) {
572 
-				return false;
573 
-			}
574 
-			if (is_null($mtime)) {
575 
-				$mtime = time();
576 
-			}
577 
-			//if native touch fails, we emulate it by changing the mtime in the cache
578 
-			$this->putFileInfo($path, array('mtime' => floor($mtime)));
579 
-		}
580 
-		return true;
581 
-	}
582 
-
583 
-	/**
584 
-	 * @param string $path
585 
-	 * @return mixed
586 
-	 */
587 
-	public function file_get_contents($path) {
588 
-		return $this->basicOperation('file_get_contents', $path, array('read'));
589 
-	}
590 
-
591 
-	/**
592 
-	 * @param bool $exists
593 
-	 * @param string $path
594 
-	 * @param bool $run
595 
-	 */
596 
-	protected function emit_file_hooks_pre($exists, $path, &$run) {
597 
-		if (!$exists) {
598 
-			\OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_create, array(
599 
-				Filesystem::signal_param_path => $this->getHookPath($path),
600 
-				Filesystem::signal_param_run => &$run,
601 
-			));
602 
-		} else {
603 
-			\OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_update, array(
604 
-				Filesystem::signal_param_path => $this->getHookPath($path),
605 
-				Filesystem::signal_param_run => &$run,
606 
-			));
607 
-		}
608 
-		\OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_write, array(
609 
-			Filesystem::signal_param_path => $this->getHookPath($path),
610 
-			Filesystem::signal_param_run => &$run,
611 
-		));
612 
-	}
613 
-
614 
-	/**
615 
-	 * @param bool $exists
616 
-	 * @param string $path
617 
-	 */
618 
-	protected function emit_file_hooks_post($exists, $path) {
619 
-		if (!$exists) {
620 
-			\OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_post_create, array(
621 
-				Filesystem::signal_param_path => $this->getHookPath($path),
622 
-			));
623 
-		} else {
624 
-			\OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_post_update, array(
625 
-				Filesystem::signal_param_path => $this->getHookPath($path),
626 
-			));
627 
-		}
628 
-		\OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_post_write, array(
629 
-			Filesystem::signal_param_path => $this->getHookPath($path),
630 
-		));
631 
-	}
632 
-
633 
-	/**
634 
-	 * @param string $path
635 
-	 * @param mixed $data
636 
-	 * @return bool|mixed
637 
-	 * @throws \Exception
638 
-	 */
639 
-	public function file_put_contents($path, $data) {
640 
-		if (is_resource($data)) { //not having to deal with streams in file_put_contents makes life easier
641 
-			$absolutePath = Filesystem::normalizePath($this->getAbsolutePath($path));
642 
-			if (Filesystem::isValidPath($path)
643 
-				and !Filesystem::isFileBlacklisted($path)
644 
-			) {
645 
-				$path = $this->getRelativePath($absolutePath);
646 
-
647 
-				$this->lockFile($path, ILockingProvider::LOCK_SHARED);
648 
-
649 
-				$exists = $this->file_exists($path);
650 
-				$run = true;
651 
-				if ($this->shouldEmitHooks($path)) {
652 
-					$this->emit_file_hooks_pre($exists, $path, $run);
653 
-				}
654 
-				if (!$run) {
655 
-					$this->unlockFile($path, ILockingProvider::LOCK_SHARED);
656 
-					return false;
657 
-				}
658 
-
659 
-				$this->changeLock($path, ILockingProvider::LOCK_EXCLUSIVE);
660 
-
661 
-				/** @var \OC\Files\Storage\Storage $storage */
662 
-				list($storage, $internalPath) = $this->resolvePath($path);
663 
-				$target = $storage->fopen($internalPath, 'w');
664 
-				if ($target) {
665 
-					list (, $result) = \OC_Helper::streamCopy($data, $target);
666 
-					fclose($target);
667 
-					fclose($data);
668 
-
669 
-					$this->writeUpdate($storage, $internalPath);
670 
-
671 
-					$this->changeLock($path, ILockingProvider::LOCK_SHARED);
672 
-
673 
-					if ($this->shouldEmitHooks($path) && $result !== false) {
674 
-						$this->emit_file_hooks_post($exists, $path);
675 
-					}
676 
-					$this->unlockFile($path, ILockingProvider::LOCK_SHARED);
677 
-					return $result;
678 
-				} else {
679 
-					$this->unlockFile($path, ILockingProvider::LOCK_EXCLUSIVE);
680 
-					return false;
681 
-				}
682 
-			} else {
683 
-				return false;
684 
-			}
685 
-		} else {
686 
-			$hooks = $this->file_exists($path) ? array('update', 'write') : array('create', 'write');
687 
-			return $this->basicOperation('file_put_contents', $path, $hooks, $data);
688 
-		}
689 
-	}
690 
-
691 
-	/**
692 
-	 * @param string $path
693 
-	 * @return bool|mixed
694 
-	 */
695 
-	public function unlink($path) {
696 
-		if ($path === '' || $path === '/') {
697 
-			// do not allow deleting the root
698 
-			return false;
699 
-		}
700 
-		$postFix = (substr($path, -1) === '/') ? '/' : '';
701 
-		$absolutePath = Filesystem::normalizePath($this->getAbsolutePath($path));
702 
-		$mount = Filesystem::getMountManager()->find($absolutePath . $postFix);
703 
-		if ($mount and $mount->getInternalPath($absolutePath) === '') {
704 
-			return $this->removeMount($mount, $absolutePath);
705 
-		}
706 
-		if ($this->is_dir($path)) {
707 
-			$result = $this->basicOperation('rmdir', $path, ['delete']);
708 
-		} else {
709 
-			$result = $this->basicOperation('unlink', $path, ['delete']);
710 
-		}
711 
-		if (!$result && !$this->file_exists($path)) { //clear ghost files from the cache on delete
712 
-			$storage = $mount->getStorage();
713 
-			$internalPath = $mount->getInternalPath($absolutePath);
714 
-			$storage->getUpdater()->remove($internalPath);
715 
-			return true;
716 
-		} else {
717 
-			return $result;
718 
-		}
719 
-	}
720 
-
721 
-	/**
722 
-	 * @param string $directory
723 
-	 * @return bool|mixed
724 
-	 */
725 
-	public function deleteAll($directory) {
726 
-		return $this->rmdir($directory);
727 
-	}
728 
-
729 
-	/**
730 
-	 * Rename/move a file or folder from the source path to target path.
731 
-	 *
732 
-	 * @param string $path1 source path
733 
-	 * @param string $path2 target path
734 
-	 *
735 
-	 * @return bool|mixed
736 
-	 */
737 
-	public function rename($path1, $path2) {
738 
-		$absolutePath1 = Filesystem::normalizePath($this->getAbsolutePath($path1));
739 
-		$absolutePath2 = Filesystem::normalizePath($this->getAbsolutePath($path2));
740 
-		$result = false;
741 
-		if (
742 
-			Filesystem::isValidPath($path2)
743 
-			and Filesystem::isValidPath($path1)
744 
-			and !Filesystem::isFileBlacklisted($path2)
745 
-		) {
746 
-			$path1 = $this->getRelativePath($absolutePath1);
747 
-			$path2 = $this->getRelativePath($absolutePath2);
748 
-			$exists = $this->file_exists($path2);
749 
-
750 
-			if ($path1 == null or $path2 == null) {
751 
-				return false;
752 
-			}
753 
-
754 
-			$this->lockFile($path1, ILockingProvider::LOCK_SHARED, true);
755 
-			try {
756 
-				$this->lockFile($path2, ILockingProvider::LOCK_SHARED, true);
757 
-
758 
-				$run = true;
759 
-				if ($this->shouldEmitHooks($path1) && (Cache\Scanner::isPartialFile($path1) && !Cache\Scanner::isPartialFile($path2))) {
760 
-					// if it was a rename from a part file to a regular file it was a write and not a rename operation
761 
-					$this->emit_file_hooks_pre($exists, $path2, $run);
762 
-				} elseif ($this->shouldEmitHooks($path1)) {
763 
-					\OC_Hook::emit(
764 
-						Filesystem::CLASSNAME, Filesystem::signal_rename,
765 
-						array(
766 
-							Filesystem::signal_param_oldpath => $this->getHookPath($path1),
767 
-							Filesystem::signal_param_newpath => $this->getHookPath($path2),
768 
-							Filesystem::signal_param_run => &$run
769 
-						)
770 
-					);
771 
-				}
772 
-				if ($run) {
773 
-					$this->verifyPath(dirname($path2), basename($path2));
774 
-
775 
-					$manager = Filesystem::getMountManager();
776 
-					$mount1 = $this->getMount($path1);
777 
-					$mount2 = $this->getMount($path2);
778 
-					$storage1 = $mount1->getStorage();
779 
-					$storage2 = $mount2->getStorage();
780 
-					$internalPath1 = $mount1->getInternalPath($absolutePath1);
781 
-					$internalPath2 = $mount2->getInternalPath($absolutePath2);
782 
-
783 
-					$this->changeLock($path1, ILockingProvider::LOCK_EXCLUSIVE, true);
784 
-					try {
785 
-						$this->changeLock($path2, ILockingProvider::LOCK_EXCLUSIVE, true);
786 
-
787 
-						if ($internalPath1 === '') {
788 
-							if ($mount1 instanceof MoveableMount) {
789 
-								if ($this->isTargetAllowed($absolutePath2)) {
790 
-									/**
791 
-									 * @var \OC\Files\Mount\MountPoint | \OC\Files\Mount\MoveableMount $mount1
792 
-									 */
793 
-									$sourceMountPoint = $mount1->getMountPoint();
794 
-									$result = $mount1->moveMount($absolutePath2);
795 
-									$manager->moveMount($sourceMountPoint, $mount1->getMountPoint());
796 
-								} else {
797 
-									$result = false;
798 
-								}
799 
-							} else {
800 
-								$result = false;
801 
-							}
802 
-							// moving a file/folder within the same mount point
803 
-						} elseif ($storage1 === $storage2) {
804 
-							if ($storage1) {
805 
-								$result = $storage1->rename($internalPath1, $internalPath2);
806 
-							} else {
807 
-								$result = false;
808 
-							}
809 
-							// moving a file/folder between storages (from $storage1 to $storage2)
810 
-						} else {
811 
-							$result = $storage2->moveFromStorage($storage1, $internalPath1, $internalPath2);
812 
-						}
813 
-
814 
-						if ((Cache\Scanner::isPartialFile($path1) && !Cache\Scanner::isPartialFile($path2)) && $result !== false) {
815 
-							// if it was a rename from a part file to a regular file it was a write and not a rename operation
816 
-							$this->writeUpdate($storage2, $internalPath2);
817 
-						} else if ($result) {
818 
-							if ($internalPath1 !== '') { // don't do a cache update for moved mounts
819 
-								$this->renameUpdate($storage1, $storage2, $internalPath1, $internalPath2);
820 
-							}
821 
-						}
822 
-					} catch(\Exception $e) {
823 
-						throw $e;
824 
-					} finally {
825 
-						$this->changeLock($path1, ILockingProvider::LOCK_SHARED, true);
826 
-						$this->changeLock($path2, ILockingProvider::LOCK_SHARED, true);
827 
-					}
828 
-
829 
-					if ((Cache\Scanner::isPartialFile($path1) && !Cache\Scanner::isPartialFile($path2)) && $result !== false) {
830 
-						if ($this->shouldEmitHooks()) {
831 
-							$this->emit_file_hooks_post($exists, $path2);
832 
-						}
833 
-					} elseif ($result) {
834 
-						if ($this->shouldEmitHooks($path1) and $this->shouldEmitHooks($path2)) {
835 
-							\OC_Hook::emit(
836 
-								Filesystem::CLASSNAME,
837 
-								Filesystem::signal_post_rename,
838 
-								array(
839 
-									Filesystem::signal_param_oldpath => $this->getHookPath($path1),
840 
-									Filesystem::signal_param_newpath => $this->getHookPath($path2)
841 
-								)
842 
-							);
843 
-						}
844 
-					}
845 
-				}
846 
-			} catch(\Exception $e) {
847 
-				throw $e;
848 
-			} finally {
849 
-				$this->unlockFile($path1, ILockingProvider::LOCK_SHARED, true);
850 
-				$this->unlockFile($path2, ILockingProvider::LOCK_SHARED, true);
851 
-			}
852 
-		}
853 
-		return $result;
854 
-	}
855 
-
856 
-	/**
857 
-	 * Copy a file/folder from the source path to target path
858 
-	 *
859 
-	 * @param string $path1 source path
860 
-	 * @param string $path2 target path
861 
-	 * @param bool $preserveMtime whether to preserve mtime on the copy
862 
-	 *
863 
-	 * @return bool|mixed
864 
-	 */
865 
-	public function copy($path1, $path2, $preserveMtime = false) {
866 
-		$absolutePath1 = Filesystem::normalizePath($this->getAbsolutePath($path1));
867 
-		$absolutePath2 = Filesystem::normalizePath($this->getAbsolutePath($path2));
868 
-		$result = false;
869 
-		if (
870 
-			Filesystem::isValidPath($path2)
871 
-			and Filesystem::isValidPath($path1)
872 
-			and !Filesystem::isFileBlacklisted($path2)
873 
-		) {
874 
-			$path1 = $this->getRelativePath($absolutePath1);
875 
-			$path2 = $this->getRelativePath($absolutePath2);
876 
-
877 
-			if ($path1 == null or $path2 == null) {
878 
-				return false;
879 
-			}
880 
-			$run = true;
881 
-
882 
-			$this->lockFile($path2, ILockingProvider::LOCK_SHARED);
883 
-			$this->lockFile($path1, ILockingProvider::LOCK_SHARED);
884 
-			$lockTypePath1 = ILockingProvider::LOCK_SHARED;
885 
-			$lockTypePath2 = ILockingProvider::LOCK_SHARED;
886 
-
887 
-			try {
888 
-
889 
-				$exists = $this->file_exists($path2);
890 
-				if ($this->shouldEmitHooks()) {
891 
-					\OC_Hook::emit(
892 
-						Filesystem::CLASSNAME,
893 
-						Filesystem::signal_copy,
894 
-						array(
895 
-							Filesystem::signal_param_oldpath => $this->getHookPath($path1),
896 
-							Filesystem::signal_param_newpath => $this->getHookPath($path2),
897 
-							Filesystem::signal_param_run => &$run
898 
-						)
899 
-					);
900 
-					$this->emit_file_hooks_pre($exists, $path2, $run);
901 
-				}
902 
-				if ($run) {
903 
-					$mount1 = $this->getMount($path1);
904 
-					$mount2 = $this->getMount($path2);
905 
-					$storage1 = $mount1->getStorage();
906 
-					$internalPath1 = $mount1->getInternalPath($absolutePath1);
907 
-					$storage2 = $mount2->getStorage();
908 
-					$internalPath2 = $mount2->getInternalPath($absolutePath2);
909 
-
910 
-					$this->changeLock($path2, ILockingProvider::LOCK_EXCLUSIVE);
911 
-					$lockTypePath2 = ILockingProvider::LOCK_EXCLUSIVE;
912 
-
913 
-					if ($mount1->getMountPoint() == $mount2->getMountPoint()) {
914 
-						if ($storage1) {
915 
-							$result = $storage1->copy($internalPath1, $internalPath2);
916 
-						} else {
917 
-							$result = false;
918 
-						}
919 
-					} else {
920 
-						$result = $storage2->copyFromStorage($storage1, $internalPath1, $internalPath2);
921 
-					}
922 
-
923 
-					$this->writeUpdate($storage2, $internalPath2);
924 
-
925 
-					$this->changeLock($path2, ILockingProvider::LOCK_SHARED);
926 
-					$lockTypePath2 = ILockingProvider::LOCK_SHARED;
927 
-
928 
-					if ($this->shouldEmitHooks() && $result !== false) {
929 
-						\OC_Hook::emit(
930 
-							Filesystem::CLASSNAME,
931 
-							Filesystem::signal_post_copy,
932 
-							array(
933 
-								Filesystem::signal_param_oldpath => $this->getHookPath($path1),
934 
-								Filesystem::signal_param_newpath => $this->getHookPath($path2)
935 
-							)
936 
-						);
937 
-						$this->emit_file_hooks_post($exists, $path2);
938 
-					}
939 
-
940 
-				}
941 
-			} catch (\Exception $e) {
942 
-				$this->unlockFile($path2, $lockTypePath2);
943 
-				$this->unlockFile($path1, $lockTypePath1);
944 
-				throw $e;
945 
-			}
946 
-
947 
-			$this->unlockFile($path2, $lockTypePath2);
948 
-			$this->unlockFile($path1, $lockTypePath1);
949 
-
950 
-		}
951 
-		return $result;
952 
-	}
953 
-
954 
-	/**
955 
-	 * @param string $path
956 
-	 * @param string $mode 'r' or 'w'
957 
-	 * @return resource
958 
-	 */
959 
-	public function fopen($path, $mode) {
960 
-		$mode = str_replace('b', '', $mode); // the binary flag is a windows only feature which we do not support
961 
-		$hooks = array();
962 
-		switch ($mode) {
963 
-			case 'r':
964 
-				$hooks[] = 'read';
965 
-				break;
966 
-			case 'r+':
967 
-			case 'w+':
968 
-			case 'x+':
969 
-			case 'a+':
970 
-				$hooks[] = 'read';
971 
-				$hooks[] = 'write';
972 
-				break;
973 
-			case 'w':
974 
-			case 'x':
975 
-			case 'a':
976 
-				$hooks[] = 'write';
977 
-				break;
978 
-			default:
979 
-				\OCP\Util::writeLog('core', 'invalid mode (' . $mode . ') for ' . $path, ILogger::ERROR);
980 
-		}
981 
-
982 
-		if ($mode !== 'r' && $mode !== 'w') {
983 
-			\OC::$server->getLogger()->info('Trying to open a file with a mode other than "r" or "w" can cause severe performance issues with some backends');
984 
-		}
985 
-
986 
-		return $this->basicOperation('fopen', $path, $hooks, $mode);
987 
-	}
988 
-
989 
-	/**
990 
-	 * @param string $path
991 
-	 * @return bool|string
992 
-	 * @throws \OCP\Files\InvalidPathException
993 
-	 */
994 
-	public function toTmpFile($path) {
995 
-		$this->assertPathLength($path);
996 
-		if (Filesystem::isValidPath($path)) {
997 
-			$source = $this->fopen($path, 'r');
998 
-			if ($source) {
999 
-				$extension = pathinfo($path, PATHINFO_EXTENSION);
1000 
-				$tmpFile = \OC::$server->getTempManager()->getTemporaryFile($extension);
1001 
-				file_put_contents($tmpFile, $source);
1002 
-				return $tmpFile;
1003 
-			} else {
1004 
-				return false;
1005 
-			}
1006 
-		} else {
1007 
-			return false;
1008 
-		}
1009 
-	}
1010 
-
1011 
-	/**
1012 
-	 * @param string $tmpFile
1013 
-	 * @param string $path
1014 
-	 * @return bool|mixed
1015 
-	 * @throws \OCP\Files\InvalidPathException
1016 
-	 */
1017 
-	public function fromTmpFile($tmpFile, $path) {
1018 
-		$this->assertPathLength($path);
1019 
-		if (Filesystem::isValidPath($path)) {
1020 
-
1021 
-			// Get directory that the file is going into
1022 
-			$filePath = dirname($path);
1023 
-
1024 
-			// Create the directories if any
1025 
-			if (!$this->file_exists($filePath)) {
1026 
-				$result = $this->createParentDirectories($filePath);
1027 
-				if ($result === false) {
1028 
-					return false;
1029 
-				}
1030 
-			}
1031 
-
1032 
-			$source = fopen($tmpFile, 'r');
1033 
-			if ($source) {
1034 
-				$result = $this->file_put_contents($path, $source);
1035 
-				// $this->file_put_contents() might have already closed
1036 
-				// the resource, so we check it, before trying to close it
1037 
-				// to avoid messages in the error log.
1038 
-				if (is_resource($source)) {
1039 
-					fclose($source);
1040 
-				}
1041 
-				unlink($tmpFile);
1042 
-				return $result;
1043 
-			} else {
1044 
-				return false;
1045 
-			}
1046 
-		} else {
1047 
-			return false;
1048 
-		}
1049 
-	}
1050 
-
1051 
-
1052 
-	/**
1053 
-	 * @param string $path
1054 
-	 * @return mixed
1055 
-	 * @throws \OCP\Files\InvalidPathException
1056 
-	 */
1057 
-	public function getMimeType($path) {
1058 
-		$this->assertPathLength($path);
1059 
-		return $this->basicOperation('getMimeType', $path);
1060 
-	}
1061 
-
1062 
-	/**
1063 
-	 * @param string $type
1064 
-	 * @param string $path
1065 
-	 * @param bool $raw
1066 
-	 * @return bool|null|string
1067 
-	 */
1068 
-	public function hash($type, $path, $raw = false) {
1069 
-		$postFix = (substr($path, -1) === '/') ? '/' : '';
1070 
-		$absolutePath = Filesystem::normalizePath($this->getAbsolutePath($path));
1071 
-		if (Filesystem::isValidPath($path)) {
1072 
-			$path = $this->getRelativePath($absolutePath);
1073 
-			if ($path == null) {
1074 
-				return false;
1075 
-			}
1076 
-			if ($this->shouldEmitHooks($path)) {
1077 
-				\OC_Hook::emit(
1078 
-					Filesystem::CLASSNAME,
1079 
-					Filesystem::signal_read,
1080 
-					array(Filesystem::signal_param_path => $this->getHookPath($path))
1081 
-				);
1082 
-			}
1083 
-			list($storage, $internalPath) = Filesystem::resolvePath($absolutePath . $postFix);
1084 
-			if ($storage) {
1085 
-				return $storage->hash($type, $internalPath, $raw);
1086 
-			}
1087 
-		}
1088 
-		return null;
1089 
-	}
1090 
-
1091 
-	/**
1092 
-	 * @param string $path
1093 
-	 * @return mixed
1094 
-	 * @throws \OCP\Files\InvalidPathException
1095 
-	 */
1096 
-	public function free_space($path = '/') {
1097 
-		$this->assertPathLength($path);
1098 
-		$result = $this->basicOperation('free_space', $path);
1099 
-		if ($result === null) {
1100 
-			throw new InvalidPathException();
1101 
-		}
1102 
-		return $result;
1103 
-	}
1104 
-
1105 
-	/**
1106 
-	 * abstraction layer for basic filesystem functions: wrapper for \OC\Files\Storage\Storage
1107 
-	 *
1108 
-	 * @param string $operation
1109 
-	 * @param string $path
1110 
-	 * @param array $hooks (optional)
1111 
-	 * @param mixed $extraParam (optional)
1112 
-	 * @return mixed
1113 
-	 * @throws \Exception
1114 
-	 *
1115 
-	 * This method takes requests for basic filesystem functions (e.g. reading & writing
1116 
-	 * files), processes hooks and proxies, sanitises paths, and finally passes them on to
1117 
-	 * \OC\Files\Storage\Storage for delegation to a storage backend for execution
1118 
-	 */
1119 
-	private function basicOperation($operation, $path, $hooks = [], $extraParam = null) {
1120 
-		$postFix = (substr($path, -1) === '/') ? '/' : '';
1121 
-		$absolutePath = Filesystem::normalizePath($this->getAbsolutePath($path));
1122 
-		if (Filesystem::isValidPath($path)
1123 
-			and !Filesystem::isFileBlacklisted($path)
1124 
-		) {
1125 
-			$path = $this->getRelativePath($absolutePath);
1126 
-			if ($path == null) {
1127 
-				return false;
1128 
-			}
1129 
-
1130 
-			if (in_array('write', $hooks) || in_array('delete', $hooks) || in_array('read', $hooks)) {
1131 
-				// always a shared lock during pre-hooks so the hook can read the file
1132 
-				$this->lockFile($path, ILockingProvider::LOCK_SHARED);
1133 
-			}
1134 
-
1135 
-			$run = $this->runHooks($hooks, $path);
1136 
-			/** @var \OC\Files\Storage\Storage $storage */
1137 
-			list($storage, $internalPath) = Filesystem::resolvePath($absolutePath . $postFix);
1138 
-			if ($run and $storage) {
1139 
-				if (in_array('write', $hooks) || in_array('delete', $hooks)) {
1140 
-					$this->changeLock($path, ILockingProvider::LOCK_EXCLUSIVE);
1141 
-				}
1142 
-				try {
1143 
-					if (!is_null($extraParam)) {
1144 
-						$result = $storage->$operation($internalPath, $extraParam);
1145 
-					} else {
1146 
-						$result = $storage->$operation($internalPath);
1147 
-					}
1148 
-				} catch (\Exception $e) {
1149 
-					if (in_array('write', $hooks) || in_array('delete', $hooks)) {
1150 
-						$this->unlockFile($path, ILockingProvider::LOCK_EXCLUSIVE);
1151 
-					} else if (in_array('read', $hooks)) {
1152 
-						$this->unlockFile($path, ILockingProvider::LOCK_SHARED);
1153 
-					}
1154 
-					throw $e;
1155 
-				}
1156 
-
1157 
-				if ($result && in_array('delete', $hooks) and $result) {
1158 
-					$this->removeUpdate($storage, $internalPath);
1159 
-				}
1160 
-				if ($result && in_array('write', $hooks) and $operation !== 'fopen') {
1161 
-					$this->writeUpdate($storage, $internalPath);
1162 
-				}
1163 
-				if ($result && in_array('touch', $hooks)) {
1164 
-					$this->writeUpdate($storage, $internalPath, $extraParam);
1165 
-				}
1166 
-
1167 
-				if ((in_array('write', $hooks) || in_array('delete', $hooks)) && ($operation !== 'fopen' || $result === false)) {
1168 
-					$this->changeLock($path, ILockingProvider::LOCK_SHARED);
1169 
-				}
1170 
-
1171 
-				$unlockLater = false;
1172 
-				if ($this->lockingEnabled && $operation === 'fopen' && is_resource($result)) {
1173 
-					$unlockLater = true;
1174 
-					// make sure our unlocking callback will still be called if connection is aborted
1175 
-					ignore_user_abort(true);
1176 
-					$result = CallbackWrapper::wrap($result, null, null, function () use ($hooks, $path) {
1177 
-						if (in_array('write', $hooks)) {
1178 
-							$this->unlockFile($path, ILockingProvider::LOCK_EXCLUSIVE);
1179 
-						} else if (in_array('read', $hooks)) {
1180 
-							$this->unlockFile($path, ILockingProvider::LOCK_SHARED);
1181 
-						}
1182 
-					});
1183 
-				}
1184 
-
1185 
-				if ($this->shouldEmitHooks($path) && $result !== false) {
1186 
-					if ($operation != 'fopen') { //no post hooks for fopen, the file stream is still open
1187 
-						$this->runHooks($hooks, $path, true);
1188 
-					}
1189 
-				}
1190 
-
1191 
-				if (!$unlockLater
1192 
-					&& (in_array('write', $hooks) || in_array('delete', $hooks) || in_array('read', $hooks))
1193 
-				) {
1194 
-					$this->unlockFile($path, ILockingProvider::LOCK_SHARED);
1195 
-				}
1196 
-				return $result;
1197 
-			} else {
1198 
-				$this->unlockFile($path, ILockingProvider::LOCK_SHARED);
1199 
-			}
1200 
-		}
1201 
-		return null;
1202 
-	}
1203 
-
1204 
-	/**
1205 
-	 * get the path relative to the default root for hook usage
1206 
-	 *
1207 
-	 * @param string $path
1208 
-	 * @return string
1209 
-	 */
1210 
-	private function getHookPath($path) {
1211 
-		if (!Filesystem::getView()) {
1212 
-			return $path;
1213 
-		}
1214 
-		return Filesystem::getView()->getRelativePath($this->getAbsolutePath($path));
1215 
-	}
1216 
-
1217 
-	private function shouldEmitHooks($path = '') {
1218 
-		if ($path && Cache\Scanner::isPartialFile($path)) {
1219 
-			return false;
1220 
-		}
1221 
-		if (!Filesystem::$loaded) {
1222 
-			return false;
1223 
-		}
1224 
-		$defaultRoot = Filesystem::getRoot();
1225 
-		if ($defaultRoot === null) {
1226 
-			return false;
1227 
-		}
1228 
-		if ($this->fakeRoot === $defaultRoot) {
1229 
-			return true;
1230 
-		}
1231 
-		$fullPath = $this->getAbsolutePath($path);
1232 
-
1233 
-		if ($fullPath === $defaultRoot) {
1234 
-			return true;
1235 
-		}
1236 
-
1237 
-		return (strlen($fullPath) > strlen($defaultRoot)) && (substr($fullPath, 0, strlen($defaultRoot) + 1) === $defaultRoot . '/');
1238 
-	}
1239 
-
1240 
-	/**
1241 
-	 * @param string[] $hooks
1242 
-	 * @param string $path
1243 
-	 * @param bool $post
1244 
-	 * @return bool
1245 
-	 */
1246 
-	private function runHooks($hooks, $path, $post = false) {
1247 
-		$relativePath = $path;
1248 
-		$path = $this->getHookPath($path);
1249 
-		$prefix = $post ? 'post_' : '';
1250 
-		$run = true;
1251 
-		if ($this->shouldEmitHooks($relativePath)) {
1252 
-			foreach ($hooks as $hook) {
1253 
-				if ($hook != 'read') {
1254 
-					\OC_Hook::emit(
1255 
-						Filesystem::CLASSNAME,
1256 
-						$prefix . $hook,
1257 
-						array(
1258 
-							Filesystem::signal_param_run => &$run,
1259 
-							Filesystem::signal_param_path => $path
1260 
-						)
1261 
-					);
1262 
-				} elseif (!$post) {
1263 
-					\OC_Hook::emit(
1264 
-						Filesystem::CLASSNAME,
1265 
-						$prefix . $hook,
1266 
-						array(
1267 
-							Filesystem::signal_param_path => $path
1268 
-						)
1269 
-					);
1270 
-				}
1271 
-			}
1272 
-		}
1273 
-		return $run;
1274 
-	}
1275 
-
1276 
-	/**
1277 
-	 * check if a file or folder has been updated since $time
1278 
-	 *
1279 
-	 * @param string $path
1280 
-	 * @param int $time
1281 
-	 * @return bool
1282 
-	 */
1283 
-	public function hasUpdated($path, $time) {
1284 
-		return $this->basicOperation('hasUpdated', $path, array(), $time);
1285 
-	}
1286 
-
1287 
-	/**
1288 
-	 * @param string $ownerId
1289 
-	 * @return \OC\User\User
1290 
-	 */
1291 
-	private function getUserObjectForOwner($ownerId) {
1292 
-		$owner = $this->userManager->get($ownerId);
1293 
-		if ($owner instanceof IUser) {
1294 
-			return $owner;
1295 
-		} else {
1296 
-			return new User($ownerId, null);
1297 
-		}
1298 
-	}
1299 
-
1300 
-	/**
1301 
-	 * Get file info from cache
1302 
-	 *
1303 
-	 * If the file is not in cached it will be scanned
1304 
-	 * If the file has changed on storage the cache will be updated
1305 
-	 *
1306 
-	 * @param \OC\Files\Storage\Storage $storage
1307 
-	 * @param string $internalPath
1308 
-	 * @param string $relativePath
1309 
-	 * @return ICacheEntry|bool
1310 
-	 */
1311 
-	private function getCacheEntry($storage, $internalPath, $relativePath) {
1312 
-		$cache = $storage->getCache($internalPath);
1313 
-		$data = $cache->get($internalPath);
1314 
-		$watcher = $storage->getWatcher($internalPath);
1315 
-
1316 
-		try {
1317 
-			// if the file is not in the cache or needs to be updated, trigger the scanner and reload the data
1318 
-			if (!$data || $data['size'] === -1) {
1319 
-				$this->lockFile($relativePath, ILockingProvider::LOCK_SHARED);
1320 
-				if (!$storage->file_exists($internalPath)) {
1321 
-					$this->unlockFile($relativePath, ILockingProvider::LOCK_SHARED);
1322 
-					return false;
1323 
-				}
1324 
-				$scanner = $storage->getScanner($internalPath);
1325 
-				$scanner->scan($internalPath, Cache\Scanner::SCAN_SHALLOW);
1326 
-				$data = $cache->get($internalPath);
1327 
-				$this->unlockFile($relativePath, ILockingProvider::LOCK_SHARED);
1328 
-			} else if (!Cache\Scanner::isPartialFile($internalPath) && $watcher->needsUpdate($internalPath, $data)) {
1329 
-				$this->lockFile($relativePath, ILockingProvider::LOCK_SHARED);
1330 
-				$watcher->update($internalPath, $data);
1331 
-				$storage->getPropagator()->propagateChange($internalPath, time());
1332 
-				$data = $cache->get($internalPath);
1333 
-				$this->unlockFile($relativePath, ILockingProvider::LOCK_SHARED);
1334 
-			}
1335 
-		} catch (LockedException $e) {
1336 
-			// if the file is locked we just use the old cache info
1337 
-		}
1338 
-
1339 
-		return $data;
1340 
-	}
1341 
-
1342 
-	/**
1343 
-	 * get the filesystem info
1344 
-	 *
1345 
-	 * @param string $path
1346 
-	 * @param boolean|string $includeMountPoints true to add mountpoint sizes,
1347 
-	 * 'ext' to add only ext storage mount point sizes. Defaults to true.
1348 
-	 * defaults to true
1349 
-	 * @return \OC\Files\FileInfo|false False if file does not exist
1350 
-	 */
1351 
-	public function getFileInfo($path, $includeMountPoints = true) {
1352 
-		$this->assertPathLength($path);
1353 
-		if (!Filesystem::isValidPath($path)) {
1354 
-			return false;
1355 
-		}
1356 
-		if (Cache\Scanner::isPartialFile($path)) {
1357 
-			return $this->getPartFileInfo($path);
1358 
-		}
1359 
-		$relativePath = $path;
1360 
-		$path = Filesystem::normalizePath($this->fakeRoot . '/' . $path);
1361 
-
1362 
-		$mount = Filesystem::getMountManager()->find($path);
1363 
-		if (!$mount) {
1364 
-			return false;
1365 
-		}
1366 
-		$storage = $mount->getStorage();
1367 
-		$internalPath = $mount->getInternalPath($path);
1368 
-		if ($storage) {
1369 
-			$data = $this->getCacheEntry($storage, $internalPath, $relativePath);
1370 
-
1371 
-			if (!$data instanceof ICacheEntry) {
1372 
-				return false;
1373 
-			}
1374 
-
1375 
-			if ($mount instanceof MoveableMount && $internalPath === '') {
1376 
-				$data['permissions'] |= \OCP\Constants::PERMISSION_DELETE;
1377 
-			}
1378 
-
1379 
-			$owner = $this->getUserObjectForOwner($storage->getOwner($internalPath));
1380 
-			$info = new FileInfo($path, $storage, $internalPath, $data, $mount, $owner);
1381 
-
1382 
-			if ($data and isset($data['fileid'])) {
1383 
-				if ($includeMountPoints and $data['mimetype'] === 'httpd/unix-directory') {
1384 
-					//add the sizes of other mount points to the folder
1385 
-					$extOnly = ($includeMountPoints === 'ext');
1386 
-					$mounts = Filesystem::getMountManager()->findIn($path);
1387 
-					$info->setSubMounts(array_filter($mounts, function (IMountPoint $mount) use ($extOnly) {
1388 
-						$subStorage = $mount->getStorage();
1389 
-						return !($extOnly && $subStorage instanceof \OCA\Files_Sharing\SharedStorage);
1390 
-					}));
1391 
-				}
1392 
-			}
1393 
-
1394 
-			return $info;
1395 
-		}
1396 
-
1397 
-		return false;
1398 
-	}
1399 
-
1400 
-	/**
1401 
-	 * get the content of a directory
1402 
-	 *
1403 
-	 * @param string $directory path under datadirectory
1404 
-	 * @param string $mimetype_filter limit returned content to this mimetype or mimepart
1405 
-	 * @return FileInfo[]
1406 
-	 */
1407 
-	public function getDirectoryContent($directory, $mimetype_filter = '') {
1408 
-		$this->assertPathLength($directory);
1409 
-		if (!Filesystem::isValidPath($directory)) {
1410 
-			return [];
1411 
-		}
1412 
-		$path = $this->getAbsolutePath($directory);
1413 
-		$path = Filesystem::normalizePath($path);
1414 
-		$mount = $this->getMount($directory);
1415 
-		if (!$mount) {
1416 
-			return [];
1417 
-		}
1418 
-		$storage = $mount->getStorage();
1419 
-		$internalPath = $mount->getInternalPath($path);
1420 
-		if ($storage) {
1421 
-			$cache = $storage->getCache($internalPath);
1422 
-			$user = \OC_User::getUser();
1423 
-
1424 
-			$data = $this->getCacheEntry($storage, $internalPath, $directory);
1425 
-
1426 
-			if (!$data instanceof ICacheEntry || !isset($data['fileid']) || !($data->getPermissions() && Constants::PERMISSION_READ)) {
1427 
-				return [];
1428 
-			}
1429 
-
1430 
-			$folderId = $data['fileid'];
1431 
-			$contents = $cache->getFolderContentsById($folderId); //TODO: mimetype_filter
1432 
-
1433 
-			$sharingDisabled = \OCP\Util::isSharingDisabledForUser();
1434 
-			/**
1435 
-			 * @var \OC\Files\FileInfo[] $files
1436 
-			 */
1437 
-			$files = array_map(function (ICacheEntry $content) use ($path, $storage, $mount, $sharingDisabled) {
1438 
-				if ($sharingDisabled) {
1439 
-					$content['permissions'] = $content['permissions'] & ~\OCP\Constants::PERMISSION_SHARE;
1440 
-				}
1441 
-				$owner = $this->getUserObjectForOwner($storage->getOwner($content['path']));
1442 
-				return new FileInfo($path . '/' . $content['name'], $storage, $content['path'], $content, $mount, $owner);
1443 
-			}, $contents);
1444 
-
1445 
-			//add a folder for any mountpoint in this directory and add the sizes of other mountpoints to the folders
1446 
-			$mounts = Filesystem::getMountManager()->findIn($path);
1447 
-			$dirLength = strlen($path);
1448 
-			foreach ($mounts as $mount) {
1449 
-				$mountPoint = $mount->getMountPoint();
1450 
-				$subStorage = $mount->getStorage();
1451 
-				if ($subStorage) {
1452 
-					$subCache = $subStorage->getCache('');
1453 
-
1454 
-					$rootEntry = $subCache->get('');
1455 
-					if (!$rootEntry) {
1456 
-						$subScanner = $subStorage->getScanner('');
1457 
-						try {
1458 
-							$subScanner->scanFile('');
1459 
-						} catch (\OCP\Files\StorageNotAvailableException $e) {
1460 
-							continue;
1461 
-						} catch (\OCP\Files\StorageInvalidException $e) {
1462 
-							continue;
1463 
-						} catch (\Exception $e) {
1464 
-							// sometimes when the storage is not available it can be any exception
1465 
-							\OC::$server->getLogger()->logException($e, [
1466 
-								'message' => 'Exception while scanning storage "' . $subStorage->getId() . '"',
1467 
-								'level' => ILogger::ERROR,
1468 
-								'app' => 'lib',
1469 
-							]);
1470 
-							continue;
1471 
-						}
1472 
-						$rootEntry = $subCache->get('');
1473 
-					}
1474 
-
1475 
-					if ($rootEntry && ($rootEntry->getPermissions() && Constants::PERMISSION_READ)) {
1476 
-						$relativePath = trim(substr($mountPoint, $dirLength), '/');
1477 
-						if ($pos = strpos($relativePath, '/')) {
1478 
-							//mountpoint inside subfolder add size to the correct folder
1479 
-							$entryName = substr($relativePath, 0, $pos);
1480 
-							foreach ($files as &$entry) {
1481 
-								if ($entry->getName() === $entryName) {
1482 
-									$entry->addSubEntry($rootEntry, $mountPoint);
1483 
-								}
1484 
-							}
1485 
-						} else { //mountpoint in this folder, add an entry for it
1486 
-							$rootEntry['name'] = $relativePath;
1487 
-							$rootEntry['type'] = $rootEntry['mimetype'] === 'httpd/unix-directory' ? 'dir' : 'file';
1488 
-							$permissions = $rootEntry['permissions'];
1489 
-							// do not allow renaming/deleting the mount point if they are not shared files/folders
1490 
-							// for shared files/folders we use the permissions given by the owner
1491 
-							if ($mount instanceof MoveableMount) {
1492 
-								$rootEntry['permissions'] = $permissions | \OCP\Constants::PERMISSION_UPDATE | \OCP\Constants::PERMISSION_DELETE;
1493 
-							} else {
1494 
-								$rootEntry['permissions'] = $permissions & (\OCP\Constants::PERMISSION_ALL - (\OCP\Constants::PERMISSION_UPDATE | \OCP\Constants::PERMISSION_DELETE));
1495 
-							}
1496 
-
1497 
-							//remove any existing entry with the same name
1498 
-							foreach ($files as $i => $file) {
1499 
-								if ($file['name'] === $rootEntry['name']) {
1500 
-									unset($files[$i]);
1501 
-									break;
1502 
-								}
1503 
-							}
1504 
-							$rootEntry['path'] = substr(Filesystem::normalizePath($path . '/' . $rootEntry['name']), strlen($user) + 2); // full path without /$user/
1505 
-
1506 
-							// if sharing was disabled for the user we remove the share permissions
1507 
-							if (\OCP\Util::isSharingDisabledForUser()) {
1508 
-								$rootEntry['permissions'] = $rootEntry['permissions'] & ~\OCP\Constants::PERMISSION_SHARE;
1509 
-							}
1510 
-
1511 
-							$owner = $this->getUserObjectForOwner($subStorage->getOwner(''));
1512 
-							$files[] = new FileInfo($path . '/' . $rootEntry['name'], $subStorage, '', $rootEntry, $mount, $owner);
1513 
-						}
1514 
-					}
1515 
-				}
1516 
-			}
1517 
-
1518 
-			if ($mimetype_filter) {
1519 
-				$files = array_filter($files, function (FileInfo $file) use ($mimetype_filter) {
1520 
-					if (strpos($mimetype_filter, '/')) {
1521 
-						return $file->getMimetype() === $mimetype_filter;
1522 
-					} else {
1523 
-						return $file->getMimePart() === $mimetype_filter;
1524 
-					}
1525 
-				});
1526 
-			}
1527 
-
1528 
-			return $files;
1529 
-		} else {
1530 
-			return [];
1531 
-		}
1532 
-	}
1533 
-
1534 
-	/**
1535 
-	 * change file metadata
1536 
-	 *
1537 
-	 * @param string $path
1538 
-	 * @param array|\OCP\Files\FileInfo $data
1539 
-	 * @return int
1540 
-	 *
1541 
-	 * returns the fileid of the updated file
1542 
-	 */
1543 
-	public function putFileInfo($path, $data) {
1544 
-		$this->assertPathLength($path);
1545 
-		if ($data instanceof FileInfo) {
1546 
-			$data = $data->getData();
1547 
-		}
1548 
-		$path = Filesystem::normalizePath($this->fakeRoot . '/' . $path);
1549 
-		/**
1550 
-		 * @var \OC\Files\Storage\Storage $storage
1551 
-		 * @var string $internalPath
1552 
-		 */
1553 
-		list($storage, $internalPath) = Filesystem::resolvePath($path);
1554 
-		if ($storage) {
1555 
-			$cache = $storage->getCache($path);
1556 
-
1557 
-			if (!$cache->inCache($internalPath)) {
1558 
-				$scanner = $storage->getScanner($internalPath);
1559 
-				$scanner->scan($internalPath, Cache\Scanner::SCAN_SHALLOW);
1560 
-			}
1561 
-
1562 
-			return $cache->put($internalPath, $data);
1563 
-		} else {
1564 
-			return -1;
1565 
-		}
1566 
-	}
1567 
-
1568 
-	/**
1569 
-	 * search for files with the name matching $query
1570 
-	 *
1571 
-	 * @param string $query
1572 
-	 * @return FileInfo[]
1573 
-	 */
1574 
-	public function search($query) {
1575 
-		return $this->searchCommon('search', array('%' . $query . '%'));
1576 
-	}
1577 
-
1578 
-	/**
1579 
-	 * search for files with the name matching $query
1580 
-	 *
1581 
-	 * @param string $query
1582 
-	 * @return FileInfo[]
1583 
-	 */
1584 
-	public function searchRaw($query) {
1585 
-		return $this->searchCommon('search', array($query));
1586 
-	}
1587 
-
1588 
-	/**
1589 
-	 * search for files by mimetype
1590 
-	 *
1591 
-	 * @param string $mimetype
1592 
-	 * @return FileInfo[]
1593 
-	 */
1594 
-	public function searchByMime($mimetype) {
1595 
-		return $this->searchCommon('searchByMime', array($mimetype));
1596 
-	}
1597 
-
1598 
-	/**
1599 
-	 * search for files by tag
1600 
-	 *
1601 
-	 * @param string|int $tag name or tag id
1602 
-	 * @param string $userId owner of the tags
1603 
-	 * @return FileInfo[]
1604 
-	 */
1605 
-	public function searchByTag($tag, $userId) {
1606 
-		return $this->searchCommon('searchByTag', array($tag, $userId));
1607 
-	}
1608 
-
1609 
-	/**
1610 
-	 * @param string $method cache method
1611 
-	 * @param array $args
1612 
-	 * @return FileInfo[]
1613 
-	 */
1614 
-	private function searchCommon($method, $args) {
1615 
-		$files = array();
1616 
-		$rootLength = strlen($this->fakeRoot);
1617 
-
1618 
-		$mount = $this->getMount('');
1619 
-		$mountPoint = $mount->getMountPoint();
1620 
-		$storage = $mount->getStorage();
1621 
-		if ($storage) {
1622 
-			$cache = $storage->getCache('');
1623 
-
1624 
-			$results = call_user_func_array(array($cache, $method), $args);
1625 
-			foreach ($results as $result) {
1626 
-				if (substr($mountPoint . $result['path'], 0, $rootLength + 1) === $this->fakeRoot . '/') {
1627 
-					$internalPath = $result['path'];
1628 
-					$path = $mountPoint . $result['path'];
1629 
-					$result['path'] = substr($mountPoint . $result['path'], $rootLength);
1630 
-					$owner = \OC::$server->getUserManager()->get($storage->getOwner($internalPath));
1631 
-					$files[] = new FileInfo($path, $storage, $internalPath, $result, $mount, $owner);
1632 
-				}
1633 
-			}
1634 
-
1635 
-			$mounts = Filesystem::getMountManager()->findIn($this->fakeRoot);
1636 
-			foreach ($mounts as $mount) {
1637 
-				$mountPoint = $mount->getMountPoint();
1638 
-				$storage = $mount->getStorage();
1639 
-				if ($storage) {
1640 
-					$cache = $storage->getCache('');
1641 
-
1642 
-					$relativeMountPoint = substr($mountPoint, $rootLength);
1643 
-					$results = call_user_func_array(array($cache, $method), $args);
1644 
-					if ($results) {
1645 
-						foreach ($results as $result) {
1646 
-							$internalPath = $result['path'];
1647 
-							$result['path'] = rtrim($relativeMountPoint . $result['path'], '/');
1648 
-							$path = rtrim($mountPoint . $internalPath, '/');
1649 
-							$owner = \OC::$server->getUserManager()->get($storage->getOwner($internalPath));
1650 
-							$files[] = new FileInfo($path, $storage, $internalPath, $result, $mount, $owner);
1651 
-						}
1652 
-					}
1653 
-				}
1654 
-			}
1655 
-		}
1656 
-		return $files;
1657 
-	}
1658 
-
1659 
-	/**
1660 
-	 * Get the owner for a file or folder
1661 
-	 *
1662 
-	 * @param string $path
1663 
-	 * @return string the user id of the owner
1664 
-	 * @throws NotFoundException
1665 
-	 */
1666 
-	public function getOwner($path) {
1667 
-		$info = $this->getFileInfo($path);
1668 
-		if (!$info) {
1669 
-			throw new NotFoundException($path . ' not found while trying to get owner');
1670 
-		}
1671 
-		return $info->getOwner()->getUID();
1672 
-	}
1673 
-
1674 
-	/**
1675 
-	 * get the ETag for a file or folder
1676 
-	 *
1677 
-	 * @param string $path
1678 
-	 * @return string
1679 
-	 */
1680 
-	public function getETag($path) {
1681 
-		/**
1682 
-		 * @var Storage\Storage $storage
1683 
-		 * @var string $internalPath
1684 
-		 */
1685 
-		list($storage, $internalPath) = $this->resolvePath($path);
1686 
-		if ($storage) {
1687 
-			return $storage->getETag($internalPath);
1688 
-		} else {
1689 
-			return null;
1690 
-		}
1691 
-	}
1692 
-
1693 
-	/**
1694 
-	 * Get the path of a file by id, relative to the view
1695 
-	 *
1696 
-	 * Note that the resulting path is not guarantied to be unique for the id, multiple paths can point to the same file
1697 
-	 *
1698 
-	 * @param int $id
1699 
-	 * @throws NotFoundException
1700 
-	 * @return string
1701 
-	 */
1702 
-	public function getPath($id) {
1703 
-		$id = (int)$id;
1704 
-		$manager = Filesystem::getMountManager();
1705 
-		$mounts = $manager->findIn($this->fakeRoot);
1706 
-		$mounts[] = $manager->find($this->fakeRoot);
1707 
-		// reverse the array so we start with the storage this view is in
1708 
-		// which is the most likely to contain the file we're looking for
1709 
-		$mounts = array_reverse($mounts);
1710 
-		foreach ($mounts as $mount) {
1711 
-			/**
1712 
-			 * @var \OC\Files\Mount\MountPoint $mount
1713 
-			 */
1714 
-			if ($mount->getStorage()) {
1715 
-				$cache = $mount->getStorage()->getCache();
1716 
-				$internalPath = $cache->getPathById($id);
1717 
-				if (is_string($internalPath)) {
1718 
-					$fullPath = $mount->getMountPoint() . $internalPath;
1719 
-					if (!is_null($path = $this->getRelativePath($fullPath))) {
1720 
-						return $path;
1721 
-					}
1722 
-				}
1723 
-			}
1724 
-		}
1725 
-		throw new NotFoundException(sprintf('File with id "%s" has not been found.', $id));
1726 
-	}
1727 
-
1728 
-	/**
1729 
-	 * @param string $path
1730 
-	 * @throws InvalidPathException
1731 
-	 */
1732 
-	private function assertPathLength($path) {
1733 
-		$maxLen = min(PHP_MAXPATHLEN, 4000);
1734 
-		// Check for the string length - performed using isset() instead of strlen()
1735 
-		// because isset() is about 5x-40x faster.
1736 
-		if (isset($path[$maxLen])) {
1737 
-			$pathLen = strlen($path);
1738 
-			throw new \OCP\Files\InvalidPathException("Path length($pathLen) exceeds max path length($maxLen): $path");
1739 
-		}
1740 
-	}
1741 
-
1742 
-	/**
1743 
-	 * check if it is allowed to move a mount point to a given target.
1744 
-	 * It is not allowed to move a mount point into a different mount point or
1745 
-	 * into an already shared folder
1746 
-	 *
1747 
-	 * @param string $target path
1748 
-	 * @return boolean
1749 
-	 */
1750 
-	private function isTargetAllowed($target) {
1751 
-
1752 
-		list($targetStorage, $targetInternalPath) = \OC\Files\Filesystem::resolvePath($target);
1753 
-		if (!$targetStorage->instanceOfStorage('\OCP\Files\IHomeStorage')) {
1754 
-			\OCP\Util::writeLog('files',
1755 
-				'It is not allowed to move one mount point into another one',
1756 
-				ILogger::DEBUG);
1757 
-			return false;
1758 
-		}
1759 
-
1760 
-		// note: cannot use the view because the target is already locked
1761 
-		$fileId = (int)$targetStorage->getCache()->getId($targetInternalPath);
1762 
-		if ($fileId === -1) {
1763 
-			// target might not exist, need to check parent instead
1764 
-			$fileId = (int)$targetStorage->getCache()->getId(dirname($targetInternalPath));
1765 
-		}
1766 
-
1767 
-		// check if any of the parents were shared by the current owner (include collections)
1768 
-		$shares = \OCP\Share::getItemShared(
1769 
-			'folder',
1770 
-			$fileId,
1771 
-			\OCP\Share::FORMAT_NONE,
1772 
-			null,
1773 
-			true
1774 
-		);
1775 
-
1776 
-		if (count($shares) > 0) {
1777 
-			\OCP\Util::writeLog('files',
1778 
-				'It is not allowed to move one mount point into a shared folder',
1779 
-				ILogger::DEBUG);
1780 
-			return false;
1781 
-		}
1782 
-
1783 
-		return true;
1784 
-	}
1785 
-
1786 
-	/**
1787 
-	 * Get a fileinfo object for files that are ignored in the cache (part files)
1788 
-	 *
1789 
-	 * @param string $path
1790 
-	 * @return \OCP\Files\FileInfo
1791 
-	 */
1792 
-	private function getPartFileInfo($path) {
1793 
-		$mount = $this->getMount($path);
1794 
-		$storage = $mount->getStorage();
1795 
-		$internalPath = $mount->getInternalPath($this->getAbsolutePath($path));
1796 
-		$owner = \OC::$server->getUserManager()->get($storage->getOwner($internalPath));
1797 
-		return new FileInfo(
1798 
-			$this->getAbsolutePath($path),
1799 
-			$storage,
1800 
-			$internalPath,
1801 
-			[
1802 
-				'fileid' => null,
1803 
-				'mimetype' => $storage->getMimeType($internalPath),
1804 
-				'name' => basename($path),
1805 
-				'etag' => null,
1806 
-				'size' => $storage->filesize($internalPath),
1807 
-				'mtime' => $storage->filemtime($internalPath),
1808 
-				'encrypted' => false,
1809 
-				'permissions' => \OCP\Constants::PERMISSION_ALL
1810 
-			],
1811 
-			$mount,
1812 
-			$owner
1813 
-		);
1814 
-	}
1815 
-
1816 
-	/**
1817 
-	 * @param string $path
1818 
-	 * @param string $fileName
1819 
-	 * @throws InvalidPathException
1820 
-	 */
1821 
-	public function verifyPath($path, $fileName) {
1822 
-		try {
1823 
-			/** @type \OCP\Files\Storage $storage */
1824 
-			list($storage, $internalPath) = $this->resolvePath($path);
1825 
-			$storage->verifyPath($internalPath, $fileName);
1826 
-		} catch (ReservedWordException $ex) {
1827 
-			$l = \OC::$server->getL10N('lib');
1828 
-			throw new InvalidPathException($l->t('File name is a reserved word'));
1829 
-		} catch (InvalidCharacterInPathException $ex) {
1830 
-			$l = \OC::$server->getL10N('lib');
1831 
-			throw new InvalidPathException($l->t('File name contains at least one invalid character'));
1832 
-		} catch (FileNameTooLongException $ex) {
1833 
-			$l = \OC::$server->getL10N('lib');
1834 
-			throw new InvalidPathException($l->t('File name is too long'));
1835 
-		} catch (InvalidDirectoryException $ex) {
1836 
-			$l = \OC::$server->getL10N('lib');
1837 
-			throw new InvalidPathException($l->t('Dot files are not allowed'));
1838 
-		} catch (EmptyFileNameException $ex) {
1839 
-			$l = \OC::$server->getL10N('lib');
1840 
-			throw new InvalidPathException($l->t('Empty filename is not allowed'));
1841 
-		}
1842 
-	}
1843 
-
1844 
-	/**
1845 
-	 * get all parent folders of $path
1846 
-	 *
1847 
-	 * @param string $path
1848 
-	 * @return string[]
1849 
-	 */
1850 
-	private function getParents($path) {
1851 
-		$path = trim($path, '/');
1852 
-		if (!$path) {
1853 
-			return [];
1854 
-		}
1855 
-
1856 
-		$parts = explode('/', $path);
1857 
-
1858 
-		// remove the single file
1859 
-		array_pop($parts);
1860 
-		$result = array('/');
1861 
-		$resultPath = '';
1862 
-		foreach ($parts as $part) {
1863 
-			if ($part) {
1864 
-				$resultPath .= '/' . $part;
1865 
-				$result[] = $resultPath;
1866 
-			}
1867 
-		}
1868 
-		return $result;
1869 
-	}
1870 
-
1871 
-	/**
1872 
-	 * Returns the mount point for which to lock
1873 
-	 *
1874 
-	 * @param string $absolutePath absolute path
1875 
-	 * @param bool $useParentMount true to return parent mount instead of whatever
1876 
-	 * is mounted directly on the given path, false otherwise
1877 
-	 * @return \OC\Files\Mount\MountPoint mount point for which to apply locks
1878 
-	 */
1879 
-	private function getMountForLock($absolutePath, $useParentMount = false) {
1880 
-		$results = [];
1881 
-		$mount = Filesystem::getMountManager()->find($absolutePath);
1882 
-		if (!$mount) {
1883 
-			return $results;
1884 
-		}
1885 
-
1886 
-		if ($useParentMount) {
1887 
-			// find out if something is mounted directly on the path
1888 
-			$internalPath = $mount->getInternalPath($absolutePath);
1889 
-			if ($internalPath === '') {
1890 
-				// resolve the parent mount instead
1891 
-				$mount = Filesystem::getMountManager()->find(dirname($absolutePath));
1892 
-			}
1893 
-		}
1894 
-
1895 
-		return $mount;
1896 
-	}
1897 
-
1898 
-	/**
1899 
-	 * Lock the given path
1900 
-	 *
1901 
-	 * @param string $path the path of the file to lock, relative to the view
1902 
-	 * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
1903 
-	 * @param bool $lockMountPoint true to lock the mount point, false to lock the attached mount/storage
1904 
-	 *
1905 
-	 * @return bool False if the path is excluded from locking, true otherwise
1906 
-	 * @throws \OCP\Lock\LockedException if the path is already locked
1907 
-	 */
1908 
-	private function lockPath($path, $type, $lockMountPoint = false) {
1909 
-		$absolutePath = $this->getAbsolutePath($path);
1910 
-		$absolutePath = Filesystem::normalizePath($absolutePath);
1911 
-		if (!$this->shouldLockFile($absolutePath)) {
1912 
-			return false;
1913 
-		}
1914 
-
1915 
-		$mount = $this->getMountForLock($absolutePath, $lockMountPoint);
1916 
-		if ($mount) {
1917 
-			try {
1918 
-				$storage = $mount->getStorage();
1919 
-				if ($storage->instanceOfStorage('\OCP\Files\Storage\ILockingStorage')) {
1920 
-					$storage->acquireLock(
1921 
-						$mount->getInternalPath($absolutePath),
1922 
-						$type,
1923 
-						$this->lockingProvider
1924 
-					);
1925 
-				}
1926 
-			} catch (\OCP\Lock\LockedException $e) {
1927 
-				// rethrow with the a human-readable path
1928 
-				throw new \OCP\Lock\LockedException(
1929 
-					$this->getPathRelativeToFiles($absolutePath),
1930 
-					$e
1931 
-				);
1932 
-			}
1933 
-		}
1934 
-
1935 
-		return true;
1936 
-	}
1937 
-
1938 
-	/**
1939 
-	 * Change the lock type
1940 
-	 *
1941 
-	 * @param string $path the path of the file to lock, relative to the view
1942 
-	 * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
1943 
-	 * @param bool $lockMountPoint true to lock the mount point, false to lock the attached mount/storage
1944 
-	 *
1945 
-	 * @return bool False if the path is excluded from locking, true otherwise
1946 
-	 * @throws \OCP\Lock\LockedException if the path is already locked
1947 
-	 */
1948 
-	public function changeLock($path, $type, $lockMountPoint = false) {
1949 
-		$path = Filesystem::normalizePath($path);
1950 
-		$absolutePath = $this->getAbsolutePath($path);
1951 
-		$absolutePath = Filesystem::normalizePath($absolutePath);
1952 
-		if (!$this->shouldLockFile($absolutePath)) {
1953 
-			return false;
1954 
-		}
1955 
-
1956 
-		$mount = $this->getMountForLock($absolutePath, $lockMountPoint);
1957 
-		if ($mount) {
1958 
-			try {
1959 
-				$storage = $mount->getStorage();
1960 
-				if ($storage->instanceOfStorage('\OCP\Files\Storage\ILockingStorage')) {
1961 
-					$storage->changeLock(
1962 
-						$mount->getInternalPath($absolutePath),
1963 
-						$type,
1964 
-						$this->lockingProvider
1965 
-					);
1966 
-				}
1967 
-			} catch (\OCP\Lock\LockedException $e) {
1968 
-				try {
1969 
-					// rethrow with the a human-readable path
1970 
-					throw new \OCP\Lock\LockedException(
1971 
-						$this->getPathRelativeToFiles($absolutePath),
1972 
-						$e
1973 
-					);
1974 
-				} catch (\InvalidArgumentException $e) {
1975 
-					throw new \OCP\Lock\LockedException(
1976 
-						$absolutePath,
1977 
-						$e
1978 
-					);
1979 
-				}
1980 
-			}
1981 
-		}
1982 
-
1983 
-		return true;
1984 
-	}
1985 
-
1986 
-	/**
1987 
-	 * Unlock the given path
1988 
-	 *
1989 
-	 * @param string $path the path of the file to unlock, relative to the view
1990 
-	 * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
1991 
-	 * @param bool $lockMountPoint true to lock the mount point, false to lock the attached mount/storage
1992 
-	 *
1993 
-	 * @return bool False if the path is excluded from locking, true otherwise
1994 
-	 */
1995 
-	private function unlockPath($path, $type, $lockMountPoint = false) {
1996 
-		$absolutePath = $this->getAbsolutePath($path);
1997 
-		$absolutePath = Filesystem::normalizePath($absolutePath);
1998 
-		if (!$this->shouldLockFile($absolutePath)) {
1999 
-			return false;
2000 
-		}
2001 
-
2002 
-		$mount = $this->getMountForLock($absolutePath, $lockMountPoint);
2003 
-		if ($mount) {
2004 
-			$storage = $mount->getStorage();
2005 
-			if ($storage && $storage->instanceOfStorage('\OCP\Files\Storage\ILockingStorage')) {
2006 
-				$storage->releaseLock(
2007 
-					$mount->getInternalPath($absolutePath),
2008 
-					$type,
2009 
-					$this->lockingProvider
2010 
-				);
2011 
-			}
2012 
-		}
2013 
-
2014 
-		return true;
2015 
-	}
2016 
-
2017 
-	/**
2018 
-	 * Lock a path and all its parents up to the root of the view
2019 
-	 *
2020 
-	 * @param string $path the path of the file to lock relative to the view
2021 
-	 * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
2022 
-	 * @param bool $lockMountPoint true to lock the mount point, false to lock the attached mount/storage
2023 
-	 *
2024 
-	 * @return bool False if the path is excluded from locking, true otherwise
2025 
-	 */
2026 
-	public function lockFile($path, $type, $lockMountPoint = false) {
2027 
-		$absolutePath = $this->getAbsolutePath($path);
2028 
-		$absolutePath = Filesystem::normalizePath($absolutePath);
2029 
-		if (!$this->shouldLockFile($absolutePath)) {
2030 
-			return false;
2031 
-		}
2032 
-
2033 
-		$this->lockPath($path, $type, $lockMountPoint);
2034 
-
2035 
-		$parents = $this->getParents($path);
2036 
-		foreach ($parents as $parent) {
2037 
-			$this->lockPath($parent, ILockingProvider::LOCK_SHARED);
2038 
-		}
2039 
-
2040 
-		return true;
2041 
-	}
2042 
-
2043 
-	/**
2044 
-	 * Unlock a path and all its parents up to the root of the view
2045 
-	 *
2046 
-	 * @param string $path the path of the file to lock relative to the view
2047 
-	 * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
2048 
-	 * @param bool $lockMountPoint true to lock the mount point, false to lock the attached mount/storage
2049 
-	 *
2050 
-	 * @return bool False if the path is excluded from locking, true otherwise
2051 
-	 */
2052 
-	public function unlockFile($path, $type, $lockMountPoint = false) {
2053 
-		$absolutePath = $this->getAbsolutePath($path);
2054 
-		$absolutePath = Filesystem::normalizePath($absolutePath);
2055 
-		if (!$this->shouldLockFile($absolutePath)) {
2056 
-			return false;
2057 
-		}
2058 
-
2059 
-		$this->unlockPath($path, $type, $lockMountPoint);
2060 
-
2061 
-		$parents = $this->getParents($path);
2062 
-		foreach ($parents as $parent) {
2063 
-			$this->unlockPath($parent, ILockingProvider::LOCK_SHARED);
2064 
-		}
2065 
-
2066 
-		return true;
2067 
-	}
2068 
-
2069 
-	/**
2070 
-	 * Only lock files in data/user/files/
2071 
-	 *
2072 
-	 * @param string $path Absolute path to the file/folder we try to (un)lock
2073 
-	 * @return bool
2074 
-	 */
2075 
-	protected function shouldLockFile($path) {
2076 
-		$path = Filesystem::normalizePath($path);
2077 
-
2078 
-		$pathSegments = explode('/', $path);
2079 
-		if (isset($pathSegments[2])) {
2080 
-			// E.g.: /username/files/path-to-file
2081 
-			return ($pathSegments[2] === 'files') && (count($pathSegments) > 3);
2082 
-		}
2083 
-
2084 
-		return strpos($path, '/appdata_') !== 0;
2085 
-	}
2086 
-
2087 
-	/**
2088 
-	 * Shortens the given absolute path to be relative to
2089 
-	 * "$user/files".
2090 
-	 *
2091 
-	 * @param string $absolutePath absolute path which is under "files"
2092 
-	 *
2093 
-	 * @return string path relative to "files" with trimmed slashes or null
2094 
-	 * if the path was NOT relative to files
2095 
-	 *
2096 
-	 * @throws \InvalidArgumentException if the given path was not under "files"
2097 
-	 * @since 8.1.0
2098 
-	 */
2099 
-	public function getPathRelativeToFiles($absolutePath) {
2100 
-		$path = Filesystem::normalizePath($absolutePath);
2101 
-		$parts = explode('/', trim($path, '/'), 3);
2102 
-		// "$user", "files", "path/to/dir"
2103 
-		if (!isset($parts[1]) || $parts[1] !== 'files') {
2104 
-			$this->logger->error(
2105 
-				'$absolutePath must be relative to "files", value is "%s"',
2106 
-				[
2107 
-					$absolutePath
2108 
-				]
2109 
-			);
2110 
-			throw new \InvalidArgumentException('$absolutePath must be relative to "files"');
2111 
-		}
2112 
-		if (isset($parts[2])) {
2113 
-			return $parts[2];
2114 
-		}
2115 
-		return '';
2116 
-	}
2117 
-
2118 
-	/**
2119 
-	 * @param string $filename
2120 
-	 * @return array
2121 
-	 * @throws \OC\User\NoUserException
2122 
-	 * @throws NotFoundException
2123 
-	 */
2124 
-	public function getUidAndFilename($filename) {
2125 
-		$info = $this->getFileInfo($filename);
2126 
-		if (!$info instanceof \OCP\Files\FileInfo) {
2127 
-			throw new NotFoundException($this->getAbsolutePath($filename) . ' not found');
2128 
-		}
2129 
-		$uid = $info->getOwner()->getUID();
2130 
-		if ($uid != \OCP\User::getUser()) {
2131 
-			Filesystem::initMountPoints($uid);
2132 
-			$ownerView = new View('/' . $uid . '/files');
2133 
-			try {
2134 
-				$filename = $ownerView->getPath($info['fileid']);
2135 
-			} catch (NotFoundException $e) {
2136 
-				throw new NotFoundException('File with id ' . $info['fileid'] . ' not found for user ' . $uid);
2137 
-			}
2138 
-		}
2139 
-		return [$uid, $filename];
2140 
-	}
2141 
-
2142 
-	/**
2143 
-	 * Creates parent non-existing folders
2144 
-	 *
2145 
-	 * @param string $filePath
2146 
-	 * @return bool
2147 
-	 */
2148 
-	private function createParentDirectories($filePath) {
2149 
-		$directoryParts = explode('/', $filePath);
2150 
-		$directoryParts = array_filter($directoryParts);
2151 
-		foreach ($directoryParts as $key => $part) {
2152 
-			$currentPathElements = array_slice($directoryParts, 0, $key);
2153 
-			$currentPath = '/' . implode('/', $currentPathElements);
2154 
-			if ($this->is_file($currentPath)) {
2155 
-				return false;
2156 
-			}
2157 
-			if (!$this->file_exists($currentPath)) {
2158 
-				$this->mkdir($currentPath);
2159 
-			}
2160 
-		}
2161 
-
2162 
-		return true;
2163 
-	}
84 
+    /** @var string */
85 
+    private $fakeRoot = '';
86 
+
87 
+    /**
88 
+     * @var \OCP\Lock\ILockingProvider
89 
+     */
90 
+    protected $lockingProvider;
91 
+
92 
+    private $lockingEnabled;
93 
+
94 
+    private $updaterEnabled = true;
95 
+
96 
+    /** @var \OC\User\Manager */
97 
+    private $userManager;
98 
+
99 
+    /** @var \OCP\ILogger */
100 
+    private $logger;
101 
+
102 
+    /**
103 
+     * @param string $root
104 
+     * @throws \Exception If $root contains an invalid path
105 
+     */
106 
+    public function __construct($root = '') {
107 
+        if (is_null($root)) {
108 
+            throw new \InvalidArgumentException('Root can\'t be null');
109 
+        }
110 
+        if (!Filesystem::isValidPath($root)) {
111 
+            throw new \Exception();
112 
+        }
113 
+
114 
+        $this->fakeRoot = $root;
115 
+        $this->lockingProvider = \OC::$server->getLockingProvider();
116 
+        $this->lockingEnabled = !($this->lockingProvider instanceof \OC\Lock\NoopLockingProvider);
117 
+        $this->userManager = \OC::$server->getUserManager();
118 
+        $this->logger = \OC::$server->getLogger();
119 
+    }
120 
+
121 
+    public function getAbsolutePath($path = '/') {
122 
+        if ($path === null) {
123 
+            return null;
124 
+        }
125 
+        $this->assertPathLength($path);
126 
+        if ($path === '') {
127 
+            $path = '/';
128 
+        }
129 
+        if ($path[0] !== '/') {
130 
+            $path = '/' . $path;
131 
+        }
132 
+        return $this->fakeRoot . $path;
133 
+    }
134 
+
135 
+    /**
136 
+     * change the root to a fake root
137 
+     *
138 
+     * @param string $fakeRoot
139 
+     * @return boolean|null
140 
+     */
141 
+    public function chroot($fakeRoot) {
142 
+        if (!$fakeRoot == '') {
143 
+            if ($fakeRoot[0] !== '/') {
144 
+                $fakeRoot = '/' . $fakeRoot;
145 
+            }
146 
+        }
147 
+        $this->fakeRoot = $fakeRoot;
148 
+    }
149 
+
150 
+    /**
151 
+     * get the fake root
152 
+     *
153 
+     * @return string
154 
+     */
155 
+    public function getRoot() {
156 
+        return $this->fakeRoot;
157 
+    }
158 
+
159 
+    /**
160 
+     * get path relative to the root of the view
161 
+     *
162 
+     * @param string $path
163 
+     * @return string
164 
+     */
165 
+    public function getRelativePath($path) {
166 
+        $this->assertPathLength($path);
167 
+        if ($this->fakeRoot == '') {
168 
+            return $path;
169 
+        }
170 
+
171 
+        if (rtrim($path, '/') === rtrim($this->fakeRoot, '/')) {
172 
+            return '/';
173 
+        }
174 
+
175 
+        // missing slashes can cause wrong matches!
176 
+        $root = rtrim($this->fakeRoot, '/') . '/';
177 
+
178 
+        if (strpos($path, $root) !== 0) {
179 
+            return null;
180 
+        } else {
181 
+            $path = substr($path, strlen($this->fakeRoot));
182 
+            if (strlen($path) === 0) {
183 
+                return '/';
184 
+            } else {
185 
+                return $path;
186 
+            }
187 
+        }
188 
+    }
189 
+
190 
+    /**
191 
+     * get the mountpoint of the storage object for a path
192 
+     * ( note: because a storage is not always mounted inside the fakeroot, the
193 
+     * returned mountpoint is relative to the absolute root of the filesystem
194 
+     * and does not take the chroot into account )
195 
+     *
196 
+     * @param string $path
197 
+     * @return string
198 
+     */
199 
+    public function getMountPoint($path) {
200 
+        return Filesystem::getMountPoint($this->getAbsolutePath($path));
201 
+    }
202 
+
203 
+    /**
204 
+     * get the mountpoint of the storage object for a path
205 
+     * ( note: because a storage is not always mounted inside the fakeroot, the
206 
+     * returned mountpoint is relative to the absolute root of the filesystem
207 
+     * and does not take the chroot into account )
208 
+     *
209 
+     * @param string $path
210 
+     * @return \OCP\Files\Mount\IMountPoint
211 
+     */
212 
+    public function getMount($path) {
213 
+        return Filesystem::getMountManager()->find($this->getAbsolutePath($path));
214 
+    }
215 
+
216 
+    /**
217 
+     * resolve a path to a storage and internal path
218 
+     *
219 
+     * @param string $path
220 
+     * @return array an array consisting of the storage and the internal path
221 
+     */
222 
+    public function resolvePath($path) {
223 
+        $a = $this->getAbsolutePath($path);
224 
+        $p = Filesystem::normalizePath($a);
225 
+        return Filesystem::resolvePath($p);
226 
+    }
227 
+
228 
+    /**
229 
+     * return the path to a local version of the file
230 
+     * we need this because we can't know if a file is stored local or not from
231 
+     * outside the filestorage and for some purposes a local file is needed
232 
+     *
233 
+     * @param string $path
234 
+     * @return string
235 
+     */
236 
+    public function getLocalFile($path) {
237 
+        $parent = substr($path, 0, strrpos($path, '/'));
238 
+        $path = $this->getAbsolutePath($path);
239 
+        list($storage, $internalPath) = Filesystem::resolvePath($path);
240 
+        if (Filesystem::isValidPath($parent) and $storage) {
241 
+            return $storage->getLocalFile($internalPath);
242 
+        } else {
243 
+            return null;
244 
+        }
245 
+    }
246 
+
247 
+    /**
248 
+     * @param string $path
249 
+     * @return string
250 
+     */
251 
+    public function getLocalFolder($path) {
252 
+        $parent = substr($path, 0, strrpos($path, '/'));
253 
+        $path = $this->getAbsolutePath($path);
254 
+        list($storage, $internalPath) = Filesystem::resolvePath($path);
255 
+        if (Filesystem::isValidPath($parent) and $storage) {
256 
+            return $storage->getLocalFolder($internalPath);
257 
+        } else {
258 
+            return null;
259 
+        }
260 
+    }
261 
+
262 
+    /**
263 
+     * the following functions operate with arguments and return values identical
264 
+     * to those of their PHP built-in equivalents. Mostly they are merely wrappers
265 
+     * for \OC\Files\Storage\Storage via basicOperation().
266 
+     */
267 
+    public function mkdir($path) {
268 
+        return $this->basicOperation('mkdir', $path, array('create', 'write'));
269 
+    }
270 
+
271 
+    /**
272 
+     * remove mount point
273 
+     *
274 
+     * @param \OC\Files\Mount\MoveableMount $mount
275 
+     * @param string $path relative to data/
276 
+     * @return boolean
277 
+     */
278 
+    protected function removeMount($mount, $path) {
279 
+        if ($mount instanceof MoveableMount) {
280 
+            // cut of /user/files to get the relative path to data/user/files
281 
+            $pathParts = explode('/', $path, 4);
282 
+            $relPath = '/' . $pathParts[3];
283 
+            $this->lockFile($relPath, ILockingProvider::LOCK_SHARED, true);
284 
+            \OC_Hook::emit(
285 
+                Filesystem::CLASSNAME, "umount",
286 
+                array(Filesystem::signal_param_path => $relPath)
287 
+            );
288 
+            $this->changeLock($relPath, ILockingProvider::LOCK_EXCLUSIVE, true);
289 
+            $result = $mount->removeMount();
290 
+            $this->changeLock($relPath, ILockingProvider::LOCK_SHARED, true);
291 
+            if ($result) {
292 
+                \OC_Hook::emit(
293 
+                    Filesystem::CLASSNAME, "post_umount",
294 
+                    array(Filesystem::signal_param_path => $relPath)
295 
+                );
296 
+            }
297 
+            $this->unlockFile($relPath, ILockingProvider::LOCK_SHARED, true);
298 
+            return $result;
299 
+        } else {
300 
+            // do not allow deleting the storage's root / the mount point
301 
+            // because for some storages it might delete the whole contents
302 
+            // but isn't supposed to work that way
303 
+            return false;
304 
+        }
305 
+    }
306 
+
307 
+    public function disableCacheUpdate() {
308 
+        $this->updaterEnabled = false;
309 
+    }
310 
+
311 
+    public function enableCacheUpdate() {
312 
+        $this->updaterEnabled = true;
313 
+    }
314 
+
315 
+    protected function writeUpdate(Storage $storage, $internalPath, $time = null) {
316 
+        if ($this->updaterEnabled) {
317 
+            if (is_null($time)) {
318 
+                $time = time();
319 
+            }
320 
+            $storage->getUpdater()->update($internalPath, $time);
321 
+        }
322 
+    }
323 
+
324 
+    protected function removeUpdate(Storage $storage, $internalPath) {
325 
+        if ($this->updaterEnabled) {
326 
+            $storage->getUpdater()->remove($internalPath);
327 
+        }
328 
+    }
329 
+
330 
+    protected function renameUpdate(Storage $sourceStorage, Storage $targetStorage, $sourceInternalPath, $targetInternalPath) {
331 
+        if ($this->updaterEnabled) {
332 
+            $targetStorage->getUpdater()->renameFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath);
333 
+        }
334 
+    }
335 
+
336 
+    /**
337 
+     * @param string $path
338 
+     * @return bool|mixed
339 
+     */
340 
+    public function rmdir($path) {
341 
+        $absolutePath = $this->getAbsolutePath($path);
342 
+        $mount = Filesystem::getMountManager()->find($absolutePath);
343 
+        if ($mount->getInternalPath($absolutePath) === '') {
344 
+            return $this->removeMount($mount, $absolutePath);
345 
+        }
346 
+        if ($this->is_dir($path)) {
347 
+            $result = $this->basicOperation('rmdir', $path, array('delete'));
348 
+        } else {
349 
+            $result = false;
350 
+        }
351 
+
352 
+        if (!$result && !$this->file_exists($path)) { //clear ghost files from the cache on delete
353 
+            $storage = $mount->getStorage();
354 
+            $internalPath = $mount->getInternalPath($absolutePath);
355 
+            $storage->getUpdater()->remove($internalPath);
356 
+        }
357 
+        return $result;
358 
+    }
359 
+
360 
+    /**
361 
+     * @param string $path
362 
+     * @return resource
363 
+     */
364 
+    public function opendir($path) {
365 
+        return $this->basicOperation('opendir', $path, array('read'));
366 
+    }
367 
+
368 
+    /**
369 
+     * @param string $path
370 
+     * @return bool|mixed
371 
+     */
372 
+    public function is_dir($path) {
373 
+        if ($path == '/') {
374 
+            return true;
375 
+        }
376 
+        return $this->basicOperation('is_dir', $path);
377 
+    }
378 
+
379 
+    /**
380 
+     * @param string $path
381 
+     * @return bool|mixed
382 
+     */
383 
+    public function is_file($path) {
384 
+        if ($path == '/') {
385 
+            return false;
386 
+        }
387 
+        return $this->basicOperation('is_file', $path);
388 
+    }
389 
+
390 
+    /**
391 
+     * @param string $path
392 
+     * @return mixed
393 
+     */
394 
+    public function stat($path) {
395 
+        return $this->basicOperation('stat', $path);
396 
+    }
397 
+
398 
+    /**
399 
+     * @param string $path
400 
+     * @return mixed
401 
+     */
402 
+    public function filetype($path) {
403 
+        return $this->basicOperation('filetype', $path);
404 
+    }
405 
+
406 
+    /**
407 
+     * @param string $path
408 
+     * @return mixed
409 
+     */
410 
+    public function filesize($path) {
411 
+        return $this->basicOperation('filesize', $path);
412 
+    }
413 
+
414 
+    /**
415 
+     * @param string $path
416 
+     * @return bool|mixed
417 
+     * @throws \OCP\Files\InvalidPathException
418 
+     */
419 
+    public function readfile($path) {
420 
+        $this->assertPathLength($path);
421 
+        @ob_end_clean();
422 
+        $handle = $this->fopen($path, 'rb');
423 
+        if ($handle) {
424 
+            $chunkSize = 8192; // 8 kB chunks
425 
+            while (!feof($handle)) {
426 
+                echo fread($handle, $chunkSize);
427 
+                flush();
428 
+            }
429 
+            fclose($handle);
430 
+            return $this->filesize($path);
431 
+        }
432 
+        return false;
433 
+    }
434 
+
435 
+    /**
436 
+     * @param string $path
437 
+     * @param int $from
438 
+     * @param int $to
439 
+     * @return bool|mixed
440 
+     * @throws \OCP\Files\InvalidPathException
441 
+     * @throws \OCP\Files\UnseekableException
442 
+     */
443 
+    public function readfilePart($path, $from, $to) {
444 
+        $this->assertPathLength($path);
445 
+        @ob_end_clean();
446 
+        $handle = $this->fopen($path, 'rb');
447 
+        if ($handle) {
448 
+            $chunkSize = 8192; // 8 kB chunks
449 
+            $startReading = true;
450 
+
451 
+            if ($from !== 0 && $from !== '0' && fseek($handle, $from) !== 0) {
452 
+                // forward file handle via chunked fread because fseek seem to have failed
453 
+
454 
+                $end = $from + 1;
455 
+                while (!feof($handle) && ftell($handle) < $end) {
456 
+                    $len = $from - ftell($handle);
457 
+                    if ($len > $chunkSize) {
458 
+                        $len = $chunkSize;
459 
+                    }
460 
+                    $result = fread($handle, $len);
461 
+
462 
+                    if ($result === false) {
463 
+                        $startReading = false;
464 
+                        break;
465 
+                    }
466 
+                }
467 
+            }
468 
+
469 
+            if ($startReading) {
470 
+                $end = $to + 1;
471 
+                while (!feof($handle) && ftell($handle) < $end) {
472 
+                    $len = $end - ftell($handle);
473 
+                    if ($len > $chunkSize) {
474 
+                        $len = $chunkSize;
475 
+                    }
476 
+                    echo fread($handle, $len);
477 
+                    flush();
478 
+                }
479 
+                return ftell($handle) - $from;
480 
+            }
481 
+
482 
+            throw new \OCP\Files\UnseekableException('fseek error');
483 
+        }
484 
+        return false;
485 
+    }
486 
+
487 
+    /**
488 
+     * @param string $path
489 
+     * @return mixed
490 
+     */
491 
+    public function isCreatable($path) {
492 
+        return $this->basicOperation('isCreatable', $path);
493 
+    }
494 
+
495 
+    /**
496 
+     * @param string $path
497 
+     * @return mixed
498 
+     */
499 
+    public function isReadable($path) {
500 
+        return $this->basicOperation('isReadable', $path);
501 
+    }
502 
+
503 
+    /**
504 
+     * @param string $path
505 
+     * @return mixed
506 
+     */
507 
+    public function isUpdatable($path) {
508 
+        return $this->basicOperation('isUpdatable', $path);
509 
+    }
510 
+
511 
+    /**
512 
+     * @param string $path
513 
+     * @return bool|mixed
514 
+     */
515 
+    public function isDeletable($path) {
516 
+        $absolutePath = $this->getAbsolutePath($path);
517 
+        $mount = Filesystem::getMountManager()->find($absolutePath);
518 
+        if ($mount->getInternalPath($absolutePath) === '') {
519 
+            return $mount instanceof MoveableMount;
520 
+        }
521 
+        return $this->basicOperation('isDeletable', $path);
522 
+    }
523 
+
524 
+    /**
525 
+     * @param string $path
526 
+     * @return mixed
527 
+     */
528 
+    public function isSharable($path) {
529 
+        return $this->basicOperation('isSharable', $path);
530 
+    }
531 
+
532 
+    /**
533 
+     * @param string $path
534 
+     * @return bool|mixed
535 
+     */
536 
+    public function file_exists($path) {
537 
+        if ($path == '/') {
538 
+            return true;
539 
+        }
540 
+        return $this->basicOperation('file_exists', $path);
541 
+    }
542 
+
543 
+    /**
544 
+     * @param string $path
545 
+     * @return mixed
546 
+     */
547 
+    public function filemtime($path) {
548 
+        return $this->basicOperation('filemtime', $path);
549 
+    }
550 
+
551 
+    /**
552 
+     * @param string $path
553 
+     * @param int|string $mtime
554 
+     * @return bool
555 
+     */
556 
+    public function touch($path, $mtime = null) {
557 
+        if (!is_null($mtime) and !is_numeric($mtime)) {
558 
+            $mtime = strtotime($mtime);
559 
+        }
560 
+
561 
+        $hooks = array('touch');
562 
+
563 
+        if (!$this->file_exists($path)) {
564 
+            $hooks[] = 'create';
565 
+            $hooks[] = 'write';
566 
+        }
567 
+        $result = $this->basicOperation('touch', $path, $hooks, $mtime);
568 
+        if (!$result) {
569 
+            // If create file fails because of permissions on external storage like SMB folders,
570 
+            // check file exists and return false if not.
571 
+            if (!$this->file_exists($path)) {
572 
+                return false;
573 
+            }
574 
+            if (is_null($mtime)) {
575 
+                $mtime = time();
576 
+            }
577 
+            //if native touch fails, we emulate it by changing the mtime in the cache
578 
+            $this->putFileInfo($path, array('mtime' => floor($mtime)));
579 
+        }
580 
+        return true;
581 
+    }
582 
+
583 
+    /**
584 
+     * @param string $path
585 
+     * @return mixed
586 
+     */
587 
+    public function file_get_contents($path) {
588 
+        return $this->basicOperation('file_get_contents', $path, array('read'));
589 
+    }
590 
+
591 
+    /**
592 
+     * @param bool $exists
593 
+     * @param string $path
594 
+     * @param bool $run
595 
+     */
596 
+    protected function emit_file_hooks_pre($exists, $path, &$run) {
597 
+        if (!$exists) {
598 
+            \OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_create, array(
599 
+                Filesystem::signal_param_path => $this->getHookPath($path),
600 
+                Filesystem::signal_param_run => &$run,
601 
+            ));
602 
+        } else {
603 
+            \OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_update, array(
604 
+                Filesystem::signal_param_path => $this->getHookPath($path),
605 
+                Filesystem::signal_param_run => &$run,
606 
+            ));
607 
+        }
608 
+        \OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_write, array(
609 
+            Filesystem::signal_param_path => $this->getHookPath($path),
610 
+            Filesystem::signal_param_run => &$run,
611 
+        ));
612 
+    }
613 
+
614 
+    /**
615 
+     * @param bool $exists
616 
+     * @param string $path
617 
+     */
618 
+    protected function emit_file_hooks_post($exists, $path) {
619 
+        if (!$exists) {
620 
+            \OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_post_create, array(
621 
+                Filesystem::signal_param_path => $this->getHookPath($path),
622 
+            ));
623 
+        } else {
624 
+            \OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_post_update, array(
625 
+                Filesystem::signal_param_path => $this->getHookPath($path),
626 
+            ));
627 
+        }
628 
+        \OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_post_write, array(
629 
+            Filesystem::signal_param_path => $this->getHookPath($path),
630 
+        ));
631 
+    }
632 
+
633 
+    /**
634 
+     * @param string $path
635 
+     * @param mixed $data
636 
+     * @return bool|mixed
637 
+     * @throws \Exception
638 
+     */
639 
+    public function file_put_contents($path, $data) {
640 
+        if (is_resource($data)) { //not having to deal with streams in file_put_contents makes life easier
641 
+            $absolutePath = Filesystem::normalizePath($this->getAbsolutePath($path));
642 
+            if (Filesystem::isValidPath($path)
643 
+                and !Filesystem::isFileBlacklisted($path)
644 
+            ) {
645 
+                $path = $this->getRelativePath($absolutePath);
646 
+
647 
+                $this->lockFile($path, ILockingProvider::LOCK_SHARED);
648 
+
649 
+                $exists = $this->file_exists($path);
650 
+                $run = true;
651 
+                if ($this->shouldEmitHooks($path)) {
652 
+                    $this->emit_file_hooks_pre($exists, $path, $run);
653 
+                }
654 
+                if (!$run) {
655 
+                    $this->unlockFile($path, ILockingProvider::LOCK_SHARED);
656 
+                    return false;
657 
+                }
658 
+
659 
+                $this->changeLock($path, ILockingProvider::LOCK_EXCLUSIVE);
660 
+
661 
+                /** @var \OC\Files\Storage\Storage $storage */
662 
+                list($storage, $internalPath) = $this->resolvePath($path);
663 
+                $target = $storage->fopen($internalPath, 'w');
664 
+                if ($target) {
665 
+                    list (, $result) = \OC_Helper::streamCopy($data, $target);
666 
+                    fclose($target);
667 
+                    fclose($data);
668 
+
669 
+                    $this->writeUpdate($storage, $internalPath);
670 
+
671 
+                    $this->changeLock($path, ILockingProvider::LOCK_SHARED);
672 
+
673 
+                    if ($this->shouldEmitHooks($path) && $result !== false) {
674 
+                        $this->emit_file_hooks_post($exists, $path);
675 
+                    }
676 
+                    $this->unlockFile($path, ILockingProvider::LOCK_SHARED);
677 
+                    return $result;
678 
+                } else {
679 
+                    $this->unlockFile($path, ILockingProvider::LOCK_EXCLUSIVE);
680 
+                    return false;
681 
+                }
682 
+            } else {
683 
+                return false;
684 
+            }
685 
+        } else {
686 
+            $hooks = $this->file_exists($path) ? array('update', 'write') : array('create', 'write');
687 
+            return $this->basicOperation('file_put_contents', $path, $hooks, $data);
688 
+        }
689 
+    }
690 
+
691 
+    /**
692 
+     * @param string $path
693 
+     * @return bool|mixed
694 
+     */
695 
+    public function unlink($path) {
696 
+        if ($path === '' || $path === '/') {
697 
+            // do not allow deleting the root
698 
+            return false;
699 
+        }
700 
+        $postFix = (substr($path, -1) === '/') ? '/' : '';
701 
+        $absolutePath = Filesystem::normalizePath($this->getAbsolutePath($path));
702 
+        $mount = Filesystem::getMountManager()->find($absolutePath . $postFix);
703 
+        if ($mount and $mount->getInternalPath($absolutePath) === '') {
704 
+            return $this->removeMount($mount, $absolutePath);
705 
+        }
706 
+        if ($this->is_dir($path)) {
707 
+            $result = $this->basicOperation('rmdir', $path, ['delete']);
708 
+        } else {
709 
+            $result = $this->basicOperation('unlink', $path, ['delete']);
710 
+        }
711 
+        if (!$result && !$this->file_exists($path)) { //clear ghost files from the cache on delete
712 
+            $storage = $mount->getStorage();
713 
+            $internalPath = $mount->getInternalPath($absolutePath);
714 
+            $storage->getUpdater()->remove($internalPath);
715 
+            return true;
716 
+        } else {
717 
+            return $result;
718 
+        }
719 
+    }
720 
+
721 
+    /**
722 
+     * @param string $directory
723 
+     * @return bool|mixed
724 
+     */
725 
+    public function deleteAll($directory) {
726 
+        return $this->rmdir($directory);
727 
+    }
728 
+
729 
+    /**
730 
+     * Rename/move a file or folder from the source path to target path.
731 
+     *
732 
+     * @param string $path1 source path
733 
+     * @param string $path2 target path
734 
+     *
735 
+     * @return bool|mixed
736 
+     */
737 
+    public function rename($path1, $path2) {
738 
+        $absolutePath1 = Filesystem::normalizePath($this->getAbsolutePath($path1));
739 
+        $absolutePath2 = Filesystem::normalizePath($this->getAbsolutePath($path2));
740 
+        $result = false;
741 
+        if (
742 
+            Filesystem::isValidPath($path2)
743 
+            and Filesystem::isValidPath($path1)
744 
+            and !Filesystem::isFileBlacklisted($path2)
745 
+        ) {
746 
+            $path1 = $this->getRelativePath($absolutePath1);
747 
+            $path2 = $this->getRelativePath($absolutePath2);
748 
+            $exists = $this->file_exists($path2);
749 
+
750 
+            if ($path1 == null or $path2 == null) {
751 
+                return false;
752 
+            }
753 
+
754 
+            $this->lockFile($path1, ILockingProvider::LOCK_SHARED, true);
755 
+            try {
756 
+                $this->lockFile($path2, ILockingProvider::LOCK_SHARED, true);
757 
+
758 
+                $run = true;
759 
+                if ($this->shouldEmitHooks($path1) && (Cache\Scanner::isPartialFile($path1) && !Cache\Scanner::isPartialFile($path2))) {
760 
+                    // if it was a rename from a part file to a regular file it was a write and not a rename operation
761 
+                    $this->emit_file_hooks_pre($exists, $path2, $run);
762 
+                } elseif ($this->shouldEmitHooks($path1)) {
763 
+                    \OC_Hook::emit(
764 
+                        Filesystem::CLASSNAME, Filesystem::signal_rename,
765 
+                        array(
766 
+                            Filesystem::signal_param_oldpath => $this->getHookPath($path1),
767 
+                            Filesystem::signal_param_newpath => $this->getHookPath($path2),
768 
+                            Filesystem::signal_param_run => &$run
769 
+                        )
770 
+                    );
771 
+                }
772 
+                if ($run) {
773 
+                    $this->verifyPath(dirname($path2), basename($path2));
774 
+
775 
+                    $manager = Filesystem::getMountManager();
776 
+                    $mount1 = $this->getMount($path1);
777 
+                    $mount2 = $this->getMount($path2);
778 
+                    $storage1 = $mount1->getStorage();
779 
+                    $storage2 = $mount2->getStorage();
780 
+                    $internalPath1 = $mount1->getInternalPath($absolutePath1);
781 
+                    $internalPath2 = $mount2->getInternalPath($absolutePath2);
782 
+
783 
+                    $this->changeLock($path1, ILockingProvider::LOCK_EXCLUSIVE, true);
784 
+                    try {
785 
+                        $this->changeLock($path2, ILockingProvider::LOCK_EXCLUSIVE, true);
786 
+
787 
+                        if ($internalPath1 === '') {
788 
+                            if ($mount1 instanceof MoveableMount) {
789 
+                                if ($this->isTargetAllowed($absolutePath2)) {
790 
+                                    /**
791 
+                                     * @var \OC\Files\Mount\MountPoint | \OC\Files\Mount\MoveableMount $mount1
792 
+                                     */
793 
+                                    $sourceMountPoint = $mount1->getMountPoint();
794 
+                                    $result = $mount1->moveMount($absolutePath2);
795 
+                                    $manager->moveMount($sourceMountPoint, $mount1->getMountPoint());
796 
+                                } else {
797 
+                                    $result = false;
798 
+                                }
799 
+                            } else {
800 
+                                $result = false;
801 
+                            }
802 
+                            // moving a file/folder within the same mount point
803 
+                        } elseif ($storage1 === $storage2) {
804 
+                            if ($storage1) {
805 
+                                $result = $storage1->rename($internalPath1, $internalPath2);
806 
+                            } else {
807 
+                                $result = false;
808 
+                            }
809 
+                            // moving a file/folder between storages (from $storage1 to $storage2)
810 
+                        } else {
811 
+                            $result = $storage2->moveFromStorage($storage1, $internalPath1, $internalPath2);
812 
+                        }
813 
+
814 
+                        if ((Cache\Scanner::isPartialFile($path1) && !Cache\Scanner::isPartialFile($path2)) && $result !== false) {
815 
+                            // if it was a rename from a part file to a regular file it was a write and not a rename operation
816 
+                            $this->writeUpdate($storage2, $internalPath2);
817 
+                        } else if ($result) {
818 
+                            if ($internalPath1 !== '') { // don't do a cache update for moved mounts
819 
+                                $this->renameUpdate($storage1, $storage2, $internalPath1, $internalPath2);
820 
+                            }
821 
+                        }
822 
+                    } catch(\Exception $e) {
823 
+                        throw $e;
824 
+                    } finally {
825 
+                        $this->changeLock($path1, ILockingProvider::LOCK_SHARED, true);
826 
+                        $this->changeLock($path2, ILockingProvider::LOCK_SHARED, true);
827 
+                    }
828 
+
829 
+                    if ((Cache\Scanner::isPartialFile($path1) && !Cache\Scanner::isPartialFile($path2)) && $result !== false) {
830 
+                        if ($this->shouldEmitHooks()) {
831 
+                            $this->emit_file_hooks_post($exists, $path2);
832 
+                        }
833 
+                    } elseif ($result) {
834 
+                        if ($this->shouldEmitHooks($path1) and $this->shouldEmitHooks($path2)) {
835 
+                            \OC_Hook::emit(
836 
+                                Filesystem::CLASSNAME,
837 
+                                Filesystem::signal_post_rename,
838 
+                                array(
839 
+                                    Filesystem::signal_param_oldpath => $this->getHookPath($path1),
840 
+                                    Filesystem::signal_param_newpath => $this->getHookPath($path2)
841 
+                                )
842 
+                            );
843 
+                        }
844 
+                    }
845 
+                }
846 
+            } catch(\Exception $e) {
847 
+                throw $e;
848 
+            } finally {
849 
+                $this->unlockFile($path1, ILockingProvider::LOCK_SHARED, true);
850 
+                $this->unlockFile($path2, ILockingProvider::LOCK_SHARED, true);
851 
+            }
852 
+        }
853 
+        return $result;
854 
+    }
855 
+
856 
+    /**
857 
+     * Copy a file/folder from the source path to target path
858 
+     *
859 
+     * @param string $path1 source path
860 
+     * @param string $path2 target path
861 
+     * @param bool $preserveMtime whether to preserve mtime on the copy
862 
+     *
863 
+     * @return bool|mixed
864 
+     */
865 
+    public function copy($path1, $path2, $preserveMtime = false) {
866 
+        $absolutePath1 = Filesystem::normalizePath($this->getAbsolutePath($path1));
867 
+        $absolutePath2 = Filesystem::normalizePath($this->getAbsolutePath($path2));
868 
+        $result = false;
869 
+        if (
870 
+            Filesystem::isValidPath($path2)
871 
+            and Filesystem::isValidPath($path1)
872 
+            and !Filesystem::isFileBlacklisted($path2)
873 
+        ) {
874 
+            $path1 = $this->getRelativePath($absolutePath1);
875 
+            $path2 = $this->getRelativePath($absolutePath2);
876 
+
877 
+            if ($path1 == null or $path2 == null) {
878 
+                return false;
879 
+            }
880 
+            $run = true;
881 
+
882 
+            $this->lockFile($path2, ILockingProvider::LOCK_SHARED);
883 
+            $this->lockFile($path1, ILockingProvider::LOCK_SHARED);
884 
+            $lockTypePath1 = ILockingProvider::LOCK_SHARED;
885 
+            $lockTypePath2 = ILockingProvider::LOCK_SHARED;
886 
+
887 
+            try {
888 
+
889 
+                $exists = $this->file_exists($path2);
890 
+                if ($this->shouldEmitHooks()) {
891 
+                    \OC_Hook::emit(
892 
+                        Filesystem::CLASSNAME,
893 
+                        Filesystem::signal_copy,
894 
+                        array(
895 
+                            Filesystem::signal_param_oldpath => $this->getHookPath($path1),
896 
+                            Filesystem::signal_param_newpath => $this->getHookPath($path2),
897 
+                            Filesystem::signal_param_run => &$run
898 
+                        )
899 
+                    );
900 
+                    $this->emit_file_hooks_pre($exists, $path2, $run);
901 
+                }
902 
+                if ($run) {
903 
+                    $mount1 = $this->getMount($path1);
904 
+                    $mount2 = $this->getMount($path2);
905 
+                    $storage1 = $mount1->getStorage();
906 
+                    $internalPath1 = $mount1->getInternalPath($absolutePath1);
907 
+                    $storage2 = $mount2->getStorage();
908 
+                    $internalPath2 = $mount2->getInternalPath($absolutePath2);
909 
+
910 
+                    $this->changeLock($path2, ILockingProvider::LOCK_EXCLUSIVE);
911 
+                    $lockTypePath2 = ILockingProvider::LOCK_EXCLUSIVE;
912 
+
913 
+                    if ($mount1->getMountPoint() == $mount2->getMountPoint()) {
914 
+                        if ($storage1) {
915 
+                            $result = $storage1->copy($internalPath1, $internalPath2);
916 
+                        } else {
917 
+                            $result = false;
918 
+                        }
919 
+                    } else {
920 
+                        $result = $storage2->copyFromStorage($storage1, $internalPath1, $internalPath2);
921 
+                    }
922 
+
923 
+                    $this->writeUpdate($storage2, $internalPath2);
924 
+
925 
+                    $this->changeLock($path2, ILockingProvider::LOCK_SHARED);
926 
+                    $lockTypePath2 = ILockingProvider::LOCK_SHARED;
927 
+
928 
+                    if ($this->shouldEmitHooks() && $result !== false) {
929 
+                        \OC_Hook::emit(
930 
+                            Filesystem::CLASSNAME,
931 
+                            Filesystem::signal_post_copy,
932 
+                            array(
933 
+                                Filesystem::signal_param_oldpath => $this->getHookPath($path1),
934 
+                                Filesystem::signal_param_newpath => $this->getHookPath($path2)
935 
+                            )
936 
+                        );
937 
+                        $this->emit_file_hooks_post($exists, $path2);
938 
+                    }
939 
+
940 
+                }
941 
+            } catch (\Exception $e) {
942 
+                $this->unlockFile($path2, $lockTypePath2);
943 
+                $this->unlockFile($path1, $lockTypePath1);
944 
+                throw $e;
945 
+            }
946 
+
947 
+            $this->unlockFile($path2, $lockTypePath2);
948 
+            $this->unlockFile($path1, $lockTypePath1);
949 
+
950 
+        }
951 
+        return $result;
952 
+    }
953 
+
954 
+    /**
955 
+     * @param string $path
956 
+     * @param string $mode 'r' or 'w'
957 
+     * @return resource
958 
+     */
959 
+    public function fopen($path, $mode) {
960 
+        $mode = str_replace('b', '', $mode); // the binary flag is a windows only feature which we do not support
961 
+        $hooks = array();
962 
+        switch ($mode) {
963 
+            case 'r':
964 
+                $hooks[] = 'read';
965 
+                break;
966 
+            case 'r+':
967 
+            case 'w+':
968 
+            case 'x+':
969 
+            case 'a+':
970 
+                $hooks[] = 'read';
971 
+                $hooks[] = 'write';
972 
+                break;
973 
+            case 'w':
974 
+            case 'x':
975 
+            case 'a':
976 
+                $hooks[] = 'write';
977 
+                break;
978 
+            default:
979 
+                \OCP\Util::writeLog('core', 'invalid mode (' . $mode . ') for ' . $path, ILogger::ERROR);
980 
+        }
981 
+
982 
+        if ($mode !== 'r' && $mode !== 'w') {
983 
+            \OC::$server->getLogger()->info('Trying to open a file with a mode other than "r" or "w" can cause severe performance issues with some backends');
984 
+        }
985 
+
986 
+        return $this->basicOperation('fopen', $path, $hooks, $mode);
987 
+    }
988 
+
989 
+    /**
990 
+     * @param string $path
991 
+     * @return bool|string
992 
+     * @throws \OCP\Files\InvalidPathException
993 
+     */
994 
+    public function toTmpFile($path) {
995 
+        $this->assertPathLength($path);
996 
+        if (Filesystem::isValidPath($path)) {
997 
+            $source = $this->fopen($path, 'r');
998 
+            if ($source) {
999 
+                $extension = pathinfo($path, PATHINFO_EXTENSION);
1000 
+                $tmpFile = \OC::$server->getTempManager()->getTemporaryFile($extension);
1001 
+                file_put_contents($tmpFile, $source);
1002 
+                return $tmpFile;
1003 
+            } else {
1004 
+                return false;
1005 
+            }
1006 
+        } else {
1007 
+            return false;
1008 
+        }
1009 
+    }
1010 
+
1011 
+    /**
1012 
+     * @param string $tmpFile
1013 
+     * @param string $path
1014 
+     * @return bool|mixed
1015 
+     * @throws \OCP\Files\InvalidPathException
1016 
+     */
1017 
+    public function fromTmpFile($tmpFile, $path) {
1018 
+        $this->assertPathLength($path);
1019 
+        if (Filesystem::isValidPath($path)) {
1020 
+
1021 
+            // Get directory that the file is going into
1022 
+            $filePath = dirname($path);
1023 
+
1024 
+            // Create the directories if any
1025 
+            if (!$this->file_exists($filePath)) {
1026 
+                $result = $this->createParentDirectories($filePath);
1027 
+                if ($result === false) {
1028 
+                    return false;
1029 
+                }
1030 
+            }
1031 
+
1032 
+            $source = fopen($tmpFile, 'r');
1033 
+            if ($source) {
1034 
+                $result = $this->file_put_contents($path, $source);
1035 
+                // $this->file_put_contents() might have already closed
1036 
+                // the resource, so we check it, before trying to close it
1037 
+                // to avoid messages in the error log.
1038 
+                if (is_resource($source)) {
1039 
+                    fclose($source);
1040 
+                }
1041 
+                unlink($tmpFile);
1042 
+                return $result;
1043 
+            } else {
1044 
+                return false;
1045 
+            }
1046 
+        } else {
1047 
+            return false;
1048 
+        }
1049 
+    }
1050 
+
1051 
+
1052 
+    /**
1053 
+     * @param string $path
1054 
+     * @return mixed
1055 
+     * @throws \OCP\Files\InvalidPathException
1056 
+     */
1057 
+    public function getMimeType($path) {
1058 
+        $this->assertPathLength($path);
1059 
+        return $this->basicOperation('getMimeType', $path);
1060 
+    }
1061 
+
1062 
+    /**
1063 
+     * @param string $type
1064 
+     * @param string $path
1065 
+     * @param bool $raw
1066 
+     * @return bool|null|string
1067 
+     */
1068 
+    public function hash($type, $path, $raw = false) {
1069 
+        $postFix = (substr($path, -1) === '/') ? '/' : '';
1070 
+        $absolutePath = Filesystem::normalizePath($this->getAbsolutePath($path));
1071 
+        if (Filesystem::isValidPath($path)) {
1072 
+            $path = $this->getRelativePath($absolutePath);
1073 
+            if ($path == null) {
1074 
+                return false;
1075 
+            }
1076 
+            if ($this->shouldEmitHooks($path)) {
1077 
+                \OC_Hook::emit(
1078 
+                    Filesystem::CLASSNAME,
1079 
+                    Filesystem::signal_read,
1080 
+                    array(Filesystem::signal_param_path => $this->getHookPath($path))
1081 
+                );
1082 
+            }
1083 
+            list($storage, $internalPath) = Filesystem::resolvePath($absolutePath . $postFix);
1084 
+            if ($storage) {
1085 
+                return $storage->hash($type, $internalPath, $raw);
1086 
+            }
1087 
+        }
1088 
+        return null;
1089 
+    }
1090 
+
1091 
+    /**
1092 
+     * @param string $path
1093 
+     * @return mixed
1094 
+     * @throws \OCP\Files\InvalidPathException
1095 
+     */
1096 
+    public function free_space($path = '/') {
1097 
+        $this->assertPathLength($path);
1098 
+        $result = $this->basicOperation('free_space', $path);
1099 
+        if ($result === null) {
1100 
+            throw new InvalidPathException();
1101 
+        }
1102 
+        return $result;
1103 
+    }
1104 
+
1105 
+    /**
1106 
+     * abstraction layer for basic filesystem functions: wrapper for \OC\Files\Storage\Storage
1107 
+     *
1108 
+     * @param string $operation
1109 
+     * @param string $path
1110 
+     * @param array $hooks (optional)
1111 
+     * @param mixed $extraParam (optional)
1112 
+     * @return mixed
1113 
+     * @throws \Exception
1114 
+     *
1115 
+     * This method takes requests for basic filesystem functions (e.g. reading & writing
1116 
+     * files), processes hooks and proxies, sanitises paths, and finally passes them on to
1117 
+     * \OC\Files\Storage\Storage for delegation to a storage backend for execution
1118 
+     */
1119 
+    private function basicOperation($operation, $path, $hooks = [], $extraParam = null) {
1120 
+        $postFix = (substr($path, -1) === '/') ? '/' : '';
1121 
+        $absolutePath = Filesystem::normalizePath($this->getAbsolutePath($path));
1122 
+        if (Filesystem::isValidPath($path)
1123 
+            and !Filesystem::isFileBlacklisted($path)
1124 
+        ) {
1125 
+            $path = $this->getRelativePath($absolutePath);
1126 
+            if ($path == null) {
1127 
+                return false;
1128 
+            }
1129 
+
1130 
+            if (in_array('write', $hooks) || in_array('delete', $hooks) || in_array('read', $hooks)) {
1131 
+                // always a shared lock during pre-hooks so the hook can read the file
1132 
+                $this->lockFile($path, ILockingProvider::LOCK_SHARED);
1133 
+            }
1134 
+
1135 
+            $run = $this->runHooks($hooks, $path);
1136 
+            /** @var \OC\Files\Storage\Storage $storage */
1137 
+            list($storage, $internalPath) = Filesystem::resolvePath($absolutePath . $postFix);
1138 
+            if ($run and $storage) {
1139 
+                if (in_array('write', $hooks) || in_array('delete', $hooks)) {
1140 
+                    $this->changeLock($path, ILockingProvider::LOCK_EXCLUSIVE);
1141 
+                }
1142 
+                try {
1143 
+                    if (!is_null($extraParam)) {
1144 
+                        $result = $storage->$operation($internalPath, $extraParam);
1145 
+                    } else {
1146 
+                        $result = $storage->$operation($internalPath);
1147 
+                    }
1148 
+                } catch (\Exception $e) {
1149 
+                    if (in_array('write', $hooks) || in_array('delete', $hooks)) {
1150 
+                        $this->unlockFile($path, ILockingProvider::LOCK_EXCLUSIVE);
1151 
+                    } else if (in_array('read', $hooks)) {
1152 
+                        $this->unlockFile($path, ILockingProvider::LOCK_SHARED);
1153 
+                    }
1154 
+                    throw $e;
1155 
+                }
1156 
+
1157 
+                if ($result && in_array('delete', $hooks) and $result) {
1158 
+                    $this->removeUpdate($storage, $internalPath);
1159 
+                }
1160 
+                if ($result && in_array('write', $hooks) and $operation !== 'fopen') {
1161 
+                    $this->writeUpdate($storage, $internalPath);
1162 
+                }
1163 
+                if ($result && in_array('touch', $hooks)) {
1164 
+                    $this->writeUpdate($storage, $internalPath, $extraParam);
1165 
+                }
1166 
+
1167 
+                if ((in_array('write', $hooks) || in_array('delete', $hooks)) && ($operation !== 'fopen' || $result === false)) {
1168 
+                    $this->changeLock($path, ILockingProvider::LOCK_SHARED);
1169 
+                }
1170 
+
1171 
+                $unlockLater = false;
1172 
+                if ($this->lockingEnabled && $operation === 'fopen' && is_resource($result)) {
1173 
+                    $unlockLater = true;
1174 
+                    // make sure our unlocking callback will still be called if connection is aborted
1175 
+                    ignore_user_abort(true);
1176 
+                    $result = CallbackWrapper::wrap($result, null, null, function () use ($hooks, $path) {
1177 
+                        if (in_array('write', $hooks)) {
1178 
+                            $this->unlockFile($path, ILockingProvider::LOCK_EXCLUSIVE);
1179 
+                        } else if (in_array('read', $hooks)) {
1180 
+                            $this->unlockFile($path, ILockingProvider::LOCK_SHARED);
1181 
+                        }
1182 
+                    });
1183 
+                }
1184 
+
1185 
+                if ($this->shouldEmitHooks($path) && $result !== false) {
1186 
+                    if ($operation != 'fopen') { //no post hooks for fopen, the file stream is still open
1187 
+                        $this->runHooks($hooks, $path, true);
1188 
+                    }
1189 
+                }
1190 
+
1191 
+                if (!$unlockLater
1192 
+                    && (in_array('write', $hooks) || in_array('delete', $hooks) || in_array('read', $hooks))
1193 
+                ) {
1194 
+                    $this->unlockFile($path, ILockingProvider::LOCK_SHARED);
1195 
+                }
1196 
+                return $result;
1197 
+            } else {
1198 
+                $this->unlockFile($path, ILockingProvider::LOCK_SHARED);
1199 
+            }
1200 
+        }
1201 
+        return null;
1202 
+    }
1203 
+
1204 
+    /**
1205 
+     * get the path relative to the default root for hook usage
1206 
+     *
1207 
+     * @param string $path
1208 
+     * @return string
1209 
+     */
1210 
+    private function getHookPath($path) {
1211 
+        if (!Filesystem::getView()) {
1212 
+            return $path;
1213 
+        }
1214 
+        return Filesystem::getView()->getRelativePath($this->getAbsolutePath($path));
1215 
+    }
1216 
+
1217 
+    private function shouldEmitHooks($path = '') {
1218 
+        if ($path && Cache\Scanner::isPartialFile($path)) {
1219 
+            return false;
1220 
+        }
1221 
+        if (!Filesystem::$loaded) {
1222 
+            return false;
1223 
+        }
1224 
+        $defaultRoot = Filesystem::getRoot();
1225 
+        if ($defaultRoot === null) {
1226 
+            return false;
1227 
+        }
1228 
+        if ($this->fakeRoot === $defaultRoot) {
1229 
+            return true;
1230 
+        }
1231 
+        $fullPath = $this->getAbsolutePath($path);
1232 
+
1233 
+        if ($fullPath === $defaultRoot) {
1234 
+            return true;
1235 
+        }
1236 
+
1237 
+        return (strlen($fullPath) > strlen($defaultRoot)) && (substr($fullPath, 0, strlen($defaultRoot) + 1) === $defaultRoot . '/');
1238 
+    }
1239 
+
1240 
+    /**
1241 
+     * @param string[] $hooks
1242 
+     * @param string $path
1243 
+     * @param bool $post
1244 
+     * @return bool
1245 
+     */
1246 
+    private function runHooks($hooks, $path, $post = false) {
1247 
+        $relativePath = $path;
1248 
+        $path = $this->getHookPath($path);
1249 
+        $prefix = $post ? 'post_' : '';
1250 
+        $run = true;
1251 
+        if ($this->shouldEmitHooks($relativePath)) {
1252 
+            foreach ($hooks as $hook) {
1253 
+                if ($hook != 'read') {
1254 
+                    \OC_Hook::emit(
1255 
+                        Filesystem::CLASSNAME,
1256 
+                        $prefix . $hook,
1257 
+                        array(
1258 
+                            Filesystem::signal_param_run => &$run,
1259 
+                            Filesystem::signal_param_path => $path
1260 
+                        )
1261 
+                    );
1262 
+                } elseif (!$post) {
1263 
+                    \OC_Hook::emit(
1264 
+                        Filesystem::CLASSNAME,
1265 
+                        $prefix . $hook,
1266 
+                        array(
1267 
+                            Filesystem::signal_param_path => $path
1268 
+                        )
1269 
+                    );
1270 
+                }
1271 
+            }
1272 
+        }
1273 
+        return $run;
1274 
+    }
1275 
+
1276 
+    /**
1277 
+     * check if a file or folder has been updated since $time
1278 
+     *
1279 
+     * @param string $path
1280 
+     * @param int $time
1281 
+     * @return bool
1282 
+     */
1283 
+    public function hasUpdated($path, $time) {
1284 
+        return $this->basicOperation('hasUpdated', $path, array(), $time);
1285 
+    }
1286 
+
1287 
+    /**
1288 
+     * @param string $ownerId
1289 
+     * @return \OC\User\User
1290 
+     */
1291 
+    private function getUserObjectForOwner($ownerId) {
1292 
+        $owner = $this->userManager->get($ownerId);
1293 
+        if ($owner instanceof IUser) {
1294 
+            return $owner;
1295 
+        } else {
1296 
+            return new User($ownerId, null);
1297 
+        }
1298 
+    }
1299 
+
1300 
+    /**
1301 
+     * Get file info from cache
1302 
+     *
1303 
+     * If the file is not in cached it will be scanned
1304 
+     * If the file has changed on storage the cache will be updated
1305 
+     *
1306 
+     * @param \OC\Files\Storage\Storage $storage
1307 
+     * @param string $internalPath
1308 
+     * @param string $relativePath
1309 
+     * @return ICacheEntry|bool
1310 
+     */
1311 
+    private function getCacheEntry($storage, $internalPath, $relativePath) {
1312 
+        $cache = $storage->getCache($internalPath);
1313 
+        $data = $cache->get($internalPath);
1314 
+        $watcher = $storage->getWatcher($internalPath);
1315 
+
1316 
+        try {
1317 
+            // if the file is not in the cache or needs to be updated, trigger the scanner and reload the data
1318 
+            if (!$data || $data['size'] === -1) {
1319 
+                $this->lockFile($relativePath, ILockingProvider::LOCK_SHARED);
1320 
+                if (!$storage->file_exists($internalPath)) {
1321 
+                    $this->unlockFile($relativePath, ILockingProvider::LOCK_SHARED);
1322 
+                    return false;
1323 
+                }
1324 
+                $scanner = $storage->getScanner($internalPath);
1325 
+                $scanner->scan($internalPath, Cache\Scanner::SCAN_SHALLOW);
1326 
+                $data = $cache->get($internalPath);
1327 
+                $this->unlockFile($relativePath, ILockingProvider::LOCK_SHARED);
1328 
+            } else if (!Cache\Scanner::isPartialFile($internalPath) && $watcher->needsUpdate($internalPath, $data)) {
1329 
+                $this->lockFile($relativePath, ILockingProvider::LOCK_SHARED);
1330 
+                $watcher->update($internalPath, $data);
1331 
+                $storage->getPropagator()->propagateChange($internalPath, time());
1332 
+                $data = $cache->get($internalPath);
1333 
+                $this->unlockFile($relativePath, ILockingProvider::LOCK_SHARED);
1334 
+            }
1335 
+        } catch (LockedException $e) {
1336 
+            // if the file is locked we just use the old cache info
1337 
+        }
1338 
+
1339 
+        return $data;
1340 
+    }
1341 
+
1342 
+    /**
1343 
+     * get the filesystem info
1344 
+     *
1345 
+     * @param string $path
1346 
+     * @param boolean|string $includeMountPoints true to add mountpoint sizes,
1347 
+     * 'ext' to add only ext storage mount point sizes. Defaults to true.
1348 
+     * defaults to true
1349 
+     * @return \OC\Files\FileInfo|false False if file does not exist
1350 
+     */
1351 
+    public function getFileInfo($path, $includeMountPoints = true) {
1352 
+        $this->assertPathLength($path);
1353 
+        if (!Filesystem::isValidPath($path)) {
1354 
+            return false;
1355 
+        }
1356 
+        if (Cache\Scanner::isPartialFile($path)) {
1357 
+            return $this->getPartFileInfo($path);
1358 
+        }
1359 
+        $relativePath = $path;
1360 
+        $path = Filesystem::normalizePath($this->fakeRoot . '/' . $path);
1361 
+
1362 
+        $mount = Filesystem::getMountManager()->find($path);
1363 
+        if (!$mount) {
1364 
+            return false;
1365 
+        }
1366 
+        $storage = $mount->getStorage();
1367 
+        $internalPath = $mount->getInternalPath($path);
1368 
+        if ($storage) {
1369 
+            $data = $this->getCacheEntry($storage, $internalPath, $relativePath);
1370 
+
1371 
+            if (!$data instanceof ICacheEntry) {
1372 
+                return false;
1373 
+            }
1374 
+
1375 
+            if ($mount instanceof MoveableMount && $internalPath === '') {
1376 
+                $data['permissions'] |= \OCP\Constants::PERMISSION_DELETE;
1377 
+            }
1378 
+
1379 
+            $owner = $this->getUserObjectForOwner($storage->getOwner($internalPath));
1380 
+            $info = new FileInfo($path, $storage, $internalPath, $data, $mount, $owner);
1381 
+
1382 
+            if ($data and isset($data['fileid'])) {
1383 
+                if ($includeMountPoints and $data['mimetype'] === 'httpd/unix-directory') {
1384 
+                    //add the sizes of other mount points to the folder
1385 
+                    $extOnly = ($includeMountPoints === 'ext');
1386 
+                    $mounts = Filesystem::getMountManager()->findIn($path);
1387 
+                    $info->setSubMounts(array_filter($mounts, function (IMountPoint $mount) use ($extOnly) {
1388 
+                        $subStorage = $mount->getStorage();
1389 
+                        return !($extOnly && $subStorage instanceof \OCA\Files_Sharing\SharedStorage);
1390 
+                    }));
1391 
+                }
1392 
+            }
1393 
+
1394 
+            return $info;
1395 
+        }
1396 
+
1397 
+        return false;
1398 
+    }
1399 
+
1400 
+    /**
1401 
+     * get the content of a directory
1402 
+     *
1403 
+     * @param string $directory path under datadirectory
1404 
+     * @param string $mimetype_filter limit returned content to this mimetype or mimepart
1405 
+     * @return FileInfo[]
1406 
+     */
1407 
+    public function getDirectoryContent($directory, $mimetype_filter = '') {
1408 
+        $this->assertPathLength($directory);
1409 
+        if (!Filesystem::isValidPath($directory)) {
1410 
+            return [];
1411 
+        }
1412 
+        $path = $this->getAbsolutePath($directory);
1413 
+        $path = Filesystem::normalizePath($path);
1414 
+        $mount = $this->getMount($directory);
1415 
+        if (!$mount) {
1416 
+            return [];
1417 
+        }
1418 
+        $storage = $mount->getStorage();
1419 
+        $internalPath = $mount->getInternalPath($path);
1420 
+        if ($storage) {
1421 
+            $cache = $storage->getCache($internalPath);
1422 
+            $user = \OC_User::getUser();
1423 
+
1424 
+            $data = $this->getCacheEntry($storage, $internalPath, $directory);
1425 
+
1426 
+            if (!$data instanceof ICacheEntry || !isset($data['fileid']) || !($data->getPermissions() && Constants::PERMISSION_READ)) {
1427 
+                return [];
1428 
+            }
1429 
+
1430 
+            $folderId = $data['fileid'];
1431 
+            $contents = $cache->getFolderContentsById($folderId); //TODO: mimetype_filter
1432 
+
1433 
+            $sharingDisabled = \OCP\Util::isSharingDisabledForUser();
1434 
+            /**
1435 
+             * @var \OC\Files\FileInfo[] $files
1436 
+             */
1437 
+            $files = array_map(function (ICacheEntry $content) use ($path, $storage, $mount, $sharingDisabled) {
1438 
+                if ($sharingDisabled) {
1439 
+                    $content['permissions'] = $content['permissions'] & ~\OCP\Constants::PERMISSION_SHARE;
1440 
+                }
1441 
+                $owner = $this->getUserObjectForOwner($storage->getOwner($content['path']));
1442 
+                return new FileInfo($path . '/' . $content['name'], $storage, $content['path'], $content, $mount, $owner);
1443 
+            }, $contents);
1444 
+
1445 
+            //add a folder for any mountpoint in this directory and add the sizes of other mountpoints to the folders
1446 
+            $mounts = Filesystem::getMountManager()->findIn($path);
1447 
+            $dirLength = strlen($path);
1448 
+            foreach ($mounts as $mount) {
1449 
+                $mountPoint = $mount->getMountPoint();
1450 
+                $subStorage = $mount->getStorage();
1451 
+                if ($subStorage) {
1452 
+                    $subCache = $subStorage->getCache('');
1453 
+
1454 
+                    $rootEntry = $subCache->get('');
1455 
+                    if (!$rootEntry) {
1456 
+                        $subScanner = $subStorage->getScanner('');
1457 
+                        try {
1458 
+                            $subScanner->scanFile('');
1459 
+                        } catch (\OCP\Files\StorageNotAvailableException $e) {
1460 
+                            continue;
1461 
+                        } catch (\OCP\Files\StorageInvalidException $e) {
1462 
+                            continue;
1463 
+                        } catch (\Exception $e) {
1464 
+                            // sometimes when the storage is not available it can be any exception
1465 
+                            \OC::$server->getLogger()->logException($e, [
1466 
+                                'message' => 'Exception while scanning storage "' . $subStorage->getId() . '"',
1467 
+                                'level' => ILogger::ERROR,
1468 
+                                'app' => 'lib',
1469 
+                            ]);
1470 
+                            continue;
1471 
+                        }
1472 
+                        $rootEntry = $subCache->get('');
1473 
+                    }
1474 
+
1475 
+                    if ($rootEntry && ($rootEntry->getPermissions() && Constants::PERMISSION_READ)) {
1476 
+                        $relativePath = trim(substr($mountPoint, $dirLength), '/');
1477 
+                        if ($pos = strpos($relativePath, '/')) {
1478 
+                            //mountpoint inside subfolder add size to the correct folder
1479 
+                            $entryName = substr($relativePath, 0, $pos);
1480 
+                            foreach ($files as &$entry) {
1481 
+                                if ($entry->getName() === $entryName) {
1482 
+                                    $entry->addSubEntry($rootEntry, $mountPoint);
1483 
+                                }
1484 
+                            }
1485 
+                        } else { //mountpoint in this folder, add an entry for it
1486 
+                            $rootEntry['name'] = $relativePath;
1487 
+                            $rootEntry['type'] = $rootEntry['mimetype'] === 'httpd/unix-directory' ? 'dir' : 'file';
1488 
+                            $permissions = $rootEntry['permissions'];
1489 
+                            // do not allow renaming/deleting the mount point if they are not shared files/folders
1490 
+                            // for shared files/folders we use the permissions given by the owner
1491 
+                            if ($mount instanceof MoveableMount) {
1492 
+                                $rootEntry['permissions'] = $permissions | \OCP\Constants::PERMISSION_UPDATE | \OCP\Constants::PERMISSION_DELETE;
1493 
+                            } else {
1494 
+                                $rootEntry['permissions'] = $permissions & (\OCP\Constants::PERMISSION_ALL - (\OCP\Constants::PERMISSION_UPDATE | \OCP\Constants::PERMISSION_DELETE));
1495 
+                            }
1496 
+
1497 
+                            //remove any existing entry with the same name
1498 
+                            foreach ($files as $i => $file) {
1499 
+                                if ($file['name'] === $rootEntry['name']) {
1500 
+                                    unset($files[$i]);
1501 
+                                    break;
1502 
+                                }
1503 
+                            }
1504 
+                            $rootEntry['path'] = substr(Filesystem::normalizePath($path . '/' . $rootEntry['name']), strlen($user) + 2); // full path without /$user/
1505 
+
1506 
+                            // if sharing was disabled for the user we remove the share permissions
1507 
+                            if (\OCP\Util::isSharingDisabledForUser()) {
1508 
+                                $rootEntry['permissions'] = $rootEntry['permissions'] & ~\OCP\Constants::PERMISSION_SHARE;
1509 
+                            }
1510 
+
1511 
+                            $owner = $this->getUserObjectForOwner($subStorage->getOwner(''));
1512 
+                            $files[] = new FileInfo($path . '/' . $rootEntry['name'], $subStorage, '', $rootEntry, $mount, $owner);
1513 
+                        }
1514 
+                    }
1515 
+                }
1516 
+            }
1517 
+
1518 
+            if ($mimetype_filter) {
1519 
+                $files = array_filter($files, function (FileInfo $file) use ($mimetype_filter) {
1520 
+                    if (strpos($mimetype_filter, '/')) {
1521 
+                        return $file->getMimetype() === $mimetype_filter;
1522 
+                    } else {
1523 
+                        return $file->getMimePart() === $mimetype_filter;
1524 
+                    }
1525 
+                });
1526 
+            }
1527 
+
1528 
+            return $files;
1529 
+        } else {
1530 
+            return [];
1531 
+        }
1532 
+    }
1533 
+
1534 
+    /**
1535 
+     * change file metadata
1536 
+     *
1537 
+     * @param string $path
1538 
+     * @param array|\OCP\Files\FileInfo $data
1539 
+     * @return int
1540 
+     *
1541 
+     * returns the fileid of the updated file
1542 
+     */
1543 
+    public function putFileInfo($path, $data) {
1544 
+        $this->assertPathLength($path);
1545 
+        if ($data instanceof FileInfo) {
1546 
+            $data = $data->getData();
1547 
+        }
1548 
+        $path = Filesystem::normalizePath($this->fakeRoot . '/' . $path);
1549 
+        /**
1550 
+         * @var \OC\Files\Storage\Storage $storage
1551 
+         * @var string $internalPath
1552 
+         */
1553 
+        list($storage, $internalPath) = Filesystem::resolvePath($path);
1554 
+        if ($storage) {
1555 
+            $cache = $storage->getCache($path);
1556 
+
1557 
+            if (!$cache->inCache($internalPath)) {
1558 
+                $scanner = $storage->getScanner($internalPath);
1559 
+                $scanner->scan($internalPath, Cache\Scanner::SCAN_SHALLOW);
1560 
+            }
1561 
+
1562 
+            return $cache->put($internalPath, $data);
1563 
+        } else {
1564 
+            return -1;
1565 
+        }
1566 
+    }
1567 
+
1568 
+    /**
1569 
+     * search for files with the name matching $query
1570 
+     *
1571 
+     * @param string $query
1572 
+     * @return FileInfo[]
1573 
+     */
1574 
+    public function search($query) {
1575 
+        return $this->searchCommon('search', array('%' . $query . '%'));
1576 
+    }
1577 
+
1578 
+    /**
1579 
+     * search for files with the name matching $query
1580 
+     *
1581 
+     * @param string $query
1582 
+     * @return FileInfo[]
1583 
+     */
1584 
+    public function searchRaw($query) {
1585 
+        return $this->searchCommon('search', array($query));
1586 
+    }
1587 
+
1588 
+    /**
1589 
+     * search for files by mimetype
1590 
+     *
1591 
+     * @param string $mimetype
1592 
+     * @return FileInfo[]
1593 
+     */
1594 
+    public function searchByMime($mimetype) {
1595 
+        return $this->searchCommon('searchByMime', array($mimetype));
1596 
+    }
1597 
+
1598 
+    /**
1599 
+     * search for files by tag
1600 
+     *
1601 
+     * @param string|int $tag name or tag id
1602 
+     * @param string $userId owner of the tags
1603 
+     * @return FileInfo[]
1604 
+     */
1605 
+    public function searchByTag($tag, $userId) {
1606 
+        return $this->searchCommon('searchByTag', array($tag, $userId));
1607 
+    }
1608 
+
1609 
+    /**
1610 
+     * @param string $method cache method
1611 
+     * @param array $args
1612 
+     * @return FileInfo[]
1613 
+     */
1614 
+    private function searchCommon($method, $args) {
1615 
+        $files = array();
1616 
+        $rootLength = strlen($this->fakeRoot);
1617 
+
1618 
+        $mount = $this->getMount('');
1619 
+        $mountPoint = $mount->getMountPoint();
1620 
+        $storage = $mount->getStorage();
1621 
+        if ($storage) {
1622 
+            $cache = $storage->getCache('');
1623 
+
1624 
+            $results = call_user_func_array(array($cache, $method), $args);
1625 
+            foreach ($results as $result) {
1626 
+                if (substr($mountPoint . $result['path'], 0, $rootLength + 1) === $this->fakeRoot . '/') {
1627 
+                    $internalPath = $result['path'];
1628 
+                    $path = $mountPoint . $result['path'];
1629 
+                    $result['path'] = substr($mountPoint . $result['path'], $rootLength);
1630 
+                    $owner = \OC::$server->getUserManager()->get($storage->getOwner($internalPath));
1631 
+                    $files[] = new FileInfo($path, $storage, $internalPath, $result, $mount, $owner);
1632 
+                }
1633 
+            }
1634 
+
1635 
+            $mounts = Filesystem::getMountManager()->findIn($this->fakeRoot);
1636 
+            foreach ($mounts as $mount) {
1637 
+                $mountPoint = $mount->getMountPoint();
1638 
+                $storage = $mount->getStorage();
1639 
+                if ($storage) {
1640 
+                    $cache = $storage->getCache('');
1641 
+
1642 
+                    $relativeMountPoint = substr($mountPoint, $rootLength);
1643 
+                    $results = call_user_func_array(array($cache, $method), $args);
1644 
+                    if ($results) {
1645 
+                        foreach ($results as $result) {
1646 
+                            $internalPath = $result['path'];
1647 
+                            $result['path'] = rtrim($relativeMountPoint . $result['path'], '/');
1648 
+                            $path = rtrim($mountPoint . $internalPath, '/');
1649 
+                            $owner = \OC::$server->getUserManager()->get($storage->getOwner($internalPath));
1650 
+                            $files[] = new FileInfo($path, $storage, $internalPath, $result, $mount, $owner);
1651 
+                        }
1652 
+                    }
1653 
+                }
1654 
+            }
1655 
+        }
1656 
+        return $files;
1657 
+    }
1658 
+
1659 
+    /**
1660 
+     * Get the owner for a file or folder
1661 
+     *
1662 
+     * @param string $path
1663 
+     * @return string the user id of the owner
1664 
+     * @throws NotFoundException
1665 
+     */
1666 
+    public function getOwner($path) {
1667 
+        $info = $this->getFileInfo($path);
1668 
+        if (!$info) {
1669 
+            throw new NotFoundException($path . ' not found while trying to get owner');
1670 
+        }
1671 
+        return $info->getOwner()->getUID();
1672 
+    }
1673 
+
1674 
+    /**
1675 
+     * get the ETag for a file or folder
1676 
+     *
1677 
+     * @param string $path
1678 
+     * @return string
1679 
+     */
1680 
+    public function getETag($path) {
1681 
+        /**
1682 
+         * @var Storage\Storage $storage
1683 
+         * @var string $internalPath
1684 
+         */
1685 
+        list($storage, $internalPath) = $this->resolvePath($path);
1686 
+        if ($storage) {
1687 
+            return $storage->getETag($internalPath);
1688 
+        } else {
1689 
+            return null;
1690 
+        }
1691 
+    }
1692 
+
1693 
+    /**
1694 
+     * Get the path of a file by id, relative to the view
1695 
+     *
1696 
+     * Note that the resulting path is not guarantied to be unique for the id, multiple paths can point to the same file
1697 
+     *
1698 
+     * @param int $id
1699 
+     * @throws NotFoundException
1700 
+     * @return string
1701 
+     */
1702 
+    public function getPath($id) {
1703 
+        $id = (int)$id;
1704 
+        $manager = Filesystem::getMountManager();
1705 
+        $mounts = $manager->findIn($this->fakeRoot);
1706 
+        $mounts[] = $manager->find($this->fakeRoot);
1707 
+        // reverse the array so we start with the storage this view is in
1708 
+        // which is the most likely to contain the file we're looking for
1709 
+        $mounts = array_reverse($mounts);
1710 
+        foreach ($mounts as $mount) {
1711 
+            /**
1712 
+             * @var \OC\Files\Mount\MountPoint $mount
1713 
+             */
1714 
+            if ($mount->getStorage()) {
1715 
+                $cache = $mount->getStorage()->getCache();
1716 
+                $internalPath = $cache->getPathById($id);
1717 
+                if (is_string($internalPath)) {
1718 
+                    $fullPath = $mount->getMountPoint() . $internalPath;
1719 
+                    if (!is_null($path = $this->getRelativePath($fullPath))) {
1720 
+                        return $path;
1721 
+                    }
1722 
+                }
1723 
+            }
1724 
+        }
1725 
+        throw new NotFoundException(sprintf('File with id "%s" has not been found.', $id));
1726 
+    }
1727 
+
1728 
+    /**
1729 
+     * @param string $path
1730 
+     * @throws InvalidPathException
1731 
+     */
1732 
+    private function assertPathLength($path) {
1733 
+        $maxLen = min(PHP_MAXPATHLEN, 4000);
1734 
+        // Check for the string length - performed using isset() instead of strlen()
1735 
+        // because isset() is about 5x-40x faster.
1736 
+        if (isset($path[$maxLen])) {
1737 
+            $pathLen = strlen($path);
1738 
+            throw new \OCP\Files\InvalidPathException("Path length($pathLen) exceeds max path length($maxLen): $path");
1739 
+        }
1740 
+    }
1741 
+
1742 
+    /**
1743 
+     * check if it is allowed to move a mount point to a given target.
1744 
+     * It is not allowed to move a mount point into a different mount point or
1745 
+     * into an already shared folder
1746 
+     *
1747 
+     * @param string $target path
1748 
+     * @return boolean
1749 
+     */
1750 
+    private function isTargetAllowed($target) {
1751 
+
1752 
+        list($targetStorage, $targetInternalPath) = \OC\Files\Filesystem::resolvePath($target);
1753 
+        if (!$targetStorage->instanceOfStorage('\OCP\Files\IHomeStorage')) {
1754 
+            \OCP\Util::writeLog('files',
1755 
+                'It is not allowed to move one mount point into another one',
1756 
+                ILogger::DEBUG);
1757 
+            return false;
1758 
+        }
1759 
+
1760 
+        // note: cannot use the view because the target is already locked
1761 
+        $fileId = (int)$targetStorage->getCache()->getId($targetInternalPath);
1762 
+        if ($fileId === -1) {
1763 
+            // target might not exist, need to check parent instead
1764 
+            $fileId = (int)$targetStorage->getCache()->getId(dirname($targetInternalPath));
1765 
+        }
1766 
+
1767 
+        // check if any of the parents were shared by the current owner (include collections)
1768 
+        $shares = \OCP\Share::getItemShared(
1769 
+            'folder',
1770 
+            $fileId,
1771 
+            \OCP\Share::FORMAT_NONE,
1772 
+            null,
1773 
+            true
1774 
+        );
1775 
+
1776 
+        if (count($shares) > 0) {
1777 
+            \OCP\Util::writeLog('files',
1778 
+                'It is not allowed to move one mount point into a shared folder',
1779 
+                ILogger::DEBUG);
1780 
+            return false;
1781 
+        }
1782 
+
1783 
+        return true;
1784 
+    }
1785 
+
1786 
+    /**
1787 
+     * Get a fileinfo object for files that are ignored in the cache (part files)
1788 
+     *
1789 
+     * @param string $path
1790 
+     * @return \OCP\Files\FileInfo
1791 
+     */
1792 
+    private function getPartFileInfo($path) {
1793 
+        $mount = $this->getMount($path);
1794 
+        $storage = $mount->getStorage();
1795 
+        $internalPath = $mount->getInternalPath($this->getAbsolutePath($path));
1796 
+        $owner = \OC::$server->getUserManager()->get($storage->getOwner($internalPath));
1797 
+        return new FileInfo(
1798 
+            $this->getAbsolutePath($path),
1799 
+            $storage,
1800 
+            $internalPath,
1801 
+            [
1802 
+                'fileid' => null,
1803 
+                'mimetype' => $storage->getMimeType($internalPath),
1804 
+                'name' => basename($path),
1805 
+                'etag' => null,
1806 
+                'size' => $storage->filesize($internalPath),
1807 
+                'mtime' => $storage->filemtime($internalPath),
1808 
+                'encrypted' => false,
1809 
+                'permissions' => \OCP\Constants::PERMISSION_ALL
1810 
+            ],
1811 
+            $mount,
1812 
+            $owner
1813 
+        );
1814 
+    }
1815 
+
1816 
+    /**
1817 
+     * @param string $path
1818 
+     * @param string $fileName
1819 
+     * @throws InvalidPathException
1820 
+     */
1821 
+    public function verifyPath($path, $fileName) {
1822 
+        try {
1823 
+            /** @type \OCP\Files\Storage $storage */
1824 
+            list($storage, $internalPath) = $this->resolvePath($path);
1825 
+            $storage->verifyPath($internalPath, $fileName);
1826 
+        } catch (ReservedWordException $ex) {
1827 
+            $l = \OC::$server->getL10N('lib');
1828 
+            throw new InvalidPathException($l->t('File name is a reserved word'));
1829 
+        } catch (InvalidCharacterInPathException $ex) {
1830 
+            $l = \OC::$server->getL10N('lib');
1831 
+            throw new InvalidPathException($l->t('File name contains at least one invalid character'));
1832 
+        } catch (FileNameTooLongException $ex) {
1833 
+            $l = \OC::$server->getL10N('lib');
1834 
+            throw new InvalidPathException($l->t('File name is too long'));
1835 
+        } catch (InvalidDirectoryException $ex) {
1836 
+            $l = \OC::$server->getL10N('lib');
1837 
+            throw new InvalidPathException($l->t('Dot files are not allowed'));
1838 
+        } catch (EmptyFileNameException $ex) {
1839 
+            $l = \OC::$server->getL10N('lib');
1840 
+            throw new InvalidPathException($l->t('Empty filename is not allowed'));
1841 
+        }
1842 
+    }
1843 
+
1844 
+    /**
1845 
+     * get all parent folders of $path
1846 
+     *
1847 
+     * @param string $path
1848 
+     * @return string[]
1849 
+     */
1850 
+    private function getParents($path) {
1851 
+        $path = trim($path, '/');
1852 
+        if (!$path) {
1853 
+            return [];
1854 
+        }
1855 
+
1856 
+        $parts = explode('/', $path);
1857 
+
1858 
+        // remove the single file
1859 
+        array_pop($parts);
1860 
+        $result = array('/');
1861 
+        $resultPath = '';
1862 
+        foreach ($parts as $part) {
1863 
+            if ($part) {
1864 
+                $resultPath .= '/' . $part;
1865 
+                $result[] = $resultPath;
1866 
+            }
1867 
+        }
1868 
+        return $result;
1869 
+    }
1870 
+
1871 
+    /**
1872 
+     * Returns the mount point for which to lock
1873 
+     *
1874 
+     * @param string $absolutePath absolute path
1875 
+     * @param bool $useParentMount true to return parent mount instead of whatever
1876 
+     * is mounted directly on the given path, false otherwise
1877 
+     * @return \OC\Files\Mount\MountPoint mount point for which to apply locks
1878 
+     */
1879 
+    private function getMountForLock($absolutePath, $useParentMount = false) {
1880 
+        $results = [];
1881 
+        $mount = Filesystem::getMountManager()->find($absolutePath);
1882 
+        if (!$mount) {
1883 
+            return $results;
1884 
+        }
1885 
+
1886 
+        if ($useParentMount) {
1887 
+            // find out if something is mounted directly on the path
1888 
+            $internalPath = $mount->getInternalPath($absolutePath);
1889 
+            if ($internalPath === '') {
1890 
+                // resolve the parent mount instead
1891 
+                $mount = Filesystem::getMountManager()->find(dirname($absolutePath));
1892 
+            }
1893 
+        }
1894 
+
1895 
+        return $mount;
1896 
+    }
1897 
+
1898 
+    /**
1899 
+     * Lock the given path
1900 
+     *
1901 
+     * @param string $path the path of the file to lock, relative to the view
1902 
+     * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
1903 
+     * @param bool $lockMountPoint true to lock the mount point, false to lock the attached mount/storage
1904 
+     *
1905 
+     * @return bool False if the path is excluded from locking, true otherwise
1906 
+     * @throws \OCP\Lock\LockedException if the path is already locked
1907 
+     */
1908 
+    private function lockPath($path, $type, $lockMountPoint = false) {
1909 
+        $absolutePath = $this->getAbsolutePath($path);
1910 
+        $absolutePath = Filesystem::normalizePath($absolutePath);
1911 
+        if (!$this->shouldLockFile($absolutePath)) {
1912 
+            return false;
1913 
+        }
1914 
+
1915 
+        $mount = $this->getMountForLock($absolutePath, $lockMountPoint);
1916 
+        if ($mount) {
1917 
+            try {
1918 
+                $storage = $mount->getStorage();
1919 
+                if ($storage->instanceOfStorage('\OCP\Files\Storage\ILockingStorage')) {
1920 
+                    $storage->acquireLock(
1921 
+                        $mount->getInternalPath($absolutePath),
1922 
+                        $type,
1923 
+                        $this->lockingProvider
1924 
+                    );
1925 
+                }
1926 
+            } catch (\OCP\Lock\LockedException $e) {
1927 
+                // rethrow with the a human-readable path
1928 
+                throw new \OCP\Lock\LockedException(
1929 
+                    $this->getPathRelativeToFiles($absolutePath),
1930 
+                    $e
1931 
+                );
1932 
+            }
1933 
+        }
1934 
+
1935 
+        return true;
1936 
+    }
1937 
+
1938 
+    /**
1939 
+     * Change the lock type
1940 
+     *
1941 
+     * @param string $path the path of the file to lock, relative to the view
1942 
+     * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
1943 
+     * @param bool $lockMountPoint true to lock the mount point, false to lock the attached mount/storage
1944 
+     *
1945 
+     * @return bool False if the path is excluded from locking, true otherwise
1946 
+     * @throws \OCP\Lock\LockedException if the path is already locked
1947 
+     */
1948 
+    public function changeLock($path, $type, $lockMountPoint = false) {
1949 
+        $path = Filesystem::normalizePath($path);
1950 
+        $absolutePath = $this->getAbsolutePath($path);
1951 
+        $absolutePath = Filesystem::normalizePath($absolutePath);
1952 
+        if (!$this->shouldLockFile($absolutePath)) {
1953 
+            return false;
1954 
+        }
1955 
+
1956 
+        $mount = $this->getMountForLock($absolutePath, $lockMountPoint);
1957 
+        if ($mount) {
1958 
+            try {
1959 
+                $storage = $mount->getStorage();
1960 
+                if ($storage->instanceOfStorage('\OCP\Files\Storage\ILockingStorage')) {
1961 
+                    $storage->changeLock(
1962 
+                        $mount->getInternalPath($absolutePath),
1963 
+                        $type,
1964 
+                        $this->lockingProvider
1965 
+                    );
1966 
+                }
1967 
+            } catch (\OCP\Lock\LockedException $e) {
1968 
+                try {
1969 
+                    // rethrow with the a human-readable path
1970 
+                    throw new \OCP\Lock\LockedException(
1971 
+                        $this->getPathRelativeToFiles($absolutePath),
1972 
+                        $e
1973 
+                    );
1974 
+                } catch (\InvalidArgumentException $e) {
1975 
+                    throw new \OCP\Lock\LockedException(
1976 
+                        $absolutePath,
1977 
+                        $e
1978 
+                    );
1979 
+                }
1980 
+            }
1981 
+        }
1982 
+
1983 
+        return true;
1984 
+    }
1985 
+
1986 
+    /**
1987 
+     * Unlock the given path
1988 
+     *
1989 
+     * @param string $path the path of the file to unlock, relative to the view
1990 
+     * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
1991 
+     * @param bool $lockMountPoint true to lock the mount point, false to lock the attached mount/storage
1992 
+     *
1993 
+     * @return bool False if the path is excluded from locking, true otherwise
1994 
+     */
1995 
+    private function unlockPath($path, $type, $lockMountPoint = false) {
1996 
+        $absolutePath = $this->getAbsolutePath($path);
1997 
+        $absolutePath = Filesystem::normalizePath($absolutePath);
1998 
+        if (!$this->shouldLockFile($absolutePath)) {
1999 
+            return false;
2000 
+        }
2001 
+
2002 
+        $mount = $this->getMountForLock($absolutePath, $lockMountPoint);
2003 
+        if ($mount) {
2004 
+            $storage = $mount->getStorage();
2005 
+            if ($storage && $storage->instanceOfStorage('\OCP\Files\Storage\ILockingStorage')) {
2006 
+                $storage->releaseLock(
2007 
+                    $mount->getInternalPath($absolutePath),
2008 
+                    $type,
2009 
+                    $this->lockingProvider
2010 
+                );
2011 
+            }
2012 
+        }
2013 
+
2014 
+        return true;
2015 
+    }
2016 
+
2017 
+    /**
2018 
+     * Lock a path and all its parents up to the root of the view
2019 
+     *
2020 
+     * @param string $path the path of the file to lock relative to the view
2021 
+     * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
2022 
+     * @param bool $lockMountPoint true to lock the mount point, false to lock the attached mount/storage
2023 
+     *
2024 
+     * @return bool False if the path is excluded from locking, true otherwise
2025 
+     */
2026 
+    public function lockFile($path, $type, $lockMountPoint = false) {
2027 
+        $absolutePath = $this->getAbsolutePath($path);
2028 
+        $absolutePath = Filesystem::normalizePath($absolutePath);
2029 
+        if (!$this->shouldLockFile($absolutePath)) {
2030 
+            return false;
2031 
+        }
2032 
+
2033 
+        $this->lockPath($path, $type, $lockMountPoint);
2034 
+
2035 
+        $parents = $this->getParents($path);
2036 
+        foreach ($parents as $parent) {
2037 
+            $this->lockPath($parent, ILockingProvider::LOCK_SHARED);
2038 
+        }
2039 
+
2040 
+        return true;
2041 
+    }
2042 
+
2043 
+    /**
2044 
+     * Unlock a path and all its parents up to the root of the view
2045 
+     *
2046 
+     * @param string $path the path of the file to lock relative to the view
2047 
+     * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
2048 
+     * @param bool $lockMountPoint true to lock the mount point, false to lock the attached mount/storage
2049 
+     *
2050 
+     * @return bool False if the path is excluded from locking, true otherwise
2051 
+     */
2052 
+    public function unlockFile($path, $type, $lockMountPoint = false) {
2053 
+        $absolutePath = $this->getAbsolutePath($path);
2054 
+        $absolutePath = Filesystem::normalizePath($absolutePath);
2055 
+        if (!$this->shouldLockFile($absolutePath)) {
2056 
+            return false;
2057 
+        }
2058 
+
2059 
+        $this->unlockPath($path, $type, $lockMountPoint);
2060 
+
2061 
+        $parents = $this->getParents($path);
2062 
+        foreach ($parents as $parent) {
2063 
+            $this->unlockPath($parent, ILockingProvider::LOCK_SHARED);
2064 
+        }
2065 
+
2066 
+        return true;
2067 
+    }
2068 
+
2069 
+    /**
2070 
+     * Only lock files in data/user/files/
2071 
+     *
2072 
+     * @param string $path Absolute path to the file/folder we try to (un)lock
2073 
+     * @return bool
2074 
+     */
2075 
+    protected function shouldLockFile($path) {
2076 
+        $path = Filesystem::normalizePath($path);
2077 
+
2078 
+        $pathSegments = explode('/', $path);
2079 
+        if (isset($pathSegments[2])) {
2080 
+            // E.g.: /username/files/path-to-file
2081 
+            return ($pathSegments[2] === 'files') && (count($pathSegments) > 3);
2082 
+        }
2083 
+
2084 
+        return strpos($path, '/appdata_') !== 0;
2085 
+    }
2086 
+
2087 
+    /**
2088 
+     * Shortens the given absolute path to be relative to
2089 
+     * "$user/files".
2090 
+     *
2091 
+     * @param string $absolutePath absolute path which is under "files"
2092 
+     *
2093 
+     * @return string path relative to "files" with trimmed slashes or null
2094 
+     * if the path was NOT relative to files
2095 
+     *
2096 
+     * @throws \InvalidArgumentException if the given path was not under "files"
2097 
+     * @since 8.1.0
2098 
+     */
2099 
+    public function getPathRelativeToFiles($absolutePath) {
2100 
+        $path = Filesystem::normalizePath($absolutePath);
2101 
+        $parts = explode('/', trim($path, '/'), 3);
2102 
+        // "$user", "files", "path/to/dir"
2103 
+        if (!isset($parts[1]) || $parts[1] !== 'files') {
2104 
+            $this->logger->error(
2105 
+                '$absolutePath must be relative to "files", value is "%s"',
2106 
+                [
2107 
+                    $absolutePath
2108 
+                ]
2109 
+            );
2110 
+            throw new \InvalidArgumentException('$absolutePath must be relative to "files"');
2111 
+        }
2112 
+        if (isset($parts[2])) {
2113 
+            return $parts[2];
2114 
+        }
2115 
+        return '';
2116 
+    }
2117 
+
2118 
+    /**
2119 
+     * @param string $filename
2120 
+     * @return array
2121 
+     * @throws \OC\User\NoUserException
2122 
+     * @throws NotFoundException
2123 
+     */
2124 
+    public function getUidAndFilename($filename) {
2125 
+        $info = $this->getFileInfo($filename);
2126 
+        if (!$info instanceof \OCP\Files\FileInfo) {
2127 
+            throw new NotFoundException($this->getAbsolutePath($filename) . ' not found');
2128 
+        }
2129 
+        $uid = $info->getOwner()->getUID();
2130 
+        if ($uid != \OCP\User::getUser()) {
2131 
+            Filesystem::initMountPoints($uid);
2132 
+            $ownerView = new View('/' . $uid . '/files');
2133 
+            try {
2134 
+                $filename = $ownerView->getPath($info['fileid']);
2135 
+            } catch (NotFoundException $e) {
2136 
+                throw new NotFoundException('File with id ' . $info['fileid'] . ' not found for user ' . $uid);
2137 
+            }
2138 
+        }
2139 
+        return [$uid, $filename];
2140 
+    }
2141 
+
2142 
+    /**
2143 
+     * Creates parent non-existing folders
2144 
+     *
2145 
+     * @param string $filePath
2146 
+     * @return bool
2147 
+     */
2148 
+    private function createParentDirectories($filePath) {
2149 
+        $directoryParts = explode('/', $filePath);
2150 
+        $directoryParts = array_filter($directoryParts);
2151 
+        foreach ($directoryParts as $key => $part) {
2152 
+            $currentPathElements = array_slice($directoryParts, 0, $key);
2153 
+            $currentPath = '/' . implode('/', $currentPathElements);
2154 
+            if ($this->is_file($currentPath)) {
2155 
+                return false;
2156 
+            }
2157 
+            if (!$this->file_exists($currentPath)) {
2158 
+                $this->mkdir($currentPath);
2159 
+            }
2160 
+        }
2161 
+
2162 
+        return true;
2163 
+    }
2164 2164 
 }
Please login to merge, or discard this patch.
Spacing   +40 added lines, -40 removed lines patch added patch discarded remove patch 
@@ -127,9 +127,9 @@  discard block
 
 block discarded – undo
127 127 
 			$path = '/';
128 128 
 		}
129 129 
 		if ($path[0] !== '/') {
130 
-			$path = '/' . $path;
130 
+			$path = '/'.$path;
131 131 
 		}
132 
-		return $this->fakeRoot . $path;
132 
+		return $this->fakeRoot.$path;
133 133 
 	}
134 134
135 135 
 	/**
 
@@ -141,7 +141,7 @@  discard block
 
 block discarded – undo
141 141 
 	public function chroot($fakeRoot) {
142 142 
 		if (!$fakeRoot == '') {
143 143 
 			if ($fakeRoot[0] !== '/') {
144 
-				$fakeRoot = '/' . $fakeRoot;
144 
+				$fakeRoot = '/'.$fakeRoot;
145 145 
 			}
146 146 
 		}
147 147 
 		$this->fakeRoot = $fakeRoot;
 
@@ -173,7 +173,7 @@  discard block
 
 block discarded – undo
173 173 
 		}
174 174
175 175 
 		// missing slashes can cause wrong matches!
176 
-		$root = rtrim($this->fakeRoot, '/') . '/';
176 
+		$root = rtrim($this->fakeRoot, '/').'/';
177 177
178 178 
 		if (strpos($path, $root) !== 0) {
179 179 
 			return null;
 
@@ -279,7 +279,7 @@  discard block
 
 block discarded – undo
279 279 
 		if ($mount instanceof MoveableMount) {
280 280 
 			// cut of /user/files to get the relative path to data/user/files
281 281 
 			$pathParts = explode('/', $path, 4);
282 
-			$relPath = '/' . $pathParts[3];
282 
+			$relPath = '/'.$pathParts[3];
283 283 
 			$this->lockFile($relPath, ILockingProvider::LOCK_SHARED, true);
284 284 
 			\OC_Hook::emit(
285 285 
 				Filesystem::CLASSNAME, "umount",
 
@@ -699,7 +699,7 @@  discard block
 
 block discarded – undo
699 699 
 		}
700 700 
 		$postFix = (substr($path, -1) === '/') ? '/' : '';
701 701 
 		$absolutePath = Filesystem::normalizePath($this->getAbsolutePath($path));
702 
-		$mount = Filesystem::getMountManager()->find($absolutePath . $postFix);
702 
+		$mount = Filesystem::getMountManager()->find($absolutePath.$postFix);
703 703 
 		if ($mount and $mount->getInternalPath($absolutePath) === '') {
704 704 
 			return $this->removeMount($mount, $absolutePath);
705 705 
 		}
 
@@ -819,7 +819,7 @@  discard block
 
 block discarded – undo
819 819 
 								$this->renameUpdate($storage1, $storage2, $internalPath1, $internalPath2);
820 820 
 							}
821 821 
 						}
822 
-					} catch(\Exception $e) {
822 
+					} catch (\Exception $e) {
823 823 
 						throw $e;
824 824 
 					} finally {
825 825 
 						$this->changeLock($path1, ILockingProvider::LOCK_SHARED, true);
 
@@ -843,7 +843,7 @@  discard block
 
 block discarded – undo
843 843 
 						}
844 844 
 					}
845 845 
 				}
846 
-			} catch(\Exception $e) {
846 
+			} catch (\Exception $e) {
847 847 
 				throw $e;
848 848 
 			} finally {
849 849 
 				$this->unlockFile($path1, ILockingProvider::LOCK_SHARED, true);
 
@@ -976,7 +976,7 @@  discard block
 
 block discarded – undo
976 976 
 				$hooks[] = 'write';
977 977 
 				break;
978 978 
 			default:
979 
-				\OCP\Util::writeLog('core', 'invalid mode (' . $mode . ') for ' . $path, ILogger::ERROR);
979 
+				\OCP\Util::writeLog('core', 'invalid mode ('.$mode.') for '.$path, ILogger::ERROR);
980 980 
 		}
981 981
982 982 
 		if ($mode !== 'r' && $mode !== 'w') {
 
@@ -1080,7 +1080,7 @@  discard block
 
 block discarded – undo
1080 1080 
 					array(Filesystem::signal_param_path => $this->getHookPath($path))
1081 1081 
 				);
1082 1082 
 			}
1083 
-			list($storage, $internalPath) = Filesystem::resolvePath($absolutePath . $postFix);
1083 
+			list($storage, $internalPath) = Filesystem::resolvePath($absolutePath.$postFix);
1084 1084 
 			if ($storage) {
1085 1085 
 				return $storage->hash($type, $internalPath, $raw);
1086 1086 
 			}
 
@@ -1134,7 +1134,7 @@  discard block
 
 block discarded – undo
1134 1134
1135 1135 
 			$run = $this->runHooks($hooks, $path);
1136 1136 
 			/** @var \OC\Files\Storage\Storage $storage */
1137 
-			list($storage, $internalPath) = Filesystem::resolvePath($absolutePath . $postFix);
1137 
+			list($storage, $internalPath) = Filesystem::resolvePath($absolutePath.$postFix);
1138 1138 
 			if ($run and $storage) {
1139 1139 
 				if (in_array('write', $hooks) || in_array('delete', $hooks)) {
1140 1140 
 					$this->changeLock($path, ILockingProvider::LOCK_EXCLUSIVE);
 
@@ -1173,7 +1173,7 @@  discard block
 
 block discarded – undo
1173 1173 
 					$unlockLater = true;
1174 1174 
 					// make sure our unlocking callback will still be called if connection is aborted
1175 1175 
 					ignore_user_abort(true);
1176 
-					$result = CallbackWrapper::wrap($result, null, null, function () use ($hooks, $path) {
1176 
+					$result = CallbackWrapper::wrap($result, null, null, function() use ($hooks, $path) {
1177 1177 
 						if (in_array('write', $hooks)) {
1178 1178 
 							$this->unlockFile($path, ILockingProvider::LOCK_EXCLUSIVE);
1179 1179 
 						} else if (in_array('read', $hooks)) {
 
@@ -1234,7 +1234,7 @@  discard block
 
 block discarded – undo
1234 1234 
 			return true;
1235 1235 
 		}
1236 1236
1237 
-		return (strlen($fullPath) > strlen($defaultRoot)) && (substr($fullPath, 0, strlen($defaultRoot) + 1) === $defaultRoot . '/');
1237 
+		return (strlen($fullPath) > strlen($defaultRoot)) && (substr($fullPath, 0, strlen($defaultRoot) + 1) === $defaultRoot.'/');
1238 1238 
 	}
1239 1239
1240 1240 
 	/**
 
@@ -1253,7 +1253,7 @@  discard block
 
 block discarded – undo
1253 1253 
 				if ($hook != 'read') {
1254 1254 
 					\OC_Hook::emit(
1255 1255 
 						Filesystem::CLASSNAME,
1256 
-						$prefix . $hook,
1256 
+						$prefix.$hook,
1257 1257 
 						array(
1258 1258 
 							Filesystem::signal_param_run => &$run,
1259 1259 
 							Filesystem::signal_param_path => $path
 
@@ -1262,7 +1262,7 @@  discard block
 
 block discarded – undo
1262 1262 
 				} elseif (!$post) {
1263 1263 
 					\OC_Hook::emit(
1264 1264 
 						Filesystem::CLASSNAME,
1265 
-						$prefix . $hook,
1265 
+						$prefix.$hook,
1266 1266 
 						array(
1267 1267 
 							Filesystem::signal_param_path => $path
1268 1268 
 						)
 
@@ -1357,7 +1357,7 @@  discard block
 
 block discarded – undo
1357 1357 
 			return $this->getPartFileInfo($path);
1358 1358 
 		}
1359 1359 
 		$relativePath = $path;
1360 
-		$path = Filesystem::normalizePath($this->fakeRoot . '/' . $path);
1360 
+		$path = Filesystem::normalizePath($this->fakeRoot.'/'.$path);
1361 1361
1362 1362 
 		$mount = Filesystem::getMountManager()->find($path);
1363 1363 
 		if (!$mount) {
 
@@ -1384,7 +1384,7 @@  discard block
 
 block discarded – undo
1384 1384 
 					//add the sizes of other mount points to the folder
1385 1385 
 					$extOnly = ($includeMountPoints === 'ext');
1386 1386 
 					$mounts = Filesystem::getMountManager()->findIn($path);
1387 
-					$info->setSubMounts(array_filter($mounts, function (IMountPoint $mount) use ($extOnly) {
1387 
+					$info->setSubMounts(array_filter($mounts, function(IMountPoint $mount) use ($extOnly) {
1388 1388 
 						$subStorage = $mount->getStorage();
1389 1389 
 						return !($extOnly && $subStorage instanceof \OCA\Files_Sharing\SharedStorage);
1390 1390 
 					}));
 
@@ -1434,12 +1434,12 @@  discard block
 
 block discarded – undo
1434 1434 
 			/**
1435 1435 
 			 * @var \OC\Files\FileInfo[] $files
1436 1436 
 			 */
1437 
-			$files = array_map(function (ICacheEntry $content) use ($path, $storage, $mount, $sharingDisabled) {
1437 
+			$files = array_map(function(ICacheEntry $content) use ($path, $storage, $mount, $sharingDisabled) {
1438 1438 
 				if ($sharingDisabled) {
1439 1439 
 					$content['permissions'] = $content['permissions'] & ~\OCP\Constants::PERMISSION_SHARE;
1440 1440 
 				}
1441 1441 
 				$owner = $this->getUserObjectForOwner($storage->getOwner($content['path']));
1442 
-				return new FileInfo($path . '/' . $content['name'], $storage, $content['path'], $content, $mount, $owner);
1442 
+				return new FileInfo($path.'/'.$content['name'], $storage, $content['path'], $content, $mount, $owner);
1443 1443 
 			}, $contents);
1444 1444
1445 1445 
 			//add a folder for any mountpoint in this directory and add the sizes of other mountpoints to the folders
 
@@ -1463,7 +1463,7 @@  discard block
 
 block discarded – undo
1463 1463 
 						} catch (\Exception $e) {
1464 1464 
 							// sometimes when the storage is not available it can be any exception
1465 1465 
 							\OC::$server->getLogger()->logException($e, [
1466 
-								'message' => 'Exception while scanning storage "' . $subStorage->getId() . '"',
1466 
+								'message' => 'Exception while scanning storage "'.$subStorage->getId().'"',
1467 1467 
 								'level' => ILogger::ERROR,
1468 1468 
 								'app' => 'lib',
1469 1469 
 							]);
 
@@ -1501,7 +1501,7 @@  discard block
 
 block discarded – undo
1501 1501 
 									break;
1502 1502 
 								}
1503 1503 
 							}
1504 
-							$rootEntry['path'] = substr(Filesystem::normalizePath($path . '/' . $rootEntry['name']), strlen($user) + 2); // full path without /$user/
1504 
+							$rootEntry['path'] = substr(Filesystem::normalizePath($path.'/'.$rootEntry['name']), strlen($user) + 2); // full path without /$user/
1505 1505
1506 1506 
 							// if sharing was disabled for the user we remove the share permissions
1507 1507 
 							if (\OCP\Util::isSharingDisabledForUser()) {
 
@@ -1509,14 +1509,14 @@  discard block
 
 block discarded – undo
1509 1509 
 							}
1510 1510
1511 1511 
 							$owner = $this->getUserObjectForOwner($subStorage->getOwner(''));
1512 
-							$files[] = new FileInfo($path . '/' . $rootEntry['name'], $subStorage, '', $rootEntry, $mount, $owner);
1512 
+							$files[] = new FileInfo($path.'/'.$rootEntry['name'], $subStorage, '', $rootEntry, $mount, $owner);
1513 1513 
 						}
1514 1514 
 					}
1515 1515 
 				}
1516 1516 
 			}
1517 1517
1518 1518 
 			if ($mimetype_filter) {
1519 
-				$files = array_filter($files, function (FileInfo $file) use ($mimetype_filter) {
1519 
+				$files = array_filter($files, function(FileInfo $file) use ($mimetype_filter) {
1520 1520 
 					if (strpos($mimetype_filter, '/')) {
1521 1521 
 						return $file->getMimetype() === $mimetype_filter;
1522 1522 
 					} else {
 
@@ -1545,7 +1545,7 @@  discard block
 
 block discarded – undo
1545 1545 
 		if ($data instanceof FileInfo) {
1546 1546 
 			$data = $data->getData();
1547 1547 
 		}
1548 
-		$path = Filesystem::normalizePath($this->fakeRoot . '/' . $path);
1548 
+		$path = Filesystem::normalizePath($this->fakeRoot.'/'.$path);
1549 1549 
 		/**
1550 1550 
 		 * @var \OC\Files\Storage\Storage $storage
1551 1551 
 		 * @var string $internalPath
 
@@ -1572,7 +1572,7 @@  discard block
 
 block discarded – undo
1572 1572 
 	 * @return FileInfo[]
1573 1573 
 	 */
1574 1574 
 	public function search($query) {
1575 
-		return $this->searchCommon('search', array('%' . $query . '%'));
1575 
+		return $this->searchCommon('search', array('%'.$query.'%'));
1576 1576 
 	}
1577 1577
1578 1578 
 	/**
 
@@ -1623,10 +1623,10 @@  discard block
 
 block discarded – undo
1623 1623
1624 1624 
 			$results = call_user_func_array(array($cache, $method), $args);
1625 1625 
 			foreach ($results as $result) {
1626 
-				if (substr($mountPoint . $result['path'], 0, $rootLength + 1) === $this->fakeRoot . '/') {
1626 
+				if (substr($mountPoint.$result['path'], 0, $rootLength + 1) === $this->fakeRoot.'/') {
1627 1627 
 					$internalPath = $result['path'];
1628 
-					$path = $mountPoint . $result['path'];
1629 
-					$result['path'] = substr($mountPoint . $result['path'], $rootLength);
1628 
+					$path = $mountPoint.$result['path'];
1629 
+					$result['path'] = substr($mountPoint.$result['path'], $rootLength);
1630 1630 
 					$owner = \OC::$server->getUserManager()->get($storage->getOwner($internalPath));
1631 1631 
 					$files[] = new FileInfo($path, $storage, $internalPath, $result, $mount, $owner);
1632 1632 
 				}
 
@@ -1644,8 +1644,8 @@  discard block
 
 block discarded – undo
1644 1644 
 					if ($results) {
1645 1645 
 						foreach ($results as $result) {
1646 1646 
 							$internalPath = $result['path'];
1647 
-							$result['path'] = rtrim($relativeMountPoint . $result['path'], '/');
1648 
-							$path = rtrim($mountPoint . $internalPath, '/');
1647 
+							$result['path'] = rtrim($relativeMountPoint.$result['path'], '/');
1648 
+							$path = rtrim($mountPoint.$internalPath, '/');
1649 1649 
 							$owner = \OC::$server->getUserManager()->get($storage->getOwner($internalPath));
1650 1650 
 							$files[] = new FileInfo($path, $storage, $internalPath, $result, $mount, $owner);
1651 1651 
 						}
 
@@ -1666,7 +1666,7 @@  discard block
 
 block discarded – undo
1666 1666 
 	public function getOwner($path) {
1667 1667 
 		$info = $this->getFileInfo($path);
1668 1668 
 		if (!$info) {
1669 
-			throw new NotFoundException($path . ' not found while trying to get owner');
1669 
+			throw new NotFoundException($path.' not found while trying to get owner');
1670 1670 
 		}
1671 1671 
 		return $info->getOwner()->getUID();
1672 1672 
 	}
 
@@ -1700,7 +1700,7 @@  discard block
 
 block discarded – undo
1700 1700 
 	 * @return string
1701 1701 
 	 */
1702 1702 
 	public function getPath($id) {
1703 
-		$id = (int)$id;
1703 
+		$id = (int) $id;
1704 1704 
 		$manager = Filesystem::getMountManager();
1705 1705 
 		$mounts = $manager->findIn($this->fakeRoot);
1706 1706 
 		$mounts[] = $manager->find($this->fakeRoot);
 
@@ -1715,7 +1715,7 @@  discard block
 
 block discarded – undo
1715 1715 
 				$cache = $mount->getStorage()->getCache();
1716 1716 
 				$internalPath = $cache->getPathById($id);
1717 1717 
 				if (is_string($internalPath)) {
1718 
-					$fullPath = $mount->getMountPoint() . $internalPath;
1718 
+					$fullPath = $mount->getMountPoint().$internalPath;
1719 1719 
 					if (!is_null($path = $this->getRelativePath($fullPath))) {
1720 1720 
 						return $path;
1721 1721 
 					}
 
@@ -1758,10 +1758,10 @@  discard block
 
 block discarded – undo
1758 1758 
 		}
1759 1759
1760 1760 
 		// note: cannot use the view because the target is already locked
1761 
-		$fileId = (int)$targetStorage->getCache()->getId($targetInternalPath);
1761 
+		$fileId = (int) $targetStorage->getCache()->getId($targetInternalPath);
1762 1762 
 		if ($fileId === -1) {
1763 1763 
 			// target might not exist, need to check parent instead
1764 
-			$fileId = (int)$targetStorage->getCache()->getId(dirname($targetInternalPath));
1764 
+			$fileId = (int) $targetStorage->getCache()->getId(dirname($targetInternalPath));
1765 1765 
 		}
1766 1766
1767 1767 
 		// check if any of the parents were shared by the current owner (include collections)
 
@@ -1861,7 +1861,7 @@  discard block
 
 block discarded – undo
1861 1861 
 		$resultPath = '';
1862 1862 
 		foreach ($parts as $part) {
1863 1863 
 			if ($part) {
1864 
-				$resultPath .= '/' . $part;
1864 
+				$resultPath .= '/'.$part;
1865 1865 
 				$result[] = $resultPath;
1866 1866 
 			}
1867 1867 
 		}
 
@@ -2124,16 +2124,16 @@  discard block
 
 block discarded – undo
2124 2124 
 	public function getUidAndFilename($filename) {
2125 2125 
 		$info = $this->getFileInfo($filename);
2126 2126 
 		if (!$info instanceof \OCP\Files\FileInfo) {
2127 
-			throw new NotFoundException($this->getAbsolutePath($filename) . ' not found');
2127 
+			throw new NotFoundException($this->getAbsolutePath($filename).' not found');
2128 2128 
 		}
2129 2129 
 		$uid = $info->getOwner()->getUID();
2130 2130 
 		if ($uid != \OCP\User::getUser()) {
2131 2131 
 			Filesystem::initMountPoints($uid);
2132 
-			$ownerView = new View('/' . $uid . '/files');
2132 
+			$ownerView = new View('/'.$uid.'/files');
2133 2133 
 			try {
2134 2134 
 				$filename = $ownerView->getPath($info['fileid']);
2135 2135 
 			} catch (NotFoundException $e) {
2136 
-				throw new NotFoundException('File with id ' . $info['fileid'] . ' not found for user ' . $uid);
2136 
+				throw new NotFoundException('File with id '.$info['fileid'].' not found for user '.$uid);
2137 2137 
 			}
2138 2138 
 		}
2139 2139 
 		return [$uid, $filename];
 
@@ -2150,7 +2150,7 @@  discard block
 
 block discarded – undo
2150 2150 
 		$directoryParts = array_filter($directoryParts);
2151 2151 
 		foreach ($directoryParts as $key => $part) {
2152 2152 
 			$currentPathElements = array_slice($directoryParts, 0, $key);
2153 
-			$currentPath = '/' . implode('/', $currentPathElements);
2153 
+			$currentPath = '/'.implode('/', $currentPathElements);
2154 2154 
 			if ($this->is_file($currentPath)) {
2155 2155 
 				return false;
2156 2156 
 			}
Please login to merge, or discard this patch.
lib/private/Files/Mount/MountPoint.php 2 patches
Indentation   +219 added lines, -219 removed lines patch added patch discarded remove patch 
@@ -36,247 +36,247 @@
 
 block discarded – undo
36 36 
 use OCP\ILogger;
37 37
38 38 
 class MountPoint implements IMountPoint {
39 
-	/**
40 
-	 * @var \OC\Files\Storage\Storage $storage
41 
-	 */
42 
-	protected $storage = null;
43 
-	protected $class;
44 
-	protected $storageId;
45 
-	protected $rootId = null;
39 
+    /**
40 
+     * @var \OC\Files\Storage\Storage $storage
41 
+     */
42 
+    protected $storage = null;
43 
+    protected $class;
44 
+    protected $storageId;
45 
+    protected $rootId = null;
46 46
47 
-	/**
48 
-	 * Configuration options for the storage backend
49 
-	 *
50 
-	 * @var array
51 
-	 */
52 
-	protected $arguments = array();
53 
-	protected $mountPoint;
47 
+    /**
48 
+     * Configuration options for the storage backend
49 
+     *
50 
+     * @var array
51 
+     */
52 
+    protected $arguments = array();
53 
+    protected $mountPoint;
54 54
55 
-	/**
56 
-	 * Mount specific options
57 
-	 *
58 
-	 * @var array
59 
-	 */
60 
-	protected $mountOptions = array();
55 
+    /**
56 
+     * Mount specific options
57 
+     *
58 
+     * @var array
59 
+     */
60 
+    protected $mountOptions = array();
61 61
62 
-	/**
63 
-	 * @var \OC\Files\Storage\StorageFactory $loader
64 
-	 */
65 
-	private $loader;
62 
+    /**
63 
+     * @var \OC\Files\Storage\StorageFactory $loader
64 
+     */
65 
+    private $loader;
66 66
67 
-	/**
68 
-	 * Specified whether the storage is invalid after failing to
69 
-	 * instantiate it.
70 
-	 *
71 
-	 * @var bool
72 
-	 */
73 
-	private $invalidStorage = false;
67 
+    /**
68 
+     * Specified whether the storage is invalid after failing to
69 
+     * instantiate it.
70 
+     *
71 
+     * @var bool
72 
+     */
73 
+    private $invalidStorage = false;
74 74
75 
-	/** @var int|null */
76 
-	protected $mountId;
75 
+    /** @var int|null */
76 
+    protected $mountId;
77 77
78 
-	/**
79 
-	 * @param string|\OC\Files\Storage\Storage $storage
80 
-	 * @param string $mountpoint
81 
-	 * @param array $arguments (optional) configuration for the storage backend
82 
-	 * @param \OCP\Files\Storage\IStorageFactory $loader
83 
-	 * @param array $mountOptions mount specific options
84 
-	 * @param int|null $mountId
85 
-	 * @throws \Exception
86 
-	 */
87 
-	public function __construct($storage, $mountpoint, $arguments = null, $loader = null, $mountOptions = null, $mountId = null) {
88 
-		if (is_null($arguments)) {
89 
-			$arguments = array();
90 
-		}
91 
-		if (is_null($loader)) {
92 
-			$this->loader = new StorageFactory();
93 
-		} else {
94 
-			$this->loader = $loader;
95 
-		}
78 
+    /**
79 
+     * @param string|\OC\Files\Storage\Storage $storage
80 
+     * @param string $mountpoint
81 
+     * @param array $arguments (optional) configuration for the storage backend
82 
+     * @param \OCP\Files\Storage\IStorageFactory $loader
83 
+     * @param array $mountOptions mount specific options
84 
+     * @param int|null $mountId
85 
+     * @throws \Exception
86 
+     */
87 
+    public function __construct($storage, $mountpoint, $arguments = null, $loader = null, $mountOptions = null, $mountId = null) {
88 
+        if (is_null($arguments)) {
89 
+            $arguments = array();
90 
+        }
91 
+        if (is_null($loader)) {
92 
+            $this->loader = new StorageFactory();
93 
+        } else {
94 
+            $this->loader = $loader;
95 
+        }
96 96
97 
-		if (!is_null($mountOptions)) {
98 
-			$this->mountOptions = $mountOptions;
99 
-		}
97 
+        if (!is_null($mountOptions)) {
98 
+            $this->mountOptions = $mountOptions;
99 
+        }
100 100
101 
-		$mountpoint = $this->formatPath($mountpoint);
102 
-		$this->mountPoint = $mountpoint;
103 
-		if ($storage instanceof Storage) {
104 
-			$this->class = get_class($storage);
105 
-			$this->storage = $this->loader->wrap($this, $storage);
106 
-		} else {
107 
-			// Update old classes to new namespace
108 
-			if (strpos($storage, 'OC_Filestorage_') !== false) {
109 
-				$storage = '\OC\Files\Storage\\' . substr($storage, 15);
110 
-			}
111 
-			$this->class = $storage;
112 
-			$this->arguments = $arguments;
113 
-		}
114 
-		$this->mountId = $mountId;
115 
-	}
101 
+        $mountpoint = $this->formatPath($mountpoint);
102 
+        $this->mountPoint = $mountpoint;
103 
+        if ($storage instanceof Storage) {
104 
+            $this->class = get_class($storage);
105 
+            $this->storage = $this->loader->wrap($this, $storage);
106 
+        } else {
107 
+            // Update old classes to new namespace
108 
+            if (strpos($storage, 'OC_Filestorage_') !== false) {
109 
+                $storage = '\OC\Files\Storage\\' . substr($storage, 15);
110 
+            }
111 
+            $this->class = $storage;
112 
+            $this->arguments = $arguments;
113 
+        }
114 
+        $this->mountId = $mountId;
115 
+    }
116 116
117 
-	/**
118 
-	 * get complete path to the mount point, relative to data/
119 
-	 *
120 
-	 * @return string
121 
-	 */
122 
-	public function getMountPoint() {
123 
-		return $this->mountPoint;
124 
-	}
117 
+    /**
118 
+     * get complete path to the mount point, relative to data/
119 
+     *
120 
+     * @return string
121 
+     */
122 
+    public function getMountPoint() {
123 
+        return $this->mountPoint;
124 
+    }
125 125
126 
-	/**
127 
-	 * Sets the mount point path, relative to data/
128 
-	 *
129 
-	 * @param string $mountPoint new mount point
130 
-	 */
131 
-	public function setMountPoint($mountPoint) {
132 
-		$this->mountPoint = $this->formatPath($mountPoint);
133 
-	}
126 
+    /**
127 
+     * Sets the mount point path, relative to data/
128 
+     *
129 
+     * @param string $mountPoint new mount point
130 
+     */
131 
+    public function setMountPoint($mountPoint) {
132 
+        $this->mountPoint = $this->formatPath($mountPoint);
133 
+    }
134 134
135 
-	/**
136 
-	 * create the storage that is mounted
137 
-	 */
138 
-	private function createStorage() {
139 
-		if ($this->invalidStorage) {
140 
-			return;
141 
-		}
135 
+    /**
136 
+     * create the storage that is mounted
137 
+     */
138 
+    private function createStorage() {
139 
+        if ($this->invalidStorage) {
140 
+            return;
141 
+        }
142 142
143 
-		if (class_exists($this->class)) {
144 
-			try {
145 
-				$class = $this->class;
146 
-				// prevent recursion by setting the storage before applying wrappers
147 
-				$this->storage = new $class($this->arguments);
148 
-				$this->storage = $this->loader->wrap($this, $this->storage);
149 
-			} catch (\Exception $exception) {
150 
-				$this->storage = null;
151 
-				$this->invalidStorage = true;
152 
-				if ($this->mountPoint === '/') {
153 
-					// the root storage could not be initialized, show the user!
154 
-					throw new \Exception('The root storage could not be initialized. Please contact your local administrator.', $exception->getCode(), $exception);
155 
-				} else {
156 
-					\OC::$server->getLogger()->logException($exception, ['level' => ILogger::ERROR]);
157 
-				}
158 
-				return;
159 
-			}
160 
-		} else {
161 
-			\OCP\Util::writeLog('core', 'storage backend ' . $this->class . ' not found', ILogger::ERROR);
162 
-			$this->invalidStorage = true;
163 
-			return;
164 
-		}
165 
-	}
143 
+        if (class_exists($this->class)) {
144 
+            try {
145 
+                $class = $this->class;
146 
+                // prevent recursion by setting the storage before applying wrappers
147 
+                $this->storage = new $class($this->arguments);
148 
+                $this->storage = $this->loader->wrap($this, $this->storage);
149 
+            } catch (\Exception $exception) {
150 
+                $this->storage = null;
151 
+                $this->invalidStorage = true;
152 
+                if ($this->mountPoint === '/') {
153 
+                    // the root storage could not be initialized, show the user!
154 
+                    throw new \Exception('The root storage could not be initialized. Please contact your local administrator.', $exception->getCode(), $exception);
155 
+                } else {
156 
+                    \OC::$server->getLogger()->logException($exception, ['level' => ILogger::ERROR]);
157 
+                }
158 
+                return;
159 
+            }
160 
+        } else {
161 
+            \OCP\Util::writeLog('core', 'storage backend ' . $this->class . ' not found', ILogger::ERROR);
162 
+            $this->invalidStorage = true;
163 
+            return;
164 
+        }
165 
+    }
166 166
167 
-	/**
168 
-	 * @return \OC\Files\Storage\Storage
169 
-	 */
170 
-	public function getStorage() {
171 
-		if (is_null($this->storage)) {
172 
-			$this->createStorage();
173 
-		}
174 
-		return $this->storage;
175 
-	}
167 
+    /**
168 
+     * @return \OC\Files\Storage\Storage
169 
+     */
170 
+    public function getStorage() {
171 
+        if (is_null($this->storage)) {
172 
+            $this->createStorage();
173 
+        }
174 
+        return $this->storage;
175 
+    }
176 176
177 
-	/**
178 
-	 * @return string
179 
-	 */
180 
-	public function getStorageId() {
181 
-		if (!$this->storageId) {
182 
-			if (is_null($this->storage)) {
183 
-				$storage = $this->createStorage(); //FIXME: start using exceptions
184 
-				if (is_null($storage)) {
185 
-					return null;
186 
-				}
177 
+    /**
178 
+     * @return string
179 
+     */
180 
+    public function getStorageId() {
181 
+        if (!$this->storageId) {
182 
+            if (is_null($this->storage)) {
183 
+                $storage = $this->createStorage(); //FIXME: start using exceptions
184 
+                if (is_null($storage)) {
185 
+                    return null;
186 
+                }
187 187
188 
-				$this->storage = $storage;
189 
-			}
190 
-			$this->storageId = $this->storage->getId();
191 
-			if (strlen($this->storageId) > 64) {
192 
-				$this->storageId = md5($this->storageId);
193 
-			}
194 
-		}
195 
-		return $this->storageId;
196 
-	}
188 
+                $this->storage = $storage;
189 
+            }
190 
+            $this->storageId = $this->storage->getId();
191 
+            if (strlen($this->storageId) > 64) {
192 
+                $this->storageId = md5($this->storageId);
193 
+            }
194 
+        }
195 
+        return $this->storageId;
196 
+    }
197 197
198 
-	/**
199 
-	 * @return int
200 
-	 */
201 
-	public function getNumericStorageId() {
202 
-		return $this->getStorage()->getStorageCache()->getNumericId();
203 
-	}
198 
+    /**
199 
+     * @return int
200 
+     */
201 
+    public function getNumericStorageId() {
202 
+        return $this->getStorage()->getStorageCache()->getNumericId();
203 
+    }
204 204
205 
-	/**
206 
-	 * @param string $path
207 
-	 * @return string
208 
-	 */
209 
-	public function getInternalPath($path) {
210 
-		$path = Filesystem::normalizePath($path, true, false, true);
211 
-		if ($this->mountPoint === $path or $this->mountPoint . '/' === $path) {
212 
-			$internalPath = '';
213 
-		} else {
214 
-			$internalPath = substr($path, strlen($this->mountPoint));
215 
-		}
216 
-		// substr returns false instead of an empty string, we always want a string
217 
-		return (string)$internalPath;
218 
-	}
205 
+    /**
206 
+     * @param string $path
207 
+     * @return string
208 
+     */
209 
+    public function getInternalPath($path) {
210 
+        $path = Filesystem::normalizePath($path, true, false, true);
211 
+        if ($this->mountPoint === $path or $this->mountPoint . '/' === $path) {
212 
+            $internalPath = '';
213 
+        } else {
214 
+            $internalPath = substr($path, strlen($this->mountPoint));
215 
+        }
216 
+        // substr returns false instead of an empty string, we always want a string
217 
+        return (string)$internalPath;
218 
+    }
219 219
220 
-	/**
221 
-	 * @param string $path
222 
-	 * @return string
223 
-	 */
224 
-	private function formatPath($path) {
225 
-		$path = Filesystem::normalizePath($path);
226 
-		if (strlen($path) > 1) {
227 
-			$path .= '/';
228 
-		}
229 
-		return $path;
230 
-	}
220 
+    /**
221 
+     * @param string $path
222 
+     * @return string
223 
+     */
224 
+    private function formatPath($path) {
225 
+        $path = Filesystem::normalizePath($path);
226 
+        if (strlen($path) > 1) {
227 
+            $path .= '/';
228 
+        }
229 
+        return $path;
230 
+    }
231 231
232 
-	/**
233 
-	 * @param callable $wrapper
234 
-	 */
235 
-	public function wrapStorage($wrapper) {
236 
-		$storage = $this->getStorage();
237 
-		// storage can be null if it couldn't be initialized
238 
-		if ($storage != null) {
239 
-			$this->storage = $wrapper($this->mountPoint, $storage, $this);
240 
-		}
241 
-	}
232 
+    /**
233 
+     * @param callable $wrapper
234 
+     */
235 
+    public function wrapStorage($wrapper) {
236 
+        $storage = $this->getStorage();
237 
+        // storage can be null if it couldn't be initialized
238 
+        if ($storage != null) {
239 
+            $this->storage = $wrapper($this->mountPoint, $storage, $this);
240 
+        }
241 
+    }
242 242
243 
-	/**
244 
-	 * Get a mount option
245 
-	 *
246 
-	 * @param string $name Name of the mount option to get
247 
-	 * @param mixed $default Default value for the mount option
248 
-	 * @return mixed
249 
-	 */
250 
-	public function getOption($name, $default) {
251 
-		return isset($this->mountOptions[$name]) ? $this->mountOptions[$name] : $default;
252 
-	}
243 
+    /**
244 
+     * Get a mount option
245 
+     *
246 
+     * @param string $name Name of the mount option to get
247 
+     * @param mixed $default Default value for the mount option
248 
+     * @return mixed
249 
+     */
250 
+    public function getOption($name, $default) {
251 
+        return isset($this->mountOptions[$name]) ? $this->mountOptions[$name] : $default;
252 
+    }
253 253
254 
-	/**
255 
-	 * Get all options for the mount
256 
-	 *
257 
-	 * @return array
258 
-	 */
259 
-	public function getOptions() {
260 
-		return $this->mountOptions;
261 
-	}
254 
+    /**
255 
+     * Get all options for the mount
256 
+     *
257 
+     * @return array
258 
+     */
259 
+    public function getOptions() {
260 
+        return $this->mountOptions;
261 
+    }
262 262
263 
-	/**
264 
-	 * Get the file id of the root of the storage
265 
-	 *
266 
-	 * @return int
267 
-	 */
268 
-	public function getStorageRootId() {
269 
-		if (is_null($this->rootId)) {
270 
-			$this->rootId = (int)$this->getStorage()->getCache()->getId('');
271 
-		}
272 
-		return $this->rootId;
273 
-	}
263 
+    /**
264 
+     * Get the file id of the root of the storage
265 
+     *
266 
+     * @return int
267 
+     */
268 
+    public function getStorageRootId() {
269 
+        if (is_null($this->rootId)) {
270 
+            $this->rootId = (int)$this->getStorage()->getCache()->getId('');
271 
+        }
272 
+        return $this->rootId;
273 
+    }
274 274
275 
-	public function getMountId() {
276 
-		return $this->mountId;
277 
-	}
275 
+    public function getMountId() {
276 
+        return $this->mountId;
277 
+    }
278 278
279 
-	public function getMountType() {
280 
-		return '';
281 
-	}
279 
+    public function getMountType() {
280 
+        return '';
281 
+    }
282 282 
 }
Please login to merge, or discard this patch.
Spacing   +5 added lines, -5 removed lines patch added patch discarded remove patch 
@@ -106,7 +106,7 @@  discard block
 
 block discarded – undo
106 106 
 		} else {
107 107 
 			// Update old classes to new namespace
108 108 
 			if (strpos($storage, 'OC_Filestorage_') !== false) {
109 
-				$storage = '\OC\Files\Storage\\' . substr($storage, 15);
109 
+				$storage = '\OC\Files\Storage\\'.substr($storage, 15);
110 110 
 			}
111 111 
 			$this->class = $storage;
112 112 
 			$this->arguments = $arguments;
 
@@ -158,7 +158,7 @@  discard block
 
 block discarded – undo
158 158 
 				return;
159 159 
 			}
160 160 
 		} else {
161 
-			\OCP\Util::writeLog('core', 'storage backend ' . $this->class . ' not found', ILogger::ERROR);
161 
+			\OCP\Util::writeLog('core', 'storage backend '.$this->class.' not found', ILogger::ERROR);
162 162 
 			$this->invalidStorage = true;
163 163 
 			return;
164 164 
 		}
 
@@ -208,13 +208,13 @@  discard block
 
 block discarded – undo
208 208 
 	 */
209 209 
 	public function getInternalPath($path) {
210 210 
 		$path = Filesystem::normalizePath($path, true, false, true);
211 
-		if ($this->mountPoint === $path or $this->mountPoint . '/' === $path) {
211 
+		if ($this->mountPoint === $path or $this->mountPoint.'/' === $path) {
212 212 
 			$internalPath = '';
213 213 
 		} else {
214 214 
 			$internalPath = substr($path, strlen($this->mountPoint));
215 215 
 		}
216 216 
 		// substr returns false instead of an empty string, we always want a string
217 
-		return (string)$internalPath;
217 
+		return (string) $internalPath;
218 218 
 	}
219 219
220 220 
 	/**
 
@@ -267,7 +267,7 @@  discard block
 
 block discarded – undo
267 267 
 	 */
268 268 
 	public function getStorageRootId() {
269 269 
 		if (is_null($this->rootId)) {
270 
-			$this->rootId = (int)$this->getStorage()->getCache()->getId('');
270 
+			$this->rootId = (int) $this->getStorage()->getCache()->getId('');
271 271 
 		}
272 272 
 		return $this->rootId;
273 273 
 	}
Please login to merge, or discard this patch.
lib/private/Files/Mount/ObjectHomeMountProvider.php 1 patch
Indentation   +100 added lines, -100 removed lines patch added patch discarded remove patch 
@@ -33,107 +33,107 @@
 
 block discarded – undo
33 33 
  * Mount provider for object store home storages
34 34 
  */
35 35 
 class ObjectHomeMountProvider implements IHomeMountProvider {
36 
-	/**
37 
-	 * @var IConfig
38 
-	 */
39 
-	private $config;
40 
-
41 
-	/**
42 
-	 * ObjectStoreHomeMountProvider constructor.
43 
-	 *
44 
-	 * @param IConfig $config
45 
-	 */
46 
-	public function __construct(IConfig $config) {
47 
-		$this->config = $config;
48 
-	}
49 
-
50 
-	/**
51 
-	 * Get the cache mount for a user
52 
-	 *
53 
-	 * @param IUser $user
54 
-	 * @param IStorageFactory $loader
55 
-	 * @return \OCP\Files\Mount\IMountPoint
56 
-	 */
57 
-	public function getHomeMountForUser(IUser $user, IStorageFactory $loader) {
58 
-
59 
-		$config = $this->getMultiBucketObjectStoreConfig($user);
60 
-		if ($config === null) {
61 
-			$config = $this->getSingleBucketObjectStoreConfig($user);
62 
-		}
63 
-
64 
-		if ($config === null) {
65 
-			return null;
66 
-		}
67 
-
68 
-		return new MountPoint('\OC\Files\ObjectStore\HomeObjectStoreStorage', '/' . $user->getUID(), $config['arguments'], $loader);
69 
-	}
70 
-
71 
-	/**
72 
-	 * @param IUser $user
73 
-	 * @return array|null
74 
-	 */
75 
-	private function getSingleBucketObjectStoreConfig(IUser $user) {
76 
-		$config = $this->config->getSystemValue('objectstore');
77 
-		if (!is_array($config)) {
78 
-			return null;
79 
-		}
80 
-
81 
-		// sanity checks
82 
-		if (empty($config['class'])) {
83 
-			\OCP\Util::writeLog('files', 'No class given for objectstore', ILogger::ERROR);
84 
-		}
85 
-		if (!isset($config['arguments'])) {
86 
-			$config['arguments'] = [];
87 
-		}
88 
-		// instantiate object store implementation
89 
-		$config['arguments']['objectstore'] = new $config['class']($config['arguments']);
90 
-
91 
-		$config['arguments']['user'] = $user;
92 
-
93 
-		return $config;
94 
-	}
95 
-
96 
-	/**
97 
-	 * @param IUser $user
98 
-	 * @return array|null
99 
-	 */
100 
-	private function getMultiBucketObjectStoreConfig(IUser $user) {
101 
-		$config = $this->config->getSystemValue('objectstore_multibucket');
102 
-		if (!is_array($config)) {
103 
-			return null;
104 
-		}
105 
-
106 
-		// sanity checks
107 
-		if (empty($config['class'])) {
108 
-			\OCP\Util::writeLog('files', 'No class given for objectstore', ILogger::ERROR);
109 
-		}
110 
-		if (!isset($config['arguments'])) {
111 
-			$config['arguments'] = [];
112 
-		}
113 
-		$config['arguments']['user'] = $user;
114 
-
115 
-		$bucket = $this->config->getUserValue($user->getUID(), 'homeobjectstore', 'bucket', null);
116 
-
117 
-		if ($bucket === null) {
118 
-			/*
36 
+    /**
37 
+     * @var IConfig
38 
+     */
39 
+    private $config;
40 
+
41 
+    /**
42 
+     * ObjectStoreHomeMountProvider constructor.
43 
+     *
44 
+     * @param IConfig $config
45 
+     */
46 
+    public function __construct(IConfig $config) {
47 
+        $this->config = $config;
48 
+    }
49 
+
50 
+    /**
51 
+     * Get the cache mount for a user
52 
+     *
53 
+     * @param IUser $user
54 
+     * @param IStorageFactory $loader
55 
+     * @return \OCP\Files\Mount\IMountPoint
56 
+     */
57 
+    public function getHomeMountForUser(IUser $user, IStorageFactory $loader) {
58 
+
59 
+        $config = $this->getMultiBucketObjectStoreConfig($user);
60 
+        if ($config === null) {
61 
+            $config = $this->getSingleBucketObjectStoreConfig($user);
62 
+        }
63 
+
64 
+        if ($config === null) {
65 
+            return null;
66 
+        }
67 
+
68 
+        return new MountPoint('\OC\Files\ObjectStore\HomeObjectStoreStorage', '/' . $user->getUID(), $config['arguments'], $loader);
69 
+    }
70 
+
71 
+    /**
72 
+     * @param IUser $user
73 
+     * @return array|null
74 
+     */
75 
+    private function getSingleBucketObjectStoreConfig(IUser $user) {
76 
+        $config = $this->config->getSystemValue('objectstore');
77 
+        if (!is_array($config)) {
78 
+            return null;
79 
+        }
80 
+
81 
+        // sanity checks
82 
+        if (empty($config['class'])) {
83 
+            \OCP\Util::writeLog('files', 'No class given for objectstore', ILogger::ERROR);
84 
+        }
85 
+        if (!isset($config['arguments'])) {
86 
+            $config['arguments'] = [];
87 
+        }
88 
+        // instantiate object store implementation
89 
+        $config['arguments']['objectstore'] = new $config['class']($config['arguments']);
90 
+
91 
+        $config['arguments']['user'] = $user;
92 
+
93 
+        return $config;
94 
+    }
95 
+
96 
+    /**
97 
+     * @param IUser $user
98 
+     * @return array|null
99 
+     */
100 
+    private function getMultiBucketObjectStoreConfig(IUser $user) {
101 
+        $config = $this->config->getSystemValue('objectstore_multibucket');
102 
+        if (!is_array($config)) {
103 
+            return null;
104 
+        }
105 
+
106 
+        // sanity checks
107 
+        if (empty($config['class'])) {
108 
+            \OCP\Util::writeLog('files', 'No class given for objectstore', ILogger::ERROR);
109 
+        }
110 
+        if (!isset($config['arguments'])) {
111 
+            $config['arguments'] = [];
112 
+        }
113 
+        $config['arguments']['user'] = $user;
114 
+
115 
+        $bucket = $this->config->getUserValue($user->getUID(), 'homeobjectstore', 'bucket', null);
116 
+
117 
+        if ($bucket === null) {
118 
+            /*
119 119 
 			 * Use any provided bucket argument as prefix
120 120 
 			 * and add the mapping from username => bucket
121 121 
 			 */
122 
-			if (!isset($config['arguments']['bucket'])) {
123 
-				$config['arguments']['bucket'] = '';
124 
-			}
125 
-			$mapper = new \OC\Files\ObjectStore\Mapper($user);
126 
-			$numBuckets = isset($config['arguments']['num_buckets']) ? $config['arguments']['num_buckets'] : 64;
127 
-			$config['arguments']['bucket'] .= $mapper->getBucket($numBuckets);
128 
-
129 
-			$this->config->setUserValue($user->getUID(), 'homeobjectstore', 'bucket', $config['arguments']['bucket']);
130 
-		} else {
131 
-			$config['arguments']['bucket'] = $bucket;
132 
-		}
133 
-
134 
-		// instantiate object store implementation
135 
-		$config['arguments']['objectstore'] = new $config['class']($config['arguments']);
136 
-
137 
-		return $config;
138 
-	}
122 
+            if (!isset($config['arguments']['bucket'])) {
123 
+                $config['arguments']['bucket'] = '';
124 
+            }
125 
+            $mapper = new \OC\Files\ObjectStore\Mapper($user);
126 
+            $numBuckets = isset($config['arguments']['num_buckets']) ? $config['arguments']['num_buckets'] : 64;
127 
+            $config['arguments']['bucket'] .= $mapper->getBucket($numBuckets);
128 
+
129 
+            $this->config->setUserValue($user->getUID(), 'homeobjectstore', 'bucket', $config['arguments']['bucket']);
130 
+        } else {
131 
+            $config['arguments']['bucket'] = $bucket;
132 
+        }
133 
+
134 
+        // instantiate object store implementation
135 
+        $config['arguments']['objectstore'] = new $config['class']($config['arguments']);
136 
+
137 
+        return $config;
138 
+    }
139 139 
 }
Please login to merge, or discard this patch.
lib/private/Files/Storage/Wrapper/Encryption.php 2 patches
Indentation   +976 added lines, -976 removed lines patch added patch discarded remove patch 
@@ -48,981 +48,981 @@
 
 block discarded – undo
48 48
49 49 
 class Encryption extends Wrapper {
50 50
51 
-	use LocalTempFileTrait;
52 
-
53 
-	/** @var string */
54 
-	private $mountPoint;
55 
-
56 
-	/** @var \OC\Encryption\Util */
57 
-	private $util;
58 
-
59 
-	/** @var \OCP\Encryption\IManager */
60 
-	private $encryptionManager;
61 
-
62 
-	/** @var \OCP\ILogger */
63 
-	private $logger;
64 
-
65 
-	/** @var string */
66 
-	private $uid;
67 
-
68 
-	/** @var array */
69 
-	protected $unencryptedSize;
70 
-
71 
-	/** @var \OCP\Encryption\IFile */
72 
-	private $fileHelper;
73 
-
74 
-	/** @var IMountPoint */
75 
-	private $mount;
76 
-
77 
-	/** @var IStorage */
78 
-	private $keyStorage;
79 
-
80 
-	/** @var Update */
81 
-	private $update;
82 
-
83 
-	/** @var Manager */
84 
-	private $mountManager;
85 
-
86 
-	/** @var array remember for which path we execute the repair step to avoid recursions */
87 
-	private $fixUnencryptedSizeOf = array();
88 
-
89 
-	/** @var  ArrayCache */
90 
-	private $arrayCache;
91 
-
92 
-	/**
93 
-	 * @param array $parameters
94 
-	 * @param IManager $encryptionManager
95 
-	 * @param Util $util
96 
-	 * @param ILogger $logger
97 
-	 * @param IFile $fileHelper
98 
-	 * @param string $uid
99 
-	 * @param IStorage $keyStorage
100 
-	 * @param Update $update
101 
-	 * @param Manager $mountManager
102 
-	 * @param ArrayCache $arrayCache
103 
-	 */
104 
-	public function __construct(
105 
-			$parameters,
106 
-			IManager $encryptionManager = null,
107 
-			Util $util = null,
108 
-			ILogger $logger = null,
109 
-			IFile $fileHelper = null,
110 
-			$uid = null,
111 
-			IStorage $keyStorage = null,
112 
-			Update $update = null,
113 
-			Manager $mountManager = null,
114 
-			ArrayCache $arrayCache = null
115 
-		) {
116 
-
117 
-		$this->mountPoint = $parameters['mountPoint'];
118 
-		$this->mount = $parameters['mount'];
119 
-		$this->encryptionManager = $encryptionManager;
120 
-		$this->util = $util;
121 
-		$this->logger = $logger;
122 
-		$this->uid = $uid;
123 
-		$this->fileHelper = $fileHelper;
124 
-		$this->keyStorage = $keyStorage;
125 
-		$this->unencryptedSize = array();
126 
-		$this->update = $update;
127 
-		$this->mountManager = $mountManager;
128 
-		$this->arrayCache = $arrayCache;
129 
-		parent::__construct($parameters);
130 
-	}
131 
-
132 
-	/**
133 
-	 * see http://php.net/manual/en/function.filesize.php
134 
-	 * The result for filesize when called on a folder is required to be 0
135 
-	 *
136 
-	 * @param string $path
137 
-	 * @return int
138 
-	 */
139 
-	public function filesize($path) {
140 
-		$fullPath = $this->getFullPath($path);
141 
-
142 
-		/** @var CacheEntry $info */
143 
-		$info = $this->getCache()->get($path);
144 
-		if (isset($this->unencryptedSize[$fullPath])) {
145 
-			$size = $this->unencryptedSize[$fullPath];
146 
-			// update file cache
147 
-			if ($info instanceof ICacheEntry) {
148 
-				$info = $info->getData();
149 
-				$info['encrypted'] = $info['encryptedVersion'];
150 
-			} else {
151 
-				if (!is_array($info)) {
152 
-					$info = [];
153 
-				}
154 
-				$info['encrypted'] = true;
155 
-			}
156 
-
157 
-			$info['size'] = $size;
158 
-			$this->getCache()->put($path, $info);
159 
-
160 
-			return $size;
161 
-		}
162 
-
163 
-		if (isset($info['fileid']) && $info['encrypted']) {
164 
-			return $this->verifyUnencryptedSize($path, $info['size']);
165 
-		}
166 
-
167 
-		return $this->storage->filesize($path);
168 
-	}
169 
-
170 
-	/**
171 
-	 * @param string $path
172 
-	 * @return array
173 
-	 */
174 
-	public function getMetaData($path) {
175 
-		$data = $this->storage->getMetaData($path);
176 
-		if (is_null($data)) {
177 
-			return null;
178 
-		}
179 
-		$fullPath = $this->getFullPath($path);
180 
-		$info = $this->getCache()->get($path);
181 
-
182 
-		if (isset($this->unencryptedSize[$fullPath])) {
183 
-			$data['encrypted'] = true;
184 
-			$data['size'] = $this->unencryptedSize[$fullPath];
185 
-		} else {
186 
-			if (isset($info['fileid']) && $info['encrypted']) {
187 
-				$data['size'] = $this->verifyUnencryptedSize($path, $info['size']);
188 
-				$data['encrypted'] = true;
189 
-			}
190 
-		}
191 
-
192 
-		if (isset($info['encryptedVersion']) && $info['encryptedVersion'] > 1) {
193 
-			$data['encryptedVersion'] = $info['encryptedVersion'];
194 
-		}
195 
-
196 
-		return $data;
197 
-	}
198 
-
199 
-	/**
200 
-	 * see http://php.net/manual/en/function.file_get_contents.php
201 
-	 *
202 
-	 * @param string $path
203 
-	 * @return string
204 
-	 */
205 
-	public function file_get_contents($path) {
206 
-
207 
-		$encryptionModule = $this->getEncryptionModule($path);
208 
-
209 
-		if ($encryptionModule) {
210 
-			$handle = $this->fopen($path, "r");
211 
-			if (!$handle) {
212 
-				return false;
213 
-			}
214 
-			$data = stream_get_contents($handle);
215 
-			fclose($handle);
216 
-			return $data;
217 
-		}
218 
-		return $this->storage->file_get_contents($path);
219 
-	}
220 
-
221 
-	/**
222 
-	 * see http://php.net/manual/en/function.file_put_contents.php
223 
-	 *
224 
-	 * @param string $path
225 
-	 * @param string $data
226 
-	 * @return bool
227 
-	 */
228 
-	public function file_put_contents($path, $data) {
229 
-		// file put content will always be translated to a stream write
230 
-		$handle = $this->fopen($path, 'w');
231 
-		if (is_resource($handle)) {
232 
-			$written = fwrite($handle, $data);
233 
-			fclose($handle);
234 
-			return $written;
235 
-		}
236 
-
237 
-		return false;
238 
-	}
239 
-
240 
-	/**
241 
-	 * see http://php.net/manual/en/function.unlink.php
242 
-	 *
243 
-	 * @param string $path
244 
-	 * @return bool
245 
-	 */
246 
-	public function unlink($path) {
247 
-		$fullPath = $this->getFullPath($path);
248 
-		if ($this->util->isExcluded($fullPath)) {
249 
-			return $this->storage->unlink($path);
250 
-		}
251 
-
252 
-		$encryptionModule = $this->getEncryptionModule($path);
253 
-		if ($encryptionModule) {
254 
-			$this->keyStorage->deleteAllFileKeys($this->getFullPath($path));
255 
-		}
256 
-
257 
-		return $this->storage->unlink($path);
258 
-	}
259 
-
260 
-	/**
261 
-	 * see http://php.net/manual/en/function.rename.php
262 
-	 *
263 
-	 * @param string $path1
264 
-	 * @param string $path2
265 
-	 * @return bool
266 
-	 */
267 
-	public function rename($path1, $path2) {
268 
-
269 
-		$result = $this->storage->rename($path1, $path2);
270 
-
271 
-		if ($result &&
272 
-			// versions always use the keys from the original file, so we can skip
273 
-			// this step for versions
274 
-			$this->isVersion($path2) === false &&
275 
-			$this->encryptionManager->isEnabled()) {
276 
-			$source = $this->getFullPath($path1);
277 
-			if (!$this->util->isExcluded($source)) {
278 
-				$target = $this->getFullPath($path2);
279 
-				if (isset($this->unencryptedSize[$source])) {
280 
-					$this->unencryptedSize[$target] = $this->unencryptedSize[$source];
281 
-				}
282 
-				$this->keyStorage->renameKeys($source, $target);
283 
-				$module = $this->getEncryptionModule($path2);
284 
-				if ($module) {
285 
-					$module->update($target, $this->uid, []);
286 
-				}
287 
-			}
288 
-		}
289 
-
290 
-		return $result;
291 
-	}
292 
-
293 
-	/**
294 
-	 * see http://php.net/manual/en/function.rmdir.php
295 
-	 *
296 
-	 * @param string $path
297 
-	 * @return bool
298 
-	 */
299 
-	public function rmdir($path) {
300 
-		$result = $this->storage->rmdir($path);
301 
-		$fullPath = $this->getFullPath($path);
302 
-		if ($result &&
303 
-			$this->util->isExcluded($fullPath) === false &&
304 
-			$this->encryptionManager->isEnabled()
305 
-		) {
306 
-			$this->keyStorage->deleteAllFileKeys($fullPath);
307 
-		}
308 
-
309 
-		return $result;
310 
-	}
311 
-
312 
-	/**
313 
-	 * check if a file can be read
314 
-	 *
315 
-	 * @param string $path
316 
-	 * @return bool
317 
-	 */
318 
-	public function isReadable($path) {
319 
-
320 
-		$isReadable = true;
321 
-
322 
-		$metaData = $this->getMetaData($path);
323 
-		if (
324 
-			!$this->is_dir($path) &&
325 
-			isset($metaData['encrypted']) &&
326 
-			$metaData['encrypted'] === true
327 
-		) {
328 
-			$fullPath = $this->getFullPath($path);
329 
-			$module = $this->getEncryptionModule($path);
330 
-			$isReadable = $module->isReadable($fullPath, $this->uid);
331 
-		}
332 
-
333 
-		return $this->storage->isReadable($path) && $isReadable;
334 
-	}
335 
-
336 
-	/**
337 
-	 * see http://php.net/manual/en/function.copy.php
338 
-	 *
339 
-	 * @param string $path1
340 
-	 * @param string $path2
341 
-	 * @return bool
342 
-	 */
343 
-	public function copy($path1, $path2) {
344 
-
345 
-		$source = $this->getFullPath($path1);
346 
-
347 
-		if ($this->util->isExcluded($source)) {
348 
-			return $this->storage->copy($path1, $path2);
349 
-		}
350 
-
351 
-		// need to stream copy file by file in case we copy between a encrypted
352 
-		// and a unencrypted storage
353 
-		$this->unlink($path2);
354 
-		return $this->copyFromStorage($this, $path1, $path2);
355 
-	}
356 
-
357 
-	/**
358 
-	 * see http://php.net/manual/en/function.fopen.php
359 
-	 *
360 
-	 * @param string $path
361 
-	 * @param string $mode
362 
-	 * @return resource|bool
363 
-	 * @throws GenericEncryptionException
364 
-	 * @throws ModuleDoesNotExistsException
365 
-	 */
366 
-	public function fopen($path, $mode) {
367 
-
368 
-		// check if the file is stored in the array cache, this means that we
369 
-		// copy a file over to the versions folder, in this case we don't want to
370 
-		// decrypt it
371 
-		if ($this->arrayCache->hasKey('encryption_copy_version_' . $path)) {
372 
-			$this->arrayCache->remove('encryption_copy_version_' . $path);
373 
-			return $this->storage->fopen($path, $mode);
374 
-		}
375 
-
376 
-		$encryptionEnabled = $this->encryptionManager->isEnabled();
377 
-		$shouldEncrypt = false;
378 
-		$encryptionModule = null;
379 
-		$header = $this->getHeader($path);
380 
-		$signed = isset($header['signed']) && $header['signed'] === 'true';
381 
-		$fullPath = $this->getFullPath($path);
382 
-		$encryptionModuleId = $this->util->getEncryptionModuleId($header);
383 
-
384 
-		if ($this->util->isExcluded($fullPath) === false) {
385 
-
386 
-			$size = $unencryptedSize = 0;
387 
-			$realFile = $this->util->stripPartialFileExtension($path);
388 
-			$targetExists = $this->file_exists($realFile) || $this->file_exists($path);
389 
-			$targetIsEncrypted = false;
390 
-			if ($targetExists) {
391 
-				// in case the file exists we require the explicit module as
392 
-				// specified in the file header - otherwise we need to fail hard to
393 
-				// prevent data loss on client side
394 
-				if (!empty($encryptionModuleId)) {
395 
-					$targetIsEncrypted = true;
396 
-					$encryptionModule = $this->encryptionManager->getEncryptionModule($encryptionModuleId);
397 
-				}
398 
-
399 
-				if ($this->file_exists($path)) {
400 
-					$size = $this->storage->filesize($path);
401 
-					$unencryptedSize = $this->filesize($path);
402 
-				} else {
403 
-					$size = $unencryptedSize = 0;
404 
-				}
405 
-			}
406 
-
407 
-			try {
408 
-
409 
-				if (
410 
-					$mode === 'w'
411 
-					|| $mode === 'w+'
412 
-					|| $mode === 'wb'
413 
-					|| $mode === 'wb+'
414 
-				) {
415 
-					// don't overwrite encrypted files if encryption is not enabled
416 
-					if ($targetIsEncrypted && $encryptionEnabled === false) {
417 
-						throw new GenericEncryptionException('Tried to access encrypted file but encryption is not enabled');
418 
-					}
419 
-					if ($encryptionEnabled) {
420 
-						// if $encryptionModuleId is empty, the default module will be used
421 
-						$encryptionModule = $this->encryptionManager->getEncryptionModule($encryptionModuleId);
422 
-						$shouldEncrypt = $encryptionModule->shouldEncrypt($fullPath);
423 
-						$signed = true;
424 
-					}
425 
-				} else {
426 
-					$info = $this->getCache()->get($path);
427 
-					// only get encryption module if we found one in the header
428 
-					// or if file should be encrypted according to the file cache
429 
-					if (!empty($encryptionModuleId)) {
430 
-						$encryptionModule = $this->encryptionManager->getEncryptionModule($encryptionModuleId);
431 
-						$shouldEncrypt = true;
432 
-					} else if (empty($encryptionModuleId) && $info['encrypted'] === true) {
433 
-						// we come from a old installation. No header and/or no module defined
434 
-						// but the file is encrypted. In this case we need to use the
435 
-						// OC_DEFAULT_MODULE to read the file
436 
-						$encryptionModule = $this->encryptionManager->getEncryptionModule('OC_DEFAULT_MODULE');
437 
-						$shouldEncrypt = true;
438 
-						$targetIsEncrypted = true;
439 
-					}
440 
-				}
441 
-			} catch (ModuleDoesNotExistsException $e) {
442 
-				$this->logger->logException($e, [
443 
-					'message' => 'Encryption module "' . $encryptionModuleId . '" not found, file will be stored unencrypted',
444 
-					'level' => ILogger::WARN,
445 
-					'app' => 'core',
446 
-				]);
447 
-			}
448 
-
449 
-			// encryption disabled on write of new file and write to existing unencrypted file -> don't encrypt
450 
-			if (!$encryptionEnabled || !$this->shouldEncrypt($path)) {
451 
-				if (!$targetExists || !$targetIsEncrypted) {
452 
-					$shouldEncrypt = false;
453 
-				}
454 
-			}
455 
-
456 
-			if ($shouldEncrypt === true && $encryptionModule !== null) {
457 
-				$headerSize = $this->getHeaderSize($path);
458 
-				$source = $this->storage->fopen($path, $mode);
459 
-				if (!is_resource($source)) {
460 
-					return false;
461 
-				}
462 
-				$handle = \OC\Files\Stream\Encryption::wrap($source, $path, $fullPath, $header,
463 
-					$this->uid, $encryptionModule, $this->storage, $this, $this->util, $this->fileHelper, $mode,
464 
-					$size, $unencryptedSize, $headerSize, $signed);
465 
-				return $handle;
466 
-			}
467 
-
468 
-		}
469 
-
470 
-		return $this->storage->fopen($path, $mode);
471 
-	}
472 
-
473 
-
474 
-	/**
475 
-	 * perform some plausibility checks if the the unencrypted size is correct.
476 
-	 * If not, we calculate the correct unencrypted size and return it
477 
-	 *
478 
-	 * @param string $path internal path relative to the storage root
479 
-	 * @param int $unencryptedSize size of the unencrypted file
480 
-	 *
481 
-	 * @return int unencrypted size
482 
-	 */
483 
-	protected function verifyUnencryptedSize($path, $unencryptedSize) {
484 
-
485 
-		$size = $this->storage->filesize($path);
486 
-		$result = $unencryptedSize;
487 
-
488 
-		if ($unencryptedSize < 0 ||
489 
-			($size > 0 && $unencryptedSize === $size)
490 
-		) {
491 
-			// check if we already calculate the unencrypted size for the
492 
-			// given path to avoid recursions
493 
-			if (isset($this->fixUnencryptedSizeOf[$this->getFullPath($path)]) === false) {
494 
-				$this->fixUnencryptedSizeOf[$this->getFullPath($path)] = true;
495 
-				try {
496 
-					$result = $this->fixUnencryptedSize($path, $size, $unencryptedSize);
497 
-				} catch (\Exception $e) {
498 
-					$this->logger->error('Couldn\'t re-calculate unencrypted size for '. $path);
499 
-					$this->logger->logException($e);
500 
-				}
501 
-				unset($this->fixUnencryptedSizeOf[$this->getFullPath($path)]);
502 
-			}
503 
-		}
504 
-
505 
-		return $result;
506 
-	}
507 
-
508 
-	/**
509 
-	 * calculate the unencrypted size
510 
-	 *
511 
-	 * @param string $path internal path relative to the storage root
512 
-	 * @param int $size size of the physical file
513 
-	 * @param int $unencryptedSize size of the unencrypted file
514 
-	 *
515 
-	 * @return int calculated unencrypted size
516 
-	 */
517 
-	protected function fixUnencryptedSize($path, $size, $unencryptedSize) {
518 
-
519 
-		$headerSize = $this->getHeaderSize($path);
520 
-		$header = $this->getHeader($path);
521 
-		$encryptionModule = $this->getEncryptionModule($path);
522 
-
523 
-		$stream = $this->storage->fopen($path, 'r');
524 
-
525 
-		// if we couldn't open the file we return the old unencrypted size
526 
-		if (!is_resource($stream)) {
527 
-			$this->logger->error('Could not open ' . $path . '. Recalculation of unencrypted size aborted.');
528 
-			return $unencryptedSize;
529 
-		}
530 
-
531 
-		$newUnencryptedSize = 0;
532 
-		$size -= $headerSize;
533 
-		$blockSize = $this->util->getBlockSize();
534 
-
535 
-		// if a header exists we skip it
536 
-		if ($headerSize > 0) {
537 
-			fread($stream, $headerSize);
538 
-		}
539 
-
540 
-		// fast path, else the calculation for $lastChunkNr is bogus
541 
-		if ($size === 0) {
542 
-			return 0;
543 
-		}
544 
-
545 
-		$signed = isset($header['signed']) && $header['signed'] === 'true';
546 
-		$unencryptedBlockSize = $encryptionModule->getUnencryptedBlockSize($signed);
547 
-
548 
-		// calculate last chunk nr
549 
-		// next highest is end of chunks, one subtracted is last one
550 
-		// we have to read the last chunk, we can't just calculate it (because of padding etc)
551 
-
552 
-		$lastChunkNr = ceil($size/ $blockSize)-1;
553 
-		// calculate last chunk position
554 
-		$lastChunkPos = ($lastChunkNr * $blockSize);
555 
-		// try to fseek to the last chunk, if it fails we have to read the whole file
556 
-		if (@fseek($stream, $lastChunkPos, SEEK_CUR) === 0) {
557 
-			$newUnencryptedSize += $lastChunkNr * $unencryptedBlockSize;
558 
-		}
559 
-
560 
-		$lastChunkContentEncrypted='';
561 
-		$count = $blockSize;
562 
-
563 
-		while ($count > 0) {
564 
-			$data=fread($stream, $blockSize);
565 
-			$count=strlen($data);
566 
-			$lastChunkContentEncrypted .= $data;
567 
-			if(strlen($lastChunkContentEncrypted) > $blockSize) {
568 
-				$newUnencryptedSize += $unencryptedBlockSize;
569 
-				$lastChunkContentEncrypted=substr($lastChunkContentEncrypted, $blockSize);
570 
-			}
571 
-		}
572 
-
573 
-		fclose($stream);
574 
-
575 
-		// we have to decrypt the last chunk to get it actual size
576 
-		$encryptionModule->begin($this->getFullPath($path), $this->uid, 'r', $header, []);
577 
-		$decryptedLastChunk = $encryptionModule->decrypt($lastChunkContentEncrypted, $lastChunkNr . 'end');
578 
-		$decryptedLastChunk .= $encryptionModule->end($this->getFullPath($path), $lastChunkNr . 'end');
579 
-
580 
-		// calc the real file size with the size of the last chunk
581 
-		$newUnencryptedSize += strlen($decryptedLastChunk);
582 
-
583 
-		$this->updateUnencryptedSize($this->getFullPath($path), $newUnencryptedSize);
584 
-
585 
-		// write to cache if applicable
586 
-		$cache = $this->storage->getCache();
587 
-		if ($cache) {
588 
-			$entry = $cache->get($path);
589 
-			$cache->update($entry['fileid'], ['size' => $newUnencryptedSize]);
590 
-		}
591 
-
592 
-		return $newUnencryptedSize;
593 
-	}
594 
-
595 
-	/**
596 
-	 * @param Storage\IStorage $sourceStorage
597 
-	 * @param string $sourceInternalPath
598 
-	 * @param string $targetInternalPath
599 
-	 * @param bool $preserveMtime
600 
-	 * @return bool
601 
-	 */
602 
-	public function moveFromStorage(Storage\IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath, $preserveMtime = true) {
603 
-		if ($sourceStorage === $this) {
604 
-			return $this->rename($sourceInternalPath, $targetInternalPath);
605 
-		}
606 
-
607 
-		// TODO clean this up once the underlying moveFromStorage in OC\Files\Storage\Wrapper\Common is fixed:
608 
-		// - call $this->storage->moveFromStorage() instead of $this->copyBetweenStorage
609 
-		// - copy the file cache update from  $this->copyBetweenStorage to this method
610 
-		// - copy the copyKeys() call from  $this->copyBetweenStorage to this method
611 
-		// - remove $this->copyBetweenStorage
612 
-
613 
-		if (!$sourceStorage->isDeletable($sourceInternalPath)) {
614 
-			return false;
615 
-		}
616 
-
617 
-		$result = $this->copyBetweenStorage($sourceStorage, $sourceInternalPath, $targetInternalPath, $preserveMtime, true);
618 
-		if ($result) {
619 
-			if ($sourceStorage->is_dir($sourceInternalPath)) {
620 
-				$result &= $sourceStorage->rmdir($sourceInternalPath);
621 
-			} else {
622 
-				$result &= $sourceStorage->unlink($sourceInternalPath);
623 
-			}
624 
-		}
625 
-		return $result;
626 
-	}
627 
-
628 
-
629 
-	/**
630 
-	 * @param Storage\IStorage $sourceStorage
631 
-	 * @param string $sourceInternalPath
632 
-	 * @param string $targetInternalPath
633 
-	 * @param bool $preserveMtime
634 
-	 * @param bool $isRename
635 
-	 * @return bool
636 
-	 */
637 
-	public function copyFromStorage(Storage\IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath, $preserveMtime = false, $isRename = false) {
638 
-
639 
-		// TODO clean this up once the underlying moveFromStorage in OC\Files\Storage\Wrapper\Common is fixed:
640 
-		// - call $this->storage->copyFromStorage() instead of $this->copyBetweenStorage
641 
-		// - copy the file cache update from  $this->copyBetweenStorage to this method
642 
-		// - copy the copyKeys() call from  $this->copyBetweenStorage to this method
643 
-		// - remove $this->copyBetweenStorage
644 
-
645 
-		return $this->copyBetweenStorage($sourceStorage, $sourceInternalPath, $targetInternalPath, $preserveMtime, $isRename);
646 
-	}
647 
-
648 
-	/**
649 
-	 * Update the encrypted cache version in the database
650 
-	 *
651 
-	 * @param Storage\IStorage $sourceStorage
652 
-	 * @param string $sourceInternalPath
653 
-	 * @param string $targetInternalPath
654 
-	 * @param bool $isRename
655 
-	 * @param bool $keepEncryptionVersion
656 
-	 */
657 
-	private function updateEncryptedVersion(Storage\IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath, $isRename, $keepEncryptionVersion) {
658 
-		$isEncrypted = $this->encryptionManager->isEnabled() && $this->shouldEncrypt($targetInternalPath);
659 
-		$cacheInformation = [
660 
-			'encrypted' => $isEncrypted,
661 
-		];
662 
-		if($isEncrypted) {
663 
-			$encryptedVersion = $sourceStorage->getCache()->get($sourceInternalPath)['encryptedVersion'];
664 
-
665 
-			// In case of a move operation from an unencrypted to an encrypted
666 
-			// storage the old encrypted version would stay with "0" while the
667 
-			// correct value would be "1". Thus we manually set the value to "1"
668 
-			// for those cases.
669 
-			// See also https://github.com/owncloud/core/issues/23078
670 
-			if($encryptedVersion === 0 || !$keepEncryptionVersion) {
671 
-				$encryptedVersion = 1;
672 
-			}
673 
-
674 
-			$cacheInformation['encryptedVersion'] = $encryptedVersion;
675 
-		}
676 
-
677 
-		// in case of a rename we need to manipulate the source cache because
678 
-		// this information will be kept for the new target
679 
-		if ($isRename) {
680 
-			$sourceStorage->getCache()->put($sourceInternalPath, $cacheInformation);
681 
-		} else {
682 
-			$this->getCache()->put($targetInternalPath, $cacheInformation);
683 
-		}
684 
-	}
685 
-
686 
-	/**
687 
-	 * copy file between two storages
688 
-	 *
689 
-	 * @param Storage\IStorage $sourceStorage
690 
-	 * @param string $sourceInternalPath
691 
-	 * @param string $targetInternalPath
692 
-	 * @param bool $preserveMtime
693 
-	 * @param bool $isRename
694 
-	 * @return bool
695 
-	 * @throws \Exception
696 
-	 */
697 
-	private function copyBetweenStorage(Storage\IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath, $preserveMtime, $isRename) {
698 
-
699 
-		// for versions we have nothing to do, because versions should always use the
700 
-		// key from the original file. Just create a 1:1 copy and done
701 
-		if ($this->isVersion($targetInternalPath) ||
702 
-			$this->isVersion($sourceInternalPath)) {
703 
-			// remember that we try to create a version so that we can detect it during
704 
-			// fopen($sourceInternalPath) and by-pass the encryption in order to
705 
-			// create a 1:1 copy of the file
706 
-			$this->arrayCache->set('encryption_copy_version_' . $sourceInternalPath, true);
707 
-			$result = $this->storage->copyFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath);
708 
-			$this->arrayCache->remove('encryption_copy_version_' . $sourceInternalPath);
709 
-			if ($result) {
710 
-				$info = $this->getCache('', $sourceStorage)->get($sourceInternalPath);
711 
-				// make sure that we update the unencrypted size for the version
712 
-				if (isset($info['encrypted']) && $info['encrypted'] === true) {
713 
-					$this->updateUnencryptedSize(
714 
-						$this->getFullPath($targetInternalPath),
715 
-						$info['size']
716 
-					);
717 
-				}
718 
-				$this->updateEncryptedVersion($sourceStorage, $sourceInternalPath, $targetInternalPath, $isRename, true);
719 
-			}
720 
-			return $result;
721 
-		}
722 
-
723 
-		// first copy the keys that we reuse the existing file key on the target location
724 
-		// and don't create a new one which would break versions for example.
725 
-		$mount = $this->mountManager->findByStorageId($sourceStorage->getId());
726 
-		if (count($mount) === 1) {
727 
-			$mountPoint = $mount[0]->getMountPoint();
728 
-			$source = $mountPoint . '/' . $sourceInternalPath;
729 
-			$target = $this->getFullPath($targetInternalPath);
730 
-			$this->copyKeys($source, $target);
731 
-		} else {
732 
-			$this->logger->error('Could not find mount point, can\'t keep encryption keys');
733 
-		}
734 
-
735 
-		if ($sourceStorage->is_dir($sourceInternalPath)) {
736 
-			$dh = $sourceStorage->opendir($sourceInternalPath);
737 
-			$result = $this->mkdir($targetInternalPath);
738 
-			if (is_resource($dh)) {
739 
-				while ($result and ($file = readdir($dh)) !== false) {
740 
-					if (!Filesystem::isIgnoredDir($file)) {
741 
-						$result &= $this->copyFromStorage($sourceStorage, $sourceInternalPath . '/' . $file, $targetInternalPath . '/' . $file, false, $isRename);
742 
-					}
743 
-				}
744 
-			}
745 
-		} else {
746 
-			try {
747 
-				$source = $sourceStorage->fopen($sourceInternalPath, 'r');
748 
-				$target = $this->fopen($targetInternalPath, 'w');
749 
-				list(, $result) = \OC_Helper::streamCopy($source, $target);
750 
-				fclose($source);
751 
-				fclose($target);
752 
-			} catch (\Exception $e) {
753 
-				fclose($source);
754 
-				fclose($target);
755 
-				throw $e;
756 
-			}
757 
-			if($result) {
758 
-				if ($preserveMtime) {
759 
-					$this->touch($targetInternalPath, $sourceStorage->filemtime($sourceInternalPath));
760 
-				}
761 
-				$this->updateEncryptedVersion($sourceStorage, $sourceInternalPath, $targetInternalPath, $isRename, false);
762 
-			} else {
763 
-				// delete partially written target file
764 
-				$this->unlink($targetInternalPath);
765 
-				// delete cache entry that was created by fopen
766 
-				$this->getCache()->remove($targetInternalPath);
767 
-			}
768 
-		}
769 
-		return (bool)$result;
770 
-
771 
-	}
772 
-
773 
-	/**
774 
-	 * get the path to a local version of the file.
775 
-	 * The local version of the file can be temporary and doesn't have to be persistent across requests
776 
-	 *
777 
-	 * @param string $path
778 
-	 * @return string
779 
-	 */
780 
-	public function getLocalFile($path) {
781 
-		if ($this->encryptionManager->isEnabled()) {
782 
-			$cachedFile = $this->getCachedFile($path);
783 
-			if (is_string($cachedFile)) {
784 
-				return $cachedFile;
785 
-			}
786 
-		}
787 
-		return $this->storage->getLocalFile($path);
788 
-	}
789 
-
790 
-	/**
791 
-	 * Returns the wrapped storage's value for isLocal()
792 
-	 *
793 
-	 * @return bool wrapped storage's isLocal() value
794 
-	 */
795 
-	public function isLocal() {
796 
-		if ($this->encryptionManager->isEnabled()) {
797 
-			return false;
798 
-		}
799 
-		return $this->storage->isLocal();
800 
-	}
801 
-
802 
-	/**
803 
-	 * see http://php.net/manual/en/function.stat.php
804 
-	 * only the following keys are required in the result: size and mtime
805 
-	 *
806 
-	 * @param string $path
807 
-	 * @return array
808 
-	 */
809 
-	public function stat($path) {
810 
-		$stat = $this->storage->stat($path);
811 
-		$fileSize = $this->filesize($path);
812 
-		$stat['size'] = $fileSize;
813 
-		$stat[7] = $fileSize;
814 
-		return $stat;
815 
-	}
816 
-
817 
-	/**
818 
-	 * see http://php.net/manual/en/function.hash.php
819 
-	 *
820 
-	 * @param string $type
821 
-	 * @param string $path
822 
-	 * @param bool $raw
823 
-	 * @return string
824 
-	 */
825 
-	public function hash($type, $path, $raw = false) {
826 
-		$fh = $this->fopen($path, 'rb');
827 
-		$ctx = hash_init($type);
828 
-		hash_update_stream($ctx, $fh);
829 
-		fclose($fh);
830 
-		return hash_final($ctx, $raw);
831 
-	}
832 
-
833 
-	/**
834 
-	 * return full path, including mount point
835 
-	 *
836 
-	 * @param string $path relative to mount point
837 
-	 * @return string full path including mount point
838 
-	 */
839 
-	protected function getFullPath($path) {
840 
-		return Filesystem::normalizePath($this->mountPoint . '/' . $path);
841 
-	}
842 
-
843 
-	/**
844 
-	 * read first block of encrypted file, typically this will contain the
845 
-	 * encryption header
846 
-	 *
847 
-	 * @param string $path
848 
-	 * @return string
849 
-	 */
850 
-	protected function readFirstBlock($path) {
851 
-		$firstBlock = '';
852 
-		if ($this->storage->file_exists($path)) {
853 
-			$handle = $this->storage->fopen($path, 'r');
854 
-			$firstBlock = fread($handle, $this->util->getHeaderSize());
855 
-			fclose($handle);
856 
-		}
857 
-		return $firstBlock;
858 
-	}
859 
-
860 
-	/**
861 
-	 * return header size of given file
862 
-	 *
863 
-	 * @param string $path
864 
-	 * @return int
865 
-	 */
866 
-	protected function getHeaderSize($path) {
867 
-		$headerSize = 0;
868 
-		$realFile = $this->util->stripPartialFileExtension($path);
869 
-		if ($this->storage->file_exists($realFile)) {
870 
-			$path = $realFile;
871 
-		}
872 
-		$firstBlock = $this->readFirstBlock($path);
873 
-
874 
-		if (substr($firstBlock, 0, strlen(Util::HEADER_START)) === Util::HEADER_START) {
875 
-			$headerSize = $this->util->getHeaderSize();
876 
-		}
877 
-
878 
-		return $headerSize;
879 
-	}
880 
-
881 
-	/**
882 
-	 * parse raw header to array
883 
-	 *
884 
-	 * @param string $rawHeader
885 
-	 * @return array
886 
-	 */
887 
-	protected function parseRawHeader($rawHeader) {
888 
-		$result = array();
889 
-		if (substr($rawHeader, 0, strlen(Util::HEADER_START)) === Util::HEADER_START) {
890 
-			$header = $rawHeader;
891 
-			$endAt = strpos($header, Util::HEADER_END);
892 
-			if ($endAt !== false) {
893 
-				$header = substr($header, 0, $endAt + strlen(Util::HEADER_END));
894 
-
895 
-				// +1 to not start with an ':' which would result in empty element at the beginning
896 
-				$exploded = explode(':', substr($header, strlen(Util::HEADER_START)+1));
897 
-
898 
-				$element = array_shift($exploded);
899 
-				while ($element !== Util::HEADER_END) {
900 
-					$result[$element] = array_shift($exploded);
901 
-					$element = array_shift($exploded);
902 
-				}
903 
-			}
904 
-		}
905 
-
906 
-		return $result;
907 
-	}
908 
-
909 
-	/**
910 
-	 * read header from file
911 
-	 *
912 
-	 * @param string $path
913 
-	 * @return array
914 
-	 */
915 
-	protected function getHeader($path) {
916 
-		$realFile = $this->util->stripPartialFileExtension($path);
917 
-		$exists = $this->storage->file_exists($realFile);
918 
-		if ($exists) {
919 
-			$path = $realFile;
920 
-		}
921 
-
922 
-		$firstBlock = $this->readFirstBlock($path);
923 
-		$result = $this->parseRawHeader($firstBlock);
924 
-
925 
-		// if the header doesn't contain a encryption module we check if it is a
926 
-		// legacy file. If true, we add the default encryption module
927 
-		if (!isset($result[Util::HEADER_ENCRYPTION_MODULE_KEY])) {
928 
-			if (!empty($result)) {
929 
-				$result[Util::HEADER_ENCRYPTION_MODULE_KEY] = 'OC_DEFAULT_MODULE';
930 
-			} else if ($exists) {
931 
-				// if the header was empty we have to check first if it is a encrypted file at all
932 
-				// We would do query to filecache only if we know that entry in filecache exists
933 
-				$info = $this->getCache()->get($path);
934 
-				if (isset($info['encrypted']) && $info['encrypted'] === true) {
935 
-					$result[Util::HEADER_ENCRYPTION_MODULE_KEY] = 'OC_DEFAULT_MODULE';
936 
-				}
937 
-			}
938 
-		}
939 
-
940 
-		return $result;
941 
-	}
942 
-
943 
-	/**
944 
-	 * read encryption module needed to read/write the file located at $path
945 
-	 *
946 
-	 * @param string $path
947 
-	 * @return null|\OCP\Encryption\IEncryptionModule
948 
-	 * @throws ModuleDoesNotExistsException
949 
-	 * @throws \Exception
950 
-	 */
951 
-	protected function getEncryptionModule($path) {
952 
-		$encryptionModule = null;
953 
-		$header = $this->getHeader($path);
954 
-		$encryptionModuleId = $this->util->getEncryptionModuleId($header);
955 
-		if (!empty($encryptionModuleId)) {
956 
-			try {
957 
-				$encryptionModule = $this->encryptionManager->getEncryptionModule($encryptionModuleId);
958 
-			} catch (ModuleDoesNotExistsException $e) {
959 
-				$this->logger->critical('Encryption module defined in "' . $path . '" not loaded!');
960 
-				throw $e;
961 
-			}
962 
-		}
963 
-
964 
-		return $encryptionModule;
965 
-	}
966 
-
967 
-	/**
968 
-	 * @param string $path
969 
-	 * @param int $unencryptedSize
970 
-	 */
971 
-	public function updateUnencryptedSize($path, $unencryptedSize) {
972 
-		$this->unencryptedSize[$path] = $unencryptedSize;
973 
-	}
974 
-
975 
-	/**
976 
-	 * copy keys to new location
977 
-	 *
978 
-	 * @param string $source path relative to data/
979 
-	 * @param string $target path relative to data/
980 
-	 * @return bool
981 
-	 */
982 
-	protected function copyKeys($source, $target) {
983 
-		if (!$this->util->isExcluded($source)) {
984 
-			return $this->keyStorage->copyKeys($source, $target);
985 
-		}
986 
-
987 
-		return false;
988 
-	}
989 
-
990 
-	/**
991 
-	 * check if path points to a files version
992 
-	 *
993 
-	 * @param $path
994 
-	 * @return bool
995 
-	 */
996 
-	protected function isVersion($path) {
997 
-		$normalized = Filesystem::normalizePath($path);
998 
-		return substr($normalized, 0, strlen('/files_versions/')) === '/files_versions/';
999 
-	}
1000 
-
1001 
-	/**
1002 
-	 * check if the given storage should be encrypted or not
1003 
-	 *
1004 
-	 * @param $path
1005 
-	 * @return bool
1006 
-	 */
1007 
-	protected function shouldEncrypt($path) {
1008 
-		$fullPath = $this->getFullPath($path);
1009 
-		$mountPointConfig = $this->mount->getOption('encrypt', true);
1010 
-		if ($mountPointConfig === false) {
1011 
-			return false;
1012 
-		}
1013 
-
1014 
-		try {
1015 
-			$encryptionModule = $this->getEncryptionModule($fullPath);
1016 
-		} catch (ModuleDoesNotExistsException $e) {
1017 
-			return false;
1018 
-		}
1019 
-
1020 
-		if ($encryptionModule === null) {
1021 
-			$encryptionModule = $this->encryptionManager->getEncryptionModule();
1022 
-		}
1023 
-
1024 
-		return $encryptionModule->shouldEncrypt($fullPath);
1025 
-
1026 
-	}
51 
+    use LocalTempFileTrait;
52 
+
53 
+    /** @var string */
54 
+    private $mountPoint;
55 
+
56 
+    /** @var \OC\Encryption\Util */
57 
+    private $util;
58 
+
59 
+    /** @var \OCP\Encryption\IManager */
60 
+    private $encryptionManager;
61 
+
62 
+    /** @var \OCP\ILogger */
63 
+    private $logger;
64 
+
65 
+    /** @var string */
66 
+    private $uid;
67 
+
68 
+    /** @var array */
69 
+    protected $unencryptedSize;
70 
+
71 
+    /** @var \OCP\Encryption\IFile */
72 
+    private $fileHelper;
73 
+
74 
+    /** @var IMountPoint */
75 
+    private $mount;
76 
+
77 
+    /** @var IStorage */
78 
+    private $keyStorage;
79 
+
80 
+    /** @var Update */
81 
+    private $update;
82 
+
83 
+    /** @var Manager */
84 
+    private $mountManager;
85 
+
86 
+    /** @var array remember for which path we execute the repair step to avoid recursions */
87 
+    private $fixUnencryptedSizeOf = array();
88 
+
89 
+    /** @var  ArrayCache */
90 
+    private $arrayCache;
91 
+
92 
+    /**
93 
+     * @param array $parameters
94 
+     * @param IManager $encryptionManager
95 
+     * @param Util $util
96 
+     * @param ILogger $logger
97 
+     * @param IFile $fileHelper
98 
+     * @param string $uid
99 
+     * @param IStorage $keyStorage
100 
+     * @param Update $update
101 
+     * @param Manager $mountManager
102 
+     * @param ArrayCache $arrayCache
103 
+     */
104 
+    public function __construct(
105 
+            $parameters,
106 
+            IManager $encryptionManager = null,
107 
+            Util $util = null,
108 
+            ILogger $logger = null,
109 
+            IFile $fileHelper = null,
110 
+            $uid = null,
111 
+            IStorage $keyStorage = null,
112 
+            Update $update = null,
113 
+            Manager $mountManager = null,
114 
+            ArrayCache $arrayCache = null
115 
+        ) {
116 
+
117 
+        $this->mountPoint = $parameters['mountPoint'];
118 
+        $this->mount = $parameters['mount'];
119 
+        $this->encryptionManager = $encryptionManager;
120 
+        $this->util = $util;
121 
+        $this->logger = $logger;
122 
+        $this->uid = $uid;
123 
+        $this->fileHelper = $fileHelper;
124 
+        $this->keyStorage = $keyStorage;
125 
+        $this->unencryptedSize = array();
126 
+        $this->update = $update;
127 
+        $this->mountManager = $mountManager;
128 
+        $this->arrayCache = $arrayCache;
129 
+        parent::__construct($parameters);
130 
+    }
131 
+
132 
+    /**
133 
+     * see http://php.net/manual/en/function.filesize.php
134 
+     * The result for filesize when called on a folder is required to be 0
135 
+     *
136 
+     * @param string $path
137 
+     * @return int
138 
+     */
139 
+    public function filesize($path) {
140 
+        $fullPath = $this->getFullPath($path);
141 
+
142 
+        /** @var CacheEntry $info */
143 
+        $info = $this->getCache()->get($path);
144 
+        if (isset($this->unencryptedSize[$fullPath])) {
145 
+            $size = $this->unencryptedSize[$fullPath];
146 
+            // update file cache
147 
+            if ($info instanceof ICacheEntry) {
148 
+                $info = $info->getData();
149 
+                $info['encrypted'] = $info['encryptedVersion'];
150 
+            } else {
151 
+                if (!is_array($info)) {
152 
+                    $info = [];
153 
+                }
154 
+                $info['encrypted'] = true;
155 
+            }
156 
+
157 
+            $info['size'] = $size;
158 
+            $this->getCache()->put($path, $info);
159 
+
160 
+            return $size;
161 
+        }
162 
+
163 
+        if (isset($info['fileid']) && $info['encrypted']) {
164 
+            return $this->verifyUnencryptedSize($path, $info['size']);
165 
+        }
166 
+
167 
+        return $this->storage->filesize($path);
168 
+    }
169 
+
170 
+    /**
171 
+     * @param string $path
172 
+     * @return array
173 
+     */
174 
+    public function getMetaData($path) {
175 
+        $data = $this->storage->getMetaData($path);
176 
+        if (is_null($data)) {
177 
+            return null;
178 
+        }
179 
+        $fullPath = $this->getFullPath($path);
180 
+        $info = $this->getCache()->get($path);
181 
+
182 
+        if (isset($this->unencryptedSize[$fullPath])) {
183 
+            $data['encrypted'] = true;
184 
+            $data['size'] = $this->unencryptedSize[$fullPath];
185 
+        } else {
186 
+            if (isset($info['fileid']) && $info['encrypted']) {
187 
+                $data['size'] = $this->verifyUnencryptedSize($path, $info['size']);
188 
+                $data['encrypted'] = true;
189 
+            }
190 
+        }
191 
+
192 
+        if (isset($info['encryptedVersion']) && $info['encryptedVersion'] > 1) {
193 
+            $data['encryptedVersion'] = $info['encryptedVersion'];
194 
+        }
195 
+
196 
+        return $data;
197 
+    }
198 
+
199 
+    /**
200 
+     * see http://php.net/manual/en/function.file_get_contents.php
201 
+     *
202 
+     * @param string $path
203 
+     * @return string
204 
+     */
205 
+    public function file_get_contents($path) {
206 
+
207 
+        $encryptionModule = $this->getEncryptionModule($path);
208 
+
209 
+        if ($encryptionModule) {
210 
+            $handle = $this->fopen($path, "r");
211 
+            if (!$handle) {
212 
+                return false;
213 
+            }
214 
+            $data = stream_get_contents($handle);
215 
+            fclose($handle);
216 
+            return $data;
217 
+        }
218 
+        return $this->storage->file_get_contents($path);
219 
+    }
220 
+
221 
+    /**
222 
+     * see http://php.net/manual/en/function.file_put_contents.php
223 
+     *
224 
+     * @param string $path
225 
+     * @param string $data
226 
+     * @return bool
227 
+     */
228 
+    public function file_put_contents($path, $data) {
229 
+        // file put content will always be translated to a stream write
230 
+        $handle = $this->fopen($path, 'w');
231 
+        if (is_resource($handle)) {
232 
+            $written = fwrite($handle, $data);
233 
+            fclose($handle);
234 
+            return $written;
235 
+        }
236 
+
237 
+        return false;
238 
+    }
239 
+
240 
+    /**
241 
+     * see http://php.net/manual/en/function.unlink.php
242 
+     *
243 
+     * @param string $path
244 
+     * @return bool
245 
+     */
246 
+    public function unlink($path) {
247 
+        $fullPath = $this->getFullPath($path);
248 
+        if ($this->util->isExcluded($fullPath)) {
249 
+            return $this->storage->unlink($path);
250 
+        }
251 
+
252 
+        $encryptionModule = $this->getEncryptionModule($path);
253 
+        if ($encryptionModule) {
254 
+            $this->keyStorage->deleteAllFileKeys($this->getFullPath($path));
255 
+        }
256 
+
257 
+        return $this->storage->unlink($path);
258 
+    }
259 
+
260 
+    /**
261 
+     * see http://php.net/manual/en/function.rename.php
262 
+     *
263 
+     * @param string $path1
264 
+     * @param string $path2
265 
+     * @return bool
266 
+     */
267 
+    public function rename($path1, $path2) {
268 
+
269 
+        $result = $this->storage->rename($path1, $path2);
270 
+
271 
+        if ($result &&
272 
+            // versions always use the keys from the original file, so we can skip
273 
+            // this step for versions
274 
+            $this->isVersion($path2) === false &&
275 
+            $this->encryptionManager->isEnabled()) {
276 
+            $source = $this->getFullPath($path1);
277 
+            if (!$this->util->isExcluded($source)) {
278 
+                $target = $this->getFullPath($path2);
279 
+                if (isset($this->unencryptedSize[$source])) {
280 
+                    $this->unencryptedSize[$target] = $this->unencryptedSize[$source];
281 
+                }
282 
+                $this->keyStorage->renameKeys($source, $target);
283 
+                $module = $this->getEncryptionModule($path2);
284 
+                if ($module) {
285 
+                    $module->update($target, $this->uid, []);
286 
+                }
287 
+            }
288 
+        }
289 
+
290 
+        return $result;
291 
+    }
292 
+
293 
+    /**
294 
+     * see http://php.net/manual/en/function.rmdir.php
295 
+     *
296 
+     * @param string $path
297 
+     * @return bool
298 
+     */
299 
+    public function rmdir($path) {
300 
+        $result = $this->storage->rmdir($path);
301 
+        $fullPath = $this->getFullPath($path);
302 
+        if ($result &&
303 
+            $this->util->isExcluded($fullPath) === false &&
304 
+            $this->encryptionManager->isEnabled()
305 
+        ) {
306 
+            $this->keyStorage->deleteAllFileKeys($fullPath);
307 
+        }
308 
+
309 
+        return $result;
310 
+    }
311 
+
312 
+    /**
313 
+     * check if a file can be read
314 
+     *
315 
+     * @param string $path
316 
+     * @return bool
317 
+     */
318 
+    public function isReadable($path) {
319 
+
320 
+        $isReadable = true;
321 
+
322 
+        $metaData = $this->getMetaData($path);
323 
+        if (
324 
+            !$this->is_dir($path) &&
325 
+            isset($metaData['encrypted']) &&
326 
+            $metaData['encrypted'] === true
327 
+        ) {
328 
+            $fullPath = $this->getFullPath($path);
329 
+            $module = $this->getEncryptionModule($path);
330 
+            $isReadable = $module->isReadable($fullPath, $this->uid);
331 
+        }
332 
+
333 
+        return $this->storage->isReadable($path) && $isReadable;
334 
+    }
335 
+
336 
+    /**
337 
+     * see http://php.net/manual/en/function.copy.php
338 
+     *
339 
+     * @param string $path1
340 
+     * @param string $path2
341 
+     * @return bool
342 
+     */
343 
+    public function copy($path1, $path2) {
344 
+
345 
+        $source = $this->getFullPath($path1);
346 
+
347 
+        if ($this->util->isExcluded($source)) {
348 
+            return $this->storage->copy($path1, $path2);
349 
+        }
350 
+
351 
+        // need to stream copy file by file in case we copy between a encrypted
352 
+        // and a unencrypted storage
353 
+        $this->unlink($path2);
354 
+        return $this->copyFromStorage($this, $path1, $path2);
355 
+    }
356 
+
357 
+    /**
358 
+     * see http://php.net/manual/en/function.fopen.php
359 
+     *
360 
+     * @param string $path
361 
+     * @param string $mode
362 
+     * @return resource|bool
363 
+     * @throws GenericEncryptionException
364 
+     * @throws ModuleDoesNotExistsException
365 
+     */
366 
+    public function fopen($path, $mode) {
367 
+
368 
+        // check if the file is stored in the array cache, this means that we
369 
+        // copy a file over to the versions folder, in this case we don't want to
370 
+        // decrypt it
371 
+        if ($this->arrayCache->hasKey('encryption_copy_version_' . $path)) {
372 
+            $this->arrayCache->remove('encryption_copy_version_' . $path);
373 
+            return $this->storage->fopen($path, $mode);
374 
+        }
375 
+
376 
+        $encryptionEnabled = $this->encryptionManager->isEnabled();
377 
+        $shouldEncrypt = false;
378 
+        $encryptionModule = null;
379 
+        $header = $this->getHeader($path);
380 
+        $signed = isset($header['signed']) && $header['signed'] === 'true';
381 
+        $fullPath = $this->getFullPath($path);
382 
+        $encryptionModuleId = $this->util->getEncryptionModuleId($header);
383 
+
384 
+        if ($this->util->isExcluded($fullPath) === false) {
385 
+
386 
+            $size = $unencryptedSize = 0;
387 
+            $realFile = $this->util->stripPartialFileExtension($path);
388 
+            $targetExists = $this->file_exists($realFile) || $this->file_exists($path);
389 
+            $targetIsEncrypted = false;
390 
+            if ($targetExists) {
391 
+                // in case the file exists we require the explicit module as
392 
+                // specified in the file header - otherwise we need to fail hard to
393 
+                // prevent data loss on client side
394 
+                if (!empty($encryptionModuleId)) {
395 
+                    $targetIsEncrypted = true;
396 
+                    $encryptionModule = $this->encryptionManager->getEncryptionModule($encryptionModuleId);
397 
+                }
398 
+
399 
+                if ($this->file_exists($path)) {
400 
+                    $size = $this->storage->filesize($path);
401 
+                    $unencryptedSize = $this->filesize($path);
402 
+                } else {
403 
+                    $size = $unencryptedSize = 0;
404 
+                }
405 
+            }
406 
+
407 
+            try {
408 
+
409 
+                if (
410 
+                    $mode === 'w'
411 
+                    || $mode === 'w+'
412 
+                    || $mode === 'wb'
413 
+                    || $mode === 'wb+'
414 
+                ) {
415 
+                    // don't overwrite encrypted files if encryption is not enabled
416 
+                    if ($targetIsEncrypted && $encryptionEnabled === false) {
417 
+                        throw new GenericEncryptionException('Tried to access encrypted file but encryption is not enabled');
418 
+                    }
419 
+                    if ($encryptionEnabled) {
420 
+                        // if $encryptionModuleId is empty, the default module will be used
421 
+                        $encryptionModule = $this->encryptionManager->getEncryptionModule($encryptionModuleId);
422 
+                        $shouldEncrypt = $encryptionModule->shouldEncrypt($fullPath);
423 
+                        $signed = true;
424 
+                    }
425 
+                } else {
426 
+                    $info = $this->getCache()->get($path);
427 
+                    // only get encryption module if we found one in the header
428 
+                    // or if file should be encrypted according to the file cache
429 
+                    if (!empty($encryptionModuleId)) {
430 
+                        $encryptionModule = $this->encryptionManager->getEncryptionModule($encryptionModuleId);
431 
+                        $shouldEncrypt = true;
432 
+                    } else if (empty($encryptionModuleId) && $info['encrypted'] === true) {
433 
+                        // we come from a old installation. No header and/or no module defined
434 
+                        // but the file is encrypted. In this case we need to use the
435 
+                        // OC_DEFAULT_MODULE to read the file
436 
+                        $encryptionModule = $this->encryptionManager->getEncryptionModule('OC_DEFAULT_MODULE');
437 
+                        $shouldEncrypt = true;
438 
+                        $targetIsEncrypted = true;
439 
+                    }
440 
+                }
441 
+            } catch (ModuleDoesNotExistsException $e) {
442 
+                $this->logger->logException($e, [
443 
+                    'message' => 'Encryption module "' . $encryptionModuleId . '" not found, file will be stored unencrypted',
444 
+                    'level' => ILogger::WARN,
445 
+                    'app' => 'core',
446 
+                ]);
447 
+            }
448 
+
449 
+            // encryption disabled on write of new file and write to existing unencrypted file -> don't encrypt
450 
+            if (!$encryptionEnabled || !$this->shouldEncrypt($path)) {
451 
+                if (!$targetExists || !$targetIsEncrypted) {
452 
+                    $shouldEncrypt = false;
453 
+                }
454 
+            }
455 
+
456 
+            if ($shouldEncrypt === true && $encryptionModule !== null) {
457 
+                $headerSize = $this->getHeaderSize($path);
458 
+                $source = $this->storage->fopen($path, $mode);
459 
+                if (!is_resource($source)) {
460 
+                    return false;
461 
+                }
462 
+                $handle = \OC\Files\Stream\Encryption::wrap($source, $path, $fullPath, $header,
463 
+                    $this->uid, $encryptionModule, $this->storage, $this, $this->util, $this->fileHelper, $mode,
464 
+                    $size, $unencryptedSize, $headerSize, $signed);
465 
+                return $handle;
466 
+            }
467 
+
468 
+        }
469 
+
470 
+        return $this->storage->fopen($path, $mode);
471 
+    }
472 
+
473 
+
474 
+    /**
475 
+     * perform some plausibility checks if the the unencrypted size is correct.
476 
+     * If not, we calculate the correct unencrypted size and return it
477 
+     *
478 
+     * @param string $path internal path relative to the storage root
479 
+     * @param int $unencryptedSize size of the unencrypted file
480 
+     *
481 
+     * @return int unencrypted size
482 
+     */
483 
+    protected function verifyUnencryptedSize($path, $unencryptedSize) {
484 
+
485 
+        $size = $this->storage->filesize($path);
486 
+        $result = $unencryptedSize;
487 
+
488 
+        if ($unencryptedSize < 0 ||
489 
+            ($size > 0 && $unencryptedSize === $size)
490 
+        ) {
491 
+            // check if we already calculate the unencrypted size for the
492 
+            // given path to avoid recursions
493 
+            if (isset($this->fixUnencryptedSizeOf[$this->getFullPath($path)]) === false) {
494 
+                $this->fixUnencryptedSizeOf[$this->getFullPath($path)] = true;
495 
+                try {
496 
+                    $result = $this->fixUnencryptedSize($path, $size, $unencryptedSize);
497 
+                } catch (\Exception $e) {
498 
+                    $this->logger->error('Couldn\'t re-calculate unencrypted size for '. $path);
499 
+                    $this->logger->logException($e);
500 
+                }
501 
+                unset($this->fixUnencryptedSizeOf[$this->getFullPath($path)]);
502 
+            }
503 
+        }
504 
+
505 
+        return $result;
506 
+    }
507 
+
508 
+    /**
509 
+     * calculate the unencrypted size
510 
+     *
511 
+     * @param string $path internal path relative to the storage root
512 
+     * @param int $size size of the physical file
513 
+     * @param int $unencryptedSize size of the unencrypted file
514 
+     *
515 
+     * @return int calculated unencrypted size
516 
+     */
517 
+    protected function fixUnencryptedSize($path, $size, $unencryptedSize) {
518 
+
519 
+        $headerSize = $this->getHeaderSize($path);
520 
+        $header = $this->getHeader($path);
521 
+        $encryptionModule = $this->getEncryptionModule($path);
522 
+
523 
+        $stream = $this->storage->fopen($path, 'r');
524 
+
525 
+        // if we couldn't open the file we return the old unencrypted size
526 
+        if (!is_resource($stream)) {
527 
+            $this->logger->error('Could not open ' . $path . '. Recalculation of unencrypted size aborted.');
528 
+            return $unencryptedSize;
529 
+        }
530 
+
531 
+        $newUnencryptedSize = 0;
532 
+        $size -= $headerSize;
533 
+        $blockSize = $this->util->getBlockSize();
534 
+
535 
+        // if a header exists we skip it
536 
+        if ($headerSize > 0) {
537 
+            fread($stream, $headerSize);
538 
+        }
539 
+
540 
+        // fast path, else the calculation for $lastChunkNr is bogus
541 
+        if ($size === 0) {
542 
+            return 0;
543 
+        }
544 
+
545 
+        $signed = isset($header['signed']) && $header['signed'] === 'true';
546 
+        $unencryptedBlockSize = $encryptionModule->getUnencryptedBlockSize($signed);
547 
+
548 
+        // calculate last chunk nr
549 
+        // next highest is end of chunks, one subtracted is last one
550 
+        // we have to read the last chunk, we can't just calculate it (because of padding etc)
551 
+
552 
+        $lastChunkNr = ceil($size/ $blockSize)-1;
553 
+        // calculate last chunk position
554 
+        $lastChunkPos = ($lastChunkNr * $blockSize);
555 
+        // try to fseek to the last chunk, if it fails we have to read the whole file
556 
+        if (@fseek($stream, $lastChunkPos, SEEK_CUR) === 0) {
557 
+            $newUnencryptedSize += $lastChunkNr * $unencryptedBlockSize;
558 
+        }
559 
+
560 
+        $lastChunkContentEncrypted='';
561 
+        $count = $blockSize;
562 
+
563 
+        while ($count > 0) {
564 
+            $data=fread($stream, $blockSize);
565 
+            $count=strlen($data);
566 
+            $lastChunkContentEncrypted .= $data;
567 
+            if(strlen($lastChunkContentEncrypted) > $blockSize) {
568 
+                $newUnencryptedSize += $unencryptedBlockSize;
569 
+                $lastChunkContentEncrypted=substr($lastChunkContentEncrypted, $blockSize);
570 
+            }
571 
+        }
572 
+
573 
+        fclose($stream);
574 
+
575 
+        // we have to decrypt the last chunk to get it actual size
576 
+        $encryptionModule->begin($this->getFullPath($path), $this->uid, 'r', $header, []);
577 
+        $decryptedLastChunk = $encryptionModule->decrypt($lastChunkContentEncrypted, $lastChunkNr . 'end');
578 
+        $decryptedLastChunk .= $encryptionModule->end($this->getFullPath($path), $lastChunkNr . 'end');
579 
+
580 
+        // calc the real file size with the size of the last chunk
581 
+        $newUnencryptedSize += strlen($decryptedLastChunk);
582 
+
583 
+        $this->updateUnencryptedSize($this->getFullPath($path), $newUnencryptedSize);
584 
+
585 
+        // write to cache if applicable
586 
+        $cache = $this->storage->getCache();
587 
+        if ($cache) {
588 
+            $entry = $cache->get($path);
589 
+            $cache->update($entry['fileid'], ['size' => $newUnencryptedSize]);
590 
+        }
591 
+
592 
+        return $newUnencryptedSize;
593 
+    }
594 
+
595 
+    /**
596 
+     * @param Storage\IStorage $sourceStorage
597 
+     * @param string $sourceInternalPath
598 
+     * @param string $targetInternalPath
599 
+     * @param bool $preserveMtime
600 
+     * @return bool
601 
+     */
602 
+    public function moveFromStorage(Storage\IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath, $preserveMtime = true) {
603 
+        if ($sourceStorage === $this) {
604 
+            return $this->rename($sourceInternalPath, $targetInternalPath);
605 
+        }
606 
+
607 
+        // TODO clean this up once the underlying moveFromStorage in OC\Files\Storage\Wrapper\Common is fixed:
608 
+        // - call $this->storage->moveFromStorage() instead of $this->copyBetweenStorage
609 
+        // - copy the file cache update from  $this->copyBetweenStorage to this method
610 
+        // - copy the copyKeys() call from  $this->copyBetweenStorage to this method
611 
+        // - remove $this->copyBetweenStorage
612 
+
613 
+        if (!$sourceStorage->isDeletable($sourceInternalPath)) {
614 
+            return false;
615 
+        }
616 
+
617 
+        $result = $this->copyBetweenStorage($sourceStorage, $sourceInternalPath, $targetInternalPath, $preserveMtime, true);
618 
+        if ($result) {
619 
+            if ($sourceStorage->is_dir($sourceInternalPath)) {
620 
+                $result &= $sourceStorage->rmdir($sourceInternalPath);
621 
+            } else {
622 
+                $result &= $sourceStorage->unlink($sourceInternalPath);
623 
+            }
624 
+        }
625 
+        return $result;
626 
+    }
627 
+
628 
+
629 
+    /**
630 
+     * @param Storage\IStorage $sourceStorage
631 
+     * @param string $sourceInternalPath
632 
+     * @param string $targetInternalPath
633 
+     * @param bool $preserveMtime
634 
+     * @param bool $isRename
635 
+     * @return bool
636 
+     */
637 
+    public function copyFromStorage(Storage\IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath, $preserveMtime = false, $isRename = false) {
638 
+
639 
+        // TODO clean this up once the underlying moveFromStorage in OC\Files\Storage\Wrapper\Common is fixed:
640 
+        // - call $this->storage->copyFromStorage() instead of $this->copyBetweenStorage
641 
+        // - copy the file cache update from  $this->copyBetweenStorage to this method
642 
+        // - copy the copyKeys() call from  $this->copyBetweenStorage to this method
643 
+        // - remove $this->copyBetweenStorage
644 
+
645 
+        return $this->copyBetweenStorage($sourceStorage, $sourceInternalPath, $targetInternalPath, $preserveMtime, $isRename);
646 
+    }
647 
+
648 
+    /**
649 
+     * Update the encrypted cache version in the database
650 
+     *
651 
+     * @param Storage\IStorage $sourceStorage
652 
+     * @param string $sourceInternalPath
653 
+     * @param string $targetInternalPath
654 
+     * @param bool $isRename
655 
+     * @param bool $keepEncryptionVersion
656 
+     */
657 
+    private function updateEncryptedVersion(Storage\IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath, $isRename, $keepEncryptionVersion) {
658 
+        $isEncrypted = $this->encryptionManager->isEnabled() && $this->shouldEncrypt($targetInternalPath);
659 
+        $cacheInformation = [
660 
+            'encrypted' => $isEncrypted,
661 
+        ];
662 
+        if($isEncrypted) {
663 
+            $encryptedVersion = $sourceStorage->getCache()->get($sourceInternalPath)['encryptedVersion'];
664 
+
665 
+            // In case of a move operation from an unencrypted to an encrypted
666 
+            // storage the old encrypted version would stay with "0" while the
667 
+            // correct value would be "1". Thus we manually set the value to "1"
668 
+            // for those cases.
669 
+            // See also https://github.com/owncloud/core/issues/23078
670 
+            if($encryptedVersion === 0 || !$keepEncryptionVersion) {
671 
+                $encryptedVersion = 1;
672 
+            }
673 
+
674 
+            $cacheInformation['encryptedVersion'] = $encryptedVersion;
675 
+        }
676 
+
677 
+        // in case of a rename we need to manipulate the source cache because
678 
+        // this information will be kept for the new target
679 
+        if ($isRename) {
680 
+            $sourceStorage->getCache()->put($sourceInternalPath, $cacheInformation);
681 
+        } else {
682 
+            $this->getCache()->put($targetInternalPath, $cacheInformation);
683 
+        }
684 
+    }
685 
+
686 
+    /**
687 
+     * copy file between two storages
688 
+     *
689 
+     * @param Storage\IStorage $sourceStorage
690 
+     * @param string $sourceInternalPath
691 
+     * @param string $targetInternalPath
692 
+     * @param bool $preserveMtime
693 
+     * @param bool $isRename
694 
+     * @return bool
695 
+     * @throws \Exception
696 
+     */
697 
+    private function copyBetweenStorage(Storage\IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath, $preserveMtime, $isRename) {
698 
+
699 
+        // for versions we have nothing to do, because versions should always use the
700 
+        // key from the original file. Just create a 1:1 copy and done
701 
+        if ($this->isVersion($targetInternalPath) ||
702 
+            $this->isVersion($sourceInternalPath)) {
703 
+            // remember that we try to create a version so that we can detect it during
704 
+            // fopen($sourceInternalPath) and by-pass the encryption in order to
705 
+            // create a 1:1 copy of the file
706 
+            $this->arrayCache->set('encryption_copy_version_' . $sourceInternalPath, true);
707 
+            $result = $this->storage->copyFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath);
708 
+            $this->arrayCache->remove('encryption_copy_version_' . $sourceInternalPath);
709 
+            if ($result) {
710 
+                $info = $this->getCache('', $sourceStorage)->get($sourceInternalPath);
711 
+                // make sure that we update the unencrypted size for the version
712 
+                if (isset($info['encrypted']) && $info['encrypted'] === true) {
713 
+                    $this->updateUnencryptedSize(
714 
+                        $this->getFullPath($targetInternalPath),
715 
+                        $info['size']
716 
+                    );
717 
+                }
718 
+                $this->updateEncryptedVersion($sourceStorage, $sourceInternalPath, $targetInternalPath, $isRename, true);
719 
+            }
720 
+            return $result;
721 
+        }
722 
+
723 
+        // first copy the keys that we reuse the existing file key on the target location
724 
+        // and don't create a new one which would break versions for example.
725 
+        $mount = $this->mountManager->findByStorageId($sourceStorage->getId());
726 
+        if (count($mount) === 1) {
727 
+            $mountPoint = $mount[0]->getMountPoint();
728 
+            $source = $mountPoint . '/' . $sourceInternalPath;
729 
+            $target = $this->getFullPath($targetInternalPath);
730 
+            $this->copyKeys($source, $target);
731 
+        } else {
732 
+            $this->logger->error('Could not find mount point, can\'t keep encryption keys');
733 
+        }
734 
+
735 
+        if ($sourceStorage->is_dir($sourceInternalPath)) {
736 
+            $dh = $sourceStorage->opendir($sourceInternalPath);
737 
+            $result = $this->mkdir($targetInternalPath);
738 
+            if (is_resource($dh)) {
739 
+                while ($result and ($file = readdir($dh)) !== false) {
740 
+                    if (!Filesystem::isIgnoredDir($file)) {
741 
+                        $result &= $this->copyFromStorage($sourceStorage, $sourceInternalPath . '/' . $file, $targetInternalPath . '/' . $file, false, $isRename);
742 
+                    }
743 
+                }
744 
+            }
745 
+        } else {
746 
+            try {
747 
+                $source = $sourceStorage->fopen($sourceInternalPath, 'r');
748 
+                $target = $this->fopen($targetInternalPath, 'w');
749 
+                list(, $result) = \OC_Helper::streamCopy($source, $target);
750 
+                fclose($source);
751 
+                fclose($target);
752 
+            } catch (\Exception $e) {
753 
+                fclose($source);
754 
+                fclose($target);
755 
+                throw $e;
756 
+            }
757 
+            if($result) {
758 
+                if ($preserveMtime) {
759 
+                    $this->touch($targetInternalPath, $sourceStorage->filemtime($sourceInternalPath));
760 
+                }
761 
+                $this->updateEncryptedVersion($sourceStorage, $sourceInternalPath, $targetInternalPath, $isRename, false);
762 
+            } else {
763 
+                // delete partially written target file
764 
+                $this->unlink($targetInternalPath);
765 
+                // delete cache entry that was created by fopen
766 
+                $this->getCache()->remove($targetInternalPath);
767 
+            }
768 
+        }
769 
+        return (bool)$result;
770 
+
771 
+    }
772 
+
773 
+    /**
774 
+     * get the path to a local version of the file.
775 
+     * The local version of the file can be temporary and doesn't have to be persistent across requests
776 
+     *
777 
+     * @param string $path
778 
+     * @return string
779 
+     */
780 
+    public function getLocalFile($path) {
781 
+        if ($this->encryptionManager->isEnabled()) {
782 
+            $cachedFile = $this->getCachedFile($path);
783 
+            if (is_string($cachedFile)) {
784 
+                return $cachedFile;
785 
+            }
786 
+        }
787 
+        return $this->storage->getLocalFile($path);
788 
+    }
789 
+
790 
+    /**
791 
+     * Returns the wrapped storage's value for isLocal()
792 
+     *
793 
+     * @return bool wrapped storage's isLocal() value
794 
+     */
795 
+    public function isLocal() {
796 
+        if ($this->encryptionManager->isEnabled()) {
797 
+            return false;
798 
+        }
799 
+        return $this->storage->isLocal();
800 
+    }
801 
+
802 
+    /**
803 
+     * see http://php.net/manual/en/function.stat.php
804 
+     * only the following keys are required in the result: size and mtime
805 
+     *
806 
+     * @param string $path
807 
+     * @return array
808 
+     */
809 
+    public function stat($path) {
810 
+        $stat = $this->storage->stat($path);
811 
+        $fileSize = $this->filesize($path);
812 
+        $stat['size'] = $fileSize;
813 
+        $stat[7] = $fileSize;
814 
+        return $stat;
815 
+    }
816 
+
817 
+    /**
818 
+     * see http://php.net/manual/en/function.hash.php
819 
+     *
820 
+     * @param string $type
821 
+     * @param string $path
822 
+     * @param bool $raw
823 
+     * @return string
824 
+     */
825 
+    public function hash($type, $path, $raw = false) {
826 
+        $fh = $this->fopen($path, 'rb');
827 
+        $ctx = hash_init($type);
828 
+        hash_update_stream($ctx, $fh);
829 
+        fclose($fh);
830 
+        return hash_final($ctx, $raw);
831 
+    }
832 
+
833 
+    /**
834 
+     * return full path, including mount point
835 
+     *
836 
+     * @param string $path relative to mount point
837 
+     * @return string full path including mount point
838 
+     */
839 
+    protected function getFullPath($path) {
840 
+        return Filesystem::normalizePath($this->mountPoint . '/' . $path);
841 
+    }
842 
+
843 
+    /**
844 
+     * read first block of encrypted file, typically this will contain the
845 
+     * encryption header
846 
+     *
847 
+     * @param string $path
848 
+     * @return string
849 
+     */
850 
+    protected function readFirstBlock($path) {
851 
+        $firstBlock = '';
852 
+        if ($this->storage->file_exists($path)) {
853 
+            $handle = $this->storage->fopen($path, 'r');
854 
+            $firstBlock = fread($handle, $this->util->getHeaderSize());
855 
+            fclose($handle);
856 
+        }
857 
+        return $firstBlock;
858 
+    }
859 
+
860 
+    /**
861 
+     * return header size of given file
862 
+     *
863 
+     * @param string $path
864 
+     * @return int
865 
+     */
866 
+    protected function getHeaderSize($path) {
867 
+        $headerSize = 0;
868 
+        $realFile = $this->util->stripPartialFileExtension($path);
869 
+        if ($this->storage->file_exists($realFile)) {
870 
+            $path = $realFile;
871 
+        }
872 
+        $firstBlock = $this->readFirstBlock($path);
873 
+
874 
+        if (substr($firstBlock, 0, strlen(Util::HEADER_START)) === Util::HEADER_START) {
875 
+            $headerSize = $this->util->getHeaderSize();
876 
+        }
877 
+
878 
+        return $headerSize;
879 
+    }
880 
+
881 
+    /**
882 
+     * parse raw header to array
883 
+     *
884 
+     * @param string $rawHeader
885 
+     * @return array
886 
+     */
887 
+    protected function parseRawHeader($rawHeader) {
888 
+        $result = array();
889 
+        if (substr($rawHeader, 0, strlen(Util::HEADER_START)) === Util::HEADER_START) {
890 
+            $header = $rawHeader;
891 
+            $endAt = strpos($header, Util::HEADER_END);
892 
+            if ($endAt !== false) {
893 
+                $header = substr($header, 0, $endAt + strlen(Util::HEADER_END));
894 
+
895 
+                // +1 to not start with an ':' which would result in empty element at the beginning
896 
+                $exploded = explode(':', substr($header, strlen(Util::HEADER_START)+1));
897 
+
898 
+                $element = array_shift($exploded);
899 
+                while ($element !== Util::HEADER_END) {
900 
+                    $result[$element] = array_shift($exploded);
901 
+                    $element = array_shift($exploded);
902 
+                }
903 
+            }
904 
+        }
905 
+
906 
+        return $result;
907 
+    }
908 
+
909 
+    /**
910 
+     * read header from file
911 
+     *
912 
+     * @param string $path
913 
+     * @return array
914 
+     */
915 
+    protected function getHeader($path) {
916 
+        $realFile = $this->util->stripPartialFileExtension($path);
917 
+        $exists = $this->storage->file_exists($realFile);
918 
+        if ($exists) {
919 
+            $path = $realFile;
920 
+        }
921 
+
922 
+        $firstBlock = $this->readFirstBlock($path);
923 
+        $result = $this->parseRawHeader($firstBlock);
924 
+
925 
+        // if the header doesn't contain a encryption module we check if it is a
926 
+        // legacy file. If true, we add the default encryption module
927 
+        if (!isset($result[Util::HEADER_ENCRYPTION_MODULE_KEY])) {
928 
+            if (!empty($result)) {
929 
+                $result[Util::HEADER_ENCRYPTION_MODULE_KEY] = 'OC_DEFAULT_MODULE';
930 
+            } else if ($exists) {
931 
+                // if the header was empty we have to check first if it is a encrypted file at all
932 
+                // We would do query to filecache only if we know that entry in filecache exists
933 
+                $info = $this->getCache()->get($path);
934 
+                if (isset($info['encrypted']) && $info['encrypted'] === true) {
935 
+                    $result[Util::HEADER_ENCRYPTION_MODULE_KEY] = 'OC_DEFAULT_MODULE';
936 
+                }
937 
+            }
938 
+        }
939 
+
940 
+        return $result;
941 
+    }
942 
+
943 
+    /**
944 
+     * read encryption module needed to read/write the file located at $path
945 
+     *
946 
+     * @param string $path
947 
+     * @return null|\OCP\Encryption\IEncryptionModule
948 
+     * @throws ModuleDoesNotExistsException
949 
+     * @throws \Exception
950 
+     */
951 
+    protected function getEncryptionModule($path) {
952 
+        $encryptionModule = null;
953 
+        $header = $this->getHeader($path);
954 
+        $encryptionModuleId = $this->util->getEncryptionModuleId($header);
955 
+        if (!empty($encryptionModuleId)) {
956 
+            try {
957 
+                $encryptionModule = $this->encryptionManager->getEncryptionModule($encryptionModuleId);
958 
+            } catch (ModuleDoesNotExistsException $e) {
959 
+                $this->logger->critical('Encryption module defined in "' . $path . '" not loaded!');
960 
+                throw $e;
961 
+            }
962 
+        }
963 
+
964 
+        return $encryptionModule;
965 
+    }
966 
+
967 
+    /**
968 
+     * @param string $path
969 
+     * @param int $unencryptedSize
970 
+     */
971 
+    public function updateUnencryptedSize($path, $unencryptedSize) {
972 
+        $this->unencryptedSize[$path] = $unencryptedSize;
973 
+    }
974 
+
975 
+    /**
976 
+     * copy keys to new location
977 
+     *
978 
+     * @param string $source path relative to data/
979 
+     * @param string $target path relative to data/
980 
+     * @return bool
981 
+     */
982 
+    protected function copyKeys($source, $target) {
983 
+        if (!$this->util->isExcluded($source)) {
984 
+            return $this->keyStorage->copyKeys($source, $target);
985 
+        }
986 
+
987 
+        return false;
988 
+    }
989 
+
990 
+    /**
991 
+     * check if path points to a files version
992 
+     *
993 
+     * @param $path
994 
+     * @return bool
995 
+     */
996 
+    protected function isVersion($path) {
997 
+        $normalized = Filesystem::normalizePath($path);
998 
+        return substr($normalized, 0, strlen('/files_versions/')) === '/files_versions/';
999 
+    }
1000 
+
1001 
+    /**
1002 
+     * check if the given storage should be encrypted or not
1003 
+     *
1004 
+     * @param $path
1005 
+     * @return bool
1006 
+     */
1007 
+    protected function shouldEncrypt($path) {
1008 
+        $fullPath = $this->getFullPath($path);
1009 
+        $mountPointConfig = $this->mount->getOption('encrypt', true);
1010 
+        if ($mountPointConfig === false) {
1011 
+            return false;
1012 
+        }
1013 
+
1014 
+        try {
1015 
+            $encryptionModule = $this->getEncryptionModule($fullPath);
1016 
+        } catch (ModuleDoesNotExistsException $e) {
1017 
+            return false;
1018 
+        }
1019 
+
1020 
+        if ($encryptionModule === null) {
1021 
+            $encryptionModule = $this->encryptionManager->getEncryptionModule();
1022 
+        }
1023 
+
1024 
+        return $encryptionModule->shouldEncrypt($fullPath);
1025 
+
1026 
+    }
1027 1027
1028 1028 
 }
Please login to merge, or discard this patch.
Spacing   +24 added lines, -24 removed lines patch added patch discarded remove patch 
@@ -368,8 +368,8 @@  discard block
 
 block discarded – undo
368 368 
 		// check if the file is stored in the array cache, this means that we
369 369 
 		// copy a file over to the versions folder, in this case we don't want to
370 370 
 		// decrypt it
371 
-		if ($this->arrayCache->hasKey('encryption_copy_version_' . $path)) {
372 
-			$this->arrayCache->remove('encryption_copy_version_' . $path);
371 
+		if ($this->arrayCache->hasKey('encryption_copy_version_'.$path)) {
372 
+			$this->arrayCache->remove('encryption_copy_version_'.$path);
373 373 
 			return $this->storage->fopen($path, $mode);
374 374 
 		}
375 375 
 
@@ -440,7 +440,7 @@  discard block
 
 block discarded – undo
440 440 
 				}
441 441 
 			} catch (ModuleDoesNotExistsException $e) {
442 442 
 				$this->logger->logException($e, [
443 
-					'message' => 'Encryption module "' . $encryptionModuleId . '" not found, file will be stored unencrypted',
443 
+					'message' => 'Encryption module "'.$encryptionModuleId.'" not found, file will be stored unencrypted',
444 444 
 					'level' => ILogger::WARN,
445 445 
 					'app' => 'core',
446 446 
 				]);
 
@@ -495,7 +495,7 @@  discard block
 
 block discarded – undo
495 495 
 				try {
496 496 
 					$result = $this->fixUnencryptedSize($path, $size, $unencryptedSize);
497 497 
 				} catch (\Exception $e) {
498 
-					$this->logger->error('Couldn\'t re-calculate unencrypted size for '. $path);
498 
+					$this->logger->error('Couldn\'t re-calculate unencrypted size for '.$path);
499 499 
 					$this->logger->logException($e);
500 500 
 				}
501 501 
 				unset($this->fixUnencryptedSizeOf[$this->getFullPath($path)]);
 
@@ -524,7 +524,7 @@  discard block
 
 block discarded – undo
524 524
525 525 
 		// if we couldn't open the file we return the old unencrypted size
526 526 
 		if (!is_resource($stream)) {
527 
-			$this->logger->error('Could not open ' . $path . '. Recalculation of unencrypted size aborted.');
527 
+			$this->logger->error('Could not open '.$path.'. Recalculation of unencrypted size aborted.');
528 528 
 			return $unencryptedSize;
529 529 
 		}
530 530 
 
@@ -549,7 +549,7 @@  discard block
 
 block discarded – undo
549 549 
 		// next highest is end of chunks, one subtracted is last one
550 550 
 		// we have to read the last chunk, we can't just calculate it (because of padding etc)
551 551
552 
-		$lastChunkNr = ceil($size/ $blockSize)-1;
552 
+		$lastChunkNr = ceil($size / $blockSize) - 1;
553 553 
 		// calculate last chunk position
554 554 
 		$lastChunkPos = ($lastChunkNr * $blockSize);
555 555 
 		// try to fseek to the last chunk, if it fails we have to read the whole file
 
@@ -557,16 +557,16 @@  discard block
 
 block discarded – undo
557 557 
 			$newUnencryptedSize += $lastChunkNr * $unencryptedBlockSize;
558 558 
 		}
559 559
560 
-		$lastChunkContentEncrypted='';
560 
+		$lastChunkContentEncrypted = '';
561 561 
 		$count = $blockSize;
562 562
563 563 
 		while ($count > 0) {
564 
-			$data=fread($stream, $blockSize);
565 
-			$count=strlen($data);
564 
+			$data = fread($stream, $blockSize);
565 
+			$count = strlen($data);
566 566 
 			$lastChunkContentEncrypted .= $data;
567 
-			if(strlen($lastChunkContentEncrypted) > $blockSize) {
567 
+			if (strlen($lastChunkContentEncrypted) > $blockSize) {
568 568 
 				$newUnencryptedSize += $unencryptedBlockSize;
569 
-				$lastChunkContentEncrypted=substr($lastChunkContentEncrypted, $blockSize);
569 
+				$lastChunkContentEncrypted = substr($lastChunkContentEncrypted, $blockSize);
570 570 
 			}
571 571 
 		}
572 572 
 
@@ -574,8 +574,8 @@  discard block
 
 block discarded – undo
574 574
575 575 
 		// we have to decrypt the last chunk to get it actual size
576 576 
 		$encryptionModule->begin($this->getFullPath($path), $this->uid, 'r', $header, []);
577 
-		$decryptedLastChunk = $encryptionModule->decrypt($lastChunkContentEncrypted, $lastChunkNr . 'end');
578 
-		$decryptedLastChunk .= $encryptionModule->end($this->getFullPath($path), $lastChunkNr . 'end');
577 
+		$decryptedLastChunk = $encryptionModule->decrypt($lastChunkContentEncrypted, $lastChunkNr.'end');
578 
+		$decryptedLastChunk .= $encryptionModule->end($this->getFullPath($path), $lastChunkNr.'end');
579 579
580 580 
 		// calc the real file size with the size of the last chunk
581 581 
 		$newUnencryptedSize += strlen($decryptedLastChunk);
 
@@ -659,7 +659,7 @@  discard block
 
 block discarded – undo
659 659 
 		$cacheInformation = [
660 660 
 			'encrypted' => $isEncrypted,
661 661 
 		];
662 
-		if($isEncrypted) {
662 
+		if ($isEncrypted) {
663 663 
 			$encryptedVersion = $sourceStorage->getCache()->get($sourceInternalPath)['encryptedVersion'];
664 664
665 665 
 			// In case of a move operation from an unencrypted to an encrypted
 
@@ -667,7 +667,7 @@  discard block
 
 block discarded – undo
667 667 
 			// correct value would be "1". Thus we manually set the value to "1"
668 668 
 			// for those cases.
669 669 
 			// See also https://github.com/owncloud/core/issues/23078
670 
-			if($encryptedVersion === 0 || !$keepEncryptionVersion) {
670 
+			if ($encryptedVersion === 0 || !$keepEncryptionVersion) {
671 671 
 				$encryptedVersion = 1;
672 672 
 			}
673 673 
 
@@ -703,9 +703,9 @@  discard block
 
 block discarded – undo
703 703 
 			// remember that we try to create a version so that we can detect it during
704 704 
 			// fopen($sourceInternalPath) and by-pass the encryption in order to
705 705 
 			// create a 1:1 copy of the file
706 
-			$this->arrayCache->set('encryption_copy_version_' . $sourceInternalPath, true);
706 
+			$this->arrayCache->set('encryption_copy_version_'.$sourceInternalPath, true);
707 707 
 			$result = $this->storage->copyFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath);
708 
-			$this->arrayCache->remove('encryption_copy_version_' . $sourceInternalPath);
708 
+			$this->arrayCache->remove('encryption_copy_version_'.$sourceInternalPath);
709 709 
 			if ($result) {
710 710 
 				$info = $this->getCache('', $sourceStorage)->get($sourceInternalPath);
711 711 
 				// make sure that we update the unencrypted size for the version
 
@@ -725,7 +725,7 @@  discard block
 
 block discarded – undo
725 725 
 		$mount = $this->mountManager->findByStorageId($sourceStorage->getId());
726 726 
 		if (count($mount) === 1) {
727 727 
 			$mountPoint = $mount[0]->getMountPoint();
728 
-			$source = $mountPoint . '/' . $sourceInternalPath;
728 
+			$source = $mountPoint.'/'.$sourceInternalPath;
729 729 
 			$target = $this->getFullPath($targetInternalPath);
730 730 
 			$this->copyKeys($source, $target);
731 731 
 		} else {
 
@@ -738,7 +738,7 @@  discard block
 
 block discarded – undo
738 738 
 			if (is_resource($dh)) {
739 739 
 				while ($result and ($file = readdir($dh)) !== false) {
740 740 
 					if (!Filesystem::isIgnoredDir($file)) {
741 
-						$result &= $this->copyFromStorage($sourceStorage, $sourceInternalPath . '/' . $file, $targetInternalPath . '/' . $file, false, $isRename);
741 
+						$result &= $this->copyFromStorage($sourceStorage, $sourceInternalPath.'/'.$file, $targetInternalPath.'/'.$file, false, $isRename);
742 742 
 					}
743 743 
 				}
744 744 
 			}
 
@@ -754,7 +754,7 @@  discard block
 
 block discarded – undo
754 754 
 				fclose($target);
755 755 
 				throw $e;
756 756 
 			}
757 
-			if($result) {
757 
+			if ($result) {
758 758 
 				if ($preserveMtime) {
759 759 
 					$this->touch($targetInternalPath, $sourceStorage->filemtime($sourceInternalPath));
760 760 
 				}
 
@@ -766,7 +766,7 @@  discard block
 
 block discarded – undo
766 766 
 				$this->getCache()->remove($targetInternalPath);
767 767 
 			}
768 768 
 		}
769 
-		return (bool)$result;
769 
+		return (bool) $result;
770 770
771 771 
 	}
772 772 
 
@@ -837,7 +837,7 @@  discard block
 
 block discarded – undo
837 837 
 	 * @return string full path including mount point
838 838 
 	 */
839 839 
 	protected function getFullPath($path) {
840 
-		return Filesystem::normalizePath($this->mountPoint . '/' . $path);
840 
+		return Filesystem::normalizePath($this->mountPoint.'/'.$path);
841 841 
 	}
842 842
843 843 
 	/**
 
@@ -893,7 +893,7 @@  discard block
 
 block discarded – undo
893 893 
 				$header = substr($header, 0, $endAt + strlen(Util::HEADER_END));
894 894
895 895 
 				// +1 to not start with an ':' which would result in empty element at the beginning
896 
-				$exploded = explode(':', substr($header, strlen(Util::HEADER_START)+1));
896 
+				$exploded = explode(':', substr($header, strlen(Util::HEADER_START) + 1));
897 897
898 898 
 				$element = array_shift($exploded);
899 899 
 				while ($element !== Util::HEADER_END) {
 
@@ -956,7 +956,7 @@  discard block
 
 block discarded – undo
956 956 
 			try {
957 957 
 				$encryptionModule = $this->encryptionManager->getEncryptionModule($encryptionModuleId);
958 958 
 			} catch (ModuleDoesNotExistsException $e) {
959 
-				$this->logger->critical('Encryption module defined in "' . $path . '" not loaded!');
959 
+				$this->logger->critical('Encryption module defined in "'.$path.'" not loaded!');
960 960 
 				throw $e;
961 961 
 			}
962 962 
 		}
Please login to merge, or discard this patch.
lib/private/Files/Storage/Local.php 2 patches
Indentation   +414 added lines, -414 removed lines patch added patch discarded remove patch 
@@ -48,418 +48,418 @@
 
 block discarded – undo
48 48 
  * for local filestore, we only have to map the paths
49 49 
  */
50 50 
 class Local extends \OC\Files\Storage\Common {
51 
-	protected $datadir;
52 
-
53 
-	protected $dataDirLength;
54 
-
55 
-	protected $allowSymlinks = false;
56 
-
57 
-	protected $realDataDir;
58 
-
59 
-	public function __construct($arguments) {
60 
-		if (!isset($arguments['datadir']) || !is_string($arguments['datadir'])) {
61 
-			throw new \InvalidArgumentException('No data directory set for local storage');
62 
-		}
63 
-		$this->datadir = str_replace('//', '/', $arguments['datadir']);
64 
-		// some crazy code uses a local storage on root...
65 
-		if ($this->datadir === '/') {
66 
-			$this->realDataDir = $this->datadir;
67 
-		} else {
68 
-			$realPath = realpath($this->datadir) ?: $this->datadir;
69 
-			$this->realDataDir = rtrim($realPath, '/') . '/';
70 
-		}
71 
-		if (substr($this->datadir, -1) !== '/') {
72 
-			$this->datadir .= '/';
73 
-		}
74 
-		$this->dataDirLength = strlen($this->realDataDir);
75 
-	}
76 
-
77 
-	public function __destruct() {
78 
-	}
79 
-
80 
-	public function getId() {
81 
-		return 'local::' . $this->datadir;
82 
-	}
83 
-
84 
-	public function mkdir($path) {
85 
-		return @mkdir($this->getSourcePath($path), 0777, true);
86 
-	}
87 
-
88 
-	public function rmdir($path) {
89 
-		if (!$this->isDeletable($path)) {
90 
-			return false;
91 
-		}
92 
-		try {
93 
-			$it = new \RecursiveIteratorIterator(
94 
-				new \RecursiveDirectoryIterator($this->getSourcePath($path)),
95 
-				\RecursiveIteratorIterator::CHILD_FIRST
96 
-			);
97 
-			/**
98 
-			 * RecursiveDirectoryIterator on an NFS path isn't iterable with foreach
99 
-			 * This bug is fixed in PHP 5.5.9 or before
100 
-			 * See #8376
101 
-			 */
102 
-			$it->rewind();
103 
-			while ($it->valid()) {
104 
-				/**
105 
-				 * @var \SplFileInfo $file
106 
-				 */
107 
-				$file = $it->current();
108 
-				if (in_array($file->getBasename(), array('.', '..'))) {
109 
-					$it->next();
110 
-					continue;
111 
-				} elseif ($file->isDir()) {
112 
-					rmdir($file->getPathname());
113 
-				} elseif ($file->isFile() || $file->isLink()) {
114 
-					unlink($file->getPathname());
115 
-				}
116 
-				$it->next();
117 
-			}
118 
-			return rmdir($this->getSourcePath($path));
119 
-		} catch (\UnexpectedValueException $e) {
120 
-			return false;
121 
-		}
122 
-	}
123 
-
124 
-	public function opendir($path) {
125 
-		return opendir($this->getSourcePath($path));
126 
-	}
127 
-
128 
-	public function is_dir($path) {
129 
-		if (substr($path, -1) == '/') {
130 
-			$path = substr($path, 0, -1);
131 
-		}
132 
-		return is_dir($this->getSourcePath($path));
133 
-	}
134 
-
135 
-	public function is_file($path) {
136 
-		return is_file($this->getSourcePath($path));
137 
-	}
138 
-
139 
-	public function stat($path) {
140 
-		clearstatcache();
141 
-		$fullPath = $this->getSourcePath($path);
142 
-		$statResult = stat($fullPath);
143 
-		if (PHP_INT_SIZE === 4 && !$this->is_dir($path)) {
144 
-			$filesize = $this->filesize($path);
145 
-			$statResult['size'] = $filesize;
146 
-			$statResult[7] = $filesize;
147 
-		}
148 
-		return $statResult;
149 
-	}
150 
-
151 
-	public function filetype($path) {
152 
-		$filetype = filetype($this->getSourcePath($path));
153 
-		if ($filetype == 'link') {
154 
-			$filetype = filetype(realpath($this->getSourcePath($path)));
155 
-		}
156 
-		return $filetype;
157 
-	}
158 
-
159 
-	public function filesize($path) {
160 
-		if ($this->is_dir($path)) {
161 
-			return 0;
162 
-		}
163 
-		$fullPath = $this->getSourcePath($path);
164 
-		if (PHP_INT_SIZE === 4) {
165 
-			$helper = new \OC\LargeFileHelper;
166 
-			return $helper->getFileSize($fullPath);
167 
-		}
168 
-		return filesize($fullPath);
169 
-	}
170 
-
171 
-	public function isReadable($path) {
172 
-		return is_readable($this->getSourcePath($path));
173 
-	}
174 
-
175 
-	public function isUpdatable($path) {
176 
-		return is_writable($this->getSourcePath($path));
177 
-	}
178 
-
179 
-	public function file_exists($path) {
180 
-		return file_exists($this->getSourcePath($path));
181 
-	}
182 
-
183 
-	public function filemtime($path) {
184 
-		$fullPath = $this->getSourcePath($path);
185 
-		clearstatcache(true, $fullPath);
186 
-		if (!$this->file_exists($path)) {
187 
-			return false;
188 
-		}
189 
-		if (PHP_INT_SIZE === 4) {
190 
-			$helper = new \OC\LargeFileHelper();
191 
-			return $helper->getFileMtime($fullPath);
192 
-		}
193 
-		return filemtime($fullPath);
194 
-	}
195 
-
196 
-	public function touch($path, $mtime = null) {
197 
-		// sets the modification time of the file to the given value.
198 
-		// If mtime is nil the current time is set.
199 
-		// note that the access time of the file always changes to the current time.
200 
-		if ($this->file_exists($path) and !$this->isUpdatable($path)) {
201 
-			return false;
202 
-		}
203 
-		if (!is_null($mtime)) {
204 
-			$result = touch($this->getSourcePath($path), $mtime);
205 
-		} else {
206 
-			$result = touch($this->getSourcePath($path));
207 
-		}
208 
-		if ($result) {
209 
-			clearstatcache(true, $this->getSourcePath($path));
210 
-		}
211 
-
212 
-		return $result;
213 
-	}
214 
-
215 
-	public function file_get_contents($path) {
216 
-		return file_get_contents($this->getSourcePath($path));
217 
-	}
218 
-
219 
-	public function file_put_contents($path, $data) {
220 
-		return file_put_contents($this->getSourcePath($path), $data);
221 
-	}
222 
-
223 
-	public function unlink($path) {
224 
-		if ($this->is_dir($path)) {
225 
-			return $this->rmdir($path);
226 
-		} else if ($this->is_file($path)) {
227 
-			return unlink($this->getSourcePath($path));
228 
-		} else {
229 
-			return false;
230 
-		}
231 
-
232 
-	}
233 
-
234 
-	public function rename($path1, $path2) {
235 
-		$srcParent = dirname($path1);
236 
-		$dstParent = dirname($path2);
237 
-
238 
-		if (!$this->isUpdatable($srcParent)) {
239 
-			\OCP\Util::writeLog('core', 'unable to rename, source directory is not writable : ' . $srcParent, ILogger::ERROR);
240 
-			return false;
241 
-		}
242 
-
243 
-		if (!$this->isUpdatable($dstParent)) {
244 
-			\OCP\Util::writeLog('core', 'unable to rename, destination directory is not writable : ' . $dstParent, ILogger::ERROR);
245 
-			return false;
246 
-		}
247 
-
248 
-		if (!$this->file_exists($path1)) {
249 
-			\OCP\Util::writeLog('core', 'unable to rename, file does not exists : ' . $path1, ILogger::ERROR);
250 
-			return false;
251 
-		}
252 
-
253 
-		if ($this->is_dir($path2)) {
254 
-			$this->rmdir($path2);
255 
-		} else if ($this->is_file($path2)) {
256 
-			$this->unlink($path2);
257 
-		}
258 
-
259 
-		if ($this->is_dir($path1)) {
260 
-			// we can't move folders across devices, use copy instead
261 
-			$stat1 = stat(dirname($this->getSourcePath($path1)));
262 
-			$stat2 = stat(dirname($this->getSourcePath($path2)));
263 
-			if ($stat1['dev'] !== $stat2['dev']) {
264 
-				$result = $this->copy($path1, $path2);
265 
-				if ($result) {
266 
-					$result &= $this->rmdir($path1);
267 
-				}
268 
-				return $result;
269 
-			}
270 
-		}
271 
-
272 
-		return rename($this->getSourcePath($path1), $this->getSourcePath($path2));
273 
-	}
274 
-
275 
-	public function copy($path1, $path2) {
276 
-		if ($this->is_dir($path1)) {
277 
-			return parent::copy($path1, $path2);
278 
-		} else {
279 
-			return copy($this->getSourcePath($path1), $this->getSourcePath($path2));
280 
-		}
281 
-	}
282 
-
283 
-	public function fopen($path, $mode) {
284 
-		return fopen($this->getSourcePath($path), $mode);
285 
-	}
286 
-
287 
-	public function hash($type, $path, $raw = false) {
288 
-		return hash_file($type, $this->getSourcePath($path), $raw);
289 
-	}
290 
-
291 
-	public function free_space($path) {
292 
-		$sourcePath = $this->getSourcePath($path);
293 
-		// using !is_dir because $sourcePath might be a part file or
294 
-		// non-existing file, so we'd still want to use the parent dir
295 
-		// in such cases
296 
-		if (!is_dir($sourcePath)) {
297 
-			// disk_free_space doesn't work on files
298 
-			$sourcePath = dirname($sourcePath);
299 
-		}
300 
-		$space = @disk_free_space($sourcePath);
301 
-		if ($space === false || is_null($space)) {
302 
-			return \OCP\Files\FileInfo::SPACE_UNKNOWN;
303 
-		}
304 
-		return $space;
305 
-	}
306 
-
307 
-	public function search($query) {
308 
-		return $this->searchInDir($query);
309 
-	}
310 
-
311 
-	public function getLocalFile($path) {
312 
-		return $this->getSourcePath($path);
313 
-	}
314 
-
315 
-	public function getLocalFolder($path) {
316 
-		return $this->getSourcePath($path);
317 
-	}
318 
-
319 
-	/**
320 
-	 * @param string $query
321 
-	 * @param string $dir
322 
-	 * @return array
323 
-	 */
324 
-	protected function searchInDir($query, $dir = '') {
325 
-		$files = array();
326 
-		$physicalDir = $this->getSourcePath($dir);
327 
-		foreach (scandir($physicalDir) as $item) {
328 
-			if (\OC\Files\Filesystem::isIgnoredDir($item))
329 
-				continue;
330 
-			$physicalItem = $physicalDir . '/' . $item;
331 
-
332 
-			if (strstr(strtolower($item), strtolower($query)) !== false) {
333 
-				$files[] = $dir . '/' . $item;
334 
-			}
335 
-			if (is_dir($physicalItem)) {
336 
-				$files = array_merge($files, $this->searchInDir($query, $dir . '/' . $item));
337 
-			}
338 
-		}
339 
-		return $files;
340 
-	}
341 
-
342 
-	/**
343 
-	 * check if a file or folder has been updated since $time
344 
-	 *
345 
-	 * @param string $path
346 
-	 * @param int $time
347 
-	 * @return bool
348 
-	 */
349 
-	public function hasUpdated($path, $time) {
350 
-		if ($this->file_exists($path)) {
351 
-			return $this->filemtime($path) > $time;
352 
-		} else {
353 
-			return true;
354 
-		}
355 
-	}
356 
-
357 
-	/**
358 
-	 * Get the source path (on disk) of a given path
359 
-	 *
360 
-	 * @param string $path
361 
-	 * @return string
362 
-	 * @throws ForbiddenException
363 
-	 */
364 
-	public function getSourcePath($path) {
365 
-		$fullPath = $this->datadir . $path;
366 
-		$currentPath = $path;
367 
-		if ($this->allowSymlinks || $currentPath === '') {
368 
-			return $fullPath;
369 
-		}
370 
-		$pathToResolve = $fullPath;
371 
-		$realPath = realpath($pathToResolve);
372 
-		while ($realPath === false) { // for non existing files check the parent directory
373 
-			$currentPath = dirname($currentPath);
374 
-			if ($currentPath === '' || $currentPath === '.') {
375 
-				return $fullPath;
376 
-			}
377 
-			$realPath = realpath($this->datadir . $currentPath);
378 
-		}
379 
-		if ($realPath) {
380 
-			$realPath = $realPath . '/';
381 
-		}
382 
-		if (substr($realPath, 0, $this->dataDirLength) === $this->realDataDir) {
383 
-			return $fullPath;
384 
-		}
385 
-
386 
-		\OCP\Util::writeLog('core', "Following symlinks is not allowed ('$fullPath' -> '$realPath' not inside '{$this->realDataDir}')", ILogger::ERROR);
387 
-		throw new ForbiddenException('Following symlinks is not allowed', false);
388 
-	}
389 
-
390 
-	/**
391 
-	 * {@inheritdoc}
392 
-	 */
393 
-	public function isLocal() {
394 
-		return true;
395 
-	}
396 
-
397 
-	/**
398 
-	 * get the ETag for a file or folder
399 
-	 *
400 
-	 * @param string $path
401 
-	 * @return string
402 
-	 */
403 
-	public function getETag($path) {
404 
-		if ($this->is_file($path)) {
405 
-			$stat = $this->stat($path);
406 
-			return md5(
407 
-				$stat['mtime'] .
408 
-				$stat['ino'] .
409 
-				$stat['dev'] .
410 
-				$stat['size']
411 
-			);
412 
-		} else {
413 
-			return parent::getETag($path);
414 
-		}
415 
-	}
416 
-
417 
-	/**
418 
-	 * @param IStorage $sourceStorage
419 
-	 * @param string $sourceInternalPath
420 
-	 * @param string $targetInternalPath
421 
-	 * @param bool $preserveMtime
422 
-	 * @return bool
423 
-	 */
424 
-	public function copyFromStorage(IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath, $preserveMtime = false) {
425 
-		if ($sourceStorage->instanceOfStorage(Local::class)) {
426 
-			if ($sourceStorage->instanceOfStorage(Jail::class)) {
427 
-				/**
428 
-				 * @var \OC\Files\Storage\Wrapper\Jail $sourceStorage
429 
-				 */
430 
-				$sourceInternalPath = $sourceStorage->getUnjailedPath($sourceInternalPath);
431 
-			}
432 
-			/**
433 
-			 * @var \OC\Files\Storage\Local $sourceStorage
434 
-			 */
435 
-			$rootStorage = new Local(['datadir' => '/']);
436 
-			return $rootStorage->copy($sourceStorage->getSourcePath($sourceInternalPath), $this->getSourcePath($targetInternalPath));
437 
-		} else {
438 
-			return parent::copyFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath);
439 
-		}
440 
-	}
441 
-
442 
-	/**
443 
-	 * @param IStorage $sourceStorage
444 
-	 * @param string $sourceInternalPath
445 
-	 * @param string $targetInternalPath
446 
-	 * @return bool
447 
-	 */
448 
-	public function moveFromStorage(IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath) {
449 
-		if ($sourceStorage->instanceOfStorage(Local::class)) {
450 
-			if ($sourceStorage->instanceOfStorage(Jail::class)) {
451 
-				/**
452 
-				 * @var \OC\Files\Storage\Wrapper\Jail $sourceStorage
453 
-				 */
454 
-				$sourceInternalPath = $sourceStorage->getUnjailedPath($sourceInternalPath);
455 
-			}
456 
-			/**
457 
-			 * @var \OC\Files\Storage\Local $sourceStorage
458 
-			 */
459 
-			$rootStorage = new Local(['datadir' => '/']);
460 
-			return $rootStorage->rename($sourceStorage->getSourcePath($sourceInternalPath), $this->getSourcePath($targetInternalPath));
461 
-		} else {
462 
-			return parent::moveFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath);
463 
-		}
464 
-	}
51 
+    protected $datadir;
52 
+
53 
+    protected $dataDirLength;
54 
+
55 
+    protected $allowSymlinks = false;
56 
+
57 
+    protected $realDataDir;
58 
+
59 
+    public function __construct($arguments) {
60 
+        if (!isset($arguments['datadir']) || !is_string($arguments['datadir'])) {
61 
+            throw new \InvalidArgumentException('No data directory set for local storage');
62 
+        }
63 
+        $this->datadir = str_replace('//', '/', $arguments['datadir']);
64 
+        // some crazy code uses a local storage on root...
65 
+        if ($this->datadir === '/') {
66 
+            $this->realDataDir = $this->datadir;
67 
+        } else {
68 
+            $realPath = realpath($this->datadir) ?: $this->datadir;
69 
+            $this->realDataDir = rtrim($realPath, '/') . '/';
70 
+        }
71 
+        if (substr($this->datadir, -1) !== '/') {
72 
+            $this->datadir .= '/';
73 
+        }
74 
+        $this->dataDirLength = strlen($this->realDataDir);
75 
+    }
76 
+
77 
+    public function __destruct() {
78 
+    }
79 
+
80 
+    public function getId() {
81 
+        return 'local::' . $this->datadir;
82 
+    }
83 
+
84 
+    public function mkdir($path) {
85 
+        return @mkdir($this->getSourcePath($path), 0777, true);
86 
+    }
87 
+
88 
+    public function rmdir($path) {
89 
+        if (!$this->isDeletable($path)) {
90 
+            return false;
91 
+        }
92 
+        try {
93 
+            $it = new \RecursiveIteratorIterator(
94 
+                new \RecursiveDirectoryIterator($this->getSourcePath($path)),
95 
+                \RecursiveIteratorIterator::CHILD_FIRST
96 
+            );
97 
+            /**
98 
+             * RecursiveDirectoryIterator on an NFS path isn't iterable with foreach
99 
+             * This bug is fixed in PHP 5.5.9 or before
100 
+             * See #8376
101 
+             */
102 
+            $it->rewind();
103 
+            while ($it->valid()) {
104 
+                /**
105 
+                 * @var \SplFileInfo $file
106 
+                 */
107 
+                $file = $it->current();
108 
+                if (in_array($file->getBasename(), array('.', '..'))) {
109 
+                    $it->next();
110 
+                    continue;
111 
+                } elseif ($file->isDir()) {
112 
+                    rmdir($file->getPathname());
113 
+                } elseif ($file->isFile() || $file->isLink()) {
114 
+                    unlink($file->getPathname());
115 
+                }
116 
+                $it->next();
117 
+            }
118 
+            return rmdir($this->getSourcePath($path));
119 
+        } catch (\UnexpectedValueException $e) {
120 
+            return false;
121 
+        }
122 
+    }
123 
+
124 
+    public function opendir($path) {
125 
+        return opendir($this->getSourcePath($path));
126 
+    }
127 
+
128 
+    public function is_dir($path) {
129 
+        if (substr($path, -1) == '/') {
130 
+            $path = substr($path, 0, -1);
131 
+        }
132 
+        return is_dir($this->getSourcePath($path));
133 
+    }
134 
+
135 
+    public function is_file($path) {
136 
+        return is_file($this->getSourcePath($path));
137 
+    }
138 
+
139 
+    public function stat($path) {
140 
+        clearstatcache();
141 
+        $fullPath = $this->getSourcePath($path);
142 
+        $statResult = stat($fullPath);
143 
+        if (PHP_INT_SIZE === 4 && !$this->is_dir($path)) {
144 
+            $filesize = $this->filesize($path);
145 
+            $statResult['size'] = $filesize;
146 
+            $statResult[7] = $filesize;
147 
+        }
148 
+        return $statResult;
149 
+    }
150 
+
151 
+    public function filetype($path) {
152 
+        $filetype = filetype($this->getSourcePath($path));
153 
+        if ($filetype == 'link') {
154 
+            $filetype = filetype(realpath($this->getSourcePath($path)));
155 
+        }
156 
+        return $filetype;
157 
+    }
158 
+
159 
+    public function filesize($path) {
160 
+        if ($this->is_dir($path)) {
161 
+            return 0;
162 
+        }
163 
+        $fullPath = $this->getSourcePath($path);
164 
+        if (PHP_INT_SIZE === 4) {
165 
+            $helper = new \OC\LargeFileHelper;
166 
+            return $helper->getFileSize($fullPath);
167 
+        }
168 
+        return filesize($fullPath);
169 
+    }
170 
+
171 
+    public function isReadable($path) {
172 
+        return is_readable($this->getSourcePath($path));
173 
+    }
174 
+
175 
+    public function isUpdatable($path) {
176 
+        return is_writable($this->getSourcePath($path));
177 
+    }
178 
+
179 
+    public function file_exists($path) {
180 
+        return file_exists($this->getSourcePath($path));
181 
+    }
182 
+
183 
+    public function filemtime($path) {
184 
+        $fullPath = $this->getSourcePath($path);
185 
+        clearstatcache(true, $fullPath);
186 
+        if (!$this->file_exists($path)) {
187 
+            return false;
188 
+        }
189 
+        if (PHP_INT_SIZE === 4) {
190 
+            $helper = new \OC\LargeFileHelper();
191 
+            return $helper->getFileMtime($fullPath);
192 
+        }
193 
+        return filemtime($fullPath);
194 
+    }
195 
+
196 
+    public function touch($path, $mtime = null) {
197 
+        // sets the modification time of the file to the given value.
198 
+        // If mtime is nil the current time is set.
199 
+        // note that the access time of the file always changes to the current time.
200 
+        if ($this->file_exists($path) and !$this->isUpdatable($path)) {
201 
+            return false;
202 
+        }
203 
+        if (!is_null($mtime)) {
204 
+            $result = touch($this->getSourcePath($path), $mtime);
205 
+        } else {
206 
+            $result = touch($this->getSourcePath($path));
207 
+        }
208 
+        if ($result) {
209 
+            clearstatcache(true, $this->getSourcePath($path));
210 
+        }
211 
+
212 
+        return $result;
213 
+    }
214 
+
215 
+    public function file_get_contents($path) {
216 
+        return file_get_contents($this->getSourcePath($path));
217 
+    }
218 
+
219 
+    public function file_put_contents($path, $data) {
220 
+        return file_put_contents($this->getSourcePath($path), $data);
221 
+    }
222 
+
223 
+    public function unlink($path) {
224 
+        if ($this->is_dir($path)) {
225 
+            return $this->rmdir($path);
226 
+        } else if ($this->is_file($path)) {
227 
+            return unlink($this->getSourcePath($path));
228 
+        } else {
229 
+            return false;
230 
+        }
231 
+
232 
+    }
233 
+
234 
+    public function rename($path1, $path2) {
235 
+        $srcParent = dirname($path1);
236 
+        $dstParent = dirname($path2);
237 
+
238 
+        if (!$this->isUpdatable($srcParent)) {
239 
+            \OCP\Util::writeLog('core', 'unable to rename, source directory is not writable : ' . $srcParent, ILogger::ERROR);
240 
+            return false;
241 
+        }
242 
+
243 
+        if (!$this->isUpdatable($dstParent)) {
244 
+            \OCP\Util::writeLog('core', 'unable to rename, destination directory is not writable : ' . $dstParent, ILogger::ERROR);
245 
+            return false;
246 
+        }
247 
+
248 
+        if (!$this->file_exists($path1)) {
249 
+            \OCP\Util::writeLog('core', 'unable to rename, file does not exists : ' . $path1, ILogger::ERROR);
250 
+            return false;
251 
+        }
252 
+
253 
+        if ($this->is_dir($path2)) {
254 
+            $this->rmdir($path2);
255 
+        } else if ($this->is_file($path2)) {
256 
+            $this->unlink($path2);
257 
+        }
258 
+
259 
+        if ($this->is_dir($path1)) {
260 
+            // we can't move folders across devices, use copy instead
261 
+            $stat1 = stat(dirname($this->getSourcePath($path1)));
262 
+            $stat2 = stat(dirname($this->getSourcePath($path2)));
263 
+            if ($stat1['dev'] !== $stat2['dev']) {
264 
+                $result = $this->copy($path1, $path2);
265 
+                if ($result) {
266 
+                    $result &= $this->rmdir($path1);
267 
+                }
268 
+                return $result;
269 
+            }
270 
+        }
271 
+
272 
+        return rename($this->getSourcePath($path1), $this->getSourcePath($path2));
273 
+    }
274 
+
275 
+    public function copy($path1, $path2) {
276 
+        if ($this->is_dir($path1)) {
277 
+            return parent::copy($path1, $path2);
278 
+        } else {
279 
+            return copy($this->getSourcePath($path1), $this->getSourcePath($path2));
280 
+        }
281 
+    }
282 
+
283 
+    public function fopen($path, $mode) {
284 
+        return fopen($this->getSourcePath($path), $mode);
285 
+    }
286 
+
287 
+    public function hash($type, $path, $raw = false) {
288 
+        return hash_file($type, $this->getSourcePath($path), $raw);
289 
+    }
290 
+
291 
+    public function free_space($path) {
292 
+        $sourcePath = $this->getSourcePath($path);
293 
+        // using !is_dir because $sourcePath might be a part file or
294 
+        // non-existing file, so we'd still want to use the parent dir
295 
+        // in such cases
296 
+        if (!is_dir($sourcePath)) {
297 
+            // disk_free_space doesn't work on files
298 
+            $sourcePath = dirname($sourcePath);
299 
+        }
300 
+        $space = @disk_free_space($sourcePath);
301 
+        if ($space === false || is_null($space)) {
302 
+            return \OCP\Files\FileInfo::SPACE_UNKNOWN;
303 
+        }
304 
+        return $space;
305 
+    }
306 
+
307 
+    public function search($query) {
308 
+        return $this->searchInDir($query);
309 
+    }
310 
+
311 
+    public function getLocalFile($path) {
312 
+        return $this->getSourcePath($path);
313 
+    }
314 
+
315 
+    public function getLocalFolder($path) {
316 
+        return $this->getSourcePath($path);
317 
+    }
318 
+
319 
+    /**
320 
+     * @param string $query
321 
+     * @param string $dir
322 
+     * @return array
323 
+     */
324 
+    protected function searchInDir($query, $dir = '') {
325 
+        $files = array();
326 
+        $physicalDir = $this->getSourcePath($dir);
327 
+        foreach (scandir($physicalDir) as $item) {
328 
+            if (\OC\Files\Filesystem::isIgnoredDir($item))
329 
+                continue;
330 
+            $physicalItem = $physicalDir . '/' . $item;
331 
+
332 
+            if (strstr(strtolower($item), strtolower($query)) !== false) {
333 
+                $files[] = $dir . '/' . $item;
334 
+            }
335 
+            if (is_dir($physicalItem)) {
336 
+                $files = array_merge($files, $this->searchInDir($query, $dir . '/' . $item));
337 
+            }
338 
+        }
339 
+        return $files;
340 
+    }
341 
+
342 
+    /**
343 
+     * check if a file or folder has been updated since $time
344 
+     *
345 
+     * @param string $path
346 
+     * @param int $time
347 
+     * @return bool
348 
+     */
349 
+    public function hasUpdated($path, $time) {
350 
+        if ($this->file_exists($path)) {
351 
+            return $this->filemtime($path) > $time;
352 
+        } else {
353 
+            return true;
354 
+        }
355 
+    }
356 
+
357 
+    /**
358 
+     * Get the source path (on disk) of a given path
359 
+     *
360 
+     * @param string $path
361 
+     * @return string
362 
+     * @throws ForbiddenException
363 
+     */
364 
+    public function getSourcePath($path) {
365 
+        $fullPath = $this->datadir . $path;
366 
+        $currentPath = $path;
367 
+        if ($this->allowSymlinks || $currentPath === '') {
368 
+            return $fullPath;
369 
+        }
370 
+        $pathToResolve = $fullPath;
371 
+        $realPath = realpath($pathToResolve);
372 
+        while ($realPath === false) { // for non existing files check the parent directory
373 
+            $currentPath = dirname($currentPath);
374 
+            if ($currentPath === '' || $currentPath === '.') {
375 
+                return $fullPath;
376 
+            }
377 
+            $realPath = realpath($this->datadir . $currentPath);
378 
+        }
379 
+        if ($realPath) {
380 
+            $realPath = $realPath . '/';
381 
+        }
382 
+        if (substr($realPath, 0, $this->dataDirLength) === $this->realDataDir) {
383 
+            return $fullPath;
384 
+        }
385 
+
386 
+        \OCP\Util::writeLog('core', "Following symlinks is not allowed ('$fullPath' -> '$realPath' not inside '{$this->realDataDir}')", ILogger::ERROR);
387 
+        throw new ForbiddenException('Following symlinks is not allowed', false);
388 
+    }
389 
+
390 
+    /**
391 
+     * {@inheritdoc}
392 
+     */
393 
+    public function isLocal() {
394 
+        return true;
395 
+    }
396 
+
397 
+    /**
398 
+     * get the ETag for a file or folder
399 
+     *
400 
+     * @param string $path
401 
+     * @return string
402 
+     */
403 
+    public function getETag($path) {
404 
+        if ($this->is_file($path)) {
405 
+            $stat = $this->stat($path);
406 
+            return md5(
407 
+                $stat['mtime'] .
408 
+                $stat['ino'] .
409 
+                $stat['dev'] .
410 
+                $stat['size']
411 
+            );
412 
+        } else {
413 
+            return parent::getETag($path);
414 
+        }
415 
+    }
416 
+
417 
+    /**
418 
+     * @param IStorage $sourceStorage
419 
+     * @param string $sourceInternalPath
420 
+     * @param string $targetInternalPath
421 
+     * @param bool $preserveMtime
422 
+     * @return bool
423 
+     */
424 
+    public function copyFromStorage(IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath, $preserveMtime = false) {
425 
+        if ($sourceStorage->instanceOfStorage(Local::class)) {
426 
+            if ($sourceStorage->instanceOfStorage(Jail::class)) {
427 
+                /**
428 
+                 * @var \OC\Files\Storage\Wrapper\Jail $sourceStorage
429 
+                 */
430 
+                $sourceInternalPath = $sourceStorage->getUnjailedPath($sourceInternalPath);
431 
+            }
432 
+            /**
433 
+             * @var \OC\Files\Storage\Local $sourceStorage
434 
+             */
435 
+            $rootStorage = new Local(['datadir' => '/']);
436 
+            return $rootStorage->copy($sourceStorage->getSourcePath($sourceInternalPath), $this->getSourcePath($targetInternalPath));
437 
+        } else {
438 
+            return parent::copyFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath);
439 
+        }
440 
+    }
441 
+
442 
+    /**
443 
+     * @param IStorage $sourceStorage
444 
+     * @param string $sourceInternalPath
445 
+     * @param string $targetInternalPath
446 
+     * @return bool
447 
+     */
448 
+    public function moveFromStorage(IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath) {
449 
+        if ($sourceStorage->instanceOfStorage(Local::class)) {
450 
+            if ($sourceStorage->instanceOfStorage(Jail::class)) {
451 
+                /**
452 
+                 * @var \OC\Files\Storage\Wrapper\Jail $sourceStorage
453 
+                 */
454 
+                $sourceInternalPath = $sourceStorage->getUnjailedPath($sourceInternalPath);
455 
+            }
456 
+            /**
457 
+             * @var \OC\Files\Storage\Local $sourceStorage
458 
+             */
459 
+            $rootStorage = new Local(['datadir' => '/']);
460 
+            return $rootStorage->rename($sourceStorage->getSourcePath($sourceInternalPath), $this->getSourcePath($targetInternalPath));
461 
+        } else {
462 
+            return parent::moveFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath);
463 
+        }
464 
+    }
465 465 
 }
Please login to merge, or discard this patch.
Spacing   +14 added lines, -14 removed lines patch added patch discarded remove patch 
@@ -66,7 +66,7 @@  discard block
 
 block discarded – undo
66 66 
 			$this->realDataDir = $this->datadir;
67 67 
 		} else {
68 68 
 			$realPath = realpath($this->datadir) ?: $this->datadir;
69 
-			$this->realDataDir = rtrim($realPath, '/') . '/';
69 
+			$this->realDataDir = rtrim($realPath, '/').'/';
70 70 
 		}
71 71 
 		if (substr($this->datadir, -1) !== '/') {
72 72 
 			$this->datadir .= '/';
 
@@ -78,7 +78,7 @@  discard block
 
 block discarded – undo
78 78 
 	}
79 79
80 80 
 	public function getId() {
81 
-		return 'local::' . $this->datadir;
81 
+		return 'local::'.$this->datadir;
82 82 
 	}
83 83
84 84 
 	public function mkdir($path) {
 
@@ -236,17 +236,17 @@  discard block
 
 block discarded – undo
236 236 
 		$dstParent = dirname($path2);
237 237
238 238 
 		if (!$this->isUpdatable($srcParent)) {
239 
-			\OCP\Util::writeLog('core', 'unable to rename, source directory is not writable : ' . $srcParent, ILogger::ERROR);
239 
+			\OCP\Util::writeLog('core', 'unable to rename, source directory is not writable : '.$srcParent, ILogger::ERROR);
240 240 
 			return false;
241 241 
 		}
242 242
243 243 
 		if (!$this->isUpdatable($dstParent)) {
244 
-			\OCP\Util::writeLog('core', 'unable to rename, destination directory is not writable : ' . $dstParent, ILogger::ERROR);
244 
+			\OCP\Util::writeLog('core', 'unable to rename, destination directory is not writable : '.$dstParent, ILogger::ERROR);
245 245 
 			return false;
246 246 
 		}
247 247
248 248 
 		if (!$this->file_exists($path1)) {
249 
-			\OCP\Util::writeLog('core', 'unable to rename, file does not exists : ' . $path1, ILogger::ERROR);
249 
+			\OCP\Util::writeLog('core', 'unable to rename, file does not exists : '.$path1, ILogger::ERROR);
250 250 
 			return false;
251 251 
 		}
252 252 
 
@@ -327,13 +327,13 @@  discard block
 
 block discarded – undo
327 327 
 		foreach (scandir($physicalDir) as $item) {
328 328 
 			if (\OC\Files\Filesystem::isIgnoredDir($item))
329 329 
 				continue;
330 
-			$physicalItem = $physicalDir . '/' . $item;
330 
+			$physicalItem = $physicalDir.'/'.$item;
331 331
332 332 
 			if (strstr(strtolower($item), strtolower($query)) !== false) {
333 
-				$files[] = $dir . '/' . $item;
333 
+				$files[] = $dir.'/'.$item;
334 334 
 			}
335 335 
 			if (is_dir($physicalItem)) {
336 
-				$files = array_merge($files, $this->searchInDir($query, $dir . '/' . $item));
336 
+				$files = array_merge($files, $this->searchInDir($query, $dir.'/'.$item));
337 337 
 			}
338 338 
 		}
339 339 
 		return $files;
 
@@ -362,7 +362,7 @@  discard block
 
 block discarded – undo
362 362 
 	 * @throws ForbiddenException
363 363 
 	 */
364 364 
 	public function getSourcePath($path) {
365 
-		$fullPath = $this->datadir . $path;
365 
+		$fullPath = $this->datadir.$path;
366 366 
 		$currentPath = $path;
367 367 
 		if ($this->allowSymlinks || $currentPath === '') {
368 368 
 			return $fullPath;
 
@@ -374,10 +374,10 @@  discard block
 
 block discarded – undo
374 374 
 			if ($currentPath === '' || $currentPath === '.') {
375 375 
 				return $fullPath;
376 376 
 			}
377 
-			$realPath = realpath($this->datadir . $currentPath);
377 
+			$realPath = realpath($this->datadir.$currentPath);
378 378 
 		}
379 379 
 		if ($realPath) {
380 
-			$realPath = $realPath . '/';
380 
+			$realPath = $realPath.'/';
381 381 
 		}
382 382 
 		if (substr($realPath, 0, $this->dataDirLength) === $this->realDataDir) {
383 383 
 			return $fullPath;
 
@@ -404,9 +404,9 @@  discard block
 
 block discarded – undo
404 404 
 		if ($this->is_file($path)) {
405 405 
 			$stat = $this->stat($path);
406 406 
 			return md5(
407 
-				$stat['mtime'] .
408 
-				$stat['ino'] .
409 
-				$stat['dev'] .
407 
+				$stat['mtime'].
408 
+				$stat['ino'].
409 
+				$stat['dev'].
410 410 
 				$stat['size']
411 411 
 			);
412 412 
 		} else {
Please login to merge, or discard this patch.