2014-02-18 15:37:32 +04:00
|
|
|
<?php
|
|
|
|
/**
|
2016-07-21 18:07:57 +03:00
|
|
|
* @copyright Copyright (c) 2016, ownCloud, Inc.
|
|
|
|
*
|
2015-03-26 13:44:34 +03:00
|
|
|
* @author Bart Visscher <bartv@thisnet.nl>
|
|
|
|
* @author Bernhard Reiter <ockham@raz.or.at>
|
2017-11-06 17:56:42 +03:00
|
|
|
* @author Bjoern Schiessle <bjoern@schiessle.org>
|
2016-05-26 20:56:05 +03:00
|
|
|
* @author Björn Schießle <bjoern@schiessle.org>
|
2015-03-26 13:44:34 +03:00
|
|
|
* @author Christopher Schäpers <kondou@ts.unde.re>
|
2016-07-21 18:07:57 +03:00
|
|
|
* @author Joas Schilling <coding@schilljs.com>
|
2015-03-26 13:44:34 +03:00
|
|
|
* @author Jörn Friedrich Dreyer <jfd@butonic.de>
|
2016-05-26 20:56:05 +03:00
|
|
|
* @author Lukas Reschke <lukas@statuscode.ch>
|
2015-03-26 13:44:34 +03:00
|
|
|
* @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 18:07:57 +03:00
|
|
|
* @author Roeland Jago Douma <roeland@famdouma.nl>
|
2015-03-26 13:44:34 +03:00
|
|
|
* @author Sebastian Döll <sebastian.doell@libasys.de>
|
2016-05-26 20:56:05 +03:00
|
|
|
* @author Stefan Weil <sw@weilnetz.de>
|
2015-03-26 13:44:34 +03:00
|
|
|
* @author Thomas Müller <thomas.mueller@tmit.eu>
|
2016-07-21 18:07:57 +03:00
|
|
|
* @author Torben Dannhauer <torben@dannhauer.de>
|
2015-03-26 13:44:34 +03:00
|
|
|
* @author Vincent Petry <pvince81@owncloud.com>
|
|
|
|
* @author Volkan Gezer <volkangezer@gmail.com>
|
2014-02-18 15:37:32 +04:00
|
|
|
*
|
2015-03-26 13:44:34 +03:00
|
|
|
* @license AGPL-3.0
|
2014-02-18 15:37:32 +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.
|
2014-02-18 15:37:32 +04:00
|
|
|
*
|
2015-03-26 13:44:34 +03:00
|
|
|
* This program is distributed in the hope that it will be useful,
|
2014-02-18 15:37:32 +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.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU Affero General Public License, version 3,
|
|
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>
|
2014-02-18 15:37:32 +04:00
|
|
|
*
|
|
|
|
*/
|
2015-02-26 13:37:37 +03:00
|
|
|
|
2014-02-18 15:37:32 +04:00
|
|
|
namespace OC\Share;
|
|
|
|
|
2015-09-03 15:34:46 +03:00
|
|
|
use OC\Files\Filesystem;
|
2016-01-25 19:17:36 +03:00
|
|
|
use OCP\DB\QueryBuilder\IQueryBuilder;
|
2016-11-03 01:26:49 +03:00
|
|
|
use OCP\ILogger;
|
|
|
|
use OCP\IUserManager;
|
2015-03-13 14:29:13 +03:00
|
|
|
use OCP\IUserSession;
|
2015-07-06 13:34:19 +03:00
|
|
|
use OCP\IDBConnection;
|
2015-03-13 14:29:13 +03:00
|
|
|
use OCP\IConfig;
|
2017-03-24 22:17:38 +03:00
|
|
|
use OCP\Util;
|
2015-03-13 14:29:13 +03:00
|
|
|
|
2014-02-18 15:37:32 +04:00
|
|
|
/**
|
|
|
|
* This class provides the ability for apps to share their content between users.
|
|
|
|
* Apps must create a backend class that implements OCP\Share_Backend and register it with this class.
|
|
|
|
*
|
|
|
|
* It provides the following hooks:
|
|
|
|
* - post_shared
|
|
|
|
*/
|
2015-04-28 09:40:47 +03:00
|
|
|
class Share extends Constants {
|
2014-02-18 15:37:32 +04:00
|
|
|
|
|
|
|
/** CRUDS permissions (Create, Read, Update, Delete, Share) using a bitmask
|
|
|
|
* Construct permissions for share() and setPermissions with Or (|) e.g.
|
|
|
|
* Give user read and update permissions: PERMISSION_READ | PERMISSION_UPDATE
|
|
|
|
*
|
|
|
|
* Check if permission is granted with And (&) e.g. Check if delete is
|
|
|
|
* granted: if ($permissions & PERMISSION_DELETE)
|
|
|
|
*
|
|
|
|
* Remove permissions with And (&) and Not (~) e.g. Remove the update
|
|
|
|
* permission: $permissions &= ~PERMISSION_UPDATE
|
|
|
|
*
|
|
|
|
* Apps are required to handle permissions on their own, this class only
|
|
|
|
* stores and manages the permissions of shares
|
|
|
|
* @see lib/public/constants.php
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Register a sharing backend class that implements OCP\Share_Backend for an item type
|
2014-04-15 19:46:11 +04:00
|
|
|
* @param string $itemType Item type
|
|
|
|
* @param string $class Backend class
|
|
|
|
* @param string $collectionOf (optional) Depends on item type
|
|
|
|
* @param array $supportedFileExtensions (optional) List of supported file extensions if this item type depends on files
|
|
|
|
* @return boolean true if backend is registered or false if error
|
2014-02-18 15:37:32 +04:00
|
|
|
*/
|
|
|
|
public static function registerBackend($itemType, $class, $collectionOf = null, $supportedFileExtensions = null) {
|
2018-01-17 23:10:40 +03:00
|
|
|
if (\OC::$server->getConfig()->getAppValue('core', 'shareapi_enabled', 'yes') == 'yes') {
|
2014-02-18 15:37:32 +04:00
|
|
|
if (!isset(self::$backendTypes[$itemType])) {
|
|
|
|
self::$backendTypes[$itemType] = array(
|
|
|
|
'class' => $class,
|
|
|
|
'collectionOf' => $collectionOf,
|
|
|
|
'supportedFileExtensions' => $supportedFileExtensions
|
|
|
|
);
|
|
|
|
if(count(self::$backendTypes) === 1) {
|
2017-03-24 22:17:38 +03:00
|
|
|
Util::addScript('core', 'merged-share-backend');
|
2014-02-18 15:37:32 +04:00
|
|
|
\OC_Util::addStyle('core', 'share');
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
2015-07-03 15:06:40 +03:00
|
|
|
\OCP\Util::writeLog('OCP\Share',
|
2014-02-18 15:37:32 +04:00
|
|
|
'Sharing backend '.$class.' not registered, '.self::$backendTypes[$itemType]['class']
|
|
|
|
.' is already registered for '.$itemType,
|
2015-07-03 15:06:40 +03:00
|
|
|
\OCP\Util::WARN);
|
2014-02-18 15:37:32 +04:00
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the items of item type shared with the current user
|
2014-04-15 19:46:11 +04:00
|
|
|
* @param string $itemType
|
|
|
|
* @param int $format (optional) Format type must be defined by the backend
|
|
|
|
* @param mixed $parameters (optional)
|
|
|
|
* @param int $limit Number of items to return (optional) Returns all by default
|
2014-05-07 22:46:08 +04:00
|
|
|
* @param boolean $includeCollections (optional)
|
2014-04-15 19:46:11 +04:00
|
|
|
* @return mixed Return depends on format
|
2014-02-18 15:37:32 +04:00
|
|
|
*/
|
|
|
|
public static function getItemsSharedWith($itemType, $format = self::FORMAT_NONE,
|
2014-12-04 21:51:04 +03:00
|
|
|
$parameters = null, $limit = -1, $includeCollections = false) {
|
2014-02-18 15:37:32 +04:00
|
|
|
return self::getItems($itemType, null, self::$shareTypeUserAndGroups, \OC_User::getUser(), null, $format,
|
|
|
|
$parameters, $limit, $includeCollections);
|
|
|
|
}
|
|
|
|
|
2014-04-08 16:42:15 +04:00
|
|
|
/**
|
|
|
|
* Get the items of item type shared with a user
|
2014-05-12 00:51:30 +04:00
|
|
|
* @param string $itemType
|
|
|
|
* @param string $user id for which user we want the shares
|
|
|
|
* @param int $format (optional) Format type must be defined by the backend
|
|
|
|
* @param mixed $parameters (optional)
|
|
|
|
* @param int $limit Number of items to return (optional) Returns all by default
|
|
|
|
* @param boolean $includeCollections (optional)
|
2014-05-13 14:27:35 +04:00
|
|
|
* @return mixed Return depends on format
|
2014-04-08 16:42:15 +04:00
|
|
|
*/
|
|
|
|
public static function getItemsSharedWithUser($itemType, $user, $format = self::FORMAT_NONE,
|
2014-12-04 21:51:04 +03:00
|
|
|
$parameters = null, $limit = -1, $includeCollections = false) {
|
2014-04-08 16:42:15 +04:00
|
|
|
return self::getItems($itemType, null, self::$shareTypeUserAndGroups, $user, null, $format,
|
|
|
|
$parameters, $limit, $includeCollections);
|
|
|
|
}
|
|
|
|
|
2014-02-18 15:37:32 +04:00
|
|
|
/**
|
|
|
|
* Get the item of item type shared with a given user by source
|
|
|
|
* @param string $itemType
|
|
|
|
* @param string $itemSource
|
2014-11-10 15:08:45 +03:00
|
|
|
* @param string $user User to whom the item was shared
|
|
|
|
* @param string $owner Owner of the share
|
2014-11-17 20:05:12 +03:00
|
|
|
* @param int $shareType only look for a specific share type
|
2014-02-18 15:37:32 +04:00
|
|
|
* @return array Return list of items with file_target, permissions and expiration
|
|
|
|
*/
|
2014-11-10 15:08:45 +03:00
|
|
|
public static function getItemSharedWithUser($itemType, $itemSource, $user, $owner = null, $shareType = null) {
|
2014-02-18 15:37:32 +04:00
|
|
|
$shares = array();
|
2015-03-24 13:08:19 +03:00
|
|
|
$fileDependent = false;
|
2014-02-18 15:37:32 +04:00
|
|
|
|
2015-04-29 15:12:12 +03:00
|
|
|
$where = 'WHERE';
|
|
|
|
$fileDependentWhere = '';
|
2014-10-01 17:13:10 +04:00
|
|
|
if ($itemType === 'file' || $itemType === 'folder') {
|
2015-03-24 13:08:19 +03:00
|
|
|
$fileDependent = true;
|
2014-10-01 17:13:10 +04:00
|
|
|
$column = 'file_source';
|
2015-04-29 15:12:12 +03:00
|
|
|
$fileDependentWhere = 'INNER JOIN `*PREFIX*filecache` ON `file_source` = `*PREFIX*filecache`.`fileid` ';
|
|
|
|
$fileDependentWhere .= 'INNER JOIN `*PREFIX*storages` ON `numeric_id` = `*PREFIX*filecache`.`storage` ';
|
2014-10-01 17:13:10 +04:00
|
|
|
} else {
|
|
|
|
$column = 'item_source';
|
|
|
|
}
|
|
|
|
|
2015-03-24 13:08:19 +03:00
|
|
|
$select = self::createSelectStatement(self::FORMAT_NONE, $fileDependent);
|
2014-09-29 13:23:18 +04:00
|
|
|
|
2014-10-01 17:13:10 +04:00
|
|
|
$where .= ' `' . $column . '` = ? AND `item_type` = ? ';
|
2014-09-26 18:58:47 +04:00
|
|
|
$arguments = array($itemSource, $itemType);
|
|
|
|
// for link shares $user === null
|
|
|
|
if ($user !== null) {
|
|
|
|
$where .= ' AND `share_with` = ? ';
|
|
|
|
$arguments[] = $user;
|
|
|
|
}
|
|
|
|
|
2014-11-17 20:05:12 +03:00
|
|
|
if ($shareType !== null) {
|
|
|
|
$where .= ' AND `share_type` = ? ';
|
|
|
|
$arguments[] = $shareType;
|
|
|
|
}
|
|
|
|
|
2014-11-10 15:08:45 +03:00
|
|
|
if ($owner !== null) {
|
|
|
|
$where .= ' AND `uid_owner` = ? ';
|
|
|
|
$arguments[] = $owner;
|
|
|
|
}
|
|
|
|
|
2015-04-29 15:12:12 +03:00
|
|
|
$query = \OC_DB::prepare('SELECT ' . $select . ' FROM `*PREFIX*share` '. $fileDependentWhere . $where);
|
2014-02-18 15:37:32 +04:00
|
|
|
|
2014-09-26 18:58:47 +04:00
|
|
|
$result = \OC_DB::executeAudited($query, $arguments);
|
2014-02-18 15:37:32 +04:00
|
|
|
|
|
|
|
while ($row = $result->fetchRow()) {
|
2015-03-24 13:08:19 +03:00
|
|
|
if ($fileDependent && !self::isFileReachable($row['path'], $row['storage_id'])) {
|
|
|
|
continue;
|
|
|
|
}
|
2015-06-29 12:54:56 +03:00
|
|
|
if ($fileDependent && (int)$row['file_parent'] === -1) {
|
|
|
|
// if it is a mount point we need to get the path from the mount manager
|
|
|
|
$mountManager = \OC\Files\Filesystem::getMountManager();
|
|
|
|
$mountPoint = $mountManager->findByStorageId($row['storage_id']);
|
|
|
|
if (!empty($mountPoint)) {
|
|
|
|
$path = $mountPoint[0]->getMountPoint();
|
|
|
|
$path = trim($path, '/');
|
|
|
|
$path = substr($path, strlen($owner) + 1); //normalize path to 'files/foo.txt`
|
|
|
|
$row['path'] = $path;
|
|
|
|
} else {
|
|
|
|
\OC::$server->getLogger()->warning(
|
|
|
|
'Could not resolve mount point for ' . $row['storage_id'],
|
|
|
|
['app' => 'OCP\Share']
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
2014-02-18 15:37:32 +04:00
|
|
|
$shares[] = $row;
|
|
|
|
}
|
|
|
|
|
|
|
|
//if didn't found a result than let's look for a group share.
|
2014-09-26 18:58:47 +04:00
|
|
|
if(empty($shares) && $user !== null) {
|
2017-03-03 10:24:27 +03:00
|
|
|
$userObject = \OC::$server->getUserManager()->get($user);
|
|
|
|
$groups = [];
|
|
|
|
if ($userObject) {
|
|
|
|
$groups = \OC::$server->getGroupManager()->getUserGroupIds($userObject);
|
|
|
|
}
|
2014-02-18 15:37:32 +04:00
|
|
|
|
2015-01-19 16:39:00 +03:00
|
|
|
if (!empty($groups)) {
|
2015-04-29 15:12:12 +03:00
|
|
|
$where = $fileDependentWhere . ' WHERE `' . $column . '` = ? AND `item_type` = ? AND `share_with` in (?)';
|
2015-01-19 16:39:00 +03:00
|
|
|
$arguments = array($itemSource, $itemType, $groups);
|
2016-01-25 19:17:36 +03:00
|
|
|
$types = array(null, null, IQueryBuilder::PARAM_STR_ARRAY);
|
2015-01-19 16:39:00 +03:00
|
|
|
|
|
|
|
if ($owner !== null) {
|
|
|
|
$where .= ' AND `uid_owner` = ?';
|
|
|
|
$arguments[] = $owner;
|
|
|
|
$types[] = null;
|
|
|
|
}
|
2014-02-18 15:37:32 +04:00
|
|
|
|
2015-01-19 16:39:00 +03:00
|
|
|
// TODO: inject connection, hopefully one day in the future when this
|
|
|
|
// class isn't static anymore...
|
2016-01-07 12:26:00 +03:00
|
|
|
$conn = \OC::$server->getDatabaseConnection();
|
2015-01-19 16:39:00 +03:00
|
|
|
$result = $conn->executeQuery(
|
2015-04-29 15:12:12 +03:00
|
|
|
'SELECT ' . $select . ' FROM `*PREFIX*share` ' . $where,
|
2015-01-19 16:39:00 +03:00
|
|
|
$arguments,
|
|
|
|
$types
|
|
|
|
);
|
2014-02-18 15:37:32 +04:00
|
|
|
|
2015-01-19 16:39:00 +03:00
|
|
|
while ($row = $result->fetch()) {
|
|
|
|
$shares[] = $row;
|
|
|
|
}
|
2014-02-18 15:37:32 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return $shares;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the item of item type shared with the current user by source
|
2014-04-15 19:46:11 +04:00
|
|
|
* @param string $itemType
|
|
|
|
* @param string $itemSource
|
|
|
|
* @param int $format (optional) Format type must be defined by the backend
|
|
|
|
* @param mixed $parameters
|
2014-05-07 22:46:08 +04:00
|
|
|
* @param boolean $includeCollections
|
2014-07-31 13:55:59 +04:00
|
|
|
* @param string $shareWith (optional) define against which user should be checked, default: current user
|
2014-09-25 13:29:57 +04:00
|
|
|
* @return array
|
2014-02-18 15:37:32 +04:00
|
|
|
*/
|
|
|
|
public static function getItemSharedWithBySource($itemType, $itemSource, $format = self::FORMAT_NONE,
|
2014-12-04 21:51:04 +03:00
|
|
|
$parameters = null, $includeCollections = false, $shareWith = null) {
|
2014-07-31 13:55:59 +04:00
|
|
|
$shareWith = ($shareWith === null) ? \OC_User::getUser() : $shareWith;
|
|
|
|
return self::getItems($itemType, $itemSource, self::$shareTypeUserAndGroups, $shareWith, null, $format,
|
2014-02-18 15:37:32 +04:00
|
|
|
$parameters, 1, $includeCollections, true);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Based on the given token the share information will be returned - password protected shares will be verified
|
|
|
|
* @param string $token
|
2015-04-28 09:40:47 +03:00
|
|
|
* @param bool $checkPasswordProtection
|
2014-05-11 21:28:45 +04:00
|
|
|
* @return array|boolean false will be returned in case the token is unknown or unauthorized
|
2014-02-18 15:37:32 +04:00
|
|
|
*/
|
|
|
|
public static function getShareByToken($token, $checkPasswordProtection = true) {
|
|
|
|
$query = \OC_DB::prepare('SELECT * FROM `*PREFIX*share` WHERE `token` = ?', 1);
|
|
|
|
$result = $query->execute(array($token));
|
2016-01-07 12:14:05 +03:00
|
|
|
if ($result === false) {
|
2015-07-03 15:06:40 +03:00
|
|
|
\OCP\Util::writeLog('OCP\Share', \OC_DB::getErrorMessage() . ', token=' . $token, \OCP\Util::ERROR);
|
2014-02-18 15:37:32 +04:00
|
|
|
}
|
|
|
|
$row = $result->fetchRow();
|
|
|
|
if ($row === false) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (is_array($row) and self::expireItem($row)) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// password protected shares need to be authenticated
|
2017-08-15 11:20:40 +03:00
|
|
|
if ($checkPasswordProtection && !\OC\Share\Share::checkPasswordProtectedShare($row)) {
|
2014-02-18 15:37:32 +04:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return $row;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* resolves reshares down to the last real share
|
2014-05-12 00:51:30 +04:00
|
|
|
* @param array $linkItem
|
|
|
|
* @return array file owner
|
2014-02-18 15:37:32 +04:00
|
|
|
*/
|
|
|
|
public static function resolveReShare($linkItem)
|
|
|
|
{
|
|
|
|
if (isset($linkItem['parent'])) {
|
|
|
|
$parent = $linkItem['parent'];
|
|
|
|
while (isset($parent)) {
|
|
|
|
$query = \OC_DB::prepare('SELECT * FROM `*PREFIX*share` WHERE `id` = ?', 1);
|
|
|
|
$item = $query->execute(array($parent))->fetchRow();
|
|
|
|
if (isset($item['parent'])) {
|
|
|
|
$parent = $item['parent'];
|
|
|
|
} else {
|
|
|
|
return $item;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return $linkItem;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the shared items of item type owned by the current user
|
2014-04-15 19:46:11 +04:00
|
|
|
* @param string $itemType
|
|
|
|
* @param int $format (optional) Format type must be defined by the backend
|
|
|
|
* @param mixed $parameters
|
|
|
|
* @param int $limit Number of items to return (optional) Returns all by default
|
2014-05-07 22:46:08 +04:00
|
|
|
* @param boolean $includeCollections
|
2014-04-15 19:46:11 +04:00
|
|
|
* @return mixed Return depends on format
|
2014-02-18 15:37:32 +04:00
|
|
|
*/
|
|
|
|
public static function getItemsShared($itemType, $format = self::FORMAT_NONE, $parameters = null,
|
2014-12-04 21:51:04 +03:00
|
|
|
$limit = -1, $includeCollections = false) {
|
2014-02-18 15:37:32 +04:00
|
|
|
return self::getItems($itemType, null, null, null, \OC_User::getUser(), $format,
|
|
|
|
$parameters, $limit, $includeCollections);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the shared item of item type owned by the current user
|
2014-04-15 19:46:11 +04:00
|
|
|
* @param string $itemType
|
|
|
|
* @param string $itemSource
|
|
|
|
* @param int $format (optional) Format type must be defined by the backend
|
|
|
|
* @param mixed $parameters
|
2014-05-07 22:46:08 +04:00
|
|
|
* @param boolean $includeCollections
|
2014-04-15 19:46:11 +04:00
|
|
|
* @return mixed Return depends on format
|
2014-02-18 15:37:32 +04:00
|
|
|
*/
|
|
|
|
public static function getItemShared($itemType, $itemSource, $format = self::FORMAT_NONE,
|
2014-12-04 21:51:04 +03:00
|
|
|
$parameters = null, $includeCollections = false) {
|
2014-02-18 15:37:32 +04:00
|
|
|
return self::getItems($itemType, $itemSource, null, null, \OC_User::getUser(), $format,
|
|
|
|
$parameters, -1, $includeCollections);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Share an item with a user, group, or via private link
|
|
|
|
* @param string $itemType
|
|
|
|
* @param string $itemSource
|
|
|
|
* @param int $shareType SHARE_TYPE_USER, SHARE_TYPE_GROUP, or SHARE_TYPE_LINK
|
|
|
|
* @param string $shareWith User or group the item is being shared with
|
|
|
|
* @param int $permissions CRUDS
|
2014-05-07 13:23:50 +04:00
|
|
|
* @param string $itemSourceName
|
2017-08-15 12:57:18 +03:00
|
|
|
* @param \DateTime|null $expirationDate
|
|
|
|
* @param bool|null $passwordChanged
|
2014-05-07 22:46:08 +04:00
|
|
|
* @return boolean|string Returns true on success or false on failure, Returns token on success for links
|
2015-06-18 13:46:52 +03:00
|
|
|
* @throws \OC\HintException when the share type is remote and the shareWith is invalid
|
2014-05-07 13:23:50 +04:00
|
|
|
* @throws \Exception
|
2017-08-15 12:57:18 +03:00
|
|
|
* @since 5.0.0 - parameter $itemSourceName was added in 6.0.0, parameter $expirationDate was added in 7.0.0, parameter $passwordChanged added in 9.0.0
|
2014-02-18 15:37:32 +04:00
|
|
|
*/
|
2015-10-23 00:13:28 +03:00
|
|
|
public static function shareItem($itemType, $itemSource, $shareType, $shareWith, $permissions, $itemSourceName = null, \DateTime $expirationDate = null, $passwordChanged = null) {
|
2014-12-04 21:51:04 +03:00
|
|
|
|
|
|
|
$backend = self::getBackend($itemType);
|
|
|
|
$l = \OC::$server->getL10N('lib');
|
|
|
|
|
|
|
|
if ($backend->isShareTypeAllowed($shareType) === false) {
|
|
|
|
$message = 'Sharing %s failed, because the backend does not allow shares from type %i';
|
|
|
|
$message_t = $l->t('Sharing %s failed, because the backend does not allow shares from type %i', array($itemSourceName, $shareType));
|
2015-08-24 13:12:08 +03:00
|
|
|
\OCP\Util::writeLog('OCP\Share', sprintf($message, $itemSourceName, $shareType), \OCP\Util::DEBUG);
|
2014-12-04 21:51:04 +03:00
|
|
|
throw new \Exception($message_t);
|
|
|
|
}
|
|
|
|
|
2014-02-18 15:37:32 +04:00
|
|
|
$uidOwner = \OC_User::getUser();
|
2014-06-04 13:07:31 +04:00
|
|
|
$shareWithinGroupOnly = self::shareWithGroupMembersOnly();
|
2014-02-18 15:37:32 +04:00
|
|
|
|
|
|
|
if (is_null($itemSourceName)) {
|
|
|
|
$itemSourceName = $itemSource;
|
|
|
|
}
|
2015-10-16 10:27:02 +03:00
|
|
|
$itemName = $itemSourceName;
|
2014-02-18 15:37:32 +04:00
|
|
|
|
2014-05-13 17:22:18 +04:00
|
|
|
// check if file can be shared
|
2014-03-18 12:25:04 +04:00
|
|
|
if ($itemType === 'file' or $itemType === 'folder') {
|
|
|
|
$path = \OC\Files\Filesystem::getPath($itemSource);
|
2015-10-16 10:27:02 +03:00
|
|
|
$itemName = $path;
|
|
|
|
|
2014-05-13 17:22:18 +04:00
|
|
|
// verify that the file exists before we try to share it
|
2014-03-18 12:25:04 +04:00
|
|
|
if (!$path) {
|
2014-04-24 03:42:18 +04:00
|
|
|
$message = 'Sharing %s failed, because the file does not exist';
|
|
|
|
$message_t = $l->t('Sharing %s failed, because the file does not exist', array($itemSourceName));
|
2015-08-24 13:12:08 +03:00
|
|
|
\OCP\Util::writeLog('OCP\Share', sprintf($message, $itemSourceName), \OCP\Util::DEBUG);
|
2014-04-24 03:42:18 +04:00
|
|
|
throw new \Exception($message_t);
|
2014-03-18 12:25:04 +04:00
|
|
|
}
|
2014-05-13 17:22:18 +04:00
|
|
|
// verify that the user has share permission
|
2015-12-08 18:48:33 +03:00
|
|
|
if (!\OC\Files\Filesystem::isSharable($path) || \OCP\Util::isSharingDisabledForUser()) {
|
2014-05-13 17:22:18 +04:00
|
|
|
$message = 'You are not allowed to share %s';
|
2015-10-13 10:00:33 +03:00
|
|
|
$message_t = $l->t('You are not allowed to share %s', [$path]);
|
|
|
|
\OCP\Util::writeLog('OCP\Share', sprintf($message, $path), \OCP\Util::DEBUG);
|
2014-05-13 17:22:18 +04:00
|
|
|
throw new \Exception($message_t);
|
|
|
|
}
|
2014-03-18 12:25:04 +04:00
|
|
|
}
|
|
|
|
|
2014-04-15 13:19:31 +04:00
|
|
|
//verify that we don't share a folder which already contains a share mount point
|
|
|
|
if ($itemType === 'folder') {
|
|
|
|
$path = '/' . $uidOwner . '/files' . \OC\Files\Filesystem::getPath($itemSource) . '/';
|
|
|
|
$mountManager = \OC\Files\Filesystem::getMountManager();
|
2014-06-10 15:50:52 +04:00
|
|
|
$mounts = $mountManager->findIn($path);
|
|
|
|
foreach ($mounts as $mount) {
|
|
|
|
if ($mount->getStorage()->instanceOfStorage('\OCA\Files_Sharing\ISharedStorage')) {
|
2014-04-15 13:19:31 +04:00
|
|
|
$message = 'Sharing "' . $itemSourceName . '" failed, because it contains files shared with you!';
|
2015-08-24 13:12:08 +03:00
|
|
|
\OCP\Util::writeLog('OCP\Share', $message, \OCP\Util::DEBUG);
|
2014-04-15 13:19:31 +04:00
|
|
|
throw new \Exception($message);
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-05-27 13:05:31 +04:00
|
|
|
// single file shares should never have delete permissions
|
|
|
|
if ($itemType === 'file') {
|
2014-11-25 18:28:41 +03:00
|
|
|
$permissions = (int)$permissions & ~\OCP\Constants::PERMISSION_DELETE;
|
2014-05-27 13:05:31 +04:00
|
|
|
}
|
|
|
|
|
2015-08-29 14:31:18 +03:00
|
|
|
//Validate expirationDate
|
|
|
|
if ($expirationDate !== null) {
|
|
|
|
try {
|
|
|
|
/*
|
|
|
|
* Reuse the validateExpireDate.
|
|
|
|
* We have to pass time() since the second arg is the time
|
|
|
|
* the file was shared, since it is not shared yet we just use
|
|
|
|
* the current time.
|
|
|
|
*/
|
|
|
|
$expirationDate = self::validateExpireDate($expirationDate->format('Y-m-d'), time(), $itemType, $itemSource);
|
|
|
|
} catch (\Exception $e) {
|
|
|
|
throw new \OC\HintException($e->getMessage(), $e->getMessage(), 404);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-02-18 15:37:32 +04:00
|
|
|
// Verify share type and sharing conditions are met
|
|
|
|
if ($shareType === self::SHARE_TYPE_USER) {
|
|
|
|
if ($shareWith == $uidOwner) {
|
2015-10-16 11:00:33 +03:00
|
|
|
$message = 'Sharing %s failed, because you can not share with yourself';
|
|
|
|
$message_t = $l->t('Sharing %s failed, because you can not share with yourself', [$itemName]);
|
|
|
|
\OCP\Util::writeLog('OCP\Share', sprintf($message, $itemSourceName), \OCP\Util::DEBUG);
|
2014-04-05 21:23:12 +04:00
|
|
|
throw new \Exception($message_t);
|
2014-02-18 15:37:32 +04:00
|
|
|
}
|
2018-01-16 15:27:45 +03:00
|
|
|
if (!\OC::$server->getUserManager()->userExists($shareWith)) {
|
2014-04-05 21:23:12 +04:00
|
|
|
$message = 'Sharing %s failed, because the user %s does not exist';
|
|
|
|
$message_t = $l->t('Sharing %s failed, because the user %s does not exist', array($itemSourceName, $shareWith));
|
2015-08-24 13:12:08 +03:00
|
|
|
\OCP\Util::writeLog('OCP\Share', sprintf($message, $itemSourceName, $shareWith), \OCP\Util::DEBUG);
|
2014-04-05 21:23:12 +04:00
|
|
|
throw new \Exception($message_t);
|
2014-02-18 15:37:32 +04:00
|
|
|
}
|
2014-06-04 13:07:31 +04:00
|
|
|
if ($shareWithinGroupOnly) {
|
2017-03-03 10:24:27 +03:00
|
|
|
$userManager = \OC::$server->getUserManager();
|
|
|
|
$groupManager = \OC::$server->getGroupManager();
|
|
|
|
$userOwner = $userManager->get($uidOwner);
|
|
|
|
$userShareWith = $userManager->get($shareWith);
|
|
|
|
$groupsOwner = [];
|
|
|
|
$groupsShareWith = [];
|
|
|
|
if ($userOwner) {
|
|
|
|
$groupsOwner = $groupManager->getUserGroupIds($userOwner);
|
|
|
|
}
|
|
|
|
if ($userShareWith) {
|
|
|
|
$groupsShareWith = $groupManager->getUserGroupIds($userShareWith);
|
|
|
|
}
|
|
|
|
$inGroup = array_intersect($groupsOwner, $groupsShareWith);
|
2014-02-18 15:37:32 +04:00
|
|
|
if (empty($inGroup)) {
|
2014-04-05 21:23:12 +04:00
|
|
|
$message = 'Sharing %s failed, because the user '
|
|
|
|
.'%s is not a member of any groups that %s is a member of';
|
2015-11-09 17:52:17 +03:00
|
|
|
$message_t = $l->t('Sharing %s failed, because the user %s is not a member of any groups that %s is a member of', array($itemName, $shareWith, $uidOwner));
|
|
|
|
\OCP\Util::writeLog('OCP\Share', sprintf($message, $itemName, $shareWith, $uidOwner), \OCP\Util::DEBUG);
|
2014-04-05 21:23:12 +04:00
|
|
|
throw new \Exception($message_t);
|
2014-02-18 15:37:32 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
// Check if the item source is already shared with the user, either from the same owner or a different user
|
|
|
|
if ($checkExists = self::getItems($itemType, $itemSource, self::$shareTypeUserAndGroups,
|
|
|
|
$shareWith, null, self::FORMAT_NONE, null, 1, true, true)) {
|
|
|
|
// Only allow the same share to occur again if it is the same
|
|
|
|
// owner and is not a user share, this use case is for increasing
|
|
|
|
// permissions for a specific user
|
|
|
|
if ($checkExists['uid_owner'] != $uidOwner || $checkExists['share_type'] == $shareType) {
|
2014-04-05 21:23:12 +04:00
|
|
|
$message = 'Sharing %s failed, because this item is already shared with %s';
|
|
|
|
$message_t = $l->t('Sharing %s failed, because this item is already shared with %s', array($itemSourceName, $shareWith));
|
2015-08-24 13:12:08 +03:00
|
|
|
\OCP\Util::writeLog('OCP\Share', sprintf($message, $itemSourceName, $shareWith), \OCP\Util::DEBUG);
|
2014-04-05 21:23:12 +04:00
|
|
|
throw new \Exception($message_t);
|
2014-02-18 15:37:32 +04:00
|
|
|
}
|
|
|
|
}
|
2015-09-04 17:22:01 +03:00
|
|
|
if ($checkExists = self::getItems($itemType, $itemSource, self::SHARE_TYPE_USER,
|
|
|
|
$shareWith, null, self::FORMAT_NONE, null, 1, true, true)) {
|
|
|
|
// Only allow the same share to occur again if it is the same
|
|
|
|
// owner and is not a user share, this use case is for increasing
|
|
|
|
// permissions for a specific user
|
|
|
|
if ($checkExists['uid_owner'] != $uidOwner || $checkExists['share_type'] == $shareType) {
|
|
|
|
$message = 'Sharing %s failed, because this item is already shared with user %s';
|
|
|
|
$message_t = $l->t('Sharing %s failed, because this item is already shared with user %s', array($itemSourceName, $shareWith));
|
2015-10-06 15:18:22 +03:00
|
|
|
\OCP\Util::writeLog('OCP\Share', sprintf($message, $itemSourceName, $shareWith), \OCP\Util::ERROR);
|
2015-09-04 17:22:01 +03:00
|
|
|
throw new \Exception($message_t);
|
|
|
|
}
|
|
|
|
}
|
2014-02-18 15:37:32 +04:00
|
|
|
} else if ($shareType === self::SHARE_TYPE_GROUP) {
|
2017-03-03 10:24:27 +03:00
|
|
|
if (!\OC::$server->getGroupManager()->groupExists($shareWith)) {
|
2014-04-05 21:23:12 +04:00
|
|
|
$message = 'Sharing %s failed, because the group %s does not exist';
|
|
|
|
$message_t = $l->t('Sharing %s failed, because the group %s does not exist', array($itemSourceName, $shareWith));
|
2015-08-24 13:12:08 +03:00
|
|
|
\OCP\Util::writeLog('OCP\Share', sprintf($message, $itemSourceName, $shareWith), \OCP\Util::DEBUG);
|
2014-04-05 21:23:12 +04:00
|
|
|
throw new \Exception($message_t);
|
2014-02-18 15:37:32 +04:00
|
|
|
}
|
2017-05-15 15:52:40 +03:00
|
|
|
if ($shareWithinGroupOnly) {
|
2017-03-03 10:24:27 +03:00
|
|
|
$group = \OC::$server->getGroupManager()->get($shareWith);
|
|
|
|
$user = \OC::$server->getUserManager()->get($uidOwner);
|
|
|
|
if (!$group || !$user || !$group->inGroup($user)) {
|
|
|
|
$message = 'Sharing %s failed, because '
|
|
|
|
. '%s is not a member of the group %s';
|
|
|
|
$message_t = $l->t('Sharing %s failed, because %s is not a member of the group %s', array($itemSourceName, $uidOwner, $shareWith));
|
|
|
|
\OCP\Util::writeLog('OCP\Share', sprintf($message, $itemSourceName, $uidOwner, $shareWith), \OCP\Util::DEBUG);
|
|
|
|
throw new \Exception($message_t);
|
|
|
|
}
|
2014-02-18 15:37:32 +04:00
|
|
|
}
|
|
|
|
// Check if the item source is already shared with the group, either from the same owner or a different user
|
|
|
|
// The check for each user in the group is done inside the put() function
|
|
|
|
if ($checkExists = self::getItems($itemType, $itemSource, self::SHARE_TYPE_GROUP, $shareWith,
|
|
|
|
null, self::FORMAT_NONE, null, 1, true, true)) {
|
2015-12-04 14:10:08 +03:00
|
|
|
|
|
|
|
if ($checkExists['share_with'] === $shareWith && $checkExists['share_type'] === \OCP\Share::SHARE_TYPE_GROUP) {
|
2014-04-05 21:23:12 +04:00
|
|
|
$message = 'Sharing %s failed, because this item is already shared with %s';
|
|
|
|
$message_t = $l->t('Sharing %s failed, because this item is already shared with %s', array($itemSourceName, $shareWith));
|
2015-08-24 13:12:08 +03:00
|
|
|
\OCP\Util::writeLog('OCP\Share', sprintf($message, $itemSourceName, $shareWith), \OCP\Util::DEBUG);
|
2014-04-05 21:23:12 +04:00
|
|
|
throw new \Exception($message_t);
|
2014-02-18 15:37:32 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
// Convert share with into an array with the keys group and users
|
|
|
|
$group = $shareWith;
|
|
|
|
$shareWith = array();
|
|
|
|
$shareWith['group'] = $group;
|
2017-03-03 10:24:27 +03:00
|
|
|
|
|
|
|
|
|
|
|
$groupObject = \OC::$server->getGroupManager()->get($group);
|
|
|
|
$userIds = [];
|
|
|
|
if ($groupObject) {
|
|
|
|
$users = $groupObject->searchUsers('', -1, 0);
|
|
|
|
foreach ($users as $user) {
|
|
|
|
$userIds[] = $user->getUID();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
$shareWith['users'] = array_diff($userIds, array($uidOwner));
|
2014-02-18 15:37:32 +04:00
|
|
|
} else if ($shareType === self::SHARE_TYPE_LINK) {
|
2014-07-28 19:13:17 +04:00
|
|
|
$updateExistingShare = false;
|
2018-01-17 23:10:40 +03:00
|
|
|
if (\OC::$server->getConfig()->getAppValue('core', 'shareapi_allow_links', 'yes') == 'yes') {
|
2014-05-12 14:19:07 +04:00
|
|
|
|
2015-12-07 18:38:49 +03:00
|
|
|
// IF the password is changed via the old ajax endpoint verify it before deleting the old share
|
|
|
|
if ($passwordChanged === true) {
|
|
|
|
self::verifyPassword($shareWith);
|
|
|
|
}
|
|
|
|
|
2014-02-18 15:37:32 +04:00
|
|
|
// when updating a link share
|
2014-05-12 14:19:07 +04:00
|
|
|
// FIXME Don't delete link if we update it
|
2014-02-18 15:37:32 +04:00
|
|
|
if ($checkExists = self::getItems($itemType, $itemSource, self::SHARE_TYPE_LINK, null,
|
|
|
|
$uidOwner, self::FORMAT_NONE, null, 1)) {
|
|
|
|
// remember old token
|
|
|
|
$oldToken = $checkExists['token'];
|
|
|
|
$oldPermissions = $checkExists['permissions'];
|
|
|
|
//delete the old share
|
2014-02-18 18:07:03 +04:00
|
|
|
Helper::delete($checkExists['id']);
|
2014-06-03 17:15:04 +04:00
|
|
|
$updateExistingShare = true;
|
2014-02-18 15:37:32 +04:00
|
|
|
}
|
|
|
|
|
2015-10-23 00:13:28 +03:00
|
|
|
if ($passwordChanged === null) {
|
|
|
|
// Generate hash of password - same method as user passwords
|
2015-10-22 18:32:40 +03:00
|
|
|
if (is_string($shareWith) && $shareWith !== '') {
|
|
|
|
self::verifyPassword($shareWith);
|
|
|
|
$shareWith = \OC::$server->getHasher()->hash($shareWith);
|
2015-10-23 00:13:28 +03:00
|
|
|
} else {
|
|
|
|
// reuse the already set password, but only if we change permissions
|
|
|
|
// otherwise the user disabled the password protection
|
|
|
|
if ($checkExists && (int)$permissions !== (int)$oldPermissions) {
|
|
|
|
$shareWith = $checkExists['share_with'];
|
|
|
|
}
|
2015-10-22 18:32:40 +03:00
|
|
|
}
|
2014-02-18 15:37:32 +04:00
|
|
|
} else {
|
2015-10-23 00:13:28 +03:00
|
|
|
if ($passwordChanged === true) {
|
|
|
|
if (is_string($shareWith) && $shareWith !== '') {
|
|
|
|
self::verifyPassword($shareWith);
|
|
|
|
$shareWith = \OC::$server->getHasher()->hash($shareWith);
|
|
|
|
}
|
|
|
|
} else if ($updateExistingShare) {
|
2014-02-18 15:37:32 +04:00
|
|
|
$shareWith = $checkExists['share_with'];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-05-12 14:19:07 +04:00
|
|
|
if (\OCP\Util::isPublicLinkPasswordRequired() && empty($shareWith)) {
|
|
|
|
$message = 'You need to provide a password to create a public link, only protected links are allowed';
|
|
|
|
$message_t = $l->t('You need to provide a password to create a public link, only protected links are allowed');
|
2015-08-24 13:12:08 +03:00
|
|
|
\OCP\Util::writeLog('OCP\Share', $message, \OCP\Util::DEBUG);
|
2014-05-12 14:19:07 +04:00
|
|
|
throw new \Exception($message_t);
|
|
|
|
}
|
|
|
|
|
2014-07-28 19:13:17 +04:00
|
|
|
if ($updateExistingShare === false &&
|
2014-12-04 21:51:04 +03:00
|
|
|
self::isDefaultExpireDateEnabled() &&
|
|
|
|
empty($expirationDate)) {
|
2014-06-03 17:15:04 +04:00
|
|
|
$expirationDate = Helper::calcExpireDate();
|
|
|
|
}
|
|
|
|
|
2014-02-18 15:37:32 +04:00
|
|
|
// Generate token
|
|
|
|
if (isset($oldToken)) {
|
|
|
|
$token = $oldToken;
|
|
|
|
} else {
|
2016-01-11 22:05:30 +03:00
|
|
|
$token = \OC::$server->getSecureRandom()->generate(self::TOKEN_LENGTH,
|
2017-07-14 15:03:25 +03:00
|
|
|
\OCP\Security\ISecureRandom::CHAR_HUMAN_READABLE
|
2014-08-03 13:31:28 +04:00
|
|
|
);
|
2014-02-18 15:37:32 +04:00
|
|
|
}
|
|
|
|
$result = self::put($itemType, $itemSource, $shareType, $shareWith, $uidOwner, $permissions,
|
2014-05-07 13:23:50 +04:00
|
|
|
null, $token, $itemSourceName, $expirationDate);
|
2014-02-18 15:37:32 +04:00
|
|
|
if ($result) {
|
|
|
|
return $token;
|
|
|
|
} else {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
2014-04-05 21:23:12 +04:00
|
|
|
$message = 'Sharing %s failed, because sharing with links is not allowed';
|
|
|
|
$message_t = $l->t('Sharing %s failed, because sharing with links is not allowed', array($itemSourceName));
|
2015-08-24 13:12:08 +03:00
|
|
|
\OCP\Util::writeLog('OCP\Share', sprintf($message, $itemSourceName), \OCP\Util::DEBUG);
|
2014-04-05 21:23:12 +04:00
|
|
|
throw new \Exception($message_t);
|
2014-12-04 21:51:04 +03:00
|
|
|
} else if ($shareType === self::SHARE_TYPE_REMOTE) {
|
2015-06-26 16:36:06 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Check if file is not already shared with the remote user
|
|
|
|
*/
|
|
|
|
if ($checkExists = self::getItems($itemType, $itemSource, self::SHARE_TYPE_REMOTE,
|
|
|
|
$shareWith, $uidOwner, self::FORMAT_NONE, null, 1, true, true)) {
|
|
|
|
$message = 'Sharing %s failed, because this item is already shared with %s';
|
|
|
|
$message_t = $l->t('Sharing %s failed, because this item is already shared with %s', array($itemSourceName, $shareWith));
|
2015-08-24 13:12:08 +03:00
|
|
|
\OCP\Util::writeLog('OCP\Share', sprintf($message, $itemSourceName, $shareWith), \OCP\Util::DEBUG);
|
2015-06-26 16:36:06 +03:00
|
|
|
throw new \Exception($message_t);
|
|
|
|
}
|
|
|
|
|
2015-12-09 14:00:00 +03:00
|
|
|
// don't allow federated shares if source and target server are the same
|
|
|
|
list($user, $remote) = Helper::splitUserRemote($shareWith);
|
|
|
|
$currentServer = self::removeProtocolFromUrl(\OC::$server->getURLGenerator()->getAbsoluteURL('/'));
|
|
|
|
$currentUser = \OC::$server->getUserSession()->getUser()->getUID();
|
|
|
|
if (Helper::isSameUserOnSameServer($user, $remote, $currentUser, $currentServer)) {
|
|
|
|
$message = 'Not allowed to create a federated share with the same user.';
|
|
|
|
$message_t = $l->t('Not allowed to create a federated share with the same user');
|
|
|
|
\OCP\Util::writeLog('OCP\Share', $message, \OCP\Util::DEBUG);
|
|
|
|
throw new \Exception($message_t);
|
|
|
|
}
|
2015-06-26 16:36:06 +03:00
|
|
|
|
2016-01-11 22:05:30 +03:00
|
|
|
$token = \OC::$server->getSecureRandom()->generate(self::TOKEN_LENGTH, \OCP\Security\ISecureRandom::CHAR_LOWER . \OCP\Security\ISecureRandom::CHAR_UPPER .
|
2014-12-04 21:51:04 +03:00
|
|
|
\OCP\Security\ISecureRandom::CHAR_DIGITS);
|
|
|
|
|
2015-06-18 12:46:37 +03:00
|
|
|
$shareWith = $user . '@' . $remote;
|
2014-12-04 21:51:04 +03:00
|
|
|
$shareId = self::put($itemType, $itemSource, $shareType, $shareWith, $uidOwner, $permissions, null, $token, $itemSourceName);
|
|
|
|
|
|
|
|
$send = false;
|
|
|
|
if ($shareId) {
|
|
|
|
$send = self::sendRemoteShare($token, $shareWith, $itemSourceName, $shareId, $uidOwner);
|
|
|
|
}
|
|
|
|
|
|
|
|
if ($send === false) {
|
|
|
|
$currentUser = \OC::$server->getUserSession()->getUser()->getUID();
|
|
|
|
self::unshare($itemType, $itemSource, $shareType, $shareWith, $currentUser);
|
|
|
|
$message_t = $l->t('Sharing %s failed, could not find %s, maybe the server is currently unreachable.', array($itemSourceName, $shareWith));
|
|
|
|
throw new \Exception($message_t);
|
|
|
|
}
|
|
|
|
|
|
|
|
return $send;
|
2014-02-18 15:37:32 +04:00
|
|
|
} else {
|
|
|
|
// Future share types need to include their own conditions
|
2014-04-05 21:23:12 +04:00
|
|
|
$message = 'Share type %s is not valid for %s';
|
|
|
|
$message_t = $l->t('Share type %s is not valid for %s', array($shareType, $itemSource));
|
2015-08-24 13:12:08 +03:00
|
|
|
\OCP\Util::writeLog('OCP\Share', sprintf($message, $shareType, $itemSource), \OCP\Util::DEBUG);
|
2014-04-05 21:23:12 +04:00
|
|
|
throw new \Exception($message_t);
|
2014-02-18 15:37:32 +04:00
|
|
|
}
|
2014-05-07 13:23:50 +04:00
|
|
|
|
|
|
|
// Put the item into the database
|
2014-12-04 21:51:04 +03:00
|
|
|
$result = self::put($itemType, $itemSource, $shareType, $shareWith, $uidOwner, $permissions, null, null, $itemSourceName, $expirationDate);
|
|
|
|
|
|
|
|
return $result ? true : false;
|
2014-02-18 15:37:32 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Unshare an item from a user, group, or delete a private link
|
2014-04-15 19:46:11 +04:00
|
|
|
* @param string $itemType
|
|
|
|
* @param string $itemSource
|
|
|
|
* @param int $shareType SHARE_TYPE_USER, SHARE_TYPE_GROUP, or SHARE_TYPE_LINK
|
|
|
|
* @param string $shareWith User or group the item is being shared with
|
2014-11-24 17:31:52 +03:00
|
|
|
* @param string $owner owner of the share, if null the current user is used
|
2014-04-15 19:46:11 +04:00
|
|
|
* @return boolean true on success or false on failure
|
2014-02-18 15:37:32 +04:00
|
|
|
*/
|
2014-11-24 17:31:52 +03:00
|
|
|
public static function unshare($itemType, $itemSource, $shareType, $shareWith, $owner = null) {
|
2014-09-26 18:58:47 +04:00
|
|
|
|
|
|
|
// check if it is a valid itemType
|
|
|
|
self::getBackend($itemType);
|
|
|
|
|
2014-11-24 17:31:52 +03:00
|
|
|
$items = self::getItemSharedWithUser($itemType, $itemSource, $shareWith, $owner, $shareType);
|
2014-09-26 18:58:47 +04:00
|
|
|
|
|
|
|
$toDelete = array();
|
|
|
|
$newParent = null;
|
2014-11-24 17:31:52 +03:00
|
|
|
$currentUser = $owner ? $owner : \OC_User::getUser();
|
2014-09-26 18:58:47 +04:00
|
|
|
foreach ($items as $item) {
|
|
|
|
// delete the item with the expected share_type and owner
|
|
|
|
if ((int)$item['share_type'] === (int)$shareType && $item['uid_owner'] === $currentUser) {
|
|
|
|
$toDelete = $item;
|
2014-12-04 21:51:04 +03:00
|
|
|
// if there is more then one result we don't have to delete the children
|
|
|
|
// but update their parent. For group shares the new parent should always be
|
|
|
|
// the original group share and not the db entry with the unique name
|
2014-09-29 13:23:18 +04:00
|
|
|
} else if ((int)$item['share_type'] === self::$shareTypeGroupUserUnique) {
|
2014-09-26 18:58:47 +04:00
|
|
|
$newParent = $item['parent'];
|
|
|
|
} else {
|
|
|
|
$newParent = $item['id'];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!empty($toDelete)) {
|
|
|
|
self::unshareItem($toDelete, $newParent);
|
2014-02-18 15:37:32 +04:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* sent status if users got informed by mail about share
|
|
|
|
* @param string $itemType
|
|
|
|
* @param string $itemSource
|
|
|
|
* @param int $shareType SHARE_TYPE_USER, SHARE_TYPE_GROUP, or SHARE_TYPE_LINK
|
2014-08-13 19:02:51 +04:00
|
|
|
* @param string $recipient with whom was the file shared
|
2014-05-07 22:46:08 +04:00
|
|
|
* @param boolean $status
|
2014-02-18 15:37:32 +04:00
|
|
|
*/
|
2014-08-13 19:02:51 +04:00
|
|
|
public static function setSendMailStatus($itemType, $itemSource, $shareType, $recipient, $status) {
|
2014-02-18 15:37:32 +04:00
|
|
|
$status = $status ? 1 : 0;
|
|
|
|
|
|
|
|
$query = \OC_DB::prepare(
|
2014-12-04 21:51:04 +03:00
|
|
|
'UPDATE `*PREFIX*share`
|
2014-02-18 15:37:32 +04:00
|
|
|
SET `mail_send` = ?
|
2014-08-13 19:02:51 +04:00
|
|
|
WHERE `item_type` = ? AND `item_source` = ? AND `share_type` = ? AND `share_with` = ?');
|
2014-02-18 15:37:32 +04:00
|
|
|
|
2014-08-13 19:02:51 +04:00
|
|
|
$result = $query->execute(array($status, $itemType, $itemSource, $shareType, $recipient));
|
2014-02-18 15:37:32 +04:00
|
|
|
|
|
|
|
if($result === false) {
|
2015-07-03 15:06:40 +03:00
|
|
|
\OCP\Util::writeLog('OCP\Share', 'Couldn\'t set send mail status', \OCP\Util::ERROR);
|
2014-02-18 15:37:32 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-07-23 18:42:33 +04:00
|
|
|
/**
|
2014-08-02 06:02:39 +04:00
|
|
|
* validate expiration date if it meets all constraints
|
2014-07-23 18:42:33 +04:00
|
|
|
*
|
2016-04-12 19:36:39 +03:00
|
|
|
* @param string $expireDate well formatted date string, e.g. "DD-MM-YYYY"
|
2014-07-23 18:42:33 +04:00
|
|
|
* @param string $shareTime timestamp when the file was shared
|
|
|
|
* @param string $itemType
|
|
|
|
* @param string $itemSource
|
2015-04-28 09:40:47 +03:00
|
|
|
* @return \DateTime validated date
|
|
|
|
* @throws \Exception when the expire date is in the past or further in the future then the enforced date
|
2014-07-23 18:42:33 +04:00
|
|
|
*/
|
|
|
|
private static function validateExpireDate($expireDate, $shareTime, $itemType, $itemSource) {
|
2014-08-31 12:05:59 +04:00
|
|
|
$l = \OC::$server->getL10N('lib');
|
2014-07-23 18:42:33 +04:00
|
|
|
$date = new \DateTime($expireDate);
|
|
|
|
$today = new \DateTime('now');
|
|
|
|
|
|
|
|
// if the user doesn't provide a share time we need to get it from the database
|
|
|
|
// fall-back mode to keep API stable, because the $shareTime parameter was added later
|
|
|
|
$defaultExpireDateEnforced = \OCP\Util::isDefaultExpireDateEnforced();
|
|
|
|
if ($defaultExpireDateEnforced && $shareTime === null) {
|
|
|
|
$items = self::getItemShared($itemType, $itemSource);
|
|
|
|
$firstItem = reset($items);
|
|
|
|
$shareTime = (int)$firstItem['stime'];
|
|
|
|
}
|
|
|
|
|
|
|
|
if ($defaultExpireDateEnforced) {
|
|
|
|
// initialize max date with share time
|
|
|
|
$maxDate = new \DateTime();
|
|
|
|
$maxDate->setTimestamp($shareTime);
|
2018-01-13 16:25:04 +03:00
|
|
|
$maxDays = \OC::$server->getConfig()->getAppValue('core', 'shareapi_expire_after_n_days', '7');
|
2014-07-23 18:42:33 +04:00
|
|
|
$maxDate->add(new \DateInterval('P' . $maxDays . 'D'));
|
|
|
|
if ($date > $maxDate) {
|
2014-08-06 22:48:26 +04:00
|
|
|
$warning = 'Cannot set expiration date. Shares cannot expire later than ' . $maxDays . ' after they have been shared';
|
|
|
|
$warning_t = $l->t('Cannot set expiration date. Shares cannot expire later than %s after they have been shared', array($maxDays));
|
2014-07-23 18:42:33 +04:00
|
|
|
\OCP\Util::writeLog('OCP\Share', $warning, \OCP\Util::WARN);
|
|
|
|
throw new \Exception($warning_t);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if ($date < $today) {
|
2014-08-02 06:02:39 +04:00
|
|
|
$message = 'Cannot set expiration date. Expiration date is in the past';
|
|
|
|
$message_t = $l->t('Cannot set expiration date. Expiration date is in the past');
|
2014-07-23 18:42:33 +04:00
|
|
|
\OCP\Util::writeLog('OCP\Share', $message, \OCP\Util::WARN);
|
|
|
|
throw new \Exception($message_t);
|
|
|
|
}
|
|
|
|
|
|
|
|
return $date;
|
|
|
|
}
|
|
|
|
|
2014-02-18 15:37:32 +04:00
|
|
|
/**
|
|
|
|
* Checks whether a share has expired, calls unshareItem() if yes.
|
|
|
|
* @param array $item Share data (usually database row)
|
2014-05-07 22:46:08 +04:00
|
|
|
* @return boolean True if item was expired, false otherwise.
|
2014-02-18 15:37:32 +04:00
|
|
|
*/
|
|
|
|
protected static function expireItem(array $item) {
|
2014-04-23 14:50:24 +04:00
|
|
|
|
2014-06-03 17:15:04 +04:00
|
|
|
$result = false;
|
2014-05-12 18:15:13 +04:00
|
|
|
|
2014-08-02 06:02:39 +04:00
|
|
|
// only use default expiration date for link shares
|
2014-06-03 17:15:04 +04:00
|
|
|
if ((int) $item['share_type'] === self::SHARE_TYPE_LINK) {
|
|
|
|
|
2014-08-02 06:02:39 +04:00
|
|
|
// calculate expiration date
|
2014-06-03 17:15:04 +04:00
|
|
|
if (!empty($item['expiration'])) {
|
|
|
|
$userDefinedExpire = new \DateTime($item['expiration']);
|
|
|
|
$expires = $userDefinedExpire->getTimestamp();
|
|
|
|
} else {
|
|
|
|
$expires = null;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2014-08-02 06:02:39 +04:00
|
|
|
// get default expiration settings
|
2014-05-12 18:15:13 +04:00
|
|
|
$defaultSettings = Helper::getDefaultExpireSetting();
|
|
|
|
$expires = Helper::calculateExpireDate($defaultSettings, $item['stime'], $expires);
|
2014-04-23 14:50:24 +04:00
|
|
|
|
2014-06-03 17:15:04 +04:00
|
|
|
|
|
|
|
if (is_int($expires)) {
|
|
|
|
$now = time();
|
|
|
|
if ($now > $expires) {
|
|
|
|
self::unshareItem($item);
|
|
|
|
$result = true;
|
|
|
|
}
|
2014-02-18 15:37:32 +04:00
|
|
|
}
|
|
|
|
}
|
2014-06-03 17:15:04 +04:00
|
|
|
return $result;
|
2014-02-18 15:37:32 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Unshares a share given a share data array
|
|
|
|
* @param array $item Share data (usually database row)
|
2015-04-28 09:40:47 +03:00
|
|
|
* @param int $newParent parent ID
|
2014-02-18 15:37:32 +04:00
|
|
|
* @return null
|
|
|
|
*/
|
2014-09-26 18:58:47 +04:00
|
|
|
protected static function unshareItem(array $item, $newParent = null) {
|
2015-02-05 19:11:27 +03:00
|
|
|
|
|
|
|
$shareType = (int)$item['share_type'];
|
|
|
|
$shareWith = null;
|
|
|
|
if ($shareType !== \OCP\Share::SHARE_TYPE_LINK) {
|
|
|
|
$shareWith = $item['share_with'];
|
|
|
|
}
|
|
|
|
|
2014-02-18 15:37:32 +04:00
|
|
|
// Pass all the vars we have for now, they may be useful
|
|
|
|
$hookParams = array(
|
2014-06-24 19:04:27 +04:00
|
|
|
'id' => $item['id'],
|
2014-02-18 15:37:32 +04:00
|
|
|
'itemType' => $item['item_type'],
|
|
|
|
'itemSource' => $item['item_source'],
|
2015-02-05 19:11:27 +03:00
|
|
|
'shareType' => $shareType,
|
|
|
|
'shareWith' => $shareWith,
|
2014-02-18 15:37:32 +04:00
|
|
|
'itemParent' => $item['parent'],
|
|
|
|
'uidOwner' => $item['uid_owner'],
|
|
|
|
);
|
2014-06-24 19:04:27 +04:00
|
|
|
if($item['item_type'] === 'file' || $item['item_type'] === 'folder') {
|
|
|
|
$hookParams['fileSource'] = $item['file_source'];
|
|
|
|
$hookParams['fileTarget'] = $item['file_target'];
|
|
|
|
}
|
2014-02-18 15:37:32 +04:00
|
|
|
|
2018-01-26 01:16:13 +03:00
|
|
|
\OC_Hook::emit(\OCP\Share::class, 'pre_unshare', $hookParams);
|
2014-09-26 18:58:47 +04:00
|
|
|
$deletedShares = Helper::delete($item['id'], false, null, $newParent);
|
2014-06-24 19:04:27 +04:00
|
|
|
$deletedShares[] = $hookParams;
|
|
|
|
$hookParams['deletedShares'] = $deletedShares;
|
2018-01-26 01:16:13 +03:00
|
|
|
\OC_Hook::emit(\OCP\Share::class, 'post_unshare', $hookParams);
|
2014-12-04 21:51:04 +03:00
|
|
|
if ((int)$item['share_type'] === \OCP\Share::SHARE_TYPE_REMOTE && \OC::$server->getUserSession()->getUser()) {
|
2015-06-18 12:46:37 +03:00
|
|
|
list(, $remote) = Helper::splitUserRemote($item['share_with']);
|
|
|
|
self::sendRemoteUnshare($remote, $item['id'], $item['token']);
|
2014-12-04 21:51:04 +03:00
|
|
|
}
|
2014-02-18 15:37:32 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the backend class for the specified item type
|
|
|
|
* @param string $itemType
|
2014-05-13 14:27:35 +04:00
|
|
|
* @throws \Exception
|
2014-02-18 15:37:32 +04:00
|
|
|
* @return \OCP\Share_Backend
|
|
|
|
*/
|
|
|
|
public static function getBackend($itemType) {
|
2014-08-31 12:05:59 +04:00
|
|
|
$l = \OC::$server->getL10N('lib');
|
2014-02-18 15:37:32 +04:00
|
|
|
if (isset(self::$backends[$itemType])) {
|
|
|
|
return self::$backends[$itemType];
|
|
|
|
} else if (isset(self::$backendTypes[$itemType]['class'])) {
|
|
|
|
$class = self::$backendTypes[$itemType]['class'];
|
|
|
|
if (class_exists($class)) {
|
|
|
|
self::$backends[$itemType] = new $class;
|
|
|
|
if (!(self::$backends[$itemType] instanceof \OCP\Share_Backend)) {
|
2014-04-05 21:23:12 +04:00
|
|
|
$message = 'Sharing backend %s must implement the interface OCP\Share_Backend';
|
|
|
|
$message_t = $l->t('Sharing backend %s must implement the interface OCP\Share_Backend', array($class));
|
2015-07-03 15:06:40 +03:00
|
|
|
\OCP\Util::writeLog('OCP\Share', sprintf($message, $class), \OCP\Util::ERROR);
|
2014-04-05 21:23:12 +04:00
|
|
|
throw new \Exception($message_t);
|
2014-02-18 15:37:32 +04:00
|
|
|
}
|
|
|
|
return self::$backends[$itemType];
|
|
|
|
} else {
|
2014-04-05 21:23:12 +04:00
|
|
|
$message = 'Sharing backend %s not found';
|
|
|
|
$message_t = $l->t('Sharing backend %s not found', array($class));
|
2015-07-03 15:06:40 +03:00
|
|
|
\OCP\Util::writeLog('OCP\Share', sprintf($message, $class), \OCP\Util::ERROR);
|
2014-04-05 21:23:12 +04:00
|
|
|
throw new \Exception($message_t);
|
2014-02-18 15:37:32 +04:00
|
|
|
}
|
|
|
|
}
|
2014-04-05 21:23:12 +04:00
|
|
|
$message = 'Sharing backend for %s not found';
|
|
|
|
$message_t = $l->t('Sharing backend for %s not found', array($itemType));
|
2015-07-03 15:06:40 +03:00
|
|
|
\OCP\Util::writeLog('OCP\Share', sprintf($message, $itemType), \OCP\Util::ERROR);
|
2014-04-05 21:23:12 +04:00
|
|
|
throw new \Exception($message_t);
|
2014-02-18 15:37:32 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Check if resharing is allowed
|
2014-04-15 19:46:11 +04:00
|
|
|
* @return boolean true if allowed or false
|
2014-02-18 15:37:32 +04:00
|
|
|
*
|
|
|
|
* Resharing is allowed by default if not configured
|
|
|
|
*/
|
2014-08-05 12:57:13 +04:00
|
|
|
public static function isResharingAllowed() {
|
2014-02-18 15:37:32 +04:00
|
|
|
if (!isset(self::$isResharingAllowed)) {
|
2018-01-17 23:10:40 +03:00
|
|
|
if (\OC::$server->getConfig()->getAppValue('core', 'shareapi_allow_resharing', 'yes') == 'yes') {
|
2014-02-18 15:37:32 +04:00
|
|
|
self::$isResharingAllowed = true;
|
|
|
|
} else {
|
|
|
|
self::$isResharingAllowed = false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return self::$isResharingAllowed;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get a list of collection item types for the specified item type
|
2014-04-15 19:46:11 +04:00
|
|
|
* @param string $itemType
|
2014-02-18 15:37:32 +04:00
|
|
|
* @return array
|
|
|
|
*/
|
|
|
|
private static function getCollectionItemTypes($itemType) {
|
|
|
|
$collectionTypes = array($itemType);
|
|
|
|
foreach (self::$backendTypes as $type => $backend) {
|
|
|
|
if (in_array($backend['collectionOf'], $collectionTypes)) {
|
|
|
|
$collectionTypes[] = $type;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// TODO Add option for collections to be collection of themselves, only 'folder' does it now...
|
2014-09-16 02:20:52 +04:00
|
|
|
if (isset(self::$backendTypes[$itemType]) && (!self::getBackend($itemType) instanceof \OCP\Share_Backend_Collection || $itemType != 'folder')) {
|
2014-02-18 15:37:32 +04:00
|
|
|
unset($collectionTypes[0]);
|
|
|
|
}
|
|
|
|
// Return array if collections were found or the item type is a
|
|
|
|
// collection itself - collections can be inside collections
|
|
|
|
if (count($collectionTypes) > 0) {
|
|
|
|
return $collectionTypes;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2014-09-16 02:20:52 +04:00
|
|
|
/**
|
2014-12-04 21:51:04 +03:00
|
|
|
* Get the owners of items shared with a user.
|
|
|
|
*
|
|
|
|
* @param string $user The user the items are shared with.
|
|
|
|
* @param string $type The type of the items shared with the user.
|
|
|
|
* @param boolean $includeCollections Include collection item types (optional)
|
|
|
|
* @param boolean $includeOwner include owner in the list of users the item is shared with (optional)
|
|
|
|
* @return array
|
|
|
|
*/
|
2014-09-16 02:20:52 +04:00
|
|
|
public static function getSharedItemsOwners($user, $type, $includeCollections = false, $includeOwner = false) {
|
|
|
|
// First, we find out if $type is part of a collection (and if that collection is part of
|
|
|
|
// another one and so on).
|
|
|
|
$collectionTypes = array();
|
|
|
|
if (!$includeCollections || !$collectionTypes = self::getCollectionItemTypes($type)) {
|
|
|
|
$collectionTypes[] = $type;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Of these collection types, along with our original $type, we make a
|
|
|
|
// list of the ones for which a sharing backend has been registered.
|
|
|
|
// FIXME: Ideally, we wouldn't need to nest getItemsSharedWith in this loop but just call it
|
|
|
|
// with its $includeCollections parameter set to true. Unfortunately, this fails currently.
|
|
|
|
$allMaybeSharedItems = array();
|
|
|
|
foreach ($collectionTypes as $collectionType) {
|
|
|
|
if (isset(self::$backends[$collectionType])) {
|
|
|
|
$allMaybeSharedItems[$collectionType] = self::getItemsSharedWithUser(
|
|
|
|
$collectionType,
|
|
|
|
$user,
|
|
|
|
self::FORMAT_NONE
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
$owners = array();
|
|
|
|
if ($includeOwner) {
|
|
|
|
$owners[] = $user;
|
|
|
|
}
|
|
|
|
|
|
|
|
// We take a look at all shared items of the given $type (or of the collections it is part of)
|
|
|
|
// and find out their owners. Then, we gather the tags for the original $type from all owners,
|
|
|
|
// and return them as elements of a list that look like "Tag (owner)".
|
|
|
|
foreach ($allMaybeSharedItems as $collectionType => $maybeSharedItems) {
|
|
|
|
foreach ($maybeSharedItems as $sharedItem) {
|
|
|
|
if (isset($sharedItem['id'])) { //workaround for https://github.com/owncloud/core/issues/2814
|
|
|
|
$owners[] = $sharedItem['uid_owner'];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return $owners;
|
|
|
|
}
|
|
|
|
|
2014-02-18 15:37:32 +04:00
|
|
|
/**
|
|
|
|
* Get shared items from the database
|
2014-04-15 19:46:11 +04:00
|
|
|
* @param string $itemType
|
2014-05-12 00:51:30 +04:00
|
|
|
* @param string $item Item source or target (optional)
|
2014-04-15 19:46:11 +04:00
|
|
|
* @param int $shareType SHARE_TYPE_USER, SHARE_TYPE_GROUP, SHARE_TYPE_LINK, $shareTypeUserAndGroups, or $shareTypeGroupUserUnique
|
|
|
|
* @param string $shareWith User or group the item is being shared with
|
2014-05-12 00:51:30 +04:00
|
|
|
* @param string $uidOwner User that is the owner of shared items (optional)
|
2014-05-01 20:11:30 +04:00
|
|
|
* @param int $format Format to convert items to with formatItems() (optional)
|
|
|
|
* @param mixed $parameters to pass to formatItems() (optional)
|
2014-05-06 20:05:06 +04:00
|
|
|
* @param int $limit Number of items to return, -1 to return all matches (optional)
|
2014-05-07 22:46:08 +04:00
|
|
|
* @param boolean $includeCollections Include collection item types (optional)
|
|
|
|
* @param boolean $itemShareWithBySource (optional)
|
|
|
|
* @param boolean $checkExpireDate
|
2014-03-06 17:00:12 +04:00
|
|
|
* @return array
|
2014-02-18 15:37:32 +04:00
|
|
|
*
|
|
|
|
* See public functions getItem(s)... for parameter usage
|
|
|
|
*
|
|
|
|
*/
|
2014-02-18 18:07:03 +04:00
|
|
|
public static function getItems($itemType, $item = null, $shareType = null, $shareWith = null,
|
2014-12-04 21:51:04 +03:00
|
|
|
$uidOwner = null, $format = self::FORMAT_NONE, $parameters = null, $limit = -1,
|
|
|
|
$includeCollections = false, $itemShareWithBySource = false, $checkExpireDate = true) {
|
2018-01-17 23:10:40 +03:00
|
|
|
if (\OC::$server->getConfig()->getAppValue('core', 'shareapi_enabled', 'yes') != 'yes') {
|
2014-03-06 17:00:12 +04:00
|
|
|
return array();
|
2014-02-18 15:37:32 +04:00
|
|
|
}
|
|
|
|
$backend = self::getBackend($itemType);
|
|
|
|
$collectionTypes = false;
|
|
|
|
// Get filesystem root to add it to the file target and remove from the
|
|
|
|
// file source, match file_source with the file cache
|
|
|
|
if ($itemType == 'file' || $itemType == 'folder') {
|
|
|
|
if(!is_null($uidOwner)) {
|
|
|
|
$root = \OC\Files\Filesystem::getRoot();
|
|
|
|
} else {
|
|
|
|
$root = '';
|
|
|
|
}
|
2015-03-24 13:08:19 +03:00
|
|
|
$where = 'INNER JOIN `*PREFIX*filecache` ON `file_source` = `*PREFIX*filecache`.`fileid` ';
|
2014-02-18 15:37:32 +04:00
|
|
|
if (!isset($item)) {
|
2015-03-24 13:08:19 +03:00
|
|
|
$where .= ' AND `file_target` IS NOT NULL ';
|
2014-02-18 15:37:32 +04:00
|
|
|
}
|
2015-03-24 13:08:19 +03:00
|
|
|
$where .= 'INNER JOIN `*PREFIX*storages` ON `numeric_id` = `*PREFIX*filecache`.`storage` ';
|
2014-02-18 15:37:32 +04:00
|
|
|
$fileDependent = true;
|
|
|
|
$queryArgs = array();
|
|
|
|
} else {
|
|
|
|
$fileDependent = false;
|
|
|
|
$root = '';
|
2014-03-03 20:27:26 +04:00
|
|
|
$collectionTypes = self::getCollectionItemTypes($itemType);
|
|
|
|
if ($includeCollections && !isset($item) && $collectionTypes) {
|
2014-02-18 15:37:32 +04:00
|
|
|
// If includeCollections is true, find collections of this item type, e.g. a music album contains songs
|
|
|
|
if (!in_array($itemType, $collectionTypes)) {
|
|
|
|
$itemTypes = array_merge(array($itemType), $collectionTypes);
|
|
|
|
} else {
|
|
|
|
$itemTypes = $collectionTypes;
|
|
|
|
}
|
|
|
|
$placeholders = join(',', array_fill(0, count($itemTypes), '?'));
|
|
|
|
$where = ' WHERE `item_type` IN ('.$placeholders.'))';
|
|
|
|
$queryArgs = $itemTypes;
|
|
|
|
} else {
|
|
|
|
$where = ' WHERE `item_type` = ?';
|
|
|
|
$queryArgs = array($itemType);
|
|
|
|
}
|
|
|
|
}
|
2018-01-17 23:10:40 +03:00
|
|
|
if (\OC::$server->getConfig()->getAppValue('core', 'shareapi_allow_links', 'yes') !== 'yes') {
|
2014-02-18 15:37:32 +04:00
|
|
|
$where .= ' AND `share_type` != ?';
|
|
|
|
$queryArgs[] = self::SHARE_TYPE_LINK;
|
|
|
|
}
|
|
|
|
if (isset($shareType)) {
|
|
|
|
// Include all user and group items
|
|
|
|
if ($shareType == self::$shareTypeUserAndGroups && isset($shareWith)) {
|
2014-11-17 15:09:13 +03:00
|
|
|
$where .= ' AND ((`share_type` in (?, ?) AND `share_with` = ?) ';
|
2014-02-18 15:37:32 +04:00
|
|
|
$queryArgs[] = self::SHARE_TYPE_USER;
|
|
|
|
$queryArgs[] = self::$shareTypeGroupUserUnique;
|
2014-11-17 15:09:13 +03:00
|
|
|
$queryArgs[] = $shareWith;
|
2017-03-03 10:24:27 +03:00
|
|
|
|
|
|
|
$user = \OC::$server->getUserManager()->get($shareWith);
|
|
|
|
$groups = [];
|
|
|
|
if ($user) {
|
|
|
|
$groups = \OC::$server->getGroupManager()->getUserGroupIds($user);
|
|
|
|
}
|
2014-11-17 15:09:13 +03:00
|
|
|
if (!empty($groups)) {
|
|
|
|
$placeholders = join(',', array_fill(0, count($groups), '?'));
|
|
|
|
$where .= ' OR (`share_type` = ? AND `share_with` IN ('.$placeholders.')) ';
|
|
|
|
$queryArgs[] = self::SHARE_TYPE_GROUP;
|
|
|
|
$queryArgs = array_merge($queryArgs, $groups);
|
|
|
|
}
|
|
|
|
$where .= ')';
|
2014-02-18 15:37:32 +04:00
|
|
|
// Don't include own group shares
|
|
|
|
$where .= ' AND `uid_owner` != ?';
|
|
|
|
$queryArgs[] = $shareWith;
|
|
|
|
} else {
|
|
|
|
$where .= ' AND `share_type` = ?';
|
|
|
|
$queryArgs[] = $shareType;
|
|
|
|
if (isset($shareWith)) {
|
|
|
|
$where .= ' AND `share_with` = ?';
|
|
|
|
$queryArgs[] = $shareWith;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (isset($uidOwner)) {
|
|
|
|
$where .= ' AND `uid_owner` = ?';
|
|
|
|
$queryArgs[] = $uidOwner;
|
|
|
|
if (!isset($shareType)) {
|
|
|
|
// Prevent unique user targets for group shares from being selected
|
|
|
|
$where .= ' AND `share_type` != ?';
|
|
|
|
$queryArgs[] = self::$shareTypeGroupUserUnique;
|
|
|
|
}
|
2014-03-03 20:24:31 +04:00
|
|
|
if ($fileDependent) {
|
2014-02-18 15:37:32 +04:00
|
|
|
$column = 'file_source';
|
|
|
|
} else {
|
|
|
|
$column = 'item_source';
|
|
|
|
}
|
|
|
|
} else {
|
2014-03-03 20:24:31 +04:00
|
|
|
if ($fileDependent) {
|
2014-02-18 15:37:32 +04:00
|
|
|
$column = 'file_target';
|
|
|
|
} else {
|
|
|
|
$column = 'item_target';
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (isset($item)) {
|
2014-03-03 20:27:26 +04:00
|
|
|
$collectionTypes = self::getCollectionItemTypes($itemType);
|
2014-10-01 17:13:10 +04:00
|
|
|
if ($includeCollections && $collectionTypes && !in_array('folder', $collectionTypes)) {
|
2014-02-18 15:37:32 +04:00
|
|
|
$where .= ' AND (';
|
|
|
|
} else {
|
|
|
|
$where .= ' AND';
|
|
|
|
}
|
|
|
|
// If looking for own shared items, check item_source else check item_target
|
|
|
|
if (isset($uidOwner) || $itemShareWithBySource) {
|
|
|
|
// If item type is a file, file source needs to be checked in case the item was converted
|
2014-03-03 20:24:31 +04:00
|
|
|
if ($fileDependent) {
|
2014-02-18 15:37:32 +04:00
|
|
|
$where .= ' `file_source` = ?';
|
|
|
|
$column = 'file_source';
|
|
|
|
} else {
|
|
|
|
$where .= ' `item_source` = ?';
|
|
|
|
$column = 'item_source';
|
|
|
|
}
|
|
|
|
} else {
|
2014-03-03 20:24:31 +04:00
|
|
|
if ($fileDependent) {
|
2014-02-18 15:37:32 +04:00
|
|
|
$where .= ' `file_target` = ?';
|
|
|
|
$item = \OC\Files\Filesystem::normalizePath($item);
|
|
|
|
} else {
|
|
|
|
$where .= ' `item_target` = ?';
|
|
|
|
}
|
|
|
|
}
|
|
|
|
$queryArgs[] = $item;
|
2014-10-01 17:13:10 +04:00
|
|
|
if ($includeCollections && $collectionTypes && !in_array('folder', $collectionTypes)) {
|
2014-02-18 15:37:32 +04:00
|
|
|
$placeholders = join(',', array_fill(0, count($collectionTypes), '?'));
|
|
|
|
$where .= ' OR `item_type` IN ('.$placeholders.'))';
|
|
|
|
$queryArgs = array_merge($queryArgs, $collectionTypes);
|
|
|
|
}
|
|
|
|
}
|
2014-08-22 17:59:44 +04:00
|
|
|
|
2014-09-26 15:01:54 +04:00
|
|
|
if ($shareType == self::$shareTypeUserAndGroups && $limit === 1) {
|
2014-08-22 17:59:44 +04:00
|
|
|
// Make sure the unique user target is returned if it exists,
|
|
|
|
// unique targets should follow the group share in the database
|
|
|
|
// If the limit is not 1, the filtering can be done later
|
|
|
|
$where .= ' ORDER BY `*PREFIX*share`.`id` DESC';
|
|
|
|
} else {
|
|
|
|
$where .= ' ORDER BY `*PREFIX*share`.`id` ASC';
|
|
|
|
}
|
|
|
|
|
2014-02-18 15:37:32 +04:00
|
|
|
if ($limit != -1 && !$includeCollections) {
|
|
|
|
// The limit must be at least 3, because filtering needs to be done
|
|
|
|
if ($limit < 3) {
|
|
|
|
$queryLimit = 3;
|
|
|
|
} else {
|
|
|
|
$queryLimit = $limit;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
$queryLimit = null;
|
|
|
|
}
|
2014-03-03 20:06:45 +04:00
|
|
|
$select = self::createSelectStatement($format, $fileDependent, $uidOwner);
|
2014-02-18 15:37:32 +04:00
|
|
|
$root = strlen($root);
|
|
|
|
$query = \OC_DB::prepare('SELECT '.$select.' FROM `*PREFIX*share` '.$where, $queryLimit);
|
|
|
|
$result = $query->execute($queryArgs);
|
2016-01-07 12:14:05 +03:00
|
|
|
if ($result === false) {
|
2015-07-03 15:06:40 +03:00
|
|
|
\OCP\Util::writeLog('OCP\Share',
|
2015-04-18 18:02:39 +03:00
|
|
|
\OC_DB::getErrorMessage() . ', select=' . $select . ' where=',
|
2015-07-03 15:06:40 +03:00
|
|
|
\OCP\Util::ERROR);
|
2014-02-18 15:37:32 +04:00
|
|
|
}
|
|
|
|
$items = array();
|
|
|
|
$targets = array();
|
|
|
|
$switchedItems = array();
|
|
|
|
$mounts = array();
|
|
|
|
while ($row = $result->fetchRow()) {
|
2014-03-03 20:20:09 +04:00
|
|
|
self::transformDBResults($row);
|
2014-02-18 15:37:32 +04:00
|
|
|
// Filter out duplicate group shares for users with unique targets
|
2015-03-24 13:08:19 +03:00
|
|
|
if ($fileDependent && !self::isFileReachable($row['path'], $row['storage_id'])) {
|
|
|
|
continue;
|
|
|
|
}
|
2014-02-18 15:37:32 +04:00
|
|
|
if ($row['share_type'] == self::$shareTypeGroupUserUnique && isset($items[$row['parent']])) {
|
|
|
|
$row['share_type'] = self::SHARE_TYPE_GROUP;
|
2014-04-14 14:04:12 +04:00
|
|
|
$row['unique_name'] = true; // remember that we use a unique name for this user
|
2014-02-18 15:37:32 +04:00
|
|
|
$row['share_with'] = $items[$row['parent']]['share_with'];
|
2014-09-26 15:01:54 +04:00
|
|
|
// if the group share was unshared from the user we keep the permission, otherwise
|
|
|
|
// we take the permission from the parent because this is always the up-to-date
|
|
|
|
// permission for the group share
|
|
|
|
if ($row['permissions'] > 0) {
|
|
|
|
$row['permissions'] = $items[$row['parent']]['permissions'];
|
|
|
|
}
|
2014-02-18 15:37:32 +04:00
|
|
|
// Remove the parent group share
|
|
|
|
unset($items[$row['parent']]);
|
|
|
|
if ($row['permissions'] == 0) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
} else if (!isset($uidOwner)) {
|
|
|
|
// Check if the same target already exists
|
2014-08-22 17:59:44 +04:00
|
|
|
if (isset($targets[$row['id']])) {
|
2014-02-18 15:37:32 +04:00
|
|
|
// Check if the same owner shared with the user twice
|
|
|
|
// through a group and user share - this is allowed
|
2014-08-22 17:59:44 +04:00
|
|
|
$id = $targets[$row['id']];
|
2014-02-18 15:37:32 +04:00
|
|
|
if (isset($items[$id]) && $items[$id]['uid_owner'] == $row['uid_owner']) {
|
|
|
|
// Switch to group share type to ensure resharing conditions aren't bypassed
|
|
|
|
if ($items[$id]['share_type'] != self::SHARE_TYPE_GROUP) {
|
|
|
|
$items[$id]['share_type'] = self::SHARE_TYPE_GROUP;
|
|
|
|
$items[$id]['share_with'] = $row['share_with'];
|
|
|
|
}
|
|
|
|
// Switch ids if sharing permission is granted on only
|
|
|
|
// one share to ensure correct parent is used if resharing
|
2014-11-25 18:28:41 +03:00
|
|
|
if (~(int)$items[$id]['permissions'] & \OCP\Constants::PERMISSION_SHARE
|
|
|
|
&& (int)$row['permissions'] & \OCP\Constants::PERMISSION_SHARE) {
|
2014-02-18 15:37:32 +04:00
|
|
|
$items[$row['id']] = $items[$id];
|
|
|
|
$switchedItems[$id] = $row['id'];
|
|
|
|
unset($items[$id]);
|
|
|
|
$id = $row['id'];
|
|
|
|
}
|
|
|
|
$items[$id]['permissions'] |= (int)$row['permissions'];
|
2014-08-22 17:59:44 +04:00
|
|
|
|
2014-02-18 15:37:32 +04:00
|
|
|
}
|
2014-08-22 17:59:44 +04:00
|
|
|
continue;
|
|
|
|
} elseif (!empty($row['parent'])) {
|
|
|
|
$targets[$row['parent']] = $row['id'];
|
2014-02-18 15:37:32 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
// Remove root from file source paths if retrieving own shared items
|
|
|
|
if (isset($uidOwner) && isset($row['path'])) {
|
|
|
|
if (isset($row['parent'])) {
|
|
|
|
$query = \OC_DB::prepare('SELECT `file_target` FROM `*PREFIX*share` WHERE `id` = ?');
|
|
|
|
$parentResult = $query->execute(array($row['parent']));
|
2016-01-07 12:14:05 +03:00
|
|
|
if ($result === false) {
|
2015-07-03 15:06:40 +03:00
|
|
|
\OCP\Util::writeLog('OCP\Share', 'Can\'t select parent: ' .
|
2015-04-18 18:02:39 +03:00
|
|
|
\OC_DB::getErrorMessage() . ', select=' . $select . ' where=' . $where,
|
2015-07-03 15:06:40 +03:00
|
|
|
\OCP\Util::ERROR);
|
2014-02-18 15:37:32 +04:00
|
|
|
} else {
|
|
|
|
$parentRow = $parentResult->fetchRow();
|
2014-04-08 21:57:07 +04:00
|
|
|
$tmpPath = $parentRow['file_target'];
|
2014-03-11 15:58:46 +04:00
|
|
|
// find the right position where the row path continues from the target path
|
|
|
|
$pos = strrpos($row['path'], $parentRow['file_target']);
|
|
|
|
$subPath = substr($row['path'], $pos);
|
|
|
|
$splitPath = explode('/', $subPath);
|
2014-02-18 15:37:32 +04:00
|
|
|
foreach (array_slice($splitPath, 2) as $pathPart) {
|
|
|
|
$tmpPath = $tmpPath . '/' . $pathPart;
|
|
|
|
}
|
2014-03-11 15:58:46 +04:00
|
|
|
$row['path'] = $tmpPath;
|
2014-02-18 15:37:32 +04:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (!isset($mounts[$row['storage']])) {
|
|
|
|
$mountPoints = \OC\Files\Filesystem::getMountByNumericId($row['storage']);
|
2014-04-21 14:35:52 +04:00
|
|
|
if (is_array($mountPoints) && !empty($mountPoints)) {
|
2014-02-18 15:37:32 +04:00
|
|
|
$mounts[$row['storage']] = current($mountPoints);
|
|
|
|
}
|
|
|
|
}
|
2014-10-01 17:13:10 +04:00
|
|
|
if (!empty($mounts[$row['storage']])) {
|
2014-02-18 15:37:32 +04:00
|
|
|
$path = $mounts[$row['storage']]->getMountPoint().$row['path'];
|
2014-08-05 22:34:32 +04:00
|
|
|
$relPath = substr($path, $root); // path relative to data/user
|
|
|
|
$row['path'] = rtrim($relPath, '/');
|
2014-02-18 15:37:32 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2014-09-25 14:35:11 +04:00
|
|
|
|
2014-02-18 15:37:32 +04:00
|
|
|
if($checkExpireDate) {
|
|
|
|
if (self::expireItem($row)) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// Check if resharing is allowed, if not remove share permission
|
2015-11-19 17:35:58 +03:00
|
|
|
if (isset($row['permissions']) && (!self::isResharingAllowed() | \OCP\Util::isSharingDisabledForUser())) {
|
2014-11-25 18:28:41 +03:00
|
|
|
$row['permissions'] &= ~\OCP\Constants::PERMISSION_SHARE;
|
2014-02-18 15:37:32 +04:00
|
|
|
}
|
|
|
|
// Add display names to result
|
2015-06-25 13:14:03 +03:00
|
|
|
$row['share_with_displayname'] = $row['share_with'];
|
2014-11-18 13:41:45 +03:00
|
|
|
if ( isset($row['share_with']) && $row['share_with'] != '' &&
|
2015-06-25 13:14:46 +03:00
|
|
|
$row['share_type'] === self::SHARE_TYPE_USER) {
|
2014-02-18 15:37:32 +04:00
|
|
|
$row['share_with_displayname'] = \OCP\User::getDisplayName($row['share_with']);
|
2015-06-25 13:14:03 +03:00
|
|
|
} else if(isset($row['share_with']) && $row['share_with'] != '' &&
|
|
|
|
$row['share_type'] === self::SHARE_TYPE_REMOTE) {
|
|
|
|
$addressBookEntries = \OC::$server->getContactsManager()->search($row['share_with'], ['CLOUD']);
|
|
|
|
foreach ($addressBookEntries as $entry) {
|
|
|
|
foreach ($entry['CLOUD'] as $cloudID) {
|
|
|
|
if ($cloudID === $row['share_with']) {
|
|
|
|
$row['share_with_displayname'] = $entry['FN'];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2014-02-18 15:37:32 +04:00
|
|
|
}
|
|
|
|
if ( isset($row['uid_owner']) && $row['uid_owner'] != '') {
|
|
|
|
$row['displayname_owner'] = \OCP\User::getDisplayName($row['uid_owner']);
|
|
|
|
}
|
|
|
|
|
2014-08-22 17:59:44 +04:00
|
|
|
if ($row['permissions'] > 0) {
|
|
|
|
$items[$row['id']] = $row;
|
|
|
|
}
|
2014-07-31 13:55:59 +04:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2014-08-22 17:59:44 +04:00
|
|
|
// group items if we are looking for items shared with the current user
|
2014-07-31 13:55:59 +04:00
|
|
|
if (isset($shareWith) && $shareWith === \OCP\User::getUser()) {
|
|
|
|
$items = self::groupItems($items, $itemType);
|
2014-02-18 15:37:32 +04:00
|
|
|
}
|
2014-07-31 13:55:59 +04:00
|
|
|
|
2014-02-18 15:37:32 +04:00
|
|
|
if (!empty($items)) {
|
|
|
|
$collectionItems = array();
|
|
|
|
foreach ($items as &$row) {
|
|
|
|
// Return only the item instead of a 2-dimensional array
|
|
|
|
if ($limit == 1 && $row[$column] == $item && ($row['item_type'] == $itemType || $itemType == 'file')) {
|
|
|
|
if ($format == self::FORMAT_NONE) {
|
|
|
|
return $row;
|
|
|
|
} else {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// Check if this is a collection of the requested item type
|
2014-10-01 17:13:10 +04:00
|
|
|
if ($includeCollections && $collectionTypes && $row['item_type'] !== 'folder' && in_array($row['item_type'], $collectionTypes)) {
|
2014-02-18 15:37:32 +04:00
|
|
|
if (($collectionBackend = self::getBackend($row['item_type']))
|
|
|
|
&& $collectionBackend instanceof \OCP\Share_Backend_Collection) {
|
|
|
|
// Collections can be inside collections, check if the item is a collection
|
|
|
|
if (isset($item) && $row['item_type'] == $itemType && $row[$column] == $item) {
|
|
|
|
$collectionItems[] = $row;
|
|
|
|
} else {
|
|
|
|
$collection = array();
|
|
|
|
$collection['item_type'] = $row['item_type'];
|
|
|
|
if ($row['item_type'] == 'file' || $row['item_type'] == 'folder') {
|
|
|
|
$collection['path'] = basename($row['path']);
|
|
|
|
}
|
|
|
|
$row['collection'] = $collection;
|
|
|
|
// Fetch all of the children sources
|
|
|
|
$children = $collectionBackend->getChildren($row[$column]);
|
|
|
|
foreach ($children as $child) {
|
|
|
|
$childItem = $row;
|
|
|
|
$childItem['item_type'] = $itemType;
|
|
|
|
if ($row['item_type'] != 'file' && $row['item_type'] != 'folder') {
|
|
|
|
$childItem['item_source'] = $child['source'];
|
|
|
|
$childItem['item_target'] = $child['target'];
|
|
|
|
}
|
|
|
|
if ($backend instanceof \OCP\Share_Backend_File_Dependent) {
|
|
|
|
if ($row['item_type'] == 'file' || $row['item_type'] == 'folder') {
|
|
|
|
$childItem['file_source'] = $child['source'];
|
2014-03-06 18:30:01 +04:00
|
|
|
} else { // TODO is this really needed if we already know that we use the file backend?
|
2014-02-18 15:37:32 +04:00
|
|
|
$meta = \OC\Files\Filesystem::getFileInfo($child['file_path']);
|
|
|
|
$childItem['file_source'] = $meta['fileid'];
|
|
|
|
}
|
|
|
|
$childItem['file_target'] =
|
|
|
|
\OC\Files\Filesystem::normalizePath($child['file_path']);
|
|
|
|
}
|
|
|
|
if (isset($item)) {
|
|
|
|
if ($childItem[$column] == $item) {
|
|
|
|
// Return only the item instead of a 2-dimensional array
|
|
|
|
if ($limit == 1) {
|
|
|
|
if ($format == self::FORMAT_NONE) {
|
|
|
|
return $childItem;
|
|
|
|
} else {
|
|
|
|
// Unset the items array and break out of both loops
|
|
|
|
$items = array();
|
|
|
|
$items[] = $childItem;
|
|
|
|
break 2;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
$collectionItems[] = $childItem;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
$collectionItems[] = $childItem;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// Remove collection item
|
|
|
|
$toRemove = $row['id'];
|
|
|
|
if (array_key_exists($toRemove, $switchedItems)) {
|
|
|
|
$toRemove = $switchedItems[$toRemove];
|
|
|
|
}
|
|
|
|
unset($items[$toRemove]);
|
2014-10-01 17:13:10 +04:00
|
|
|
} elseif ($includeCollections && $collectionTypes && in_array($row['item_type'], $collectionTypes)) {
|
|
|
|
// FIXME: Thats a dirty hack to improve file sharing performance,
|
|
|
|
// see github issue #10588 for more details
|
|
|
|
// Need to find a solution which works for all back-ends
|
|
|
|
$collectionBackend = self::getBackend($row['item_type']);
|
|
|
|
$sharedParents = $collectionBackend->getParents($row['item_source']);
|
|
|
|
foreach ($sharedParents as $parent) {
|
|
|
|
$collectionItems[] = $parent;
|
|
|
|
}
|
2014-02-18 15:37:32 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!empty($collectionItems)) {
|
2015-10-13 11:05:49 +03:00
|
|
|
$collectionItems = array_unique($collectionItems, SORT_REGULAR);
|
2014-02-18 15:37:32 +04:00
|
|
|
$items = array_merge($items, $collectionItems);
|
|
|
|
}
|
2014-03-06 17:00:12 +04:00
|
|
|
|
2015-10-05 12:27:47 +03:00
|
|
|
// filter out invalid items, these can appear when subshare entries exist
|
|
|
|
// for a group in which the requested user isn't a member any more
|
|
|
|
$items = array_filter($items, function($item) {
|
|
|
|
return $item['share_type'] !== self::$shareTypeGroupUserUnique;
|
|
|
|
});
|
|
|
|
|
2014-03-03 20:30:16 +04:00
|
|
|
return self::formatResult($items, $column, $backend, $format, $parameters);
|
2014-10-01 17:13:10 +04:00
|
|
|
} elseif ($includeCollections && $collectionTypes && in_array('folder', $collectionTypes)) {
|
|
|
|
// FIXME: Thats a dirty hack to improve file sharing performance,
|
|
|
|
// see github issue #10588 for more details
|
|
|
|
// Need to find a solution which works for all back-ends
|
|
|
|
$collectionItems = array();
|
|
|
|
$collectionBackend = self::getBackend('folder');
|
2014-11-10 15:08:45 +03:00
|
|
|
$sharedParents = $collectionBackend->getParents($item, $shareWith, $uidOwner);
|
2014-10-01 17:13:10 +04:00
|
|
|
foreach ($sharedParents as $parent) {
|
|
|
|
$collectionItems[] = $parent;
|
|
|
|
}
|
|
|
|
if ($limit === 1) {
|
|
|
|
return reset($collectionItems);
|
|
|
|
}
|
|
|
|
return self::formatResult($collectionItems, $column, $backend, $format, $parameters);
|
2014-02-18 15:37:32 +04:00
|
|
|
}
|
2014-03-06 17:00:12 +04:00
|
|
|
|
2014-02-18 15:37:32 +04:00
|
|
|
return array();
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2014-07-31 13:55:59 +04:00
|
|
|
* group items with link to the same source
|
|
|
|
*
|
|
|
|
* @param array $items
|
|
|
|
* @param string $itemType
|
|
|
|
* @return array of grouped items
|
|
|
|
*/
|
2014-08-01 18:24:19 +04:00
|
|
|
protected static function groupItems($items, $itemType) {
|
2014-07-31 13:55:59 +04:00
|
|
|
|
2018-01-26 14:36:25 +03:00
|
|
|
$fileSharing = $itemType === 'file' || $itemType === 'folder';
|
2014-07-31 13:55:59 +04:00
|
|
|
|
|
|
|
$result = array();
|
|
|
|
|
|
|
|
foreach ($items as $item) {
|
|
|
|
$grouped = false;
|
|
|
|
foreach ($result as $key => $r) {
|
|
|
|
// for file/folder shares we need to compare file_source, otherwise we compare item_source
|
|
|
|
// only group shares if they already point to the same target, otherwise the file where shared
|
|
|
|
// before grouping of shares was added. In this case we don't group them toi avoid confusions
|
|
|
|
if (( $fileSharing && $item['file_source'] === $r['file_source'] && $item['file_target'] === $r['file_target']) ||
|
2014-12-04 21:51:04 +03:00
|
|
|
(!$fileSharing && $item['item_source'] === $r['item_source'] && $item['item_target'] === $r['item_target'])) {
|
2014-07-31 13:55:59 +04:00
|
|
|
// add the first item to the list of grouped shares
|
|
|
|
if (!isset($result[$key]['grouped'])) {
|
|
|
|
$result[$key]['grouped'][] = $result[$key];
|
|
|
|
}
|
|
|
|
$result[$key]['permissions'] = (int) $item['permissions'] | (int) $r['permissions'];
|
|
|
|
$result[$key]['grouped'][] = $item;
|
|
|
|
$grouped = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!$grouped) {
|
|
|
|
$result[] = $item;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
return $result;
|
|
|
|
}
|
|
|
|
|
2014-12-04 21:51:04 +03:00
|
|
|
/**
|
2014-02-18 15:37:32 +04:00
|
|
|
* Put shared item into the database
|
2014-04-15 19:46:11 +04:00
|
|
|
* @param string $itemType Item type
|
|
|
|
* @param string $itemSource Item source
|
|
|
|
* @param int $shareType SHARE_TYPE_USER, SHARE_TYPE_GROUP, or SHARE_TYPE_LINK
|
|
|
|
* @param string $shareWith User or group the item is being shared with
|
|
|
|
* @param string $uidOwner User that is the owner of shared item
|
|
|
|
* @param int $permissions CRUDS permissions
|
2014-05-07 22:46:08 +04:00
|
|
|
* @param boolean|array $parentFolder Parent folder target (optional)
|
2014-04-15 19:46:11 +04:00
|
|
|
* @param string $token (optional)
|
|
|
|
* @param string $itemSourceName name of the source item (optional)
|
2014-05-07 13:23:50 +04:00
|
|
|
* @param \DateTime $expirationDate (optional)
|
2014-05-13 14:27:35 +04:00
|
|
|
* @throws \Exception
|
2014-12-04 21:51:04 +03:00
|
|
|
* @return mixed id of the new share or false
|
2014-02-18 15:37:32 +04:00
|
|
|
*/
|
|
|
|
private static function put($itemType, $itemSource, $shareType, $shareWith, $uidOwner,
|
2014-12-04 21:51:04 +03:00
|
|
|
$permissions, $parentFolder = null, $token = null, $itemSourceName = null, \DateTime $expirationDate = null) {
|
2014-04-05 21:23:12 +04:00
|
|
|
|
2014-07-31 13:55:59 +04:00
|
|
|
$queriesToExecute = array();
|
2014-09-29 13:23:18 +04:00
|
|
|
$suggestedItemTarget = null;
|
2015-10-05 13:03:36 +03:00
|
|
|
$groupFileTarget = $fileTarget = $suggestedFileTarget = $filePath = '';
|
|
|
|
$groupItemTarget = $itemTarget = $fileSource = $parent = 0;
|
2014-04-05 21:23:12 +04:00
|
|
|
|
2014-07-31 13:55:59 +04:00
|
|
|
$result = self::checkReshare($itemType, $itemSource, $shareType, $shareWith, $uidOwner, $permissions, $itemSourceName, $expirationDate);
|
|
|
|
if(!empty($result)) {
|
|
|
|
$parent = $result['parent'];
|
|
|
|
$itemSource = $result['itemSource'];
|
|
|
|
$fileSource = $result['fileSource'];
|
|
|
|
$suggestedItemTarget = $result['suggestedItemTarget'];
|
|
|
|
$suggestedFileTarget = $result['suggestedFileTarget'];
|
|
|
|
$filePath = $result['filePath'];
|
2014-02-18 15:37:32 +04:00
|
|
|
}
|
2014-05-07 13:23:50 +04:00
|
|
|
|
2014-07-31 13:55:59 +04:00
|
|
|
$isGroupShare = false;
|
2014-02-18 15:37:32 +04:00
|
|
|
if ($shareType == self::SHARE_TYPE_GROUP) {
|
2014-07-31 13:55:59 +04:00
|
|
|
$isGroupShare = true;
|
2015-02-05 16:00:05 +03:00
|
|
|
if (isset($shareWith['users'])) {
|
|
|
|
$users = $shareWith['users'];
|
|
|
|
} else {
|
2017-03-03 10:24:27 +03:00
|
|
|
$group = \OC::$server->getGroupManager()->get($shareWith['group']);
|
|
|
|
if ($group) {
|
|
|
|
$users = $group->searchUsers('', -1, 0);
|
|
|
|
$userIds = [];
|
|
|
|
foreach ($users as $user) {
|
|
|
|
$userIds[] = $user->getUID();
|
|
|
|
}
|
|
|
|
$users = $userIds;
|
|
|
|
} else {
|
|
|
|
$users = [];
|
|
|
|
}
|
2015-02-05 16:00:05 +03:00
|
|
|
}
|
2014-07-31 13:55:59 +04:00
|
|
|
// remove current user from list
|
|
|
|
if (in_array(\OCP\User::getUser(), $users)) {
|
|
|
|
unset($users[array_search(\OCP\User::getUser(), $users)]);
|
2014-02-18 15:37:32 +04:00
|
|
|
}
|
2015-03-20 17:51:25 +03:00
|
|
|
$groupItemTarget = Helper::generateTarget($itemType, $itemSource,
|
|
|
|
$shareType, $shareWith['group'], $uidOwner, $suggestedItemTarget);
|
|
|
|
$groupFileTarget = Helper::generateTarget($itemType, $itemSource,
|
|
|
|
$shareType, $shareWith['group'], $uidOwner, $filePath);
|
2014-02-18 15:37:32 +04:00
|
|
|
|
2014-07-31 13:55:59 +04:00
|
|
|
// add group share to table and remember the id as parent
|
2014-05-07 13:23:50 +04:00
|
|
|
$queriesToExecute['groupShare'] = array(
|
|
|
|
'itemType' => $itemType,
|
|
|
|
'itemSource' => $itemSource,
|
|
|
|
'itemTarget' => $groupItemTarget,
|
|
|
|
'shareType' => $shareType,
|
|
|
|
'shareWith' => $shareWith['group'],
|
|
|
|
'uidOwner' => $uidOwner,
|
|
|
|
'permissions' => $permissions,
|
|
|
|
'shareTime' => time(),
|
|
|
|
'fileSource' => $fileSource,
|
2015-03-20 17:51:25 +03:00
|
|
|
'fileTarget' => $groupFileTarget,
|
2014-05-07 13:23:50 +04:00
|
|
|
'token' => $token,
|
|
|
|
'parent' => $parent,
|
|
|
|
'expiration' => $expirationDate,
|
|
|
|
);
|
2014-07-31 13:55:59 +04:00
|
|
|
|
|
|
|
} else {
|
|
|
|
$users = array($shareWith);
|
|
|
|
$itemTarget = Helper::generateTarget($itemType, $itemSource, $shareType, $shareWith, $uidOwner,
|
2014-12-04 21:51:04 +03:00
|
|
|
$suggestedItemTarget);
|
2014-07-31 13:55:59 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
$run = true;
|
|
|
|
$error = '';
|
|
|
|
$preHookData = array(
|
|
|
|
'itemType' => $itemType,
|
|
|
|
'itemSource' => $itemSource,
|
|
|
|
'shareType' => $shareType,
|
|
|
|
'uidOwner' => $uidOwner,
|
|
|
|
'permissions' => $permissions,
|
|
|
|
'fileSource' => $fileSource,
|
|
|
|
'expiration' => $expirationDate,
|
|
|
|
'token' => $token,
|
|
|
|
'run' => &$run,
|
|
|
|
'error' => &$error
|
|
|
|
);
|
|
|
|
|
2018-01-27 01:46:40 +03:00
|
|
|
$preHookData['itemTarget'] = $isGroupShare ? $groupItemTarget : $itemTarget;
|
|
|
|
$preHookData['shareWith'] = $isGroupShare ? $shareWith['group'] : $shareWith;
|
2014-07-31 13:55:59 +04:00
|
|
|
|
2018-01-26 01:16:13 +03:00
|
|
|
\OC_Hook::emit(\OCP\Share::class, 'pre_shared', $preHookData);
|
2014-07-31 13:55:59 +04:00
|
|
|
|
|
|
|
if ($run === false) {
|
|
|
|
throw new \Exception($error);
|
|
|
|
}
|
|
|
|
|
|
|
|
foreach ($users as $user) {
|
2014-08-22 17:59:44 +04:00
|
|
|
$sourceId = ($itemType === 'file' || $itemType === 'folder') ? $fileSource : $itemSource;
|
|
|
|
$sourceExists = self::getItemSharedWithBySource($itemType, $sourceId, self::FORMAT_NONE, null, true, $user);
|
2014-07-31 13:55:59 +04:00
|
|
|
|
2018-01-27 01:46:40 +03:00
|
|
|
$userShareType = $isGroupShare ? self::$shareTypeGroupUserUnique : $shareType;
|
2014-07-31 13:55:59 +04:00
|
|
|
|
2015-10-02 14:07:20 +03:00
|
|
|
if ($sourceExists && $sourceExists['item_source'] === $itemSource) {
|
2014-07-31 13:55:59 +04:00
|
|
|
$fileTarget = $sourceExists['file_target'];
|
|
|
|
$itemTarget = $sourceExists['item_target'];
|
|
|
|
|
2014-09-26 15:01:54 +04:00
|
|
|
// for group shares we don't need a additional entry if the target is the same
|
2014-09-26 15:10:31 +04:00
|
|
|
if($isGroupShare && $groupItemTarget === $itemTarget) {
|
|
|
|
continue;
|
|
|
|
}
|
2014-09-26 15:01:54 +04:00
|
|
|
|
2014-07-31 13:55:59 +04:00
|
|
|
} elseif(!$sourceExists && !$isGroupShare) {
|
|
|
|
|
2015-02-09 14:59:29 +03:00
|
|
|
$itemTarget = Helper::generateTarget($itemType, $itemSource, $userShareType, $user,
|
2014-02-18 15:37:32 +04:00
|
|
|
$uidOwner, $suggestedItemTarget, $parent);
|
|
|
|
if (isset($fileSource)) {
|
|
|
|
if ($parentFolder) {
|
|
|
|
if ($parentFolder === true) {
|
2015-02-09 14:59:29 +03:00
|
|
|
$fileTarget = Helper::generateTarget('file', $filePath, $userShareType, $user,
|
2014-02-18 15:37:32 +04:00
|
|
|
$uidOwner, $suggestedFileTarget, $parent);
|
|
|
|
if ($fileTarget != $groupFileTarget) {
|
2014-07-31 13:55:59 +04:00
|
|
|
$parentFolders[$user]['folder'] = $fileTarget;
|
2014-02-18 15:37:32 +04:00
|
|
|
}
|
2014-07-31 13:55:59 +04:00
|
|
|
} else if (isset($parentFolder[$user])) {
|
|
|
|
$fileTarget = $parentFolder[$user]['folder'].$itemSource;
|
|
|
|
$parent = $parentFolder[$user]['id'];
|
2014-02-18 15:37:32 +04:00
|
|
|
}
|
|
|
|
} else {
|
2015-02-09 14:59:29 +03:00
|
|
|
$fileTarget = Helper::generateTarget('file', $filePath, $userShareType,
|
2014-07-31 13:55:59 +04:00
|
|
|
$user, $uidOwner, $suggestedFileTarget, $parent);
|
2014-02-18 15:37:32 +04:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
$fileTarget = null;
|
|
|
|
}
|
2014-05-07 13:23:50 +04:00
|
|
|
|
2014-07-31 13:55:59 +04:00
|
|
|
} else {
|
2014-08-22 17:59:44 +04:00
|
|
|
|
|
|
|
// group share which doesn't exists until now, check if we need a unique target for this user
|
|
|
|
|
|
|
|
$itemTarget = Helper::generateTarget($itemType, $itemSource, self::SHARE_TYPE_USER, $user,
|
|
|
|
$uidOwner, $suggestedItemTarget, $parent);
|
|
|
|
|
|
|
|
// do we also need a file target
|
|
|
|
if (isset($fileSource)) {
|
|
|
|
$fileTarget = Helper::generateTarget('file', $filePath, self::SHARE_TYPE_USER, $user,
|
2014-12-04 21:51:04 +03:00
|
|
|
$uidOwner, $suggestedFileTarget, $parent);
|
2014-08-22 17:59:44 +04:00
|
|
|
} else {
|
|
|
|
$fileTarget = null;
|
|
|
|
}
|
|
|
|
|
2015-02-05 16:00:05 +03:00
|
|
|
if (($itemTarget === $groupItemTarget) &&
|
|
|
|
(!isset($fileSource) || $fileTarget === $groupFileTarget)) {
|
2014-08-22 17:59:44 +04:00
|
|
|
continue;
|
|
|
|
}
|
2014-07-31 13:55:59 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
$queriesToExecute[] = array(
|
2014-12-04 21:51:04 +03:00
|
|
|
'itemType' => $itemType,
|
|
|
|
'itemSource' => $itemSource,
|
|
|
|
'itemTarget' => $itemTarget,
|
2015-02-09 14:59:29 +03:00
|
|
|
'shareType' => $userShareType,
|
2014-12-04 21:51:04 +03:00
|
|
|
'shareWith' => $user,
|
|
|
|
'uidOwner' => $uidOwner,
|
|
|
|
'permissions' => $permissions,
|
|
|
|
'shareTime' => time(),
|
|
|
|
'fileSource' => $fileSource,
|
|
|
|
'fileTarget' => $fileTarget,
|
|
|
|
'token' => $token,
|
|
|
|
'parent' => $parent,
|
|
|
|
'expiration' => $expirationDate,
|
|
|
|
);
|
2014-07-31 13:55:59 +04:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2014-12-04 21:51:04 +03:00
|
|
|
$id = false;
|
2014-07-31 13:55:59 +04:00
|
|
|
if ($isGroupShare) {
|
2014-12-04 21:51:04 +03:00
|
|
|
$id = self::insertShare($queriesToExecute['groupShare']);
|
2014-04-09 19:51:54 +04:00
|
|
|
// Save this id, any extra rows for this group share will need to reference it
|
2016-01-07 12:22:30 +03:00
|
|
|
$parent = \OC::$server->getDatabaseConnection()->lastInsertId('*PREFIX*share');
|
2014-04-09 19:51:54 +04:00
|
|
|
unset($queriesToExecute['groupShare']);
|
2014-07-31 13:55:59 +04:00
|
|
|
}
|
2014-05-07 13:23:50 +04:00
|
|
|
|
2014-07-31 13:55:59 +04:00
|
|
|
foreach ($queriesToExecute as $shareQuery) {
|
|
|
|
$shareQuery['parent'] = $parent;
|
2014-12-04 21:51:04 +03:00
|
|
|
$id = self::insertShare($shareQuery);
|
2014-07-31 13:55:59 +04:00
|
|
|
}
|
2014-04-09 19:51:54 +04:00
|
|
|
|
2014-07-31 13:55:59 +04:00
|
|
|
$postHookData = array(
|
|
|
|
'itemType' => $itemType,
|
|
|
|
'itemSource' => $itemSource,
|
|
|
|
'parent' => $parent,
|
|
|
|
'shareType' => $shareType,
|
|
|
|
'uidOwner' => $uidOwner,
|
|
|
|
'permissions' => $permissions,
|
|
|
|
'fileSource' => $fileSource,
|
|
|
|
'id' => $parent,
|
|
|
|
'token' => $token,
|
|
|
|
'expirationDate' => $expirationDate,
|
|
|
|
);
|
|
|
|
|
2018-01-27 01:46:40 +03:00
|
|
|
$postHookData['shareWith'] = $isGroupShare ? $shareWith['group'] : $shareWith;
|
|
|
|
$postHookData['itemTarget'] = $isGroupShare ? $groupItemTarget : $itemTarget;
|
|
|
|
$postHookData['fileTarget'] = $isGroupShare ? $groupFileTarget : $fileTarget;
|
2014-07-31 13:55:59 +04:00
|
|
|
|
2018-01-26 01:16:13 +03:00
|
|
|
\OC_Hook::emit(\OCP\Share::class, 'post_shared', $postHookData);
|
2014-07-31 13:55:59 +04:00
|
|
|
|
|
|
|
|
2014-12-04 21:51:04 +03:00
|
|
|
return $id ? $id : false;
|
2014-07-31 13:55:59 +04:00
|
|
|
}
|
|
|
|
|
2016-02-08 18:43:39 +03:00
|
|
|
/**
|
|
|
|
* @param string $itemType
|
|
|
|
* @param string $itemSource
|
2016-02-09 12:40:00 +03:00
|
|
|
* @param int $shareType
|
2016-02-08 18:43:39 +03:00
|
|
|
* @param string $shareWith
|
|
|
|
* @param string $uidOwner
|
2016-02-09 12:40:00 +03:00
|
|
|
* @param int $permissions
|
2016-02-08 18:43:39 +03:00
|
|
|
* @param string|null $itemSourceName
|
|
|
|
* @param null|\DateTime $expirationDate
|
|
|
|
*/
|
2014-07-31 13:55:59 +04:00
|
|
|
private static function checkReshare($itemType, $itemSource, $shareType, $shareWith, $uidOwner, $permissions, $itemSourceName, $expirationDate) {
|
|
|
|
$backend = self::getBackend($itemType);
|
|
|
|
|
|
|
|
$l = \OC::$server->getL10N('lib');
|
|
|
|
$result = array();
|
|
|
|
|
2014-10-01 17:13:10 +04:00
|
|
|
$column = ($itemType === 'file' || $itemType === 'folder') ? 'file_source' : 'item_source';
|
|
|
|
|
2014-07-31 13:55:59 +04:00
|
|
|
$checkReshare = self::getItemSharedWithBySource($itemType, $itemSource, self::FORMAT_NONE, null, true);
|
|
|
|
if ($checkReshare) {
|
|
|
|
// Check if attempting to share back to owner
|
|
|
|
if ($checkReshare['uid_owner'] == $shareWith && $shareType == self::SHARE_TYPE_USER) {
|
|
|
|
$message = 'Sharing %s failed, because the user %s is the original sharer';
|
2015-10-16 11:00:33 +03:00
|
|
|
$message_t = $l->t('Sharing failed, because the user %s is the original sharer', [$shareWith]);
|
2014-07-31 13:55:59 +04:00
|
|
|
|
2015-08-24 13:12:08 +03:00
|
|
|
\OCP\Util::writeLog('OCP\Share', sprintf($message, $itemSourceName, $shareWith), \OCP\Util::DEBUG);
|
2014-07-31 13:55:59 +04:00
|
|
|
throw new \Exception($message_t);
|
2014-02-18 15:37:32 +04:00
|
|
|
}
|
2015-04-29 15:18:46 +03:00
|
|
|
}
|
2014-02-18 15:37:32 +04:00
|
|
|
|
2015-04-29 15:18:46 +03:00
|
|
|
if ($checkReshare && $checkReshare['uid_owner'] !== \OC_User::getUser()) {
|
2014-07-31 13:55:59 +04:00
|
|
|
// Check if share permissions is granted
|
2014-11-25 18:28:41 +03:00
|
|
|
if (self::isResharingAllowed() && (int)$checkReshare['permissions'] & \OCP\Constants::PERMISSION_SHARE) {
|
2014-07-31 13:55:59 +04:00
|
|
|
if (~(int)$checkReshare['permissions'] & $permissions) {
|
|
|
|
$message = 'Sharing %s failed, because the permissions exceed permissions granted to %s';
|
|
|
|
$message_t = $l->t('Sharing %s failed, because the permissions exceed permissions granted to %s', array($itemSourceName, $uidOwner));
|
|
|
|
|
2015-08-24 13:12:08 +03:00
|
|
|
\OCP\Util::writeLog('OCP\Share', sprintf($message, $itemSourceName, $uidOwner), \OCP\Util::DEBUG);
|
2014-07-31 13:55:59 +04:00
|
|
|
throw new \Exception($message_t);
|
2014-02-18 15:37:32 +04:00
|
|
|
} else {
|
2014-07-31 13:55:59 +04:00
|
|
|
// TODO Don't check if inside folder
|
|
|
|
$result['parent'] = $checkReshare['id'];
|
2015-12-01 19:43:05 +03:00
|
|
|
|
|
|
|
$result['expirationDate'] = $expirationDate;
|
|
|
|
// $checkReshare['expiration'] could be null and then is always less than any value
|
|
|
|
if(isset($checkReshare['expiration']) && $checkReshare['expiration'] < $expirationDate) {
|
|
|
|
$result['expirationDate'] = $checkReshare['expiration'];
|
|
|
|
}
|
|
|
|
|
2014-10-01 17:13:10 +04:00
|
|
|
// only suggest the same name as new target if it is a reshare of the
|
|
|
|
// same file/folder and not the reshare of a child
|
|
|
|
if ($checkReshare[$column] === $itemSource) {
|
|
|
|
$result['filePath'] = $checkReshare['file_target'];
|
|
|
|
$result['itemSource'] = $checkReshare['item_source'];
|
|
|
|
$result['fileSource'] = $checkReshare['file_source'];
|
|
|
|
$result['suggestedItemTarget'] = $checkReshare['item_target'];
|
|
|
|
$result['suggestedFileTarget'] = $checkReshare['file_target'];
|
|
|
|
} else {
|
|
|
|
$result['filePath'] = ($backend instanceof \OCP\Share_Backend_File_Dependent) ? $backend->getFilePath($itemSource, $uidOwner) : null;
|
|
|
|
$result['suggestedItemTarget'] = null;
|
|
|
|
$result['suggestedFileTarget'] = null;
|
|
|
|
$result['itemSource'] = $itemSource;
|
|
|
|
$result['fileSource'] = ($backend instanceof \OCP\Share_Backend_File_Dependent) ? $itemSource : null;
|
|
|
|
}
|
2014-02-18 15:37:32 +04:00
|
|
|
}
|
|
|
|
} else {
|
2014-07-31 13:55:59 +04:00
|
|
|
$message = 'Sharing %s failed, because resharing is not allowed';
|
|
|
|
$message_t = $l->t('Sharing %s failed, because resharing is not allowed', array($itemSourceName));
|
2014-05-07 13:23:50 +04:00
|
|
|
|
2015-08-24 13:12:08 +03:00
|
|
|
\OCP\Util::writeLog('OCP\Share', sprintf($message, $itemSourceName), \OCP\Util::DEBUG);
|
2014-07-31 13:55:59 +04:00
|
|
|
throw new \Exception($message_t);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
$result['parent'] = null;
|
|
|
|
$result['suggestedItemTarget'] = null;
|
|
|
|
$result['suggestedFileTarget'] = null;
|
|
|
|
$result['itemSource'] = $itemSource;
|
|
|
|
$result['expirationDate'] = $expirationDate;
|
|
|
|
if (!$backend->isValidSource($itemSource, $uidOwner)) {
|
|
|
|
$message = 'Sharing %s failed, because the sharing backend for '
|
|
|
|
.'%s could not find its source';
|
|
|
|
$message_t = $l->t('Sharing %s failed, because the sharing backend for %s could not find its source', array($itemSource, $itemType));
|
2015-08-24 13:12:08 +03:00
|
|
|
\OCP\Util::writeLog('OCP\Share', sprintf($message, $itemSource, $itemType), \OCP\Util::DEBUG);
|
2014-07-31 13:55:59 +04:00
|
|
|
throw new \Exception($message_t);
|
|
|
|
}
|
|
|
|
if ($backend instanceof \OCP\Share_Backend_File_Dependent) {
|
|
|
|
$result['filePath'] = $backend->getFilePath($itemSource, $uidOwner);
|
|
|
|
if ($itemType == 'file' || $itemType == 'folder') {
|
|
|
|
$result['fileSource'] = $itemSource;
|
|
|
|
} else {
|
|
|
|
$meta = \OC\Files\Filesystem::getFileInfo($result['filePath']);
|
|
|
|
$result['fileSource'] = $meta['fileid'];
|
|
|
|
}
|
|
|
|
if ($result['fileSource'] == -1) {
|
|
|
|
$message = 'Sharing %s failed, because the file could not be found in the file cache';
|
|
|
|
$message_t = $l->t('Sharing %s failed, because the file could not be found in the file cache', array($itemSource));
|
2014-05-07 13:23:50 +04:00
|
|
|
|
2015-08-24 13:12:08 +03:00
|
|
|
\OCP\Util::writeLog('OCP\Share', sprintf($message, $itemSource), \OCP\Util::DEBUG);
|
2014-07-31 13:55:59 +04:00
|
|
|
throw new \Exception($message_t);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
$result['filePath'] = null;
|
|
|
|
$result['fileSource'] = null;
|
2014-02-18 15:37:32 +04:00
|
|
|
}
|
|
|
|
}
|
2014-07-31 13:55:59 +04:00
|
|
|
|
|
|
|
return $result;
|
2014-02-18 15:37:32 +04:00
|
|
|
}
|
|
|
|
|
2014-12-04 21:51:04 +03:00
|
|
|
/**
|
|
|
|
*
|
|
|
|
* @param array $shareData
|
|
|
|
* @return mixed false in case of a failure or the id of the new share
|
|
|
|
*/
|
2015-04-28 09:40:47 +03:00
|
|
|
private static function insertShare(array $shareData) {
|
|
|
|
|
2014-05-07 13:23:50 +04:00
|
|
|
$query = \OC_DB::prepare('INSERT INTO `*PREFIX*share` ('
|
|
|
|
.' `item_type`, `item_source`, `item_target`, `share_type`,'
|
|
|
|
.' `share_with`, `uid_owner`, `permissions`, `stime`, `file_source`,'
|
|
|
|
.' `file_target`, `token`, `parent`, `expiration`) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)');
|
|
|
|
$query->bindValue(1, $shareData['itemType']);
|
|
|
|
$query->bindValue(2, $shareData['itemSource']);
|
|
|
|
$query->bindValue(3, $shareData['itemTarget']);
|
|
|
|
$query->bindValue(4, $shareData['shareType']);
|
|
|
|
$query->bindValue(5, $shareData['shareWith']);
|
|
|
|
$query->bindValue(6, $shareData['uidOwner']);
|
|
|
|
$query->bindValue(7, $shareData['permissions']);
|
|
|
|
$query->bindValue(8, $shareData['shareTime']);
|
|
|
|
$query->bindValue(9, $shareData['fileSource']);
|
|
|
|
$query->bindValue(10, $shareData['fileTarget']);
|
|
|
|
$query->bindValue(11, $shareData['token']);
|
|
|
|
$query->bindValue(12, $shareData['parent']);
|
|
|
|
$query->bindValue(13, $shareData['expiration'], 'datetime');
|
2014-12-04 21:51:04 +03:00
|
|
|
$result = $query->execute();
|
|
|
|
|
|
|
|
$id = false;
|
|
|
|
if ($result) {
|
2015-11-19 19:18:22 +03:00
|
|
|
$id = \OC::$server->getDatabaseConnection()->lastInsertId('*PREFIX*share');
|
2014-12-04 21:51:04 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
return $id;
|
|
|
|
|
2014-05-07 13:23:50 +04:00
|
|
|
}
|
2015-04-28 09:40:47 +03:00
|
|
|
|
2014-02-18 15:37:32 +04:00
|
|
|
/**
|
|
|
|
* In case a password protected link is not yet authenticated this function will return false
|
|
|
|
*
|
|
|
|
* @param array $linkItem
|
2014-05-07 22:46:08 +04:00
|
|
|
* @return boolean
|
2014-02-18 15:37:32 +04:00
|
|
|
*/
|
|
|
|
public static function checkPasswordProtectedShare(array $linkItem) {
|
|
|
|
if (!isset($linkItem['share_with'])) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
if (!isset($linkItem['share_type'])) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
if (!isset($linkItem['id'])) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ($linkItem['share_type'] != \OCP\Share::SHARE_TYPE_LINK) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2014-07-16 21:40:22 +04:00
|
|
|
if ( \OC::$server->getSession()->exists('public_link_authenticated')
|
2016-05-31 07:53:28 +03:00
|
|
|
&& \OC::$server->getSession()->get('public_link_authenticated') === (string)$linkItem['id'] ) {
|
2014-02-18 15:37:32 +04:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
2014-03-03 20:06:45 +04:00
|
|
|
|
|
|
|
/**
|
2014-05-19 19:50:53 +04:00
|
|
|
* construct select statement
|
2014-03-03 20:06:45 +04:00
|
|
|
* @param int $format
|
2014-05-07 22:46:08 +04:00
|
|
|
* @param boolean $fileDependent ist it a file/folder share or a generla share
|
2014-03-03 20:06:45 +04:00
|
|
|
* @param string $uidOwner
|
|
|
|
* @return string select statement
|
|
|
|
*/
|
|
|
|
private static function createSelectStatement($format, $fileDependent, $uidOwner = null) {
|
|
|
|
$select = '*';
|
|
|
|
if ($format == self::FORMAT_STATUSES) {
|
|
|
|
if ($fileDependent) {
|
2015-03-24 13:08:19 +03:00
|
|
|
$select = '`*PREFIX*share`.`id`, `*PREFIX*share`.`parent`, `share_type`, `path`, `storage`, '
|
|
|
|
. '`share_with`, `uid_owner` , `file_source`, `stime`, `*PREFIX*share`.`permissions`, '
|
2016-02-10 18:48:29 +03:00
|
|
|
. '`*PREFIX*storages`.`id` AS `storage_id`, `*PREFIX*filecache`.`parent` as `file_parent`, '
|
|
|
|
. '`uid_initiator`';
|
2014-03-03 20:06:45 +04:00
|
|
|
} else {
|
2014-09-25 14:35:11 +04:00
|
|
|
$select = '`id`, `parent`, `share_type`, `share_with`, `uid_owner`, `item_source`, `stime`, `*PREFIX*share`.`permissions`';
|
2014-03-03 20:06:45 +04:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (isset($uidOwner)) {
|
|
|
|
if ($fileDependent) {
|
|
|
|
$select = '`*PREFIX*share`.`id`, `item_type`, `item_source`, `*PREFIX*share`.`parent`,'
|
2014-12-04 21:51:04 +03:00
|
|
|
. ' `share_type`, `share_with`, `file_source`, `file_target`, `path`, `*PREFIX*share`.`permissions`, `stime`,'
|
2015-03-24 13:08:19 +03:00
|
|
|
. ' `expiration`, `token`, `storage`, `mail_send`, `uid_owner`, '
|
2015-06-29 12:54:56 +03:00
|
|
|
. '`*PREFIX*storages`.`id` AS `storage_id`, `*PREFIX*filecache`.`parent` as `file_parent`';
|
2014-03-03 20:06:45 +04:00
|
|
|
} else {
|
2014-06-03 19:57:56 +04:00
|
|
|
$select = '`id`, `item_type`, `item_source`, `parent`, `share_type`, `share_with`, `*PREFIX*share`.`permissions`,'
|
2014-12-04 21:51:04 +03:00
|
|
|
. ' `stime`, `file_source`, `expiration`, `token`, `mail_send`, `uid_owner`';
|
2014-03-03 20:06:45 +04:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if ($fileDependent) {
|
2016-08-01 13:49:41 +03:00
|
|
|
if ($format == \OCA\Files_Sharing\ShareBackend\File::FORMAT_GET_FOLDER_CONTENTS || $format == \OCA\Files_Sharing\ShareBackend\File::FORMAT_FILE_APP_ROOT) {
|
2014-03-03 20:06:45 +04:00
|
|
|
$select = '`*PREFIX*share`.`id`, `item_type`, `item_source`, `*PREFIX*share`.`parent`, `uid_owner`, '
|
2014-12-04 21:51:04 +03:00
|
|
|
. '`share_type`, `share_with`, `file_source`, `path`, `file_target`, `stime`, '
|
|
|
|
. '`*PREFIX*share`.`permissions`, `expiration`, `storage`, `*PREFIX*filecache`.`parent` as `file_parent`, '
|
2015-03-30 18:29:05 +03:00
|
|
|
. '`name`, `mtime`, `mimetype`, `mimepart`, `size`, `encrypted`, `etag`, `mail_send`';
|
2014-03-03 20:06:45 +04:00
|
|
|
} else {
|
2015-03-24 13:08:19 +03:00
|
|
|
$select = '`*PREFIX*share`.`id`, `item_type`, `item_source`, `item_target`,'
|
|
|
|
. '`*PREFIX*share`.`parent`, `share_type`, `share_with`, `uid_owner`,'
|
|
|
|
. '`file_source`, `path`, `file_target`, `*PREFIX*share`.`permissions`,'
|
|
|
|
. '`stime`, `expiration`, `token`, `storage`, `mail_send`,'
|
2015-06-29 12:54:56 +03:00
|
|
|
. '`*PREFIX*storages`.`id` AS `storage_id`, `*PREFIX*filecache`.`parent` as `file_parent`';
|
2014-03-03 20:06:45 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return $select;
|
|
|
|
}
|
2014-03-03 20:20:09 +04:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
2014-05-19 19:50:53 +04:00
|
|
|
* transform db results
|
2014-03-03 20:20:09 +04:00
|
|
|
* @param array $row result
|
|
|
|
*/
|
|
|
|
private static function transformDBResults(&$row) {
|
|
|
|
if (isset($row['id'])) {
|
|
|
|
$row['id'] = (int) $row['id'];
|
|
|
|
}
|
|
|
|
if (isset($row['share_type'])) {
|
|
|
|
$row['share_type'] = (int) $row['share_type'];
|
|
|
|
}
|
|
|
|
if (isset($row['parent'])) {
|
|
|
|
$row['parent'] = (int) $row['parent'];
|
|
|
|
}
|
|
|
|
if (isset($row['file_parent'])) {
|
|
|
|
$row['file_parent'] = (int) $row['file_parent'];
|
|
|
|
}
|
|
|
|
if (isset($row['file_source'])) {
|
|
|
|
$row['file_source'] = (int) $row['file_source'];
|
|
|
|
}
|
|
|
|
if (isset($row['permissions'])) {
|
|
|
|
$row['permissions'] = (int) $row['permissions'];
|
|
|
|
}
|
|
|
|
if (isset($row['storage'])) {
|
|
|
|
$row['storage'] = (int) $row['storage'];
|
|
|
|
}
|
|
|
|
if (isset($row['stime'])) {
|
|
|
|
$row['stime'] = (int) $row['stime'];
|
|
|
|
}
|
2015-09-17 14:34:15 +03:00
|
|
|
if (isset($row['expiration']) && $row['share_type'] !== self::SHARE_TYPE_LINK) {
|
|
|
|
// discard expiration date for non-link shares, which might have been
|
|
|
|
// set by ancient bugs
|
|
|
|
$row['expiration'] = null;
|
|
|
|
}
|
2014-03-03 20:20:09 +04:00
|
|
|
}
|
2014-03-03 20:30:16 +04:00
|
|
|
|
|
|
|
/**
|
2014-05-19 19:50:53 +04:00
|
|
|
* format result
|
2014-03-03 20:30:16 +04:00
|
|
|
* @param array $items result
|
2014-04-15 19:46:11 +04:00
|
|
|
* @param string $column is it a file share or a general share ('file_target' or 'item_target')
|
|
|
|
* @param \OCP\Share_Backend $backend sharing backend
|
2014-03-03 20:30:16 +04:00
|
|
|
* @param int $format
|
2014-04-15 19:46:11 +04:00
|
|
|
* @param array $parameters additional format parameters
|
|
|
|
* @return array format result
|
2014-03-03 20:30:16 +04:00
|
|
|
*/
|
|
|
|
private static function formatResult($items, $column, $backend, $format = self::FORMAT_NONE , $parameters = null) {
|
|
|
|
if ($format === self::FORMAT_NONE) {
|
|
|
|
return $items;
|
|
|
|
} else if ($format === self::FORMAT_STATUSES) {
|
|
|
|
$statuses = array();
|
|
|
|
foreach ($items as $item) {
|
|
|
|
if ($item['share_type'] === self::SHARE_TYPE_LINK) {
|
2016-02-10 18:48:29 +03:00
|
|
|
if ($item['uid_initiator'] !== \OC::$server->getUserSession()->getUser()->getUID()) {
|
|
|
|
continue;
|
|
|
|
}
|
2014-03-03 20:30:16 +04:00
|
|
|
$statuses[$item[$column]]['link'] = true;
|
|
|
|
} else if (!isset($statuses[$item[$column]])) {
|
|
|
|
$statuses[$item[$column]]['link'] = false;
|
|
|
|
}
|
2014-07-10 15:19:35 +04:00
|
|
|
if (!empty($item['file_target'])) {
|
2014-03-03 20:30:16 +04:00
|
|
|
$statuses[$item[$column]]['path'] = $item['path'];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return $statuses;
|
|
|
|
} else {
|
|
|
|
return $backend->formatItems($items, $format, $parameters);
|
|
|
|
}
|
|
|
|
}
|
2014-06-04 13:07:31 +04:00
|
|
|
|
2014-12-04 21:51:04 +03:00
|
|
|
/**
|
|
|
|
* remove protocol from URL
|
|
|
|
*
|
|
|
|
* @param string $url
|
|
|
|
* @return string
|
|
|
|
*/
|
2015-12-09 14:00:00 +03:00
|
|
|
public static function removeProtocolFromUrl($url) {
|
2014-12-04 21:51:04 +03:00
|
|
|
if (strpos($url, 'https://') === 0) {
|
|
|
|
return substr($url, strlen('https://'));
|
|
|
|
} else if (strpos($url, 'http://') === 0) {
|
|
|
|
return substr($url, strlen('http://'));
|
|
|
|
}
|
|
|
|
|
|
|
|
return $url;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* try http post first with https and then with http as a fallback
|
|
|
|
*
|
2016-02-25 22:46:01 +03:00
|
|
|
* @param string $remoteDomain
|
|
|
|
* @param string $urlSuffix
|
2014-12-04 21:51:04 +03:00
|
|
|
* @param array $fields post parameters
|
2015-04-28 10:10:59 +03:00
|
|
|
* @return array
|
2014-12-04 21:51:04 +03:00
|
|
|
*/
|
2016-02-25 22:46:01 +03:00
|
|
|
private static function tryHttpPostToShareEndpoint($remoteDomain, $urlSuffix, array $fields) {
|
2014-12-04 21:51:04 +03:00
|
|
|
$protocol = 'https://';
|
2015-04-28 10:10:59 +03:00
|
|
|
$result = [
|
|
|
|
'success' => false,
|
|
|
|
'result' => '',
|
|
|
|
];
|
2014-12-04 21:51:04 +03:00
|
|
|
$try = 0;
|
2017-04-05 23:35:59 +03:00
|
|
|
$discoveryService = \OC::$server->query(\OCP\OCS\IDiscoveryService::class);
|
2015-04-28 10:10:59 +03:00
|
|
|
while ($result['success'] === false && $try < 2) {
|
2017-03-10 17:37:21 +03:00
|
|
|
$federationEndpoints = $discoveryService->discover($protocol . $remoteDomain, 'FEDERATED_SHARING');
|
|
|
|
$endpoint = isset($federationEndpoints['share']) ? $federationEndpoints['share'] : '/ocs/v2.php/cloud/shares';
|
2016-02-25 22:46:01 +03:00
|
|
|
$result = \OC::$server->getHTTPHelper()->post($protocol . $remoteDomain . $endpoint . $urlSuffix . '?format=' . self::RESPONSE_FORMAT, $fields);
|
2014-12-04 21:51:04 +03:00
|
|
|
$try++;
|
|
|
|
$protocol = 'http://';
|
|
|
|
}
|
|
|
|
|
|
|
|
return $result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* send server-to-server share to remote server
|
|
|
|
*
|
|
|
|
* @param string $token
|
|
|
|
* @param string $shareWith
|
|
|
|
* @param string $name
|
|
|
|
* @param int $remote_id
|
|
|
|
* @param string $owner
|
|
|
|
* @return bool
|
|
|
|
*/
|
|
|
|
private static function sendRemoteShare($token, $shareWith, $name, $remote_id, $owner) {
|
|
|
|
|
2015-06-18 10:21:06 +03:00
|
|
|
list($user, $remote) = Helper::splitUserRemote($shareWith);
|
2014-12-04 21:51:04 +03:00
|
|
|
|
|
|
|
if ($user && $remote) {
|
2016-02-25 22:46:01 +03:00
|
|
|
$url = $remote;
|
2014-12-04 21:51:04 +03:00
|
|
|
|
2015-01-29 15:09:44 +03:00
|
|
|
$local = \OC::$server->getURLGenerator()->getAbsoluteURL('/');
|
2014-12-04 21:51:04 +03:00
|
|
|
|
|
|
|
$fields = array(
|
|
|
|
'shareWith' => $user,
|
|
|
|
'token' => $token,
|
|
|
|
'name' => $name,
|
|
|
|
'remoteId' => $remote_id,
|
|
|
|
'owner' => $owner,
|
|
|
|
'remote' => $local,
|
|
|
|
);
|
|
|
|
|
|
|
|
$url = self::removeProtocolFromUrl($url);
|
2016-02-25 22:46:01 +03:00
|
|
|
$result = self::tryHttpPostToShareEndpoint($url, '', $fields);
|
2014-12-04 21:51:04 +03:00
|
|
|
$status = json_decode($result['result'], true);
|
|
|
|
|
2016-02-25 22:46:01 +03:00
|
|
|
if ($result['success'] && ($status['ocs']['meta']['statuscode'] === 100 || $status['ocs']['meta']['statuscode'] === 200)) {
|
2018-01-26 01:16:13 +03:00
|
|
|
\OC_Hook::emit(\OCP\Share::class, 'federated_share_added', ['server' => $remote]);
|
2015-11-23 19:01:53 +03:00
|
|
|
return true;
|
|
|
|
}
|
2014-12-04 21:51:04 +03:00
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* send server-to-server unshare to remote server
|
|
|
|
*
|
2015-04-28 09:40:47 +03:00
|
|
|
* @param string $remote url
|
2014-12-04 21:51:04 +03:00
|
|
|
* @param int $id share id
|
|
|
|
* @param string $token
|
|
|
|
* @return bool
|
|
|
|
*/
|
|
|
|
private static function sendRemoteUnshare($remote, $id, $token) {
|
2016-02-25 22:46:01 +03:00
|
|
|
$url = rtrim($remote, '/');
|
2014-12-04 21:51:04 +03:00
|
|
|
$fields = array('token' => $token, 'format' => 'json');
|
2015-04-27 23:08:44 +03:00
|
|
|
$url = self::removeProtocolFromUrl($url);
|
2016-02-25 22:46:01 +03:00
|
|
|
$result = self::tryHttpPostToShareEndpoint($url, '/'.$id.'/unshare', $fields);
|
2014-12-04 21:51:04 +03:00
|
|
|
$status = json_decode($result['result'], true);
|
|
|
|
|
2016-02-25 22:46:01 +03:00
|
|
|
return ($result['success'] && ($status['ocs']['meta']['statuscode'] === 100 || $status['ocs']['meta']['statuscode'] === 200));
|
2014-12-04 21:51:04 +03:00
|
|
|
}
|
|
|
|
|
2014-06-04 13:07:31 +04:00
|
|
|
/**
|
|
|
|
* check if user can only share with group members
|
|
|
|
* @return bool
|
|
|
|
*/
|
|
|
|
public static function shareWithGroupMembersOnly() {
|
2018-01-17 23:10:40 +03:00
|
|
|
$value = \OC::$server->getConfig()->getAppValue('core', 'shareapi_only_share_with_group_members', 'no');
|
2018-01-26 14:36:25 +03:00
|
|
|
return $value === 'yes';
|
2014-06-04 13:07:31 +04:00
|
|
|
}
|
|
|
|
|
2015-04-28 09:40:47 +03:00
|
|
|
/**
|
|
|
|
* @return bool
|
|
|
|
*/
|
2014-06-03 17:15:04 +04:00
|
|
|
public static function isDefaultExpireDateEnabled() {
|
2018-01-13 16:25:04 +03:00
|
|
|
$defaultExpireDateEnabled = \OC::$server->getConfig()->getAppValue('core', 'shareapi_default_expire_date', 'no');
|
2018-01-26 14:36:25 +03:00
|
|
|
return $defaultExpireDateEnabled === 'yes';
|
2014-06-03 17:15:04 +04:00
|
|
|
}
|
|
|
|
|
2015-04-28 09:40:47 +03:00
|
|
|
/**
|
|
|
|
* @return int
|
|
|
|
*/
|
2014-06-03 17:15:04 +04:00
|
|
|
public static function getExpireInterval() {
|
2018-01-13 16:25:04 +03:00
|
|
|
return (int)\OC::$server->getConfig()->getAppValue('core', 'shareapi_expire_after_n_days', '7');
|
2014-06-03 17:15:04 +04:00
|
|
|
}
|
|
|
|
|
2015-03-24 13:08:19 +03:00
|
|
|
/**
|
|
|
|
* Checks whether the given path is reachable for the given owner
|
|
|
|
*
|
|
|
|
* @param string $path path relative to files
|
|
|
|
* @param string $ownerStorageId storage id of the owner
|
|
|
|
*
|
|
|
|
* @return boolean true if file is reachable, false otherwise
|
|
|
|
*/
|
|
|
|
private static function isFileReachable($path, $ownerStorageId) {
|
|
|
|
// if outside the home storage, file is always considered reachable
|
2015-10-12 18:34:51 +03:00
|
|
|
if (!(substr($ownerStorageId, 0, 6) === 'home::' ||
|
|
|
|
substr($ownerStorageId, 0, 13) === 'object::user:'
|
|
|
|
)) {
|
2015-03-24 13:08:19 +03:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// if inside the home storage, the file has to be under "/files/"
|
|
|
|
$path = ltrim($path, '/');
|
|
|
|
if (substr($path, 0, 6) === 'files/') {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2015-03-13 14:29:13 +03:00
|
|
|
/**
|
|
|
|
* @param IConfig $config
|
2017-03-14 19:40:42 +03:00
|
|
|
* @return bool
|
2015-03-13 14:29:13 +03:00
|
|
|
*/
|
|
|
|
public static function enforcePassword(IConfig $config) {
|
|
|
|
$enforcePassword = $config->getAppValue('core', 'shareapi_enforce_links_password', 'no');
|
2018-01-26 14:36:25 +03:00
|
|
|
return $enforcePassword === 'yes';
|
2015-03-13 14:29:13 +03:00
|
|
|
}
|
2015-03-09 18:20:18 +03:00
|
|
|
|
2015-07-23 15:44:48 +03:00
|
|
|
/**
|
|
|
|
* @param string $password
|
|
|
|
* @throws \Exception
|
|
|
|
*/
|
|
|
|
private static function verifyPassword($password) {
|
|
|
|
|
|
|
|
$accepted = true;
|
|
|
|
$message = '';
|
|
|
|
\OCP\Util::emitHook('\OC\Share', 'verifyPassword', [
|
|
|
|
'password' => $password,
|
|
|
|
'accepted' => &$accepted,
|
|
|
|
'message' => &$message
|
|
|
|
]);
|
|
|
|
|
|
|
|
if (!$accepted) {
|
|
|
|
throw new \Exception($message);
|
|
|
|
}
|
|
|
|
}
|
2014-02-18 15:37:32 +04:00
|
|
|
}
|