2013-06-30 20:02:34 +04:00
|
|
|
<?php
|
|
|
|
/**
|
2016-05-26 20:56:05 +03:00
|
|
|
* @author Björn Schießle <bjoern@schiessle.org>
|
2016-01-12 17:02:16 +03:00
|
|
|
* @author Joas Schilling <nickvergessen@owncloud.com>
|
2015-03-26 13:44:34 +03:00
|
|
|
* @author Morris Jobke <hey@morrisjobke.de>
|
|
|
|
* @author Robin Appelman <icewind@owncloud.com>
|
|
|
|
* @author Thomas Müller <thomas.mueller@tmit.eu>
|
|
|
|
* @author Vincent Petry <pvince81@owncloud.com>
|
|
|
|
*
|
2016-01-12 17:02:16 +03:00
|
|
|
* @copyright Copyright (c) 2016, ownCloud, Inc.
|
2015-03-26 13:44:34 +03:00
|
|
|
* @license AGPL-3.0
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* 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/>
|
|
|
|
*
|
2013-06-30 20:02:34 +04:00
|
|
|
*/
|
2015-02-26 13:37:37 +03:00
|
|
|
|
2015-08-30 20:13:01 +03:00
|
|
|
namespace OCA\DAV\Connector\Sabre;
|
2013-06-30 20:02:34 +04:00
|
|
|
|
2015-11-13 16:13:16 +03:00
|
|
|
use OCA\DAV\Connector\Sabre\Exception\Forbidden;
|
2015-08-30 20:13:01 +03:00
|
|
|
use OCA\DAV\Connector\Sabre\Exception\InvalidPath;
|
|
|
|
use OCA\DAV\Connector\Sabre\Exception\FileLocked;
|
2014-02-25 19:23:09 +04:00
|
|
|
use OC\Files\FileInfo;
|
2014-06-17 16:10:11 +04:00
|
|
|
use OC\Files\Mount\MoveableMount;
|
2015-11-13 16:13:16 +03:00
|
|
|
use OCP\Files\ForbiddenException;
|
2014-07-01 17:03:29 +04:00
|
|
|
use OCP\Files\StorageInvalidException;
|
2014-06-30 18:36:11 +04:00
|
|
|
use OCP\Files\StorageNotAvailableException;
|
2015-05-29 10:59:20 +03:00
|
|
|
use OCP\Lock\LockedException;
|
2013-06-30 20:02:34 +04:00
|
|
|
|
2015-02-12 14:29:01 +03:00
|
|
|
class ObjectTree extends \Sabre\DAV\Tree {
|
2013-09-26 12:50:15 +04:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @var \OC\Files\View
|
|
|
|
*/
|
2014-02-25 19:23:09 +04:00
|
|
|
protected $fileView;
|
|
|
|
|
2014-06-17 16:10:11 +04:00
|
|
|
/**
|
2015-08-07 18:36:14 +03:00
|
|
|
* @var \OCP\Files\Mount\IMountManager
|
2014-06-17 16:10:11 +04:00
|
|
|
*/
|
|
|
|
protected $mountManager;
|
|
|
|
|
2014-02-25 19:23:09 +04:00
|
|
|
/**
|
|
|
|
* Creates the object
|
2014-03-04 16:28:48 +04:00
|
|
|
*/
|
|
|
|
public function __construct() {
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2015-01-27 11:22:52 +03:00
|
|
|
* @param \Sabre\DAV\INode $rootNode
|
2014-02-25 19:23:09 +04:00
|
|
|
* @param \OC\Files\View $view
|
2015-08-07 18:36:14 +03:00
|
|
|
* @param \OCP\Files\Mount\IMountManager $mountManager
|
2014-02-25 19:23:09 +04:00
|
|
|
*/
|
2015-08-07 18:36:14 +03:00
|
|
|
public function init(\Sabre\DAV\INode $rootNode, \OC\Files\View $view, \OCP\Files\Mount\IMountManager $mountManager) {
|
2014-03-04 16:28:48 +04:00
|
|
|
$this->rootNode = $rootNode;
|
2014-02-25 19:23:09 +04:00
|
|
|
$this->fileView = $view;
|
2014-06-17 16:10:11 +04:00
|
|
|
$this->mountManager = $mountManager;
|
2014-02-25 19:23:09 +04:00
|
|
|
}
|
2013-09-26 12:50:15 +04:00
|
|
|
|
2015-02-12 14:29:01 +03:00
|
|
|
/**
|
|
|
|
* If the given path is a chunked file name, converts it
|
|
|
|
* to the real file name. Only applies if the OC-CHUNKED header
|
|
|
|
* is present.
|
|
|
|
*
|
|
|
|
* @param string $path chunk file path to convert
|
2016-06-30 12:09:20 +03:00
|
|
|
*
|
2015-02-12 14:29:01 +03:00
|
|
|
* @return string path to real file
|
|
|
|
*/
|
|
|
|
private function resolveChunkFile($path) {
|
|
|
|
if (isset($_SERVER['HTTP_OC_CHUNKED'])) {
|
|
|
|
// resolve to real file name to find the proper node
|
|
|
|
list($dir, $name) = \Sabre\HTTP\URLUtil::splitPath($path);
|
|
|
|
if ($dir == '/' || $dir == '.') {
|
|
|
|
$dir = '';
|
|
|
|
}
|
|
|
|
|
|
|
|
$info = \OC_FileChunking::decodeName($name);
|
|
|
|
// only replace path if it was really the chunked file
|
|
|
|
if (isset($info['transferid'])) {
|
|
|
|
// getNodePath is called for multiple nodes within a chunk
|
|
|
|
// upload call
|
|
|
|
$path = $dir . '/' . $info['name'];
|
|
|
|
$path = ltrim($path, '/');
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return $path;
|
|
|
|
}
|
|
|
|
|
2015-12-30 16:10:03 +03:00
|
|
|
public function cacheNode(Node $node) {
|
|
|
|
$this->cache[trim($node->getPath(), '/')] = $node;
|
|
|
|
}
|
|
|
|
|
2013-06-30 20:02:34 +04:00
|
|
|
/**
|
|
|
|
* Returns the INode object for the requested path
|
|
|
|
*
|
|
|
|
* @param string $path
|
2014-01-09 17:25:48 +04:00
|
|
|
* @return \Sabre\DAV\INode
|
2016-03-24 16:29:55 +03:00
|
|
|
* @throws InvalidPath
|
|
|
|
* @throws \Sabre\DAV\Exception\Locked
|
|
|
|
* @throws \Sabre\DAV\Exception\NotFound
|
|
|
|
* @throws \Sabre\DAV\Exception\ServiceUnavailable
|
2013-06-30 20:02:34 +04:00
|
|
|
*/
|
|
|
|
public function getNodeForPath($path) {
|
2014-03-04 16:28:48 +04:00
|
|
|
if (!$this->fileView) {
|
2014-01-09 17:25:48 +04:00
|
|
|
throw new \Sabre\DAV\Exception\ServiceUnavailable('filesystem not setup');
|
2014-03-04 16:28:48 +04:00
|
|
|
}
|
2013-06-30 20:02:34 +04:00
|
|
|
|
|
|
|
$path = trim($path, '/');
|
2015-12-30 16:10:03 +03:00
|
|
|
|
|
|
|
if (isset($this->cache[$path])) {
|
|
|
|
return $this->cache[$path];
|
|
|
|
}
|
|
|
|
|
2015-06-11 18:10:11 +03:00
|
|
|
if ($path) {
|
2015-06-15 18:49:11 +03:00
|
|
|
try {
|
|
|
|
$this->fileView->verifyPath($path, basename($path));
|
|
|
|
} catch (\OCP\Files\InvalidPathException $ex) {
|
|
|
|
throw new InvalidPath($ex->getMessage());
|
|
|
|
}
|
2015-06-11 18:10:11 +03:00
|
|
|
}
|
|
|
|
|
2013-06-30 20:02:34 +04:00
|
|
|
// Is it the root node?
|
|
|
|
if (!strlen($path)) {
|
|
|
|
return $this->rootNode;
|
|
|
|
}
|
|
|
|
|
2013-11-27 15:46:12 +04:00
|
|
|
if (pathinfo($path, PATHINFO_EXTENSION) === 'part') {
|
|
|
|
// read from storage
|
2014-02-25 19:23:09 +04:00
|
|
|
$absPath = $this->fileView->getAbsolutePath($path);
|
2014-12-16 16:24:48 +03:00
|
|
|
$mount = $this->fileView->getMount($path);
|
|
|
|
$storage = $mount->getStorage();
|
|
|
|
$internalPath = $mount->getInternalPath($absPath);
|
2016-02-11 19:22:40 +03:00
|
|
|
if ($storage && $storage->file_exists($internalPath)) {
|
2014-02-25 19:23:09 +04:00
|
|
|
/**
|
|
|
|
* @var \OC\Files\Storage\Storage $storage
|
|
|
|
*/
|
2013-11-27 15:46:12 +04:00
|
|
|
// get data directly
|
2015-12-02 17:05:29 +03:00
|
|
|
$data = $storage->getMetaData($internalPath);
|
2014-12-16 16:24:48 +03:00
|
|
|
$info = new FileInfo($absPath, $storage, $internalPath, $data, $mount);
|
2014-02-25 19:23:09 +04:00
|
|
|
} else {
|
|
|
|
$info = null;
|
2013-11-27 15:46:12 +04:00
|
|
|
}
|
2014-02-25 19:23:09 +04:00
|
|
|
} else {
|
2015-02-12 14:29:01 +03:00
|
|
|
// resolve chunk file name to real name, if applicable
|
|
|
|
$path = $this->resolveChunkFile($path);
|
|
|
|
|
2013-11-27 15:46:12 +04:00
|
|
|
// read from cache
|
2014-06-30 18:36:11 +04:00
|
|
|
try {
|
|
|
|
$info = $this->fileView->getFileInfo($path);
|
|
|
|
} catch (StorageNotAvailableException $e) {
|
|
|
|
throw new \Sabre\DAV\Exception\ServiceUnavailable('Storage not available');
|
2015-02-12 14:29:01 +03:00
|
|
|
} catch (StorageInvalidException $e) {
|
2014-07-01 17:03:29 +04:00
|
|
|
throw new \Sabre\DAV\Exception\NotFound('Storage ' . $path . ' is invalid');
|
2015-06-16 15:37:41 +03:00
|
|
|
} catch (LockedException $e) {
|
|
|
|
throw new \Sabre\DAV\Exception\Locked();
|
2016-06-01 15:51:25 +03:00
|
|
|
} catch (ForbiddenException $e) {
|
|
|
|
throw new \Sabre\DAV\Exception\Forbidden();
|
2014-06-30 18:36:11 +04:00
|
|
|
}
|
2013-11-27 15:46:12 +04:00
|
|
|
}
|
2013-06-30 20:02:34 +04:00
|
|
|
|
|
|
|
if (!$info) {
|
2014-01-09 17:25:48 +04:00
|
|
|
throw new \Sabre\DAV\Exception\NotFound('File with name ' . $path . ' could not be located');
|
2013-06-30 20:02:34 +04:00
|
|
|
}
|
|
|
|
|
2014-02-25 19:23:09 +04:00
|
|
|
if ($info->getType() === 'dir') {
|
2015-12-30 16:10:03 +03:00
|
|
|
$node = new \OCA\DAV\Connector\Sabre\Directory($this->fileView, $info, $this);
|
2013-06-30 20:02:34 +04:00
|
|
|
} else {
|
2015-08-30 20:13:01 +03:00
|
|
|
$node = new \OCA\DAV\Connector\Sabre\File($this->fileView, $info);
|
2013-06-30 20:02:34 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
$this->cache[$path] = $node;
|
|
|
|
return $node;
|
|
|
|
|
|
|
|
}
|
2013-06-30 20:27:55 +04:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Moves a file from one location to another
|
|
|
|
*
|
|
|
|
* @param string $sourcePath The path to the file which should be moved
|
|
|
|
* @param string $destinationPath The full destination path, so not just the destination parent node
|
2016-06-30 14:19:50 +03:00
|
|
|
* @throws FileLocked
|
|
|
|
* @throws Forbidden
|
|
|
|
* @throws InvalidPath
|
2014-01-09 17:25:48 +04:00
|
|
|
* @throws \Sabre\DAV\Exception\Forbidden
|
2016-06-30 14:19:50 +03:00
|
|
|
* @throws \Sabre\DAV\Exception\Locked
|
|
|
|
* @throws \Sabre\DAV\Exception\NotFound
|
|
|
|
* @throws \Sabre\DAV\Exception\ServiceUnavailable
|
2013-06-30 20:27:55 +04:00
|
|
|
* @return int
|
|
|
|
*/
|
|
|
|
public function move($sourcePath, $destinationPath) {
|
2014-03-04 16:28:48 +04:00
|
|
|
if (!$this->fileView) {
|
2014-01-09 17:25:48 +04:00
|
|
|
throw new \Sabre\DAV\Exception\ServiceUnavailable('filesystem not setup');
|
2014-03-04 16:28:48 +04:00
|
|
|
}
|
2013-06-30 20:27:55 +04:00
|
|
|
|
2016-06-30 12:09:20 +03:00
|
|
|
$infoDestination = $this->fileView->getFileInfo(dirname($destinationPath));
|
|
|
|
$infoSource = $this->fileView->getFileInfo($sourcePath);
|
|
|
|
$destinationPermission = $infoDestination && $infoDestination->isUpdateable();
|
|
|
|
$sourcePermission = $infoSource && $infoSource->isDeletable();
|
|
|
|
|
|
|
|
if (!$destinationPermission || !$sourcePermission) {
|
2016-06-30 14:17:53 +03:00
|
|
|
throw new Forbidden('No permissions to move object.');
|
2016-06-30 12:09:20 +03:00
|
|
|
}
|
|
|
|
|
2015-03-19 23:18:48 +03:00
|
|
|
$targetNodeExists = $this->nodeExists($destinationPath);
|
2013-06-30 20:27:55 +04:00
|
|
|
$sourceNode = $this->getNodeForPath($sourcePath);
|
2015-03-19 23:18:48 +03:00
|
|
|
if ($sourceNode instanceof \Sabre\DAV\ICollection && $targetNodeExists) {
|
2015-12-16 16:44:28 +03:00
|
|
|
throw new \Sabre\DAV\Exception\Forbidden('Could not copy directory ' . $sourceNode->getName() . ', target exists');
|
2013-06-30 20:27:55 +04:00
|
|
|
}
|
2015-02-12 14:29:01 +03:00
|
|
|
list($sourceDir,) = \Sabre\HTTP\URLUtil::splitPath($sourcePath);
|
|
|
|
list($destinationDir,) = \Sabre\HTTP\URLUtil::splitPath($destinationPath);
|
2013-06-30 20:27:55 +04:00
|
|
|
|
2014-06-17 16:10:11 +04:00
|
|
|
$isMovableMount = false;
|
|
|
|
$sourceMount = $this->mountManager->find($this->fileView->getAbsolutePath($sourcePath));
|
|
|
|
$internalPath = $sourceMount->getInternalPath($this->fileView->getAbsolutePath($sourcePath));
|
|
|
|
if ($sourceMount instanceof MoveableMount && $internalPath === '') {
|
|
|
|
$isMovableMount = true;
|
2014-04-17 17:54:45 +04:00
|
|
|
}
|
|
|
|
|
2014-11-06 12:59:36 +03:00
|
|
|
try {
|
2015-03-19 23:18:48 +03:00
|
|
|
$sameFolder = ($sourceDir === $destinationDir);
|
|
|
|
// if we're overwriting or same folder
|
|
|
|
if ($targetNodeExists || $sameFolder) {
|
|
|
|
// note that renaming a share mount point is always allowed
|
|
|
|
if (!$this->fileView->isUpdatable($destinationDir) && !$isMovableMount) {
|
|
|
|
throw new \Sabre\DAV\Exception\Forbidden();
|
|
|
|
}
|
|
|
|
} else {
|
2014-11-06 12:59:36 +03:00
|
|
|
if (!$this->fileView->isCreatable($destinationDir)) {
|
|
|
|
throw new \Sabre\DAV\Exception\Forbidden();
|
|
|
|
}
|
2015-03-19 23:18:48 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!$sameFolder) {
|
|
|
|
// moving to a different folder, source will be gone, like a deletion
|
|
|
|
// note that moving a share mount point is always allowed
|
2014-11-06 12:59:36 +03:00
|
|
|
if (!$this->fileView->isDeletable($sourcePath) && !$isMovableMount) {
|
|
|
|
throw new \Sabre\DAV\Exception\Forbidden();
|
|
|
|
}
|
2013-10-08 13:43:44 +04:00
|
|
|
}
|
2013-09-24 15:26:12 +04:00
|
|
|
|
2014-11-06 12:59:36 +03:00
|
|
|
$fileName = basename($destinationPath);
|
2015-02-18 19:44:13 +03:00
|
|
|
try {
|
|
|
|
$this->fileView->verifyPath($destinationDir, $fileName);
|
|
|
|
} catch (\OCP\Files\InvalidPathException $ex) {
|
2015-02-18 20:28:24 +03:00
|
|
|
throw new InvalidPath($ex->getMessage());
|
2014-11-06 12:59:36 +03:00
|
|
|
}
|
2014-01-13 16:14:05 +04:00
|
|
|
|
2014-11-06 12:59:36 +03:00
|
|
|
$renameOkay = $this->fileView->rename($sourcePath, $destinationPath);
|
|
|
|
if (!$renameOkay) {
|
|
|
|
throw new \Sabre\DAV\Exception\Forbidden('');
|
|
|
|
}
|
2015-05-29 10:59:20 +03:00
|
|
|
} catch (StorageNotAvailableException $e) {
|
2014-11-06 12:59:36 +03:00
|
|
|
throw new \Sabre\DAV\Exception\ServiceUnavailable($e->getMessage());
|
2015-11-13 16:13:16 +03:00
|
|
|
} catch (ForbiddenException $ex) {
|
|
|
|
throw new Forbidden($ex->getMessage(), $ex->getRetry());
|
2015-05-29 10:59:20 +03:00
|
|
|
} catch (LockedException $e) {
|
|
|
|
throw new FileLocked($e->getMessage(), $e->getCode(), $e);
|
2013-09-24 15:26:12 +04:00
|
|
|
}
|
2013-06-30 20:27:55 +04:00
|
|
|
|
|
|
|
$this->markDirty($sourceDir);
|
|
|
|
$this->markDirty($destinationDir);
|
|
|
|
|
|
|
|
}
|
2013-06-30 21:41:38 +04:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Copies a file or directory.
|
|
|
|
*
|
|
|
|
* This method must work recursively and delete the destination
|
|
|
|
* if it exists
|
|
|
|
*
|
|
|
|
* @param string $source
|
|
|
|
* @param string $destination
|
2016-06-30 14:19:50 +03:00
|
|
|
* @throws FileLocked
|
|
|
|
* @throws Forbidden
|
|
|
|
* @throws InvalidPath
|
|
|
|
* @throws \Exception
|
|
|
|
* @throws \Sabre\DAV\Exception\Forbidden
|
|
|
|
* @throws \Sabre\DAV\Exception\Locked
|
|
|
|
* @throws \Sabre\DAV\Exception\NotFound
|
2014-01-09 17:25:48 +04:00
|
|
|
* @throws \Sabre\DAV\Exception\ServiceUnavailable
|
2013-06-30 21:41:38 +04:00
|
|
|
* @return void
|
|
|
|
*/
|
|
|
|
public function copy($source, $destination) {
|
2014-03-04 16:28:48 +04:00
|
|
|
if (!$this->fileView) {
|
2014-01-09 17:25:48 +04:00
|
|
|
throw new \Sabre\DAV\Exception\ServiceUnavailable('filesystem not setup');
|
2014-03-04 16:28:48 +04:00
|
|
|
}
|
2013-06-30 21:41:38 +04:00
|
|
|
|
2016-06-30 12:09:20 +03:00
|
|
|
|
|
|
|
$info = $this->fileView->getFileInfo(dirname($destination));
|
|
|
|
if ($info && !$info->isUpdateable()) {
|
2016-06-30 14:17:53 +03:00
|
|
|
throw new Forbidden('No permissions to move object.');
|
2016-06-30 12:09:20 +03:00
|
|
|
}
|
|
|
|
|
2015-02-25 18:35:13 +03:00
|
|
|
// this will trigger existence check
|
2015-02-26 13:16:42 +03:00
|
|
|
$this->getNodeForPath($source);
|
2013-06-30 21:41:38 +04:00
|
|
|
|
2015-05-29 20:14:38 +03:00
|
|
|
list($destinationDir, $destinationName) = \Sabre\HTTP\URLUtil::splitPath($destination);
|
|
|
|
try {
|
|
|
|
$this->fileView->verifyPath($destinationDir, $destinationName);
|
|
|
|
} catch (\OCP\Files\InvalidPathException $ex) {
|
|
|
|
throw new InvalidPath($ex->getMessage());
|
|
|
|
}
|
|
|
|
|
2015-02-25 18:35:13 +03:00
|
|
|
try {
|
|
|
|
$this->fileView->copy($source, $destination);
|
2015-05-29 10:59:20 +03:00
|
|
|
} catch (StorageNotAvailableException $e) {
|
2014-11-06 12:59:36 +03:00
|
|
|
throw new \Sabre\DAV\Exception\ServiceUnavailable($e->getMessage());
|
2015-11-13 16:13:16 +03:00
|
|
|
} catch (ForbiddenException $ex) {
|
|
|
|
throw new Forbidden($ex->getMessage(), $ex->getRetry());
|
2015-05-29 11:55:25 +03:00
|
|
|
} catch (LockedException $e) {
|
|
|
|
throw new FileLocked($e->getMessage(), $e->getCode(), $e);
|
2013-06-30 21:41:38 +04:00
|
|
|
}
|
|
|
|
|
2015-02-12 14:29:01 +03:00
|
|
|
list($destinationDir,) = \Sabre\HTTP\URLUtil::splitPath($destination);
|
2013-06-30 21:41:38 +04:00
|
|
|
$this->markDirty($destinationDir);
|
|
|
|
}
|
2013-06-30 20:02:34 +04:00
|
|
|
}
|