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 ;
2016-01-25 19:17:36 +03:00
use OCP\DB\QueryBuilder\IQueryBuilder ;
2015-03-13 14:29:13 +03:00
use OCP\IConfig ;
2018-04-25 16:22:28 +03:00
use OCP\ILogger ;
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
}
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 ,
2018-04-25 16:22:28 +03:00
ILogger :: 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 ) {
2018-04-25 16:22:28 +03:00
\OCP\Util :: writeLog ( 'OCP\Share' , \OC_DB :: getErrorMessage () . ', token=' . $token , ILogger :: 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 ;
}
/**
* 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
2018-06-29 11:33:12 +03:00
* @ deprecated 14.0 . 0 TESTS ONLY - this methods is as of 2018 - 06 only used by tests
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 ));
2018-04-25 16:22:28 +03:00
\OCP\Util :: writeLog ( 'OCP\Share' , sprintf ( $message , $itemSourceName , $shareType ), ILogger :: 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 ();
2018-11-02 01:18:44 +03:00
$shareWithinGroupOnly = \OC :: $server -> getConfig () -> getAppValue ( 'core' , 'shareapi_only_share_with_group_members' , 'no' ) === 'yes' ;
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 ));
2018-04-25 16:22:28 +03:00
\OCP\Util :: writeLog ( 'OCP\Share' , sprintf ( $message , $itemSourceName ), ILogger :: 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 ]);
2018-04-25 16:22:28 +03:00
\OCP\Util :: writeLog ( 'OCP\Share' , sprintf ( $message , $path ), ILogger :: 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!' ;
2018-04-25 16:22:28 +03:00
\OCP\Util :: writeLog ( 'OCP\Share' , $message , ILogger :: 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 ]);
2018-04-25 16:22:28 +03:00
\OCP\Util :: writeLog ( 'OCP\Share' , sprintf ( $message , $itemSourceName ), ILogger :: 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 )) {
2018-10-09 15:32:14 +03:00
$message = 'Sharing %1$s failed, because the user %2$s does not exist' ;
$message_t = $l -> t ( 'Sharing %1$s failed, because the user %2$s does not exist' , array ( $itemSourceName , $shareWith ));
2018-04-25 16:22:28 +03:00
\OCP\Util :: writeLog ( 'OCP\Share' , sprintf ( $message , $itemSourceName , $shareWith ), ILogger :: 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 )) {
2018-10-09 15:32:14 +03:00
$message = 'Sharing %1$s failed, because the user '
. '%2$s is not a member of any groups that %3$s is a member of' ;
$message_t = $l -> t ( 'Sharing %1$s failed, because the user %2$s is not a member of any groups that %3$s is a member of' , array ( $itemName , $shareWith , $uidOwner ));
2018-04-25 16:22:28 +03:00
\OCP\Util :: writeLog ( 'OCP\Share' , sprintf ( $message , $itemName , $shareWith , $uidOwner ), ILogger :: 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 ) {
2018-10-09 15:32:14 +03:00
$message = 'Sharing %1$s failed, because this item is already shared with %2$s' ;
$message_t = $l -> t ( 'Sharing %1$s failed, because this item is already shared with %2$s' , array ( $itemSourceName , $shareWith ));
2018-04-25 16:22:28 +03:00
\OCP\Util :: writeLog ( 'OCP\Share' , sprintf ( $message , $itemSourceName , $shareWith ), ILogger :: 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 ) {
2018-10-09 15:32:14 +03:00
$message = 'Sharing %1$s failed, because this item is already shared with user %2$s' ;
$message_t = $l -> t ( 'Sharing %1$s failed, because this item is already shared with user %2$s' , array ( $itemSourceName , $shareWith ));
2018-04-25 16:22:28 +03:00
\OCP\Util :: writeLog ( 'OCP\Share' , sprintf ( $message , $itemSourceName , $shareWith ), ILogger :: 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 )) {
2018-10-09 15:32:14 +03:00
$message = 'Sharing %1$s failed, because the group %2$s does not exist' ;
$message_t = $l -> t ( 'Sharing %1$s failed, because the group %2$s does not exist' , array ( $itemSourceName , $shareWith ));
2018-04-25 16:22:28 +03:00
\OCP\Util :: writeLog ( 'OCP\Share' , sprintf ( $message , $itemSourceName , $shareWith ), ILogger :: 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 )) {
2018-10-09 15:32:14 +03:00
$message = 'Sharing %1$s failed, because '
. '%2$s is not a member of the group %3$s' ;
$message_t = $l -> t ( 'Sharing %1$s failed, because %2$s is not a member of the group %3$s' , array ( $itemSourceName , $uidOwner , $shareWith ));
2018-04-25 16:22:28 +03:00
\OCP\Util :: writeLog ( 'OCP\Share' , sprintf ( $message , $itemSourceName , $uidOwner , $shareWith ), ILogger :: DEBUG );
2017-03-03 10:24:27 +03:00
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 ) {
2018-10-09 15:32:14 +03:00
$message = 'Sharing %1$s failed, because this item is already shared with %2$s' ;
$message_t = $l -> t ( 'Sharing %1$s failed, because this item is already shared with %2$s' , array ( $itemSourceName , $shareWith ));
2018-04-25 16:22:28 +03:00
\OCP\Util :: writeLog ( 'OCP\Share' , sprintf ( $message , $itemSourceName , $shareWith ), ILogger :: 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' );
2018-04-25 16:22:28 +03:00
\OCP\Util :: writeLog ( 'OCP\Share' , $message , ILogger :: 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 ));
2018-04-25 16:22:28 +03:00
\OCP\Util :: writeLog ( 'OCP\Share' , sprintf ( $message , $itemSourceName ), ILogger :: 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 )) {
2018-10-09 15:32:14 +03:00
$message = 'Sharing %1$s failed, because this item is already shared with %2$s' ;
$message_t = $l -> t ( 'Sharing %1$s failed, because this item is already shared with %2$s' , array ( $itemSourceName , $shareWith ));
2018-04-25 16:22:28 +03:00
\OCP\Util :: writeLog ( 'OCP\Share' , sprintf ( $message , $itemSourceName , $shareWith ), ILogger :: 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' );
2018-04-25 16:22:28 +03:00
\OCP\Util :: writeLog ( 'OCP\Share' , $message , ILogger :: DEBUG );
2015-12-09 14:00:00 +03:00
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 );
2018-10-09 15:32:14 +03:00
$message_t = $l -> t ( 'Sharing %1$s failed, could not find %2$s, maybe the server is currently unreachable.' , array ( $itemSourceName , $shareWith ));
2014-12-04 21:51:04 +03:00
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
2018-10-09 15:32:14 +03:00
$message = 'Share type %1$s is not valid for %2$s' ;
$message_t = $l -> t ( 'Share type %1$s is not valid for %2$s' , array ( $shareType , $itemSource ));
2018-04-25 16:22:28 +03:00
\OCP\Util :: writeLog ( 'OCP\Share' , sprintf ( $message , $shareType , $itemSource ), ILogger :: 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 ) {
2018-04-25 16:22:28 +03:00
\OCP\Util :: writeLog ( 'OCP\Share' , 'Couldn\'t set send mail status' , ILogger :: 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 ));
2018-04-25 16:22:28 +03:00
\OCP\Util :: writeLog ( 'OCP\Share' , $warning , ILogger :: WARN );
2014-07-23 18:42:33 +04:00
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' );
2018-04-25 16:22:28 +03:00
\OCP\Util :: writeLog ( 'OCP\Share' , $message , ILogger :: WARN );
2014-07-23 18:42:33 +04:00
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 ));
2018-04-25 16:22:28 +03:00
\OCP\Util :: writeLog ( 'OCP\Share' , sprintf ( $message , $class ), ILogger :: 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 ));
2018-04-25 16:22:28 +03:00
\OCP\Util :: writeLog ( 'OCP\Share' , sprintf ( $message , $class ), ILogger :: 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 ));
2018-04-25 16:22:28 +03:00
\OCP\Util :: writeLog ( 'OCP\Share' , sprintf ( $message , $itemType ), ILogger :: 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 ;
}
2018-02-13 23:48:24 +03:00
$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 = 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 )) {
2018-02-13 23:48:24 +03:00
$placeholders = implode ( ',' , array_fill ( 0 , count ( $groups ), '?' ));
2014-11-17 15:09:13 +03:00
$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 )) {
2018-02-13 23:48:24 +03:00
$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 );
}
}
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=' ,
2018-04-25 16:22:28 +03:00
ILogger :: 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 ,
2018-04-25 16:22:28 +03:00
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' ];
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 ) {
2018-03-25 21:42:03 +03:00
$shareWithUser = \OC :: $server -> getUserManager () -> get ( $row [ 'share_with' ]);
$row [ 'share_with_displayname' ] = $shareWithUser === null ? $row [ 'share_with' ] : $shareWithUser -> getDisplayName ();
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' ] != '' ) {
2018-03-25 21:42:38 +03:00
$ownerUser = \OC :: $server -> getUserManager () -> get ( $row [ 'uid_owner' ]);
2018-03-25 21:42:03 +03:00
$row [ 'displayname_owner' ] = $ownerUser === null ? $row [ 'uid_owner' ] : $ownerUser -> getDisplayName ();
2014-02-18 15:37:32 +04:00
}
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 ) {
2018-10-09 15:32:14 +03:00
$message = 'Sharing %1$s failed, because the user %2$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
2018-04-25 16:22:28 +03:00
\OCP\Util :: writeLog ( 'OCP\Share' , sprintf ( $message , $itemSourceName , $shareWith ), ILogger :: 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 ) {
2018-10-09 15:32:14 +03:00
$message = 'Sharing %1$s failed, because the permissions exceed permissions granted to %2$s' ;
$message_t = $l -> t ( 'Sharing %1$s failed, because the permissions exceed permissions granted to %2$s' , array ( $itemSourceName , $uidOwner ));
2014-07-31 13:55:59 +04:00
2018-04-25 16:22:28 +03:00
\OCP\Util :: writeLog ( 'OCP\Share' , sprintf ( $message , $itemSourceName , $uidOwner ), ILogger :: 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
2018-04-25 16:22:28 +03:00
\OCP\Util :: writeLog ( 'OCP\Share' , sprintf ( $message , $itemSourceName ), ILogger :: 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 )) {
2018-10-09 15:32:14 +03:00
$message = 'Sharing %1$s failed, because the sharing backend for '
. '%2$s could not find its source' ;
$message_t = $l -> t ( 'Sharing %1$s failed, because the sharing backend for %2$s could not find its source' , array ( $itemSource , $itemType ));
2018-04-25 16:22:28 +03:00
\OCP\Util :: writeLog ( 'OCP\Share' , sprintf ( $message , $itemSource , $itemType ), ILogger :: 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
2018-04-25 16:22:28 +03:00
\OCP\Util :: writeLog ( 'OCP\Share' , sprintf ( $message , $itemSource ), ILogger :: 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' ;
2018-03-13 18:30:41 +03:00
$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 ()];
}
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
}
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-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
}