nextcloud / server

lib/private/Encryption/EncryptionWrapper.php

Indentation +71 added lines, -71 removed lines

@@ -42,83 +42,83 @@
  */
 class EncryptionWrapper {
 
-	/** @var ArrayCache  */
-	private $arrayCache;
+    /** @var ArrayCache  */
+    private $arrayCache;
 
-	/** @var  Manager */
-	private $manager;
+    /** @var  Manager */
+    private $manager;
 
-	/** @var  ILogger */
-	private $logger;
+    /** @var  ILogger */
+    private $logger;
 
-	/**
-	 * EncryptionWrapper constructor.
-	 *
-	 * @param ArrayCache $arrayCache
-	 * @param Manager $manager
-	 * @param ILogger $logger
-	 */
-	public function __construct(ArrayCache $arrayCache,
-								Manager $manager,
-								ILogger $logger
-	) {
-		$this->arrayCache = $arrayCache;
-		$this->manager = $manager;
-		$this->logger = $logger;
-	}
+    /**
+     * EncryptionWrapper constructor.
+     *
+     * @param ArrayCache $arrayCache
+     * @param Manager $manager
+     * @param ILogger $logger
+     */
+    public function __construct(ArrayCache $arrayCache,
+                                Manager $manager,
+                                ILogger $logger
+    ) {
+        $this->arrayCache = $arrayCache;
+        $this->manager = $manager;
+        $this->logger = $logger;
+    }
 
-	/**
-	 * Wraps the given storage when it is not a shared storage
-	 *
-	 * @param string $mountPoint
-	 * @param Storage $storage
-	 * @param IMountPoint $mount
-	 * @return Encryption|Storage
-	 */
-	public function wrapStorage($mountPoint, Storage $storage, IMountPoint $mount) {
-		$parameters = [
-			'storage' => $storage,
-			'mountPoint' => $mountPoint,
-			'mount' => $mount
-		];
+    /**
+     * Wraps the given storage when it is not a shared storage
+     *
+     * @param string $mountPoint
+     * @param Storage $storage
+     * @param IMountPoint $mount
+     * @return Encryption|Storage
+     */
+    public function wrapStorage($mountPoint, Storage $storage, IMountPoint $mount) {
+        $parameters = [
+            'storage' => $storage,
+            'mountPoint' => $mountPoint,
+            'mount' => $mount
+        ];
 
-		if (!$storage->instanceOfStorage(Storage\IDisableEncryptionStorage::class)) {
+        if (!$storage->instanceOfStorage(Storage\IDisableEncryptionStorage::class)) {
 
-			$user = \OC::$server->getUserSession()->getUser();
-			$mountManager = Filesystem::getMountManager();
-			$uid = $user ? $user->getUID() : null;
-			$fileHelper = \OC::$server->getEncryptionFilesHelper();
-			$keyStorage = \OC::$server->getEncryptionKeyStorage();
+            $user = \OC::$server->getUserSession()->getUser();
+            $mountManager = Filesystem::getMountManager();
+            $uid = $user ? $user->getUID() : null;
+            $fileHelper = \OC::$server->getEncryptionFilesHelper();
+            $keyStorage = \OC::$server->getEncryptionKeyStorage();
 
-			$util = new Util(
-				new View(),
-				\OC::$server->getUserManager(),
-				\OC::$server->getGroupManager(),
-				\OC::$server->getConfig()
-			);
-			$update = new Update(
-				new View(),
-				$util,
-				Filesystem::getMountManager(),
-				$this->manager,
-				$fileHelper,
-				$uid
-			);
-			return new Encryption(
-				$parameters,
-				$this->manager,
-				$util,
-				$this->logger,
-				$fileHelper,
-				$uid,
-				$keyStorage,
-				$update,
-				$mountManager,
-				$this->arrayCache
-			);
-		} else {
-			return $storage;
-		}
-	}
+            $util = new Util(
+                new View(),
+                \OC::$server->getUserManager(),
+                \OC::$server->getGroupManager(),
+                \OC::$server->getConfig()
+            );
+            $update = new Update(
+                new View(),
+                $util,
+                Filesystem::getMountManager(),
+                $this->manager,
+                $fileHelper,
+                $uid
+            );
+            return new Encryption(
+                $parameters,
+                $this->manager,
+                $util,
+                $this->logger,
+                $fileHelper,
+                $uid,
+                $keyStorage,
+                $update,
+                $mountManager,
+                $this->arrayCache
+            );
+        } else {
+            return $storage;
+        }
+    }
 
 }

apps/files_sharing/lib/External/Storage.php

Indentation +376 added lines, -376 removed lines

@@ -44,380 +44,380 @@
 use OCP\Files\StorageNotAvailableException;
 
 class Storage extends DAV implements ISharedStorage, IDisableEncryptionStorage {
-	/** @var ICloudId */
-	private $cloudId;
-	/** @var string */
-	private $mountPoint;
-	/** @var string */
-	private $token;
-	/** @var \OCP\ICacheFactory */
-	private $memcacheFactory;
-	/** @var \OCP\Http\Client\IClientService */
-	private $httpClient;
-	/** @var bool */
-	private $updateChecked = false;
-
-	/**
-	 * @var \OCA\Files_Sharing\External\Manager
-	 */
-	private $manager;
-
-	public function __construct($options) {
-		$this->memcacheFactory = \OC::$server->getMemCacheFactory();
-		$this->httpClient = $options['HttpClientService'];
-
-		$this->manager = $options['manager'];
-		$this->cloudId = $options['cloudId'];
-		$discoveryService = \OC::$server->query(\OCP\OCS\IDiscoveryService::class);
-
-		list($protocol, $remote) = explode('://', $this->cloudId->getRemote());
-		if (strpos($remote, '/')) {
-			list($host, $root) = explode('/', $remote, 2);
-		} else {
-			$host = $remote;
-			$root = '';
-		}
-		$secure = $protocol === 'https';
-		$federatedSharingEndpoints = $discoveryService->discover($this->cloudId->getRemote(), 'FEDERATED_SHARING');
-		$webDavEndpoint = isset($federatedSharingEndpoints['webdav']) ? $federatedSharingEndpoints['webdav'] : '/public.php/webdav';
-		$root = rtrim($root, '/') . $webDavEndpoint;
-		$this->mountPoint = $options['mountpoint'];
-		$this->token = $options['token'];
-
-		parent::__construct(array(
-			'secure' => $secure,
-			'host' => $host,
-			'root' => $root,
-			'user' => $options['token'],
-			'password' => (string)$options['password']
-		));
-	}
-
-	public function getWatcher($path = '', $storage = null) {
-		if (!$storage) {
-			$storage = $this;
-		}
-		if (!isset($this->watcher)) {
-			$this->watcher = new Watcher($storage);
-			$this->watcher->setPolicy(\OC\Files\Cache\Watcher::CHECK_ONCE);
-		}
-		return $this->watcher;
-	}
-
-	public function getRemoteUser() {
-		return $this->cloudId->getUser();
-	}
-
-	public function getRemote() {
-		return $this->cloudId->getRemote();
-	}
-
-	public function getMountPoint() {
-		return $this->mountPoint;
-	}
-
-	public function getToken() {
-		return $this->token;
-	}
-
-	public function getPassword() {
-		return $this->password;
-	}
-
-	/**
-	 * @brief get id of the mount point
-	 * @return string
-	 */
-	public function getId() {
-		return 'shared::' . md5($this->token . '@' . $this->getRemote());
-	}
-
-	public function getCache($path = '', $storage = null) {
-		if (is_null($this->cache)) {
-			$this->cache = new Cache($this, $this->cloudId);
-		}
-		return $this->cache;
-	}
-
-	/**
-	 * @param string $path
-	 * @param \OC\Files\Storage\Storage $storage
-	 * @return \OCA\Files_Sharing\External\Scanner
-	 */
-	public function getScanner($path = '', $storage = null) {
-		if (!$storage) {
-			$storage = $this;
-		}
-		if (!isset($this->scanner)) {
-			$this->scanner = new Scanner($storage);
-		}
-		return $this->scanner;
-	}
-
-	/**
-	 * check if a file or folder has been updated since $time
-	 *
-	 * @param string $path
-	 * @param int $time
-	 * @throws \OCP\Files\StorageNotAvailableException
-	 * @throws \OCP\Files\StorageInvalidException
-	 * @return bool
-	 */
-	public function hasUpdated($path, $time) {
-		// since for owncloud webdav servers we can rely on etag propagation we only need to check the root of the storage
-		// because of that we only do one check for the entire storage per request
-		if ($this->updateChecked) {
-			return false;
-		}
-		$this->updateChecked = true;
-		try {
-			return parent::hasUpdated('', $time);
-		} catch (StorageInvalidException $e) {
-			// check if it needs to be removed
-			$this->checkStorageAvailability();
-			throw $e;
-		} catch (StorageNotAvailableException $e) {
-			// check if it needs to be removed or just temp unavailable
-			$this->checkStorageAvailability();
-			throw $e;
-		}
-	}
-
-	public function test() {
-		try {
-			return parent::test();
-		} catch (StorageInvalidException $e) {
-			// check if it needs to be removed
-			$this->checkStorageAvailability();
-			throw $e;
-		} catch (StorageNotAvailableException $e) {
-			// check if it needs to be removed or just temp unavailable
-			$this->checkStorageAvailability();
-			throw $e;
-		}
-	}
-
-	/**
-	 * Check whether this storage is permanently or temporarily
-	 * unavailable
-	 *
-	 * @throws \OCP\Files\StorageNotAvailableException
-	 * @throws \OCP\Files\StorageInvalidException
-	 */
-	public function checkStorageAvailability() {
-		// see if we can find out why the share is unavailable
-		try {
-			$this->getShareInfo();
-		} catch (NotFoundException $e) {
-			// a 404 can either mean that the share no longer exists or there is no Nextcloud on the remote
-			if ($this->testRemote()) {
-				// valid Nextcloud instance means that the public share no longer exists
-				// since this is permanent (re-sharing the file will create a new token)
-				// we remove the invalid storage
-				$this->manager->removeShare($this->mountPoint);
-				$this->manager->getMountManager()->removeMount($this->mountPoint);
-				throw new StorageInvalidException();
-			} else {
-				// Nextcloud instance is gone, likely to be a temporary server configuration error
-				throw new StorageNotAvailableException();
-			}
-		} catch (ForbiddenException $e) {
-			// auth error, remove share for now (provide a dialog in the future)
-			$this->manager->removeShare($this->mountPoint);
-			$this->manager->getMountManager()->removeMount($this->mountPoint);
-			throw new StorageInvalidException();
-		} catch (\GuzzleHttp\Exception\ConnectException $e) {
-			throw new StorageNotAvailableException();
-		} catch (\GuzzleHttp\Exception\RequestException $e) {
-			throw new StorageNotAvailableException();
-		} catch (\Exception $e) {
-			throw $e;
-		}
-	}
-
-	public function file_exists($path) {
-		if ($path === '') {
-			return true;
-		} else {
-			return parent::file_exists($path);
-		}
-	}
-
-	/**
-	 * check if the configured remote is a valid federated share provider
-	 *
-	 * @return bool
-	 */
-	protected function testRemote() {
-		try {
-			return $this->testRemoteUrl($this->getRemote() . '/ocs-provider/index.php')
-				|| $this->testRemoteUrl($this->getRemote() . '/ocs-provider/')
-				|| $this->testRemoteUrl($this->getRemote() . '/status.php');
-		} catch (\Exception $e) {
-			return false;
-		}
-	}
-
-	/**
-	 * @param string $url
-	 * @return bool
-	 */
-	private function testRemoteUrl($url) {
-		$cache = $this->memcacheFactory->createDistributed('files_sharing_remote_url');
-		if($cache->hasKey($url)) {
-			return (bool)$cache->get($url);
-		}
-
-		$client = $this->httpClient->newClient();
-		try {
-			$result = $client->get($url, [
-				'timeout' => 10,
-				'connect_timeout' => 10,
-			])->getBody();
-			$data = json_decode($result);
-			$returnValue = (is_object($data) && !empty($data->version));
-		} catch (ConnectException $e) {
-			$returnValue = false;
-		} catch (ClientException $e) {
-			$returnValue = false;
-		}
-
-		$cache->set($url, $returnValue, 60*60*24);
-		return $returnValue;
-	}
-
-	/**
-	 * Whether the remote is an ownCloud/Nextcloud, used since some sharing features are not
-	 * standardized. Let's use this to detect whether to use it.
-	 *
-	 * @return bool
-	 */
-	public function remoteIsOwnCloud() {
-		if(defined('PHPUNIT_RUN') || !$this->testRemoteUrl($this->getRemote() . '/status.php')) {
-			return false;
-		}
-		return true;
-	}
-
-	/**
-	 * @return mixed
-	 * @throws ForbiddenException
-	 * @throws NotFoundException
-	 * @throws \Exception
-	 */
-	public function getShareInfo() {
-		$remote = $this->getRemote();
-		$token = $this->getToken();
-		$password = $this->getPassword();
-
-		// If remote is not an ownCloud do not try to get any share info
-		if(!$this->remoteIsOwnCloud()) {
-			return ['status' => 'unsupported'];
-		}
-
-		$url = rtrim($remote, '/') . '/index.php/apps/files_sharing/shareinfo?t=' . $token;
-
-		// TODO: DI
-		$client = \OC::$server->getHTTPClientService()->newClient();
-		try {
-			$response = $client->post($url, [
-				'body' => ['password' => $password],
-				'timeout' => 10,
-				'connect_timeout' => 10,
-			]);
-		} catch (\GuzzleHttp\Exception\RequestException $e) {
-			if ($e->getCode() === Http::STATUS_UNAUTHORIZED || $e->getCode() === Http::STATUS_FORBIDDEN) {
-				throw new ForbiddenException();
-			}
-			if ($e->getCode() === Http::STATUS_NOT_FOUND) {
-				throw new NotFoundException();
-			}
-			// throw this to be on the safe side: the share will still be visible
-			// in the UI in case the failure is intermittent, and the user will
-			// be able to decide whether to remove it if it's really gone
-			throw new StorageNotAvailableException();
-		}
-
-		return json_decode($response->getBody(), true);
-	}
-
-	public function getOwner($path) {
-		return $this->cloudId->getDisplayId();
-	}
-
-	public function isSharable($path) {
-		if (\OCP\Util::isSharingDisabledForUser() || !\OC\Share\Share::isResharingAllowed()) {
-			return false;
-		}
-		return ($this->getPermissions($path) & Constants::PERMISSION_SHARE);
-	}
-
-	public function getPermissions($path) {
-		$response = $this->propfind($path);
-		// old federated sharing permissions
-		if (isset($response['{http://open-collaboration-services.org/ns}share-permissions'])) {
-			$permissions = $response['{http://open-collaboration-services.org/ns}share-permissions'];
-		} else if (isset($response['{http://open-cloud-mesh.org/ns}share-permissions'])) {
-			// permissions provided by the OCM API
-			$permissions = $this->ocmPermissions2ncPermissions($response['{http://open-collaboration-services.org/ns}share-permissions']);
-		} else {
-			// use default permission if remote server doesn't provide the share permissions
-			$permissions = $this->getDefaultPermissions($path);
-		}
-
-		return $permissions;
-	}
-
-	public function needsPartFile() {
-		return false;
-	}
-
-	/**
-	 * translate OCM Permissions to Nextcloud permissions
-	 *
-	 * @param string $ocmPermissions json encoded OCM permissions
-	 * @param string $path path to file
-	 * @return int
-	 */
-	protected function ocmPermissions2ncPermissions($ocmPermissions, $path) {
-		try {
-			$ocmPermissions = json_decode($ocmPermissions);
-			$ncPermissions = 0;
-			foreach($ocmPermissions as $permission) {
-				switch (strtolower($permission)) {
-					case 'read':
-						$ncPermissions += Constants::PERMISSION_READ;
-						break;
-					case 'write':
-						$ncPermissions += Constants::PERMISSION_CREATE + Constants::PERMISSION_UPDATE;
-						break;
-					case 'share':
-						$ncPermissions += Constants::PERMISSION_SHARE;
-						break;
-					default:
-						throw new \Exception();
-				}
-			}
-		} catch (\Exception $e) {
-			$ncPermissions = $this->getDefaultPermissions($path);
-		}
-
-		return $ncPermissions;
-	}
-
-	/**
-	 * calculate default permissions in case no permissions are provided
-	 *
-	 * @param $path
-	 * @return int
-	 */
-	protected function getDefaultPermissions($path) {
-		if ($this->is_dir($path)) {
-			$permissions = Constants::PERMISSION_ALL;
-		} else {
-			$permissions = Constants::PERMISSION_ALL & ~Constants::PERMISSION_CREATE;
-		}
-
-		return $permissions;
-	}
+    /** @var ICloudId */
+    private $cloudId;
+    /** @var string */
+    private $mountPoint;
+    /** @var string */
+    private $token;
+    /** @var \OCP\ICacheFactory */
+    private $memcacheFactory;
+    /** @var \OCP\Http\Client\IClientService */
+    private $httpClient;
+    /** @var bool */
+    private $updateChecked = false;
+
+    /**
+     * @var \OCA\Files_Sharing\External\Manager
+     */
+    private $manager;
+
+    public function __construct($options) {
+        $this->memcacheFactory = \OC::$server->getMemCacheFactory();
+        $this->httpClient = $options['HttpClientService'];
+
+        $this->manager = $options['manager'];
+        $this->cloudId = $options['cloudId'];
+        $discoveryService = \OC::$server->query(\OCP\OCS\IDiscoveryService::class);
+
+        list($protocol, $remote) = explode('://', $this->cloudId->getRemote());
+        if (strpos($remote, '/')) {
+            list($host, $root) = explode('/', $remote, 2);
+        } else {
+            $host = $remote;
+            $root = '';
+        }
+        $secure = $protocol === 'https';
+        $federatedSharingEndpoints = $discoveryService->discover($this->cloudId->getRemote(), 'FEDERATED_SHARING');
+        $webDavEndpoint = isset($federatedSharingEndpoints['webdav']) ? $federatedSharingEndpoints['webdav'] : '/public.php/webdav';
+        $root = rtrim($root, '/') . $webDavEndpoint;
+        $this->mountPoint = $options['mountpoint'];
+        $this->token = $options['token'];
+
+        parent::__construct(array(
+            'secure' => $secure,
+            'host' => $host,
+            'root' => $root,
+            'user' => $options['token'],
+            'password' => (string)$options['password']
+        ));
+    }
+
+    public function getWatcher($path = '', $storage = null) {
+        if (!$storage) {
+            $storage = $this;
+        }
+        if (!isset($this->watcher)) {
+            $this->watcher = new Watcher($storage);
+            $this->watcher->setPolicy(\OC\Files\Cache\Watcher::CHECK_ONCE);
+        }
+        return $this->watcher;
+    }
+
+    public function getRemoteUser() {
+        return $this->cloudId->getUser();
+    }
+
+    public function getRemote() {
+        return $this->cloudId->getRemote();
+    }
+
+    public function getMountPoint() {
+        return $this->mountPoint;
+    }
+
+    public function getToken() {
+        return $this->token;
+    }
+
+    public function getPassword() {
+        return $this->password;
+    }
+
+    /**
+     * @brief get id of the mount point
+     * @return string
+     */
+    public function getId() {
+        return 'shared::' . md5($this->token . '@' . $this->getRemote());
+    }
+
+    public function getCache($path = '', $storage = null) {
+        if (is_null($this->cache)) {
+            $this->cache = new Cache($this, $this->cloudId);
+        }
+        return $this->cache;
+    }
+
+    /**
+     * @param string $path
+     * @param \OC\Files\Storage\Storage $storage
+     * @return \OCA\Files_Sharing\External\Scanner
+     */
+    public function getScanner($path = '', $storage = null) {
+        if (!$storage) {
+            $storage = $this;
+        }
+        if (!isset($this->scanner)) {
+            $this->scanner = new Scanner($storage);
+        }
+        return $this->scanner;
+    }
+
+    /**
+     * check if a file or folder has been updated since $time
+     *
+     * @param string $path
+     * @param int $time
+     * @throws \OCP\Files\StorageNotAvailableException
+     * @throws \OCP\Files\StorageInvalidException
+     * @return bool
+     */
+    public function hasUpdated($path, $time) {
+        // since for owncloud webdav servers we can rely on etag propagation we only need to check the root of the storage
+        // because of that we only do one check for the entire storage per request
+        if ($this->updateChecked) {
+            return false;
+        }
+        $this->updateChecked = true;
+        try {
+            return parent::hasUpdated('', $time);
+        } catch (StorageInvalidException $e) {
+            // check if it needs to be removed
+            $this->checkStorageAvailability();
+            throw $e;
+        } catch (StorageNotAvailableException $e) {
+            // check if it needs to be removed or just temp unavailable
+            $this->checkStorageAvailability();
+            throw $e;
+        }
+    }
+
+    public function test() {
+        try {
+            return parent::test();
+        } catch (StorageInvalidException $e) {
+            // check if it needs to be removed
+            $this->checkStorageAvailability();
+            throw $e;
+        } catch (StorageNotAvailableException $e) {
+            // check if it needs to be removed or just temp unavailable
+            $this->checkStorageAvailability();
+            throw $e;
+        }
+    }
+
+    /**
+     * Check whether this storage is permanently or temporarily
+     * unavailable
+     *
+     * @throws \OCP\Files\StorageNotAvailableException
+     * @throws \OCP\Files\StorageInvalidException
+     */
+    public function checkStorageAvailability() {
+        // see if we can find out why the share is unavailable
+        try {
+            $this->getShareInfo();
+        } catch (NotFoundException $e) {
+            // a 404 can either mean that the share no longer exists or there is no Nextcloud on the remote
+            if ($this->testRemote()) {
+                // valid Nextcloud instance means that the public share no longer exists
+                // since this is permanent (re-sharing the file will create a new token)
+                // we remove the invalid storage
+                $this->manager->removeShare($this->mountPoint);
+                $this->manager->getMountManager()->removeMount($this->mountPoint);
+                throw new StorageInvalidException();
+            } else {
+                // Nextcloud instance is gone, likely to be a temporary server configuration error
+                throw new StorageNotAvailableException();
+            }
+        } catch (ForbiddenException $e) {
+            // auth error, remove share for now (provide a dialog in the future)
+            $this->manager->removeShare($this->mountPoint);
+            $this->manager->getMountManager()->removeMount($this->mountPoint);
+            throw new StorageInvalidException();
+        } catch (\GuzzleHttp\Exception\ConnectException $e) {
+            throw new StorageNotAvailableException();
+        } catch (\GuzzleHttp\Exception\RequestException $e) {
+            throw new StorageNotAvailableException();
+        } catch (\Exception $e) {
+            throw $e;
+        }
+    }
+
+    public function file_exists($path) {
+        if ($path === '') {
+            return true;
+        } else {
+            return parent::file_exists($path);
+        }
+    }
+
+    /**
+     * check if the configured remote is a valid federated share provider
+     *
+     * @return bool
+     */
+    protected function testRemote() {
+        try {
+            return $this->testRemoteUrl($this->getRemote() . '/ocs-provider/index.php')
+                || $this->testRemoteUrl($this->getRemote() . '/ocs-provider/')
+                || $this->testRemoteUrl($this->getRemote() . '/status.php');
+        } catch (\Exception $e) {
+            return false;
+        }
+    }
+
+    /**
+     * @param string $url
+     * @return bool
+     */
+    private function testRemoteUrl($url) {
+        $cache = $this->memcacheFactory->createDistributed('files_sharing_remote_url');
+        if($cache->hasKey($url)) {
+            return (bool)$cache->get($url);
+        }
+
+        $client = $this->httpClient->newClient();
+        try {
+            $result = $client->get($url, [
+                'timeout' => 10,
+                'connect_timeout' => 10,
+            ])->getBody();
+            $data = json_decode($result);
+            $returnValue = (is_object($data) && !empty($data->version));
+        } catch (ConnectException $e) {
+            $returnValue = false;
+        } catch (ClientException $e) {
+            $returnValue = false;
+        }
+
+        $cache->set($url, $returnValue, 60*60*24);
+        return $returnValue;
+    }
+
+    /**
+     * Whether the remote is an ownCloud/Nextcloud, used since some sharing features are not
+     * standardized. Let's use this to detect whether to use it.
+     *
+     * @return bool
+     */
+    public function remoteIsOwnCloud() {
+        if(defined('PHPUNIT_RUN') || !$this->testRemoteUrl($this->getRemote() . '/status.php')) {
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * @return mixed
+     * @throws ForbiddenException
+     * @throws NotFoundException
+     * @throws \Exception
+     */
+    public function getShareInfo() {
+        $remote = $this->getRemote();
+        $token = $this->getToken();
+        $password = $this->getPassword();
+
+        // If remote is not an ownCloud do not try to get any share info
+        if(!$this->remoteIsOwnCloud()) {
+            return ['status' => 'unsupported'];
+        }
+
+        $url = rtrim($remote, '/') . '/index.php/apps/files_sharing/shareinfo?t=' . $token;
+
+        // TODO: DI
+        $client = \OC::$server->getHTTPClientService()->newClient();
+        try {
+            $response = $client->post($url, [
+                'body' => ['password' => $password],
+                'timeout' => 10,
+                'connect_timeout' => 10,
+            ]);
+        } catch (\GuzzleHttp\Exception\RequestException $e) {
+            if ($e->getCode() === Http::STATUS_UNAUTHORIZED || $e->getCode() === Http::STATUS_FORBIDDEN) {
+                throw new ForbiddenException();
+            }
+            if ($e->getCode() === Http::STATUS_NOT_FOUND) {
+                throw new NotFoundException();
+            }
+            // throw this to be on the safe side: the share will still be visible
+            // in the UI in case the failure is intermittent, and the user will
+            // be able to decide whether to remove it if it's really gone
+            throw new StorageNotAvailableException();
+        }
+
+        return json_decode($response->getBody(), true);
+    }
+
+    public function getOwner($path) {
+        return $this->cloudId->getDisplayId();
+    }
+
+    public function isSharable($path) {
+        if (\OCP\Util::isSharingDisabledForUser() || !\OC\Share\Share::isResharingAllowed()) {
+            return false;
+        }
+        return ($this->getPermissions($path) & Constants::PERMISSION_SHARE);
+    }
+
+    public function getPermissions($path) {
+        $response = $this->propfind($path);
+        // old federated sharing permissions
+        if (isset($response['{http://open-collaboration-services.org/ns}share-permissions'])) {
+            $permissions = $response['{http://open-collaboration-services.org/ns}share-permissions'];
+        } else if (isset($response['{http://open-cloud-mesh.org/ns}share-permissions'])) {
+            // permissions provided by the OCM API
+            $permissions = $this->ocmPermissions2ncPermissions($response['{http://open-collaboration-services.org/ns}share-permissions']);
+        } else {
+            // use default permission if remote server doesn't provide the share permissions
+            $permissions = $this->getDefaultPermissions($path);
+        }
+
+        return $permissions;
+    }
+
+    public function needsPartFile() {
+        return false;
+    }
+
+    /**
+     * translate OCM Permissions to Nextcloud permissions
+     *
+     * @param string $ocmPermissions json encoded OCM permissions
+     * @param string $path path to file
+     * @return int
+     */
+    protected function ocmPermissions2ncPermissions($ocmPermissions, $path) {
+        try {
+            $ocmPermissions = json_decode($ocmPermissions);
+            $ncPermissions = 0;
+            foreach($ocmPermissions as $permission) {
+                switch (strtolower($permission)) {
+                    case 'read':
+                        $ncPermissions += Constants::PERMISSION_READ;
+                        break;
+                    case 'write':
+                        $ncPermissions += Constants::PERMISSION_CREATE + Constants::PERMISSION_UPDATE;
+                        break;
+                    case 'share':
+                        $ncPermissions += Constants::PERMISSION_SHARE;
+                        break;
+                    default:
+                        throw new \Exception();
+                }
+            }
+        } catch (\Exception $e) {
+            $ncPermissions = $this->getDefaultPermissions($path);
+        }
+
+        return $ncPermissions;
+    }
+
+    /**
+     * calculate default permissions in case no permissions are provided
+     *
+     * @param $path
+     * @return int
+     */
+    protected function getDefaultPermissions($path) {
+        if ($this->is_dir($path)) {
+            $permissions = Constants::PERMISSION_ALL;
+        } else {
+            $permissions = Constants::PERMISSION_ALL & ~Constants::PERMISSION_CREATE;
+        }
+
+        return $permissions;
+    }
 }

apps/files_sharing/lib/SharedStorage.php

Indentation +455 added lines, -455 removed lines

@@ -49,459 +49,459 @@
  */
 class SharedStorage extends \OC\Files\Storage\Wrapper\Jail implements ISharedStorage, IDisableEncryptionStorage {
 
-	/** @var \OCP\Share\IShare */
-	private $superShare;
-
-	/** @var \OCP\Share\IShare[] */
-	private $groupedShares;
-
-	/**
-	 * @var \OC\Files\View
-	 */
-	private $ownerView;
-
-	private $initialized = false;
-
-	/**
-	 * @var ICacheEntry
-	 */
-	private $sourceRootInfo;
-
-	/** @var string */
-	private $user;
-
-	/**
-	 * @var \OCP\ILogger
-	 */
-	private $logger;
-
-	/** @var  IStorage */
-	private $nonMaskedStorage;
-
-	private $options;
-
-	/** @var boolean */
-	private $sharingDisabledForUser;
-
-	public function __construct($arguments) {
-		$this->ownerView = $arguments['ownerView'];
-		$this->logger = \OC::$server->getLogger();
-
-		$this->superShare = $arguments['superShare'];
-		$this->groupedShares = $arguments['groupedShares'];
-
-		$this->user = $arguments['user'];
-		if (isset($arguments['sharingDisabledForUser'])) {
-			$this->sharingDisabledForUser = $arguments['sharingDisabledForUser'];
-		} else {
-			$this->sharingDisabledForUser = false;
-		}
-
-		parent::__construct([
-			'storage' => null,
-			'root' => null,
-		]);
-	}
-
-	/**
-	 * @return ICacheEntry
-	 */
-	private function getSourceRootInfo() {
-		if (is_null($this->sourceRootInfo)) {
-			if (is_null($this->superShare->getNodeCacheEntry())) {
-				$this->init();
-				$this->sourceRootInfo = $this->nonMaskedStorage->getCache()->get($this->rootPath);
-			} else {
-				$this->sourceRootInfo = $this->superShare->getNodeCacheEntry();
-			}
-		}
-		return $this->sourceRootInfo;
-	}
-
-	private function init() {
-		if ($this->initialized) {
-			return;
-		}
-		$this->initialized = true;
-		try {
-			Filesystem::initMountPoints($this->superShare->getShareOwner());
-			$sourcePath = $this->ownerView->getPath($this->superShare->getNodeId());
-			list($this->nonMaskedStorage, $this->rootPath) = $this->ownerView->resolvePath($sourcePath);
-			$this->storage = new PermissionsMask([
-				'storage' => $this->nonMaskedStorage,
-				'mask' => $this->superShare->getPermissions()
-			]);
-		} catch (NotFoundException $e) {
-			// original file not accessible or deleted, set FailedStorage
-			$this->storage = new FailedStorage(['exception' => $e]);
-			$this->cache = new FailedCache();
-			$this->rootPath = '';
-		} catch (NoUserException $e) {
-			// sharer user deleted, set FailedStorage
-			$this->storage = new FailedStorage(['exception' => $e]);
-			$this->cache = new FailedCache();
-			$this->rootPath = '';
-		} catch (\Exception $e) {
-			$this->storage = new FailedStorage(['exception' => $e]);
-			$this->cache = new FailedCache();
-			$this->rootPath = '';
-			$this->logger->logException($e);
-		}
-
-		if (!$this->nonMaskedStorage) {
-			$this->nonMaskedStorage = $this->storage;
-		}
-	}
-
-	/**
-	 * @inheritdoc
-	 */
-	public function instanceOfStorage($class) {
-		if ($class === '\OC\Files\Storage\Common') {
-			return true;
-		}
-		if (in_array($class, ['\OC\Files\Storage\Home', '\OC\Files\ObjectStore\HomeObjectStoreStorage'])) {
-			return false;
-		}
-		return parent::instanceOfStorage($class);
-	}
-
-	/**
-	 * @return string
-	 */
-	public function getShareId() {
-		return $this->superShare->getId();
-	}
-
-	private function isValid() {
-		return $this->getSourceRootInfo() && ($this->getSourceRootInfo()->getPermissions() & Constants::PERMISSION_SHARE) === Constants::PERMISSION_SHARE;
-	}
-
-	/**
-	 * get id of the mount point
-	 *
-	 * @return string
-	 */
-	public function getId() {
-		return 'shared::' . $this->getMountPoint();
-	}
-
-	/**
-	 * Get the permissions granted for a shared file
-	 *
-	 * @param string $target Shared target file path
-	 * @return int CRUDS permissions granted
-	 */
-	public function getPermissions($target = '') {
-		if (!$this->isValid()) {
-			return 0;
-		}
-		$permissions = parent::getPermissions($target) & $this->superShare->getPermissions();
-
-		// part files and the mount point always have delete permissions
-		if ($target === '' || pathinfo($target, PATHINFO_EXTENSION) === 'part') {
-			$permissions |= \OCP\Constants::PERMISSION_DELETE;
-		}
-
-		if ($this->sharingDisabledForUser) {
-			$permissions &= ~\OCP\Constants::PERMISSION_SHARE;
-		}
-
-		return $permissions;
-	}
-
-	public function isCreatable($path) {
-		return ($this->getPermissions($path) & \OCP\Constants::PERMISSION_CREATE);
-	}
-
-	public function isReadable($path) {
-		if (!$this->isValid()) {
-			return false;
-		}
-		if (!$this->file_exists($path)) {
-			return false;
-		}
-		/** @var IStorage $storage */
-		/** @var string $internalPath */
-		list($storage, $internalPath) = $this->resolvePath($path);
-		return $storage->isReadable($internalPath);
-	}
-
-	public function isUpdatable($path) {
-		return ($this->getPermissions($path) & \OCP\Constants::PERMISSION_UPDATE);
-	}
-
-	public function isDeletable($path) {
-		return ($this->getPermissions($path) & \OCP\Constants::PERMISSION_DELETE);
-	}
-
-	public function isSharable($path) {
-		if (\OCP\Util::isSharingDisabledForUser() || !\OC\Share\Share::isResharingAllowed()) {
-			return false;
-		}
-		return ($this->getPermissions($path) & \OCP\Constants::PERMISSION_SHARE);
-	}
-
-	public function fopen($path, $mode) {
-		if ($source = $this->getUnjailedPath($path)) {
-			switch ($mode) {
-				case 'r+':
-				case 'rb+':
-				case 'w+':
-				case 'wb+':
-				case 'x+':
-				case 'xb+':
-				case 'a+':
-				case 'ab+':
-				case 'w':
-				case 'wb':
-				case 'x':
-				case 'xb':
-				case 'a':
-				case 'ab':
-					$creatable = $this->isCreatable(dirname($path));
-					$updatable = $this->isUpdatable($path);
-					// if neither permissions given, no need to continue
-					if (!$creatable && !$updatable) {
-						if (pathinfo($path, PATHINFO_EXTENSION) === 'part') {
-							$updatable = $this->isUpdatable(dirname($path));
-						}
-
-						if (!$updatable) {
-							return false;
-						}
-					}
-
-					$exists = $this->file_exists($path);
-					// if a file exists, updatable permissions are required
-					if ($exists && !$updatable) {
-						return false;
-					}
-
-					// part file is allowed if !$creatable but the final file is $updatable
-					if (pathinfo($path, PATHINFO_EXTENSION) !== 'part') {
-						if (!$exists && !$creatable) {
-							return false;
-						}
-					}
-			}
-			$info = array(
-				'target' => $this->getMountPoint() . $path,
-				'source' => $source,
-				'mode' => $mode,
-			);
-			\OCP\Util::emitHook('\OC\Files\Storage\Shared', 'fopen', $info);
-			return $this->nonMaskedStorage->fopen($this->getUnjailedPath($path), $mode);
-		}
-		return false;
-	}
-
-	/**
-	 * see http://php.net/manual/en/function.rename.php
-	 *
-	 * @param string $path1
-	 * @param string $path2
-	 * @return bool
-	 */
-	public function rename($path1, $path2) {
-		$this->init();
-		$isPartFile = pathinfo($path1, PATHINFO_EXTENSION) === 'part';
-		$targetExists = $this->file_exists($path2);
-		$sameFodler = dirname($path1) === dirname($path2);
-
-		if ($targetExists || ($sameFodler && !$isPartFile)) {
-			if (!$this->isUpdatable('')) {
-				return false;
-			}
-		} else {
-			if (!$this->isCreatable('')) {
-				return false;
-			}
-		}
-
-		return $this->nonMaskedStorage->rename($this->getUnjailedPath($path1), $this->getUnjailedPath($path2));
-	}
-
-	/**
-	 * return mount point of share, relative to data/user/files
-	 *
-	 * @return string
-	 */
-	public function getMountPoint() {
-		return $this->superShare->getTarget();
-	}
-
-	/**
-	 * @param string $path
-	 */
-	public function setMountPoint($path) {
-		$this->superShare->setTarget($path);
-
-		foreach ($this->groupedShares as $share) {
-			$share->setTarget($path);
-		}
-	}
-
-	/**
-	 * get the user who shared the file
-	 *
-	 * @return string
-	 */
-	public function getSharedFrom() {
-		return $this->superShare->getShareOwner();
-	}
-
-	/**
-	 * @return \OCP\Share\IShare
-	 */
-	public function getShare() {
-		return $this->superShare;
-	}
-
-	/**
-	 * return share type, can be "file" or "folder"
-	 *
-	 * @return string
-	 */
-	public function getItemType() {
-		return $this->superShare->getNodeType();
-	}
-
-	/**
-	 * @param string $path
-	 * @param null $storage
-	 * @return Cache
-	 */
-	public function getCache($path = '', $storage = null) {
-		if ($this->cache) {
-			return $this->cache;
-		}
-		if (!$storage) {
-			$storage = $this;
-		}
-		$sourceRoot  = $this->getSourceRootInfo();
-		if ($this->storage instanceof FailedStorage) {
-			return new FailedCache();
-		}
-
-		$this->cache = new \OCA\Files_Sharing\Cache($storage, $sourceRoot, $this->superShare);
-		return $this->cache;
-	}
-
-	public function getScanner($path = '', $storage = null) {
-		if (!$storage) {
-			$storage = $this;
-		}
-		return new \OCA\Files_Sharing\Scanner($storage);
-	}
-
-	public function getOwner($path) {
-		return $this->superShare->getShareOwner();
-	}
-
-	/**
-	 * unshare complete storage, also the grouped shares
-	 *
-	 * @return bool
-	 */
-	public function unshareStorage() {
-		foreach ($this->groupedShares as $share) {
-			\OC::$server->getShareManager()->deleteFromSelf($share, $this->user);
-		}
-		return true;
-	}
-
-	/**
-	 * @param string $path
-	 * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
-	 * @param \OCP\Lock\ILockingProvider $provider
-	 * @throws \OCP\Lock\LockedException
-	 */
-	public function acquireLock($path, $type, ILockingProvider $provider) {
-		/** @var \OCP\Files\Storage $targetStorage */
-		list($targetStorage, $targetInternalPath) = $this->resolvePath($path);
-		$targetStorage->acquireLock($targetInternalPath, $type, $provider);
-		// lock the parent folders of the owner when locking the share as recipient
-		if ($path === '') {
-			$sourcePath = $this->ownerView->getPath($this->superShare->getNodeId());
-			$this->ownerView->lockFile(dirname($sourcePath), ILockingProvider::LOCK_SHARED, true);
-		}
-	}
-
-	/**
-	 * @param string $path
-	 * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
-	 * @param \OCP\Lock\ILockingProvider $provider
-	 */
-	public function releaseLock($path, $type, ILockingProvider $provider) {
-		/** @var \OCP\Files\Storage $targetStorage */
-		list($targetStorage, $targetInternalPath) = $this->resolvePath($path);
-		$targetStorage->releaseLock($targetInternalPath, $type, $provider);
-		// unlock the parent folders of the owner when unlocking the share as recipient
-		if ($path === '') {
-			$sourcePath = $this->ownerView->getPath($this->superShare->getNodeId());
-			$this->ownerView->unlockFile(dirname($sourcePath), ILockingProvider::LOCK_SHARED, true);
-		}
-	}
-
-	/**
-	 * @param string $path
-	 * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
-	 * @param \OCP\Lock\ILockingProvider $provider
-	 */
-	public function changeLock($path, $type, ILockingProvider $provider) {
-		/** @var \OCP\Files\Storage $targetStorage */
-		list($targetStorage, $targetInternalPath) = $this->resolvePath($path);
-		$targetStorage->changeLock($targetInternalPath, $type, $provider);
-	}
-
-	/**
-	 * @return array [ available, last_checked ]
-	 */
-	public function getAvailability() {
-		// shares do not participate in availability logic
-		return [
-			'available' => true,
-			'last_checked' => 0
-		];
-	}
-
-	/**
-	 * @param bool $available
-	 */
-	public function setAvailability($available) {
-		// shares do not participate in availability logic
-	}
-
-	public function getSourceStorage() {
-		$this->init();
-		return $this->nonMaskedStorage;
-	}
-
-	public function getWrapperStorage() {
-		$this->init();
-		return $this->storage;
-	}
-
-	public function file_get_contents($path) {
-		$info = [
-			'target' => $this->getMountPoint() . '/' . $path,
-			'source' => $this->getUnjailedPath($path),
-		];
-		\OCP\Util::emitHook('\OC\Files\Storage\Shared', 'file_get_contents', $info);
-		return parent::file_get_contents($path);
-	}
-
-	public function file_put_contents($path, $data) {
-		$info = [
-			'target' => $this->getMountPoint() . '/' . $path,
-			'source' => $this->getUnjailedPath($path),
-		];
-		\OCP\Util::emitHook('\OC\Files\Storage\Shared', 'file_put_contents', $info);
-		return parent::file_put_contents($path, $data);
-	}
-
-	public function setMountOptions(array $options) {
-		$this->mountOptions = $options;
-	}
+    /** @var \OCP\Share\IShare */
+    private $superShare;
+
+    /** @var \OCP\Share\IShare[] */
+    private $groupedShares;
+
+    /**
+     * @var \OC\Files\View
+     */
+    private $ownerView;
+
+    private $initialized = false;
+
+    /**
+     * @var ICacheEntry
+     */
+    private $sourceRootInfo;
+
+    /** @var string */
+    private $user;
+
+    /**
+     * @var \OCP\ILogger
+     */
+    private $logger;
+
+    /** @var  IStorage */
+    private $nonMaskedStorage;
+
+    private $options;
+
+    /** @var boolean */
+    private $sharingDisabledForUser;
+
+    public function __construct($arguments) {
+        $this->ownerView = $arguments['ownerView'];
+        $this->logger = \OC::$server->getLogger();
+
+        $this->superShare = $arguments['superShare'];
+        $this->groupedShares = $arguments['groupedShares'];
+
+        $this->user = $arguments['user'];
+        if (isset($arguments['sharingDisabledForUser'])) {
+            $this->sharingDisabledForUser = $arguments['sharingDisabledForUser'];
+        } else {
+            $this->sharingDisabledForUser = false;
+        }
+
+        parent::__construct([
+            'storage' => null,
+            'root' => null,
+        ]);
+    }
+
+    /**
+     * @return ICacheEntry
+     */
+    private function getSourceRootInfo() {
+        if (is_null($this->sourceRootInfo)) {
+            if (is_null($this->superShare->getNodeCacheEntry())) {
+                $this->init();
+                $this->sourceRootInfo = $this->nonMaskedStorage->getCache()->get($this->rootPath);
+            } else {
+                $this->sourceRootInfo = $this->superShare->getNodeCacheEntry();
+            }
+        }
+        return $this->sourceRootInfo;
+    }
+
+    private function init() {
+        if ($this->initialized) {
+            return;
+        }
+        $this->initialized = true;
+        try {
+            Filesystem::initMountPoints($this->superShare->getShareOwner());
+            $sourcePath = $this->ownerView->getPath($this->superShare->getNodeId());
+            list($this->nonMaskedStorage, $this->rootPath) = $this->ownerView->resolvePath($sourcePath);
+            $this->storage = new PermissionsMask([
+                'storage' => $this->nonMaskedStorage,
+                'mask' => $this->superShare->getPermissions()
+            ]);
+        } catch (NotFoundException $e) {
+            // original file not accessible or deleted, set FailedStorage
+            $this->storage = new FailedStorage(['exception' => $e]);
+            $this->cache = new FailedCache();
+            $this->rootPath = '';
+        } catch (NoUserException $e) {
+            // sharer user deleted, set FailedStorage
+            $this->storage = new FailedStorage(['exception' => $e]);
+            $this->cache = new FailedCache();
+            $this->rootPath = '';
+        } catch (\Exception $e) {
+            $this->storage = new FailedStorage(['exception' => $e]);
+            $this->cache = new FailedCache();
+            $this->rootPath = '';
+            $this->logger->logException($e);
+        }
+
+        if (!$this->nonMaskedStorage) {
+            $this->nonMaskedStorage = $this->storage;
+        }
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public function instanceOfStorage($class) {
+        if ($class === '\OC\Files\Storage\Common') {
+            return true;
+        }
+        if (in_array($class, ['\OC\Files\Storage\Home', '\OC\Files\ObjectStore\HomeObjectStoreStorage'])) {
+            return false;
+        }
+        return parent::instanceOfStorage($class);
+    }
+
+    /**
+     * @return string
+     */
+    public function getShareId() {
+        return $this->superShare->getId();
+    }
+
+    private function isValid() {
+        return $this->getSourceRootInfo() && ($this->getSourceRootInfo()->getPermissions() & Constants::PERMISSION_SHARE) === Constants::PERMISSION_SHARE;
+    }
+
+    /**
+     * get id of the mount point
+     *
+     * @return string
+     */
+    public function getId() {
+        return 'shared::' . $this->getMountPoint();
+    }
+
+    /**
+     * Get the permissions granted for a shared file
+     *
+     * @param string $target Shared target file path
+     * @return int CRUDS permissions granted
+     */
+    public function getPermissions($target = '') {
+        if (!$this->isValid()) {
+            return 0;
+        }
+        $permissions = parent::getPermissions($target) & $this->superShare->getPermissions();
+
+        // part files and the mount point always have delete permissions
+        if ($target === '' || pathinfo($target, PATHINFO_EXTENSION) === 'part') {
+            $permissions |= \OCP\Constants::PERMISSION_DELETE;
+        }
+
+        if ($this->sharingDisabledForUser) {
+            $permissions &= ~\OCP\Constants::PERMISSION_SHARE;
+        }
+
+        return $permissions;
+    }
+
+    public function isCreatable($path) {
+        return ($this->getPermissions($path) & \OCP\Constants::PERMISSION_CREATE);
+    }
+
+    public function isReadable($path) {
+        if (!$this->isValid()) {
+            return false;
+        }
+        if (!$this->file_exists($path)) {
+            return false;
+        }
+        /** @var IStorage $storage */
+        /** @var string $internalPath */
+        list($storage, $internalPath) = $this->resolvePath($path);
+        return $storage->isReadable($internalPath);
+    }
+
+    public function isUpdatable($path) {
+        return ($this->getPermissions($path) & \OCP\Constants::PERMISSION_UPDATE);
+    }
+
+    public function isDeletable($path) {
+        return ($this->getPermissions($path) & \OCP\Constants::PERMISSION_DELETE);
+    }
+
+    public function isSharable($path) {
+        if (\OCP\Util::isSharingDisabledForUser() || !\OC\Share\Share::isResharingAllowed()) {
+            return false;
+        }
+        return ($this->getPermissions($path) & \OCP\Constants::PERMISSION_SHARE);
+    }
+
+    public function fopen($path, $mode) {
+        if ($source = $this->getUnjailedPath($path)) {
+            switch ($mode) {
+                case 'r+':
+                case 'rb+':
+                case 'w+':
+                case 'wb+':
+                case 'x+':
+                case 'xb+':
+                case 'a+':
+                case 'ab+':
+                case 'w':
+                case 'wb':
+                case 'x':
+                case 'xb':
+                case 'a':
+                case 'ab':
+                    $creatable = $this->isCreatable(dirname($path));
+                    $updatable = $this->isUpdatable($path);
+                    // if neither permissions given, no need to continue
+                    if (!$creatable && !$updatable) {
+                        if (pathinfo($path, PATHINFO_EXTENSION) === 'part') {
+                            $updatable = $this->isUpdatable(dirname($path));
+                        }
+
+                        if (!$updatable) {
+                            return false;
+                        }
+                    }
+
+                    $exists = $this->file_exists($path);
+                    // if a file exists, updatable permissions are required
+                    if ($exists && !$updatable) {
+                        return false;
+                    }
+
+                    // part file is allowed if !$creatable but the final file is $updatable
+                    if (pathinfo($path, PATHINFO_EXTENSION) !== 'part') {
+                        if (!$exists && !$creatable) {
+                            return false;
+                        }
+                    }
+            }
+            $info = array(
+                'target' => $this->getMountPoint() . $path,
+                'source' => $source,
+                'mode' => $mode,
+            );
+            \OCP\Util::emitHook('\OC\Files\Storage\Shared', 'fopen', $info);
+            return $this->nonMaskedStorage->fopen($this->getUnjailedPath($path), $mode);
+        }
+        return false;
+    }
+
+    /**
+     * see http://php.net/manual/en/function.rename.php
+     *
+     * @param string $path1
+     * @param string $path2
+     * @return bool
+     */
+    public function rename($path1, $path2) {
+        $this->init();
+        $isPartFile = pathinfo($path1, PATHINFO_EXTENSION) === 'part';
+        $targetExists = $this->file_exists($path2);
+        $sameFodler = dirname($path1) === dirname($path2);
+
+        if ($targetExists || ($sameFodler && !$isPartFile)) {
+            if (!$this->isUpdatable('')) {
+                return false;
+            }
+        } else {
+            if (!$this->isCreatable('')) {
+                return false;
+            }
+        }
+
+        return $this->nonMaskedStorage->rename($this->getUnjailedPath($path1), $this->getUnjailedPath($path2));
+    }
+
+    /**
+     * return mount point of share, relative to data/user/files
+     *
+     * @return string
+     */
+    public function getMountPoint() {
+        return $this->superShare->getTarget();
+    }
+
+    /**
+     * @param string $path
+     */
+    public function setMountPoint($path) {
+        $this->superShare->setTarget($path);
+
+        foreach ($this->groupedShares as $share) {
+            $share->setTarget($path);
+        }
+    }
+
+    /**
+     * get the user who shared the file
+     *
+     * @return string
+     */
+    public function getSharedFrom() {
+        return $this->superShare->getShareOwner();
+    }
+
+    /**
+     * @return \OCP\Share\IShare
+     */
+    public function getShare() {
+        return $this->superShare;
+    }
+
+    /**
+     * return share type, can be "file" or "folder"
+     *
+     * @return string
+     */
+    public function getItemType() {
+        return $this->superShare->getNodeType();
+    }
+
+    /**
+     * @param string $path
+     * @param null $storage
+     * @return Cache
+     */
+    public function getCache($path = '', $storage = null) {
+        if ($this->cache) {
+            return $this->cache;
+        }
+        if (!$storage) {
+            $storage = $this;
+        }
+        $sourceRoot  = $this->getSourceRootInfo();
+        if ($this->storage instanceof FailedStorage) {
+            return new FailedCache();
+        }
+
+        $this->cache = new \OCA\Files_Sharing\Cache($storage, $sourceRoot, $this->superShare);
+        return $this->cache;
+    }
+
+    public function getScanner($path = '', $storage = null) {
+        if (!$storage) {
+            $storage = $this;
+        }
+        return new \OCA\Files_Sharing\Scanner($storage);
+    }
+
+    public function getOwner($path) {
+        return $this->superShare->getShareOwner();
+    }
+
+    /**
+     * unshare complete storage, also the grouped shares
+     *
+     * @return bool
+     */
+    public function unshareStorage() {
+        foreach ($this->groupedShares as $share) {
+            \OC::$server->getShareManager()->deleteFromSelf($share, $this->user);
+        }
+        return true;
+    }
+
+    /**
+     * @param string $path
+     * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
+     * @param \OCP\Lock\ILockingProvider $provider
+     * @throws \OCP\Lock\LockedException
+     */
+    public function acquireLock($path, $type, ILockingProvider $provider) {
+        /** @var \OCP\Files\Storage $targetStorage */
+        list($targetStorage, $targetInternalPath) = $this->resolvePath($path);
+        $targetStorage->acquireLock($targetInternalPath, $type, $provider);
+        // lock the parent folders of the owner when locking the share as recipient
+        if ($path === '') {
+            $sourcePath = $this->ownerView->getPath($this->superShare->getNodeId());
+            $this->ownerView->lockFile(dirname($sourcePath), ILockingProvider::LOCK_SHARED, true);
+        }
+    }
+
+    /**
+     * @param string $path
+     * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
+     * @param \OCP\Lock\ILockingProvider $provider
+     */
+    public function releaseLock($path, $type, ILockingProvider $provider) {
+        /** @var \OCP\Files\Storage $targetStorage */
+        list($targetStorage, $targetInternalPath) = $this->resolvePath($path);
+        $targetStorage->releaseLock($targetInternalPath, $type, $provider);
+        // unlock the parent folders of the owner when unlocking the share as recipient
+        if ($path === '') {
+            $sourcePath = $this->ownerView->getPath($this->superShare->getNodeId());
+            $this->ownerView->unlockFile(dirname($sourcePath), ILockingProvider::LOCK_SHARED, true);
+        }
+    }
+
+    /**
+     * @param string $path
+     * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
+     * @param \OCP\Lock\ILockingProvider $provider
+     */
+    public function changeLock($path, $type, ILockingProvider $provider) {
+        /** @var \OCP\Files\Storage $targetStorage */
+        list($targetStorage, $targetInternalPath) = $this->resolvePath($path);
+        $targetStorage->changeLock($targetInternalPath, $type, $provider);
+    }
+
+    /**
+     * @return array [ available, last_checked ]
+     */
+    public function getAvailability() {
+        // shares do not participate in availability logic
+        return [
+            'available' => true,
+            'last_checked' => 0
+        ];
+    }
+
+    /**
+     * @param bool $available
+     */
+    public function setAvailability($available) {
+        // shares do not participate in availability logic
+    }
+
+    public function getSourceStorage() {
+        $this->init();
+        return $this->nonMaskedStorage;
+    }
+
+    public function getWrapperStorage() {
+        $this->init();
+        return $this->storage;
+    }
+
+    public function file_get_contents($path) {
+        $info = [
+            'target' => $this->getMountPoint() . '/' . $path,
+            'source' => $this->getUnjailedPath($path),
+        ];
+        \OCP\Util::emitHook('\OC\Files\Storage\Shared', 'file_get_contents', $info);
+        return parent::file_get_contents($path);
+    }
+
+    public function file_put_contents($path, $data) {
+        $info = [
+            'target' => $this->getMountPoint() . '/' . $path,
+            'source' => $this->getUnjailedPath($path),
+        ];
+        \OCP\Util::emitHook('\OC\Files\Storage\Shared', 'file_put_contents', $info);
+        return parent::file_put_contents($path, $data);
+    }
+
+    public function setMountOptions(array $options) {
+        $this->mountOptions = $options;
+    }
 }

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

Indentation +36 added lines, -36 removed lines

@@ -36,46 +36,46 @@
  *
  */
 class OwnCloud extends \OC\Files\Storage\DAV implements IDisableEncryptionStorage {
-	const OC_URL_SUFFIX = 'remote.php/webdav';
+    const OC_URL_SUFFIX = 'remote.php/webdav';
 
-	public function __construct($params) {
-		// extract context path from host if specified
-		// (owncloud install path on host)
-		$host = $params['host'];
-		// strip protocol
-		if (substr($host, 0, 8) === "https://") {
-			$host = substr($host, 8);
-			$params['secure'] = true;
-		} else if (substr($host, 0, 7) === "http://") {
-			$host = substr($host, 7);
-			$params['secure'] = false;
-		}
-		$contextPath = '';
-		$hostSlashPos = strpos($host, '/');
-		if ($hostSlashPos !== false){
-			$contextPath = substr($host, $hostSlashPos);
-			$host = substr($host, 0, $hostSlashPos);
-		}
+    public function __construct($params) {
+        // extract context path from host if specified
+        // (owncloud install path on host)
+        $host = $params['host'];
+        // strip protocol
+        if (substr($host, 0, 8) === "https://") {
+            $host = substr($host, 8);
+            $params['secure'] = true;
+        } else if (substr($host, 0, 7) === "http://") {
+            $host = substr($host, 7);
+            $params['secure'] = false;
+        }
+        $contextPath = '';
+        $hostSlashPos = strpos($host, '/');
+        if ($hostSlashPos !== false){
+            $contextPath = substr($host, $hostSlashPos);
+            $host = substr($host, 0, $hostSlashPos);
+        }
 
-		if (substr($contextPath, -1) !== '/'){
-			$contextPath .= '/';
-		}
+        if (substr($contextPath, -1) !== '/'){
+            $contextPath .= '/';
+        }
 
-		if (isset($params['root'])){
-			$root = '/' . ltrim($params['root'], '/');
-		}
-		else{
-			$root = '/';
-		}
+        if (isset($params['root'])){
+            $root = '/' . ltrim($params['root'], '/');
+        }
+        else{
+            $root = '/';
+        }
 
-		$params['host'] = $host;
-		$params['root'] = $contextPath . self::OC_URL_SUFFIX . $root;
-		$params['authType'] = Client::AUTH_BASIC;
+        $params['host'] = $host;
+        $params['root'] = $contextPath . self::OC_URL_SUFFIX . $root;
+        $params['authType'] = Client::AUTH_BASIC;
 
-		parent::__construct($params);
-	}
+        parent::__construct($params);
+    }
 
-	public function needsPartFile() {
-		return false;
-	}
+    public function needsPartFile() {
+        return false;
+    }
 }

Spacing +6 added lines, -6 removed lines

@@ -52,24 +52,24 @@
 		}
 		$contextPath = '';
 		$hostSlashPos = strpos($host, '/');
-		if ($hostSlashPos !== false){
+		if ($hostSlashPos !== false) {
 			$contextPath = substr($host, $hostSlashPos);
 			$host = substr($host, 0, $hostSlashPos);
 		}
 
-		if (substr($contextPath, -1) !== '/'){
+		if (substr($contextPath, -1) !== '/') {
 			$contextPath .= '/';
 		}
 
-		if (isset($params['root'])){
-			$root = '/' . ltrim($params['root'], '/');
+		if (isset($params['root'])) {
+			$root = '/'.ltrim($params['root'], '/');
 		}
-		else{
+		else {
 			$root = '/';
 		}
 
 		$params['host'] = $host;
-		$params['root'] = $contextPath . self::OC_URL_SUFFIX . $root;
+		$params['root'] = $contextPath.self::OC_URL_SUFFIX.$root;
 		$params['authType'] = Client::AUTH_BASIC;
 
 		parent::__construct($params);