nextcloud/lib/private/Share/Share.php

1144 lines
42 KiB
PHP
Raw Normal View History

2014-02-18 15:37:32 +04:00
<?php
/**
2016-07-21 18:07:57 +03:00
* @copyright Copyright (c) 2016, ownCloud, Inc.
*
* @author Arthur Schiwon <blizzz@arthur-schiwon.de>
2015-03-26 13:44:34 +03:00
* @author Bart Visscher <bartv@thisnet.nl>
* @author Bernhard Reiter <ockham@raz.or.at>
* @author Bjoern Schiessle <bjoern@schiessle.org>
2016-05-26 20:56:05 +03:00
* @author Björn Schießle <bjoern@schiessle.org>
* @author Christoph Wurst <christoph@winzerhof-wurst.at>
2016-07-21 18:07:57 +03:00
* @author Joas Schilling <coding@schilljs.com>
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>
* @author Thomas Müller <thomas.mueller@tmit.eu>
* @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
*
*/
2014-02-18 15:37:32 +04:00
namespace OC\Share;
2016-01-25 19:17:36 +03:00
use OCP\DB\QueryBuilder\IQueryBuilder;
use OCP\ILogger;
use OCP\Share\IShare;
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
*/
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
* @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) {
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] = [
2014-02-18 15:37:32 +04:00
'class' => $class,
'collectionOf' => $collectionOf,
'supportedFileExtensions' => $supportedFileExtensions
];
2014-02-18 15:37:32 +04:00
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,
ILogger::WARN);
2014-02-18 15:37:32 +04:00
}
return false;
}
/**
* Get the items of item type shared with the current user
* @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
* @param boolean $includeCollections (optional)
* @return mixed Return depends on format
* @deprecated TESTS ONLY - this methods is only used by tests
* called like this:
* \OC\Share\Share::getItemsSharedWith('folder'); (apps/files_sharing/tests/UpdaterTest.php)
2014-02-18 15:37:32 +04:00
*/
public static function getItemsSharedWith() {
return self::getItems('folder', null, self::$shareTypeUserAndGroups, \OC_User::getUser(), null, self::FORMAT_NONE,
null, -1, false);
2014-02-18 15:37:32 +04:00
}
/**
* Get the items of item type shared with a user
* @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
*/
public static function getItemsSharedWithUser($itemType, $user, $format = self::FORMAT_NONE,
$parameters = null, $limit = -1, $includeCollections = false) {
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
* @param string $user User to whom the item was shared
* @param string $owner Owner of the share
* @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
*/
public static function getItemSharedWithUser($itemType, $itemSource, $user, $owner = null, $shareType = null) {
$shares = [];
$fileDependent = false;
2014-02-18 15:37:32 +04:00
$where = 'WHERE';
$fileDependentWhere = '';
2014-10-01 17:13:10 +04:00
if ($itemType === 'file' || $itemType === 'folder') {
$fileDependent = true;
2014-10-01 17:13:10 +04:00
$column = 'file_source';
$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';
}
$select = self::createSelectStatement(self::FORMAT_NONE, $fileDependent);
2014-10-01 17:13:10 +04:00
$where .= ' `' . $column . '` = ? AND `item_type` = ? ';
$arguments = [$itemSource, $itemType];
// for link shares $user === null
if ($user !== null) {
$where .= ' AND `share_with` = ? ';
$arguments[] = $user;
}
if ($shareType !== null) {
$where .= ' AND `share_type` = ? ';
$arguments[] = $shareType;
}
if ($owner !== null) {
$where .= ' AND `uid_owner` = ? ';
$arguments[] = $owner;
}
$query = \OC_DB::prepare('SELECT ' . $select . ' FROM `*PREFIX*share` '. $fileDependentWhere . $where);
2014-02-18 15:37:32 +04:00
$result = \OC_DB::executeAudited($query, $arguments);
2014-02-18 15:37:32 +04:00
while ($row = $result->fetchRow()) {
if ($fileDependent && !self::isFileReachable($row['path'], $row['storage_id'])) {
continue;
}
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.
if (empty($shares) && $user !== null) {
$userObject = \OC::$server->getUserManager()->get($user);
$groups = [];
if ($userObject) {
$groups = \OC::$server->getGroupManager()->getUserGroupIds($userObject);
}
2014-02-18 15:37:32 +04:00
if (!empty($groups)) {
$where = $fileDependentWhere . ' WHERE `' . $column . '` = ? AND `item_type` = ? AND `share_with` in (?)';
$arguments = [$itemSource, $itemType, $groups];
$types = [null, null, IQueryBuilder::PARAM_STR_ARRAY];
if ($owner !== null) {
$where .= ' AND `uid_owner` = ?';
$arguments[] = $owner;
$types[] = null;
}
2014-02-18 15:37:32 +04: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();
$result = $conn->executeQuery(
'SELECT ' . $select . ' FROM `*PREFIX*share` ' . $where,
$arguments,
$types
);
2014-02-18 15:37:32 +04: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
* @param string $itemType
* @param string $itemSource
* @param int $format (optional) Format type must be defined by the backend
* @param mixed $parameters
* @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,
$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);
}
/**
* Get the shared item of item type owned by the current user
* @param string $itemType
* @param string $itemSource
* @param int $format (optional) Format type must be defined by the backend
* @param mixed $parameters
* @param boolean $includeCollections
* @return mixed Return depends on format
2014-02-18 15:37:32 +04:00
*/
public static function getItemShared($itemType, $itemSource, $format = self::FORMAT_NONE,
$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);
}
/**
* Unshare an item from a user, group, or delete a 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
2014-11-24 17:31:52 +03:00
* @param string $owner owner of the share, if null the current user is used
* @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) {
// 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);
$toDelete = [];
$newParent = null;
2014-11-24 17:31:52 +03:00
$currentUser = $owner ? $owner : \OC_User::getUser();
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;
// 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
} elseif ((int)$item['share_type'] === self::$shareTypeGroupUserUnique) {
$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;
}
/**
* Checks whether a share has expired, calls unshareItem() if yes.
* @param array $item Share data (usually database row)
* @return boolean True if item was expired, false otherwise.
2014-02-18 15:37:32 +04:00
*/
protected static function expireItem(array $item) {
2014-06-03 17:15:04 +04:00
$result = false;
2014-08-02 06:02:39 +04:00
// only use default expiration date for link shares
if ((int) $item['share_type'] === IShare::TYPE_LINK) {
2014-06-03 17:15:04 +04:00
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
$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)
* @param int $newParent parent ID
2014-02-18 15:37:32 +04:00
* @return null
*/
protected static function unshareItem(array $item, $newParent = null) {
$shareType = (int)$item['share_type'];
$shareWith = null;
if ($shareType !== IShare::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 = [
'id' => $item['id'],
'itemType' => $item['item_type'],
'itemSource' => $item['item_source'],
'shareType' => $shareType,
'shareWith' => $shareWith,
'itemParent' => $item['parent'],
'uidOwner' => $item['uid_owner'],
];
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
\OC_Hook::emit(\OCP\Share::class, 'pre_unshare', $hookParams);
$deletedShares = Helper::delete($item['id'], false, null, $newParent);
$deletedShares[] = $hookParams;
$hookParams['deletedShares'] = $deletedShares;
\OC_Hook::emit(\OCP\Share::class, 'post_unshare', $hookParams);
if ((int)$item['share_type'] === IShare::TYPE_REMOTE && \OC::$server->getUserSession()->getUser()) {
list(, $remote) = Helper::splitUserRemote($item['share_with']);
self::sendRemoteUnshare($remote, $item['id'], $item['token']);
}
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];
} elseif (isset(self::$backendTypes[$itemType]['class'])) {
2014-02-18 15:37:32 +04:00
$class = self::$backendTypes[$itemType]['class'];
if (class_exists($class)) {
self::$backends[$itemType] = new $class;
if (!(self::$backends[$itemType] instanceof \OCP\Share_Backend)) {
$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', [$class]);
\OCP\Util::writeLog('OCP\Share', sprintf($message, $class), ILogger::ERROR);
throw new \Exception($message_t);
2014-02-18 15:37:32 +04:00
}
return self::$backends[$itemType];
} else {
$message = 'Sharing backend %s not found';
$message_t = $l->t('Sharing backend %s not found', [$class]);
\OCP\Util::writeLog('OCP\Share', sprintf($message, $class), ILogger::ERROR);
throw new \Exception($message_t);
2014-02-18 15:37:32 +04:00
}
}
$message = 'Sharing backend for %s not found';
$message_t = $l->t('Sharing backend for %s not found', [$itemType]);
\OCP\Util::writeLog('OCP\Share', sprintf($message, $itemType), ILogger::ERROR);
throw new \Exception($message_t);
2014-02-18 15:37:32 +04:00
}
/**
* Check if resharing is allowed
* @return boolean true if allowed or false
2014-02-18 15:37:32 +04:00
*
* Resharing is allowed by default if not configured
*/
public static function isResharingAllowed() {
2014-02-18 15:37:32 +04:00
if (!isset(self::$isResharingAllowed)) {
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
* @param string $itemType
2014-02-18 15:37:32 +04:00
* @return array
*/
private static function getCollectionItemTypes($itemType) {
$collectionTypes = [$itemType];
2014-02-18 15:37:32 +04:00
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...
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;
}
/**
* Get shared items from the database
* @param string $itemType
* @param string $item Item source or target (optional)
* @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
* @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)
* @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
*
*/
public static function getItems($itemType, $item = null, $shareType = null, $shareWith = null,
$uidOwner = null, $format = self::FORMAT_NONE, $parameters = null, $limit = -1,
$includeCollections = false, $itemShareWithBySource = false, $checkExpireDate = true) {
if (\OC::$server->getConfig()->getAppValue('core', 'shareapi_enabled', 'yes') != 'yes') {
return [];
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)) {
2014-02-18 15:37:32 +04:00
$root = \OC\Files\Filesystem::getRoot();
} else {
$root = '';
}
$where = 'INNER JOIN `*PREFIX*filecache` ON `file_source` = `*PREFIX*filecache`.`fileid` ';
2014-02-18 15:37:32 +04:00
if (!isset($item)) {
$where .= ' AND `file_target` IS NOT NULL ';
2014-02-18 15:37:32 +04:00
}
$where .= 'INNER JOIN `*PREFIX*storages` ON `numeric_id` = `*PREFIX*filecache`.`storage` ';
2014-02-18 15:37:32 +04:00
$fileDependent = true;
$queryArgs = [];
2014-02-18 15:37:32 +04:00
} else {
$fileDependent = false;
$root = '';
$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([$itemType], $collectionTypes);
2014-02-18 15:37:32 +04:00
} else {
$itemTypes = $collectionTypes;
}
$placeholders = implode(',', array_fill(0, count($itemTypes), '?'));
2014-02-18 15:37:32 +04:00
$where = ' WHERE `item_type` IN ('.$placeholders.'))';
$queryArgs = $itemTypes;
} else {
$where = ' WHERE `item_type` = ?';
$queryArgs = [$itemType];
2014-02-18 15:37:32 +04: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[] = IShare::TYPE_LINK;
2014-02-18 15:37:32 +04:00
}
if (isset($shareType)) {
// Include all user and group items
if ($shareType == self::$shareTypeUserAndGroups && isset($shareWith)) {
$where .= ' AND ((`share_type` in (?, ?) AND `share_with` = ?) ';
$queryArgs[] = IShare::TYPE_USER;
2014-02-18 15:37:32 +04:00
$queryArgs[] = self::$shareTypeGroupUserUnique;
$queryArgs[] = $shareWith;
$user = \OC::$server->getUserManager()->get($shareWith);
$groups = [];
if ($user) {
$groups = \OC::$server->getGroupManager()->getUserGroupIds($user);
}
if (!empty($groups)) {
$placeholders = implode(',', array_fill(0, count($groups), '?'));
$where .= ' OR (`share_type` = ? AND `share_with` IN ('.$placeholders.')) ';
$queryArgs[] = IShare::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)) {
$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)) {
$placeholders = implode(',', array_fill(0, count($collectionTypes), '?'));
2014-02-18 15:37:32 +04:00
$where .= ' OR `item_type` IN ('.$placeholders.'))';
$queryArgs = array_merge($queryArgs, $collectionTypes);
}
}
if ($shareType == self::$shareTypeUserAndGroups && $limit === 1) {
// 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',
\OC_DB::getErrorMessage() . ', select=' . $select . ' where=',
ILogger::ERROR);
2014-02-18 15:37:32 +04:00
}
$items = [];
$targets = [];
$switchedItems = [];
$mounts = [];
2014-02-18 15:37:32 +04:00
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
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'] = IShare::TYPE_GROUP;
$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'];
// 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;
}
} elseif (!isset($uidOwner)) {
2014-02-18 15:37:32 +04:00
// Check if the same target already exists
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
$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'] != IShare::TYPE_GROUP) {
$items[$id]['share_type'] = IShare::TYPE_GROUP;
2014-02-18 15:37:32 +04:00
$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
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'];
}
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([$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: ' .
\OC_DB::getErrorMessage() . ', select=' . $select . ' where=' . $where,
ILogger::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'];
// 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;
}
$row['path'] = $tmpPath;
2014-02-18 15:37:32 +04:00
}
} else {
if (!isset($mounts[$row['storage']])) {
$mountPoints = \OC\Files\Filesystem::getMountByNumericId($row['storage']);
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
}
}
}
if ($checkExpireDate) {
2014-02-18 15:37:32 +04:00
if (self::expireItem($row)) {
continue;
}
}
// Check if resharing is allowed, if not remove share permission
if (isset($row['permissions']) && (!self::isResharingAllowed() | \OCP\Util::isSharingDisabledForUser())) {
$row['permissions'] &= ~\OCP\Constants::PERMISSION_SHARE;
2014-02-18 15:37:32 +04:00
}
// Add display names to result
$row['share_with_displayname'] = $row['share_with'];
if (isset($row['share_with']) && $row['share_with'] != '' &&
$row['share_type'] === IShare::TYPE_USER) {
$shareWithUser = \OC::$server->getUserManager()->get($row['share_with']);
$row['share_with_displayname'] = $shareWithUser === null ? $row['share_with'] : $shareWithUser->getDisplayName();
} elseif (isset($row['share_with']) && $row['share_with'] != '' &&
$row['share_type'] === IShare::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'] != '') {
$ownerUser = \OC::$server->getUserManager()->get($row['uid_owner']);
$row['displayname_owner'] = $ownerUser === null ? $row['uid_owner'] : $ownerUser->getDisplayName();
2014-02-18 15:37:32 +04:00
}
if ($row['permissions'] > 0) {
$items[$row['id']] = $row;
}
2014-07-31 13:55:59 +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 = [];
2014-02-18 15:37:32 +04:00
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 = [];
2014-02-18 15:37:32 +04:00
$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 = [];
2014-02-18 15:37:32 +04:00
$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)) {
$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
// 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 = [];
2014-10-01 17:13:10 +04:00
$collectionBackend = self::getBackend('folder');
$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
return [];
2014-02-18 15:37:32 +04:00
}
/**
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
*/
protected static function groupItems($items, $itemType) {
$fileSharing = $itemType === 'file' || $itemType === 'folder';
2014-07-31 13:55:59 +04:00
$result = [];
2014-07-31 13:55:59 +04:00
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']) ||
(!$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-03-03 20:06:45 +04:00
/**
* construct select statement
2014-03-03 20:06:45 +04:00
* @param int $format
* @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) {
$select = '`*PREFIX*share`.`id`, `*PREFIX*share`.`parent`, `share_type`, `path`, `storage`, '
. '`share_with`, `uid_owner` , `file_source`, `stime`, `*PREFIX*share`.`permissions`, '
. '`*PREFIX*storages`.`id` AS `storage_id`, `*PREFIX*filecache`.`parent` as `file_parent`, '
. '`uid_initiator`';
2014-03-03 20:06:45 +04:00
} else {
$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`,'
. ' `share_type`, `share_with`, `file_source`, `file_target`, `path`, `*PREFIX*share`.`permissions`, `stime`,'
. ' `expiration`, `token`, `storage`, `mail_send`, `uid_owner`, '
. '`*PREFIX*storages`.`id` AS `storage_id`, `*PREFIX*filecache`.`parent` as `file_parent`';
2014-03-03 20:06:45 +04:00
} else {
$select = '`id`, `item_type`, `item_source`, `parent`, `share_type`, `share_with`, `*PREFIX*share`.`permissions`,'
. ' `stime`, `file_source`, `expiration`, `token`, `mail_send`, `uid_owner`';
2014-03-03 20:06:45 +04:00
}
} else {
if ($fileDependent) {
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`, '
. '`share_type`, `share_with`, `file_source`, `path`, `file_target`, `stime`, '
. '`*PREFIX*share`.`permissions`, `expiration`, `storage`, `*PREFIX*filecache`.`parent` as `file_parent`, '
. '`name`, `mtime`, `mimetype`, `mimepart`, `size`, `encrypted`, `etag`, `mail_send`';
2014-03-03 20:06:45 +04:00
} else {
$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`,'
. '`*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
/**
* 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'];
}
if (isset($row['expiration']) && $row['share_type'] !== IShare::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
/**
* format result
2014-03-03 20:30:16 +04:00
* @param array $items result
* @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
* @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;
} elseif ($format === self::FORMAT_STATUSES) {
$statuses = [];
2014-03-03 20:30:16 +04:00
foreach ($items as $item) {
if ($item['share_type'] === IShare::TYPE_LINK) {
if ($item['uid_initiator'] !== \OC::$server->getUserSession()->getUser()->getUID()) {
continue;
}
2014-03-03 20:30:16 +04:00
$statuses[$item[$column]]['link'] = true;
} elseif (!isset($statuses[$item[$column]])) {
2014-03-03 20:30:16 +04:00
$statuses[$item[$column]]['link'] = false;
}
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
/**
* remove protocol from URL
*
* @param string $url
* @return string
*/
public static function removeProtocolFromUrl($url) {
if (strpos($url, 'https://') === 0) {
return substr($url, strlen('https://'));
} elseif (strpos($url, 'http://') === 0) {
return substr($url, strlen('http://'));
}
return $url;
}
/**
* try http post first with https and then with http as a fallback
*
* @param string $remoteDomain
* @param string $urlSuffix
* @param array $fields post parameters
* @return array
*/
private static function tryHttpPostToShareEndpoint($remoteDomain, $urlSuffix, array $fields) {
$protocol = 'https://';
$result = [
'success' => false,
'result' => '',
];
$try = 0;
$discoveryService = \OC::$server->query(\OCP\OCS\IDiscoveryService::class);
while ($result['success'] === false && $try < 2) {
$federationEndpoints = $discoveryService->discover($protocol . $remoteDomain, 'FEDERATED_SHARING');
$endpoint = isset($federationEndpoints['share']) ? $federationEndpoints['share'] : '/ocs/v2.php/cloud/shares';
$client = \OC::$server->getHTTPClientService()->newClient();
try {
$response = $client->post(
$protocol . $remoteDomain . $endpoint . $urlSuffix . '?format=' . self::RESPONSE_FORMAT,
[
'body' => $fields,
'connect_timeout' => 10,
]
);
$result = ['success' => true, 'result' => $response->getBody()];
} catch (\Exception $e) {
$result = ['success' => false, 'result' => $e->getMessage()];
}
$try++;
$protocol = 'http://';
}
return $result;
}
/**
* send server-to-server unshare to remote server
*
* @param string $remote url
* @param int $id share id
* @param string $token
* @return bool
*/
private static function sendRemoteUnshare($remote, $id, $token) {
$url = rtrim($remote, '/');
$fields = ['token' => $token, 'format' => 'json'];
$url = self::removeProtocolFromUrl($url);
$result = self::tryHttpPostToShareEndpoint($url, '/'.$id.'/unshare', $fields);
$status = json_decode($result['result'], true);
return ($result['success'] && ($status['ocs']['meta']['statuscode'] === 100 || $status['ocs']['meta']['statuscode'] === 200));
}
/**
* @return int
*/
2014-06-03 17:15:04 +04:00
public static function getExpireInterval() {
return (int)\OC::$server->getConfig()->getAppValue('core', 'shareapi_expire_after_n_days', '7');
2014-06-03 17:15:04 +04: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
if (!(substr($ownerStorageId, 0, 6) === 'home::' ||
substr($ownerStorageId, 0, 13) === 'object::user:'
)) {
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;
}
2014-02-18 15:37:32 +04:00
}