2011-06-12 00:14:24 +04:00
|
|
|
<?php
|
|
|
|
/**
|
2016-07-21 17:49:16 +03:00
|
|
|
* @copyright Copyright (c) 2016, ownCloud, Inc.
|
|
|
|
*
|
2015-03-26 13:44:34 +03:00
|
|
|
* @author Bart Visscher <bartv@thisnet.nl>
|
2016-05-26 20:56:05 +03:00
|
|
|
* @author Björn Schießle <bjoern@schiessle.org>
|
2016-07-21 17:49:16 +03:00
|
|
|
* @author Joas Schilling <coding@schilljs.com>
|
2015-03-26 13:44:34 +03:00
|
|
|
* @author Michael Gapczynski <GapczynskiM@gmail.com>
|
|
|
|
* @author Morris Jobke <hey@morrisjobke.de>
|
2016-07-21 19:13:36 +03:00
|
|
|
* @author Robin Appelman <robin@icewind.nl>
|
2016-01-12 17:02:16 +03:00
|
|
|
* @author Robin McCorkell <robin@mccorkell.me.uk>
|
2016-07-21 17:49:16 +03:00
|
|
|
* @author Roeland Jago Douma <roeland@famdouma.nl>
|
2015-03-26 13:44:34 +03:00
|
|
|
* @author scambra <sergio@entrecables.com>
|
2017-11-06 17:56:42 +03:00
|
|
|
* @author Thomas Müller <thomas.mueller@tmit.eu>
|
2015-03-26 13:44:34 +03:00
|
|
|
* @author Vincent Petry <pvince81@owncloud.com>
|
2011-06-12 00:14:24 +04:00
|
|
|
*
|
2015-03-26 13:44:34 +03:00
|
|
|
* @license AGPL-3.0
|
2011-06-12 00:14:24 +04:00
|
|
|
*
|
2015-03-26 13:44:34 +03:00
|
|
|
* This code is free software: you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU Affero General Public License, version 3,
|
|
|
|
* as published by the Free Software Foundation.
|
2011-06-12 00:14:24 +04:00
|
|
|
*
|
2015-03-26 13:44:34 +03:00
|
|
|
* This program is distributed in the hope that it will be useful,
|
2011-06-12 00:14:24 +04:00
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
2015-03-26 13:44:34 +03:00
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU Affero General Public License for more details.
|
2011-06-12 00:14:24 +04:00
|
|
|
*
|
2015-03-26 13:44:34 +03:00
|
|
|
* You should have received a copy of the GNU Affero General Public License, version 3,
|
2019-12-03 21:57:53 +03:00
|
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>
|
2011-06-12 00:14:24 +04:00
|
|
|
*
|
|
|
|
*/
|
2015-02-26 13:37:37 +03:00
|
|
|
|
2016-06-01 15:29:31 +03:00
|
|
|
namespace OCA\Files_Sharing;
|
2015-03-09 18:20:18 +03:00
|
|
|
|
2017-03-20 20:31:34 +03:00
|
|
|
use OC\Files\Cache\FailedCache;
|
2020-09-15 17:29:21 +03:00
|
|
|
use OC\Files\Cache\LazyWatcher;
|
|
|
|
use OC\Files\Cache\NullWatcher;
|
2014-05-22 03:41:27 +04:00
|
|
|
use OC\Files\Filesystem;
|
2016-10-24 15:33:54 +03:00
|
|
|
use OC\Files\Storage\FailedStorage;
|
2019-11-22 22:52:10 +03:00
|
|
|
use OC\Files\Storage\Wrapper\PermissionsMask;
|
|
|
|
use OC\User\NoUserException;
|
2016-01-29 15:05:53 +03:00
|
|
|
use OCP\Constants;
|
2016-01-22 15:01:37 +03:00
|
|
|
use OCP\Files\Cache\ICacheEntry;
|
2016-08-23 20:15:28 +03:00
|
|
|
use OCP\Files\NotFoundException;
|
2018-11-27 18:54:00 +03:00
|
|
|
use OCP\Files\Storage\IDisableEncryptionStorage;
|
2016-01-22 15:01:37 +03:00
|
|
|
use OCP\Files\Storage\IStorage;
|
2015-05-04 15:21:34 +03:00
|
|
|
use OCP\Lock\ILockingProvider;
|
2012-09-07 20:30:48 +04:00
|
|
|
|
2011-06-16 22:40:21 +04:00
|
|
|
/**
|
|
|
|
* Convert target path to source path and pass the function call to the correct storage provider
|
|
|
|
*/
|
2018-11-27 18:54:00 +03:00
|
|
|
class SharedStorage extends \OC\Files\Storage\Wrapper\Jail implements ISharedStorage, IDisableEncryptionStorage {
|
2016-06-01 15:29:31 +03:00
|
|
|
|
2016-04-15 10:01:10 +03:00
|
|
|
/** @var \OCP\Share\IShare */
|
2016-06-15 10:47:33 +03:00
|
|
|
private $superShare;
|
|
|
|
|
|
|
|
/** @var \OCP\Share\IShare[] */
|
|
|
|
private $groupedShares;
|
2012-08-29 10:42:49 +04:00
|
|
|
|
2015-06-29 20:13:39 +03:00
|
|
|
/**
|
|
|
|
* @var \OC\Files\View
|
|
|
|
*/
|
|
|
|
private $ownerView;
|
|
|
|
|
2015-09-04 17:48:45 +03:00
|
|
|
private $initialized = false;
|
|
|
|
|
2016-01-22 15:01:37 +03:00
|
|
|
/**
|
|
|
|
* @var ICacheEntry
|
|
|
|
*/
|
|
|
|
private $sourceRootInfo;
|
|
|
|
|
2016-04-15 10:01:10 +03:00
|
|
|
/** @var string */
|
|
|
|
private $user;
|
|
|
|
|
2016-03-09 18:44:57 +03:00
|
|
|
/**
|
|
|
|
* @var \OCP\ILogger
|
|
|
|
*/
|
|
|
|
private $logger;
|
|
|
|
|
2016-12-02 19:59:02 +03:00
|
|
|
/** @var IStorage */
|
|
|
|
private $nonMaskedStorage;
|
|
|
|
|
2016-11-17 16:18:47 +03:00
|
|
|
private $options;
|
|
|
|
|
2018-08-16 21:24:02 +03:00
|
|
|
/** @var boolean */
|
|
|
|
private $sharingDisabledForUser;
|
|
|
|
|
2011-07-12 21:10:29 +04:00
|
|
|
public function __construct($arguments) {
|
2015-06-29 20:13:39 +03:00
|
|
|
$this->ownerView = $arguments['ownerView'];
|
2016-03-09 18:44:57 +03:00
|
|
|
$this->logger = \OC::$server->getLogger();
|
2016-06-15 10:47:33 +03:00
|
|
|
|
|
|
|
$this->superShare = $arguments['superShare'];
|
|
|
|
$this->groupedShares = $arguments['groupedShares'];
|
|
|
|
|
2016-04-15 10:01:10 +03:00
|
|
|
$this->user = $arguments['user'];
|
2018-08-16 21:24:02 +03:00
|
|
|
if (isset($arguments['sharingDisabledForUser'])) {
|
|
|
|
$this->sharingDisabledForUser = $arguments['sharingDisabledForUser'];
|
|
|
|
} else {
|
|
|
|
$this->sharingDisabledForUser = false;
|
|
|
|
}
|
2016-04-15 10:01:10 +03:00
|
|
|
|
|
|
|
parent::__construct([
|
2016-08-22 13:27:56 +03:00
|
|
|
'storage' => null,
|
|
|
|
'root' => null,
|
2016-04-15 10:01:10 +03:00
|
|
|
]);
|
2011-06-16 22:40:21 +04:00
|
|
|
}
|
2012-06-23 01:43:04 +04:00
|
|
|
|
2016-11-17 16:18:47 +03:00
|
|
|
/**
|
|
|
|
* @return ICacheEntry
|
|
|
|
*/
|
|
|
|
private function getSourceRootInfo() {
|
|
|
|
if (is_null($this->sourceRootInfo)) {
|
|
|
|
if (is_null($this->superShare->getNodeCacheEntry())) {
|
2017-03-20 20:02:21 +03:00
|
|
|
$this->init();
|
2016-12-02 19:59:02 +03:00
|
|
|
$this->sourceRootInfo = $this->nonMaskedStorage->getCache()->get($this->rootPath);
|
2016-11-17 16:18:47 +03:00
|
|
|
} else {
|
|
|
|
$this->sourceRootInfo = $this->superShare->getNodeCacheEntry();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return $this->sourceRootInfo;
|
|
|
|
}
|
|
|
|
|
2015-09-03 14:46:08 +03:00
|
|
|
private function init() {
|
2015-09-04 17:48:45 +03:00
|
|
|
if ($this->initialized) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
$this->initialized = true;
|
2016-03-09 18:44:57 +03:00
|
|
|
try {
|
2016-06-15 10:47:33 +03:00
|
|
|
Filesystem::initMountPoints($this->superShare->getShareOwner());
|
|
|
|
$sourcePath = $this->ownerView->getPath($this->superShare->getNodeId());
|
2020-09-15 17:29:21 +03:00
|
|
|
[$this->nonMaskedStorage, $this->rootPath] = $this->ownerView->resolvePath($sourcePath);
|
2016-12-02 19:59:02 +03:00
|
|
|
$this->storage = new PermissionsMask([
|
|
|
|
'storage' => $this->nonMaskedStorage,
|
|
|
|
'mask' => $this->superShare->getPermissions()
|
|
|
|
]);
|
2016-08-23 20:15:28 +03:00
|
|
|
} catch (NotFoundException $e) {
|
2017-01-25 14:22:09 +03:00
|
|
|
// original file not accessible or deleted, set FailedStorage
|
|
|
|
$this->storage = new FailedStorage(['exception' => $e]);
|
2017-03-23 17:01:23 +03:00
|
|
|
$this->cache = new FailedCache();
|
2017-01-25 14:22:09 +03:00
|
|
|
$this->rootPath = '';
|
|
|
|
} catch (NoUserException $e) {
|
|
|
|
// sharer user deleted, set FailedStorage
|
2016-08-23 20:15:28 +03:00
|
|
|
$this->storage = new FailedStorage(['exception' => $e]);
|
2017-03-23 17:01:23 +03:00
|
|
|
$this->cache = new FailedCache();
|
2016-08-23 20:15:28 +03:00
|
|
|
$this->rootPath = '';
|
2016-03-09 18:44:57 +03:00
|
|
|
} catch (\Exception $e) {
|
2016-08-22 13:32:39 +03:00
|
|
|
$this->storage = new FailedStorage(['exception' => $e]);
|
2017-03-23 17:01:23 +03:00
|
|
|
$this->cache = new FailedCache();
|
2016-08-22 13:32:39 +03:00
|
|
|
$this->rootPath = '';
|
2016-03-09 18:44:57 +03:00
|
|
|
$this->logger->logException($e);
|
|
|
|
}
|
2017-03-20 20:02:21 +03:00
|
|
|
|
|
|
|
if (!$this->nonMaskedStorage) {
|
|
|
|
$this->nonMaskedStorage = $this->storage;
|
|
|
|
}
|
2015-09-03 14:46:08 +03:00
|
|
|
}
|
|
|
|
|
2016-08-01 15:22:30 +03:00
|
|
|
/**
|
|
|
|
* @inheritdoc
|
|
|
|
*/
|
|
|
|
public function instanceOfStorage($class) {
|
2016-11-17 16:18:47 +03:00
|
|
|
if ($class === '\OC\Files\Storage\Common') {
|
|
|
|
return true;
|
|
|
|
}
|
2020-09-15 17:29:21 +03:00
|
|
|
if (in_array($class, ['\OC\Files\Storage\Home', '\OC\Files\ObjectStore\HomeObjectStoreStorage', '\OCP\Files\IHomeStorage'])) {
|
2016-08-01 15:22:30 +03:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return parent::instanceOfStorage($class);
|
|
|
|
}
|
|
|
|
|
2016-06-15 10:47:33 +03:00
|
|
|
/**
|
|
|
|
* @return string
|
|
|
|
*/
|
|
|
|
public function getShareId() {
|
|
|
|
return $this->superShare->getId();
|
|
|
|
}
|
|
|
|
|
2016-01-29 15:05:53 +03:00
|
|
|
private function isValid() {
|
2016-11-17 16:18:47 +03:00
|
|
|
return $this->getSourceRootInfo() && ($this->getSourceRootInfo()->getPermissions() & Constants::PERMISSION_SHARE) === Constants::PERMISSION_SHARE;
|
2016-01-29 15:05:53 +03:00
|
|
|
}
|
|
|
|
|
2014-04-04 20:32:49 +04:00
|
|
|
/**
|
2014-05-19 19:50:53 +04:00
|
|
|
* get id of the mount point
|
2015-03-09 18:20:18 +03:00
|
|
|
*
|
2014-04-04 20:32:49 +04:00
|
|
|
* @return string
|
|
|
|
*/
|
2013-11-11 20:58:20 +04:00
|
|
|
public function getId() {
|
2014-04-14 13:33:10 +04:00
|
|
|
return 'shared::' . $this->getMountPoint();
|
2011-06-27 19:47:36 +04:00
|
|
|
}
|
2012-06-23 01:43:04 +04:00
|
|
|
|
2012-07-24 04:08:05 +04:00
|
|
|
/**
|
2014-05-19 19:50:53 +04:00
|
|
|
* Get the permissions granted for a shared file
|
2015-03-09 18:20:18 +03:00
|
|
|
*
|
2014-05-15 16:19:32 +04:00
|
|
|
* @param string $target Shared target file path
|
2014-05-07 18:49:07 +04:00
|
|
|
* @return int CRUDS permissions granted
|
2013-11-11 20:58:20 +04:00
|
|
|
*/
|
2014-05-23 19:15:05 +04:00
|
|
|
public function getPermissions($target = '') {
|
2016-01-29 15:05:53 +03:00
|
|
|
if (!$this->isValid()) {
|
|
|
|
return 0;
|
|
|
|
}
|
2018-09-03 23:56:28 +03:00
|
|
|
$permissions = parent::getPermissions($target) & $this->superShare->getPermissions();
|
|
|
|
|
2014-06-03 21:47:23 +04:00
|
|
|
// part files and the mount point always have delete permissions
|
|
|
|
if ($target === '' || pathinfo($target, PATHINFO_EXTENSION) === 'part') {
|
2014-11-25 18:28:41 +03:00
|
|
|
$permissions |= \OCP\Constants::PERMISSION_DELETE;
|
2012-07-24 04:08:05 +04:00
|
|
|
}
|
2014-05-13 17:22:18 +04:00
|
|
|
|
2018-08-16 21:24:02 +03:00
|
|
|
if ($this->sharingDisabledForUser) {
|
2014-11-25 18:28:41 +03:00
|
|
|
$permissions &= ~\OCP\Constants::PERMISSION_SHARE;
|
2014-05-13 17:22:18 +04:00
|
|
|
}
|
|
|
|
|
2014-05-07 18:49:07 +04:00
|
|
|
return $permissions;
|
2012-07-06 14:22:21 +04:00
|
|
|
}
|
|
|
|
|
2012-07-25 01:42:07 +04:00
|
|
|
public function isCreatable($path) {
|
2014-11-25 18:28:41 +03:00
|
|
|
return ($this->getPermissions($path) & \OCP\Constants::PERMISSION_CREATE);
|
2012-07-25 01:42:07 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
public function isReadable($path) {
|
2016-01-29 15:05:53 +03:00
|
|
|
if (!$this->isValid()) {
|
|
|
|
return false;
|
2015-05-12 19:49:25 +03:00
|
|
|
}
|
2016-01-29 15:05:53 +03:00
|
|
|
if (!$this->file_exists($path)) {
|
|
|
|
return false;
|
|
|
|
}
|
2016-10-24 15:33:54 +03:00
|
|
|
/** @var IStorage $storage */
|
|
|
|
/** @var string $internalPath */
|
2020-09-15 17:29:21 +03:00
|
|
|
[$storage, $internalPath] = $this->resolvePath($path);
|
2016-01-29 15:05:53 +03:00
|
|
|
return $storage->isReadable($internalPath);
|
2011-06-16 22:40:21 +04:00
|
|
|
}
|
2012-07-25 01:42:07 +04:00
|
|
|
|
|
|
|
public function isUpdatable($path) {
|
2014-11-25 18:28:41 +03:00
|
|
|
return ($this->getPermissions($path) & \OCP\Constants::PERMISSION_UPDATE);
|
2011-06-16 22:40:21 +04:00
|
|
|
}
|
2012-07-25 01:42:07 +04:00
|
|
|
|
|
|
|
public function isDeletable($path) {
|
2014-11-25 18:28:41 +03:00
|
|
|
return ($this->getPermissions($path) & \OCP\Constants::PERMISSION_DELETE);
|
2012-07-25 01:42:07 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
public function isSharable($path) {
|
2015-12-08 15:02:57 +03:00
|
|
|
if (\OCP\Util::isSharingDisabledForUser() || !\OC\Share\Share::isResharingAllowed()) {
|
2014-05-13 17:22:18 +04:00
|
|
|
return false;
|
|
|
|
}
|
2014-11-25 18:28:41 +03:00
|
|
|
return ($this->getPermissions($path) & \OCP\Constants::PERMISSION_SHARE);
|
2012-07-25 01:42:07 +04:00
|
|
|
}
|
|
|
|
|
2011-06-16 22:40:21 +04:00
|
|
|
public function fopen($path, $mode) {
|
2020-08-28 12:43:23 +03:00
|
|
|
$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));
|
2013-11-11 20:58:20 +04:00
|
|
|
}
|
2015-01-30 16:19:23 +03:00
|
|
|
|
2020-08-28 12:43:23 +03:00
|
|
|
if (!$updatable) {
|
2013-11-11 20:58:20 +04:00
|
|
|
return false;
|
|
|
|
}
|
2020-08-28 12:43:23 +03:00
|
|
|
}
|
2015-01-30 16:19:23 +03:00
|
|
|
|
2020-08-28 12:43:23 +03:00
|
|
|
$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;
|
2015-01-30 16:19:23 +03:00
|
|
|
}
|
2020-08-28 12:43:23 +03:00
|
|
|
}
|
2011-06-16 22:40:21 +04:00
|
|
|
}
|
2020-08-28 12:43:23 +03:00
|
|
|
$info = [
|
|
|
|
'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);
|
2011-06-16 22:40:21 +04:00
|
|
|
}
|
2012-07-24 22:50:43 +04:00
|
|
|
|
2016-04-15 10:01:10 +03:00
|
|
|
/**
|
|
|
|
* see http://php.net/manual/en/function.rename.php
|
|
|
|
*
|
|
|
|
* @param string $path1
|
|
|
|
* @param string $path2
|
|
|
|
* @return bool
|
|
|
|
*/
|
|
|
|
public function rename($path1, $path2) {
|
2016-12-02 19:59:02 +03:00
|
|
|
$this->init();
|
2016-04-15 10:01:10 +03:00
|
|
|
$isPartFile = pathinfo($path1, PATHINFO_EXTENSION) === 'part';
|
|
|
|
$targetExists = $this->file_exists($path2);
|
|
|
|
$sameFodler = dirname($path1) === dirname($path2);
|
2011-08-20 04:05:57 +04:00
|
|
|
|
2016-04-15 10:01:10 +03:00
|
|
|
if ($targetExists || ($sameFodler && !$isPartFile)) {
|
|
|
|
if (!$this->isUpdatable('')) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (!$this->isCreatable('')) {
|
|
|
|
return false;
|
|
|
|
}
|
2011-08-20 04:05:57 +04:00
|
|
|
}
|
2013-11-11 20:58:20 +04:00
|
|
|
|
2017-04-12 15:55:47 +03:00
|
|
|
return $this->nonMaskedStorage->rename($this->getUnjailedPath($path1), $this->getUnjailedPath($path2));
|
2012-03-01 02:42:40 +04:00
|
|
|
}
|
2012-05-11 03:56:25 +04:00
|
|
|
|
2014-04-14 13:33:10 +04:00
|
|
|
/**
|
2014-04-30 18:56:09 +04:00
|
|
|
* return mount point of share, relative to data/user/files
|
|
|
|
*
|
|
|
|
* @return string
|
2014-04-14 13:33:10 +04:00
|
|
|
*/
|
2014-04-30 18:56:09 +04:00
|
|
|
public function getMountPoint() {
|
2016-06-15 10:47:33 +03:00
|
|
|
return $this->superShare->getTarget();
|
2014-05-22 03:41:27 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2016-04-15 10:01:10 +03:00
|
|
|
* @param string $path
|
2014-05-22 03:41:27 +04:00
|
|
|
*/
|
2016-04-15 10:01:10 +03:00
|
|
|
public function setMountPoint($path) {
|
2016-06-15 10:47:33 +03:00
|
|
|
$this->superShare->setTarget($path);
|
2014-04-14 14:04:12 +04:00
|
|
|
|
2016-06-15 10:47:33 +03:00
|
|
|
foreach ($this->groupedShares as $share) {
|
|
|
|
$share->setTarget($path);
|
|
|
|
}
|
2014-05-22 03:41:27 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* get the user who shared the file
|
2015-03-09 18:20:18 +03:00
|
|
|
*
|
2014-04-08 18:37:34 +04:00
|
|
|
* @return string
|
|
|
|
*/
|
|
|
|
public function getSharedFrom() {
|
2016-06-15 10:47:33 +03:00
|
|
|
return $this->superShare->getShareOwner();
|
2014-04-08 18:37:34 +04:00
|
|
|
}
|
|
|
|
|
2014-05-22 03:41:27 +04:00
|
|
|
/**
|
2016-04-15 10:01:10 +03:00
|
|
|
* @return \OCP\Share\IShare
|
2014-05-22 03:41:27 +04:00
|
|
|
*/
|
|
|
|
public function getShare() {
|
2016-06-15 10:47:33 +03:00
|
|
|
return $this->superShare;
|
2014-05-22 03:41:27 +04:00
|
|
|
}
|
|
|
|
|
2014-04-02 14:04:51 +04:00
|
|
|
/**
|
2014-05-19 19:50:53 +04:00
|
|
|
* return share type, can be "file" or "folder"
|
2015-03-09 18:20:18 +03:00
|
|
|
*
|
2014-04-02 14:04:51 +04:00
|
|
|
* @return string
|
|
|
|
*/
|
2014-04-14 13:33:10 +04:00
|
|
|
public function getItemType() {
|
2016-06-15 10:47:33 +03:00
|
|
|
return $this->superShare->getNodeType();
|
2013-01-01 20:19:33 +04:00
|
|
|
}
|
|
|
|
|
2017-03-27 15:05:01 +03:00
|
|
|
/**
|
|
|
|
* @param string $path
|
|
|
|
* @param null $storage
|
|
|
|
* @return Cache
|
|
|
|
*/
|
2014-06-12 19:23:34 +04:00
|
|
|
public function getCache($path = '', $storage = null) {
|
2016-11-17 13:48:29 +03:00
|
|
|
if ($this->cache) {
|
|
|
|
return $this->cache;
|
|
|
|
}
|
2014-06-12 19:23:34 +04:00
|
|
|
if (!$storage) {
|
|
|
|
$storage = $this;
|
|
|
|
}
|
2018-10-16 11:57:37 +03:00
|
|
|
$sourceRoot = $this->getSourceRootInfo();
|
2017-03-20 20:31:34 +03:00
|
|
|
if ($this->storage instanceof FailedStorage) {
|
|
|
|
return new FailedCache();
|
|
|
|
}
|
2018-10-16 11:57:37 +03:00
|
|
|
|
|
|
|
$this->cache = new \OCA\Files_Sharing\Cache($storage, $sourceRoot, $this->superShare);
|
2016-11-17 13:48:29 +03:00
|
|
|
return $this->cache;
|
2012-06-15 18:43:24 +04:00
|
|
|
}
|
2012-09-23 03:51:00 +04:00
|
|
|
|
2014-06-12 19:23:34 +04:00
|
|
|
public function getScanner($path = '', $storage = null) {
|
|
|
|
if (!$storage) {
|
|
|
|
$storage = $this;
|
|
|
|
}
|
2016-05-02 16:16:20 +03:00
|
|
|
return new \OCA\Files_Sharing\Scanner($storage);
|
2013-01-01 23:47:25 +04:00
|
|
|
}
|
|
|
|
|
2012-12-16 04:44:46 +04:00
|
|
|
public function getOwner($path) {
|
2016-06-15 10:47:33 +03:00
|
|
|
return $this->superShare->getShareOwner();
|
2012-12-16 04:44:46 +04:00
|
|
|
}
|
|
|
|
|
2020-09-15 17:29:21 +03:00
|
|
|
public function getWatcher($path = '', $storage = null) {
|
|
|
|
// cache updating is handled by the share source
|
|
|
|
return new NullWatcher();
|
|
|
|
}
|
|
|
|
|
2014-07-31 13:55:59 +04:00
|
|
|
/**
|
|
|
|
* unshare complete storage, also the grouped shares
|
2014-09-25 13:29:57 +04:00
|
|
|
*
|
|
|
|
* @return bool
|
2014-07-31 13:55:59 +04:00
|
|
|
*/
|
|
|
|
public function unshareStorage() {
|
2016-06-15 10:47:33 +03:00
|
|
|
foreach ($this->groupedShares as $share) {
|
|
|
|
\OC::$server->getShareManager()->deleteFromSelf($share, $this->user);
|
|
|
|
}
|
2016-04-15 10:01:10 +03:00
|
|
|
return true;
|
2014-07-31 13:55:59 +04:00
|
|
|
}
|
|
|
|
|
2015-05-04 15:21:34 +03:00
|
|
|
/**
|
|
|
|
* @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 */
|
2020-09-15 17:29:21 +03:00
|
|
|
[$targetStorage, $targetInternalPath] = $this->resolvePath($path);
|
2015-05-04 15:21:34 +03:00
|
|
|
$targetStorage->acquireLock($targetInternalPath, $type, $provider);
|
2015-06-29 20:13:39 +03:00
|
|
|
// lock the parent folders of the owner when locking the share as recipient
|
|
|
|
if ($path === '') {
|
2016-06-15 10:47:33 +03:00
|
|
|
$sourcePath = $this->ownerView->getPath($this->superShare->getNodeId());
|
2015-06-30 14:49:54 +03:00
|
|
|
$this->ownerView->lockFile(dirname($sourcePath), ILockingProvider::LOCK_SHARED, true);
|
2015-06-29 20:13:39 +03:00
|
|
|
}
|
2015-05-04 15:21:34 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @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 */
|
2020-09-15 17:29:21 +03:00
|
|
|
[$targetStorage, $targetInternalPath] = $this->resolvePath($path);
|
2015-05-04 15:21:34 +03:00
|
|
|
$targetStorage->releaseLock($targetInternalPath, $type, $provider);
|
2015-06-29 20:13:39 +03:00
|
|
|
// unlock the parent folders of the owner when unlocking the share as recipient
|
|
|
|
if ($path === '') {
|
2016-06-15 10:47:33 +03:00
|
|
|
$sourcePath = $this->ownerView->getPath($this->superShare->getNodeId());
|
2015-06-30 14:49:54 +03:00
|
|
|
$this->ownerView->unlockFile(dirname($sourcePath), ILockingProvider::LOCK_SHARED, true);
|
2015-06-29 20:13:39 +03:00
|
|
|
}
|
2015-05-04 15:21:34 +03:00
|
|
|
}
|
2015-05-29 15:40:06 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @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 */
|
2020-09-15 17:29:21 +03:00
|
|
|
[$targetStorage, $targetInternalPath] = $this->resolvePath($path);
|
2015-05-29 15:40:06 +03:00
|
|
|
$targetStorage->changeLock($targetInternalPath, $type, $provider);
|
|
|
|
}
|
2015-08-21 00:43:46 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @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
|
|
|
|
}
|
2016-01-11 15:58:22 +03:00
|
|
|
|
2016-08-22 16:12:39 +03:00
|
|
|
public function getSourceStorage() {
|
2016-12-14 16:35:45 +03:00
|
|
|
$this->init();
|
|
|
|
return $this->nonMaskedStorage;
|
2016-08-22 16:12:39 +03:00
|
|
|
}
|
|
|
|
|
2016-08-22 13:27:56 +03:00
|
|
|
public function getWrapperStorage() {
|
|
|
|
$this->init();
|
|
|
|
return $this->storage;
|
2016-02-24 12:39:04 +03:00
|
|
|
}
|
2016-04-15 10:01:10 +03:00
|
|
|
|
2016-06-08 09:19:32 +03:00
|
|
|
public function file_get_contents($path) {
|
|
|
|
$info = [
|
|
|
|
'target' => $this->getMountPoint() . '/' . $path,
|
2017-04-12 15:55:47 +03:00
|
|
|
'source' => $this->getUnjailedPath($path),
|
2016-06-08 09:19:32 +03:00
|
|
|
];
|
|
|
|
\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,
|
2017-04-12 15:55:47 +03:00
|
|
|
'source' => $this->getUnjailedPath($path),
|
2016-06-08 09:19:32 +03:00
|
|
|
];
|
|
|
|
\OCP\Util::emitHook('\OC\Files\Storage\Shared', 'file_put_contents', $info);
|
|
|
|
return parent::file_put_contents($path, $data);
|
|
|
|
}
|
|
|
|
|
2016-11-17 16:18:47 +03:00
|
|
|
public function setMountOptions(array $options) {
|
|
|
|
$this->mountOptions = $options;
|
|
|
|
}
|
2020-08-14 09:06:53 +03:00
|
|
|
|
|
|
|
public function getUnjailedPath($path) {
|
|
|
|
$this->init();
|
|
|
|
return parent::getUnjailedPath($path);
|
|
|
|
}
|
2012-05-11 03:56:25 +04:00
|
|
|
}
|