aboutsummaryrefslogtreecommitdiffstats
path: root/lib/files
diff options
context:
space:
mode:
Diffstat (limited to 'lib/files')
-rw-r--r--lib/files/cache/cache.php304
-rw-r--r--lib/files/cache/permissions.php85
-rw-r--r--lib/files/cache/scanner.php110
-rw-r--r--lib/files/file.php61
-rw-r--r--lib/files/filesystem.php658
-rw-r--r--lib/files/storage/common.php270
-rw-r--r--lib/files/storage/commontest.php80
-rw-r--r--lib/files/storage/local.php208
-rw-r--r--lib/files/storage/storage.php66
-rw-r--r--lib/files/storage/temporary.php26
-rw-r--r--lib/files/view.php817
11 files changed, 2685 insertions, 0 deletions
diff --git a/lib/files/cache/cache.php b/lib/files/cache/cache.php
new file mode 100644
index 00000000000..5efc7d67c4a
--- /dev/null
+++ b/lib/files/cache/cache.php
@@ -0,0 +1,304 @@
+<?php
+/**
+ * Copyright (c) 2012 Robin Appelman <icewind@owncloud.com>
+ * This file is licensed under the Affero General Public License version 3 or
+ * later.
+ * See the COPYING-README file.
+ */
+
+namespace OC\Files\Cache;
+
+/**
+ * Metadata cache for the filesystem
+ *
+ * don't use this class directly if you need to get metadata, use \OC\Files\Filesystem::getFileInfo instead
+ */
+class Cache {
+ const NOT_FOUND = 0;
+ const PARTIAL = 1; //only partial data available, file not cached in the database
+ const SHALLOW = 2; //folder in cache, but not all child files are completely scanned
+ const COMPLETE = 3;
+
+ /**
+ * @var \OC\Files\Storage\Storage
+ */
+ private $storage;
+
+ /**
+ * @var array partial data for the cache
+ */
+ private $partial = array();
+
+ private $storageId;
+
+ /**
+ * @param \OC\Files\Storage\Storage $storage
+ */
+ public function __construct(\OC\Files\Storage\Storage $storage) {
+ $this->storage = $storage;
+ $this->storageId = $storage->getId();
+ }
+
+ /**
+ * get the stored metadata of a file or folder
+ *
+ * @param string/int $file
+ * @return array
+ */
+ public function get($file) {
+ if (is_string($file)) {
+ $where = 'WHERE `storage` = ? AND `path_hash` = ?';
+ $params = array($this->storageId, md5($file));
+ } else { //file id
+ $where = 'WHERE `fileid` = ?';
+ $params = array($file);
+ }
+ $query = \OC_DB::prepare(
+ 'SELECT `fileid`, `storage`, `path`, `parent`, `name`, `mimetype`, `mimepart`, `size`, `mtime`, `encrypted`
+ FROM `*PREFIX*filecache` ' . $where);
+ $result = $query->execute($params);
+ $data = $result->fetchRow();
+
+ //merge partial data
+ if (!$data and is_string($file)) {
+ if (isset($this->partial[$file])) {
+ $data = $this->partial[$file];
+ }
+ } else {
+ //fix types
+ $data['fileid'] = (int)$data['fileid'];
+ $data['size'] = (int)$data['size'];
+ $data['mtime'] = (int)$data['mtime'];
+ $data['encrypted'] = (bool)$data['encrypted'];
+ }
+
+ return $data;
+ }
+
+ /**
+ * get the metadata of all files stored in $folder
+ *
+ * @param string $folder
+ * @return array
+ */
+ public function getFolderContents($folder) {
+ $fileId = $this->getId($folder);
+ if ($fileId > -1) {
+ $query = \OC_DB::prepare(
+ 'SELECT `fileid`, `storage`, `path`, `parent`, `name`, `mimetype`, `mimepart`, `size`, `mtime`, `encrypted`
+ FROM `*PREFIX*filecache` WHERE parent = ?');
+ $result = $query->execute(array($fileId));
+ return $result->fetchAll();
+ } else {
+ return array();
+ }
+ }
+
+ /**
+ * store meta data for a file or folder
+ *
+ * @param string $file
+ * @param array $data
+ *
+ * @return int file id
+ */
+ public function put($file, array $data) {
+ if (($id = $this->getId($file)) > -1) {
+ $this->update($id, $data);
+ return $id;
+ } else {
+ if (isset($this->partial[$file])) { //add any saved partial data
+ $data = array_merge($this->partial[$file], $data);
+ unset($this->partial[$file]);
+ }
+
+ $requiredFields = array('size', 'mtime', 'mimetype');
+ foreach ($requiredFields as $field) {
+ if (!isset($data[$field])) { //data not complete save as partial and return
+ $this->partial[$file] = $data;
+ return -1;
+ }
+ }
+
+ $data['path'] = $file;
+ $data['parent'] = $this->getParentId($file);
+ $data['name'] = basename($file);
+ $data['encrypted'] = isset($data['encrypted']) ? ((int)$data['encrypted']) : 0;
+
+ list($queryParts, $params) = $this->buildParts($data);
+ $queryParts[] = '`storage`';
+ $params[] = $this->storageId;
+ $valuesPlaceholder = array_fill(0, count($queryParts), '?');
+
+ $query = \OC_DB::prepare('INSERT INTO `*PREFIX*filecache`(' . implode(', ', $queryParts) . ') VALUES(' . implode(', ', $valuesPlaceholder) . ')');
+ $query->execute($params);
+
+ return (int)\OC_DB::insertid('*PREFIX*filecache');
+ }
+ }
+
+ /**
+ * update the metadata in the cache
+ *
+ * @param int $id
+ * @param array $data
+ */
+ public function update($id, array $data) {
+ list($queryParts, $params) = $this->buildParts($data);
+ $params[] = $id;
+
+ $query = \OC_DB::prepare('UPDATE `*PREFIX*filecache` SET ' . implode(' = ?, ', $queryParts) . '=? WHERE fileid = ?');
+ $query->execute($params);
+ }
+
+ /**
+ * extract query parts and params array from data array
+ *
+ * @param array $data
+ * @return array
+ */
+ static function buildParts(array $data) {
+ $fields = array('path', 'parent', 'name', 'mimetype', 'size', 'mtime', 'encrypted');
+
+ $params = array();
+ $queryParts = array();
+ foreach ($data as $name => $value) {
+ if (array_search($name, $fields) !== false) {
+ $params[] = $value;
+ $queryParts[] = '`' . $name . '`';
+ if ($name === 'path') {
+ $params[] = md5($value);
+ $queryParts[] = '`path_hash`';
+ } elseif ($name === 'mimetype') {
+ $params[] = substr($value, 0, strpos($value, '/'));
+ $queryParts[] = '`mimepart`';
+ }
+ }
+ }
+ return array($queryParts, $params);
+ }
+
+ /**
+ * get the file id for a file
+ *
+ * @param string $file
+ * @return int
+ */
+ public function getId($file) {
+ $pathHash = md5($file);
+
+ $query = \OC_DB::prepare('SELECT `fileid` FROM `*PREFIX*filecache` WHERE `storage` = ? AND `path_hash` = ?');
+ $result = $query->execute(array($this->storageId, $pathHash));
+
+ if ($row = $result->fetchRow()) {
+ return $row['fileid'];
+ } else {
+ return -1;
+ }
+ }
+
+ /**
+ * get the id of the parent folder of a file
+ *
+ * @param string $file
+ * @return int
+ */
+ public function getParentId($file) {
+ if ($file === '') {
+ return -1;
+ } else {
+ $parent = dirname($file);
+ if ($parent === '.') {
+ $parent = '';
+ }
+ return $this->getId($parent);
+ }
+ }
+
+ /**
+ * check if a file is available in the cache
+ *
+ * @param string $file
+ * @return bool
+ */
+ public function inCache($file) {
+ return $this->getId($file) != -1;
+ }
+
+ /**
+ * remove a file or folder from the cache
+ *
+ * @param string $file
+ */
+ public function remove($file) {
+ $pathHash = md5($file);
+ $query = \OC_DB::prepare('DELETE FROM `*PREFIX*filecache` WHERE `storage` = ? AND `path_hash` = ?');
+ $query->execute(array($this->storageId, $pathHash));
+ }
+
+ /**
+ * remove all entries for files that are stored on the storage from the cache
+ */
+ public function clear() {
+ $query = \OC_DB::prepare('DELETE FROM `*PREFIX*filecache` WHERE storage=?');
+ $query->execute(array($this->storageId));
+ }
+
+ /**
+ * @param string $file
+ *
+ * @return int, Cache::NOT_FOUND, Cache::PARTIAL, Cache::SHALLOW or Cache::COMPLETE
+ */
+ public function getStatus($file) {
+ $pathHash = md5($file);
+ $query = \OC_DB::prepare('SELECT `size` FROM `*PREFIX*filecache` WHERE `storage` = ? AND `path_hash` = ?');
+ $result = $query->execute(array($this->storageId, $pathHash));
+ if ($row = $result->fetchRow()) {
+ if ((int)$row['size'] === -1) {
+ return self::SHALLOW;
+ } else {
+ return self::COMPLETE;
+ }
+ } else {
+ if (isset($this->partial[$file])) {
+ return self::PARTIAL;
+ } else {
+ return self::NOT_FOUND;
+ }
+ }
+ }
+
+ /**
+ * search for files matching $pattern
+ *
+ * @param string $pattern
+ * @return array of file data
+ */
+ public function search($pattern) {
+ $query = \OC_DB::prepare('
+ SELECT `fileid`, `storage`, `path`, `parent`, `name`, `mimetype`, `mimepart`, `size`, `mtime`, `encrypted`
+ FROM `*PREFIX*filecache` WHERE `name` LIKE ? AND `storage` = ?'
+ );
+ $result = $query->execute(array($pattern, $this->storageId));
+ $files = array();
+ while ($row = $result->fetchRow()) {
+ $files[] = $row;
+ }
+ return $files;
+ }
+
+ /**
+ * get all file ids on the files on the storage
+ *
+ * @return int[]
+ */
+ public function getAll() {
+ $query = \OC_DB::prepare('SELECT `fileid` FROM `*PREFIX*filecache` WHERE `storage` = ?');
+ $result = $query->execute(array($this->storageId));
+ $ids = array();
+ while ($row = $result->fetchRow()) {
+ $ids[] = $row['fileid'];
+ }
+ return $ids;
+ }
+}
diff --git a/lib/files/cache/permissions.php b/lib/files/cache/permissions.php
new file mode 100644
index 00000000000..e3fa63c464a
--- /dev/null
+++ b/lib/files/cache/permissions.php
@@ -0,0 +1,85 @@
+<?php
+/**
+ * Copyright (c) 2012 Robin Appelman <icewind@owncloud.com>
+ * This file is licensed under the Affero General Public License version 3 or
+ * later.
+ * See the COPYING-README file.
+ */
+
+namespace OC\Files\Cache;
+
+class Permissions {
+ /**
+ * get the permissions for a single file
+ *
+ * @param int $fileId
+ * @param string $user
+ * @return int (-1 if file no permissions set)
+ */
+ static public function get($fileId, $user) {
+ $query = \OC_DB::prepare('SELECT `permissions` FROM `*PREFIX*permissions` WHERE `user` = ? AND `fileid` = ?');
+ $result = $query->execute(array($user, $fileId));
+ if ($row = $result->fetchRow()) {
+ return $row['permissions'];
+ } else {
+ return -1;
+ }
+ }
+
+ /**
+ * set the permissions of a file
+ *
+ * @param int $fileId
+ * @param string $user
+ * @param int $permissions
+ */
+ static public function set($fileId, $user, $permissions) {
+ if (self::get($fileId, $user) !== -1) {
+ $query = \OC_DB::prepare('UPDATE `*PREFIX*permissions` SET `permissions` = ? WHERE `user` = ? AND `fileid` = ?');
+ } else {
+ $query = \OC_DB::prepare('INSERT INTO `*PREFIX*permissions`(`permissions`, `user`, `fileid`) VALUES(?, ?,? )');
+ }
+ $query->execute(array($permissions, $user, $fileId));
+ }
+
+ /**
+ * get the permissions of multiply files
+ *
+ * @param int[] $fileIds
+ * @param string $user
+ * @return int[]
+ */
+ static public function getMultiple($fileIds, $user) {
+ $params = $fileIds;
+ $params[] = $user;
+ $inPart = implode(', ', array_fill(0, count($fileIds), '?'));
+
+ $query = \OC_DB::prepare('SELECT `fileid`, `permissions` FROM `*PREFIX*permissions` WHERE `fileid` IN (' . $inPart . ') AND `user` = ?');
+ $result = $query->execute($params);
+ $filePermissions = array();
+ while ($row = $result->fetchRow()) {
+ $filePermissions[$row['fileid']] = $row['permissions'];
+ }
+ return $filePermissions;
+ }
+
+ /**
+ * remove the permissions for a file
+ *
+ * @param int $fileId
+ * @param string $user
+ */
+ static public function remove($fileId, $user) {
+ $query = \OC_DB::prepare('DELETE FROM `*PREFIX*permissions` WHERE `fileid` = ? AND `user` = ?');
+ $query->execute(array($fileId, $user));
+ }
+
+ static public function removeMultiple($fileIds, $user) {
+ $params = $fileIds;
+ $params[] = $user;
+ $inPart = implode(', ', array_fill(0, count($fileIds), '?'));
+
+ $query = \OC_DB::prepare('DELETE FROM `*PREFIX*permissions` WHERE `fileid` IN (' . $inPart . ') AND `user` = ?');
+ $query->execute($params);
+ }
+}
diff --git a/lib/files/cache/scanner.php b/lib/files/cache/scanner.php
new file mode 100644
index 00000000000..0adde1d354d
--- /dev/null
+++ b/lib/files/cache/scanner.php
@@ -0,0 +1,110 @@
+<?php
+/**
+ * Copyright (c) 2012 Robin Appelman <icewind@owncloud.com>
+ * This file is licensed under the Affero General Public License version 3 or
+ * later.
+ * See the COPYING-README file.
+ */
+
+namespace OC\Files\Cache;
+
+class Scanner {
+ /**
+ * @var \OC\Files\Storage\Storage $storage
+ */
+ private $storage;
+
+ /**
+ * @var \OC\Files\Cache\Cache $cache
+ */
+ private $cache;
+
+ const SCAN_RECURSIVE = true;
+ const SCAN_SHALLOW = false;
+
+ public function __construct(\OC\Files\Storage\Storage $storage) {
+ $this->storage = $storage;
+ $this->cache = new Cache($storage);
+ }
+
+ /**
+ * get all the metadata of a file or folder
+ * *
+ *
+ * @param string $path
+ * @return array with metadata of the file
+ */
+ public function getData($path) {
+ $data = array();
+ if (!$this->storage->isReadable($path)) return null; //cant read, nothing we can do
+ $data['mimetype'] = $this->storage->getMimeType($path);
+ $data['mtime'] = $this->storage->filemtime($path);
+ if ($data['mimetype'] == 'httpd/unix-directory') {
+ $data['size'] = -1; //unknown
+ $data['permissions'] = $this->storage->getPermissions($path . '/');
+ } else {
+ $data['size'] = $this->storage->filesize($path);
+ $data['permissions'] = $this->storage->getPermissions($path);
+ }
+ return $data;
+ }
+
+ /**
+ * scan a single file and store it in the cache
+ *
+ * @param string $file
+ * @return array with metadata of the scanned file
+ */
+ public function scanFile($file) {
+ $data = $this->getData($file);
+ if ($file !== '') {
+ $parent = dirname($file);
+ if ($parent === '.') {
+ $parent = '';
+ }
+ if (!$this->cache->inCache($parent)) {
+ $this->scanFile($parent);
+ }
+ }
+ $id = $this->cache->put($file, $data);
+ Permissions::set($id, \OC_User::getUser(), $data['permissions']);
+ return $data;
+ }
+
+ /**
+ * scan all the files in a folder and store them in the cache
+ *
+ * @param string $path
+ * @param SCAN_RECURSIVE/SCAN_SHALLOW $recursive
+ * @return int the size of the scanned folder or -1 if the size is unknown at this stage
+ */
+ public function scan($path, $recursive = self::SCAN_RECURSIVE) {
+ $this->scanFile($path);
+
+ $size = 0;
+ if ($dh = $this->storage->opendir($path)) {
+ while ($file = readdir($dh)) {
+ if ($file !== '.' and $file !== '..') {
+ $child = ($path !== '') ? $path . '/' . $file : $file;
+ $data = $this->scanFile($child);
+ if ($data['mimetype'] === 'httpd/unix-directory') {
+ if ($recursive === self::SCAN_RECURSIVE) {
+ $data['size'] = $this->scan($child, self::SCAN_RECURSIVE);
+ } else {
+ $data['size'] = -1;
+ }
+ }
+ if ($data['size'] === -1) {
+ $size = -1;
+ } elseif ($size !== -1) {
+ $size += $data['size'];
+ }
+ }
+ }
+ }
+ if ($size !== -1) {
+ $this->cache->put($path, array('size' => $size));
+ }
+ return $size;
+ }
+}
diff --git a/lib/files/file.php b/lib/files/file.php
new file mode 100644
index 00000000000..0d33cea7ee7
--- /dev/null
+++ b/lib/files/file.php
@@ -0,0 +1,61 @@
+<?php
+/**
+ * Copyright (c) 2012 Robin Appelman <icewind@owncloud.com>
+ * This file is licensed under the Affero General Public License version 3 or
+ * later.
+ * See the COPYING-README file.
+ */
+
+namespace OC\Files;
+
+/**
+ * representation of the location a file or folder is stored
+ */
+
+class File{
+ /**
+ * @var Storage\Storage $storage
+ */
+ private $storage;
+ /**
+ * @var string internalPath
+ */
+ private $internalPath;
+
+ public function __construct(Storage\Storage $storage, $internalPath){
+ $this->storage = $storage;
+ $this->internalPath = $internalPath;
+ }
+
+ public static function resolve($fullPath){
+ $storage = null;
+ $internalPath = '';
+ list($storage, $internalPath) = \OC\Files\Filesystem::resolvePath($fullPath);
+ return new File($storage, $internalPath);
+ }
+
+ /**
+ * get the internal path of the file inside the filestorage
+ * @return string
+ */
+ public function getInternalPath(){
+ return $this->internalPath;
+ }
+
+ /**
+ * get the storage the file is stored in
+ * @return \OC\Files\Storage\Storage
+ */
+ public function getStorage(){
+ return $this->storage;
+ }
+
+ /**
+ * get the id of the storage the file is stored in
+ * @return string
+ */
+ public function getStorageId(){
+ return $this->storage->getId();
+ }
+
+}
diff --git a/lib/files/filesystem.php b/lib/files/filesystem.php
new file mode 100644
index 00000000000..b3c92f38558
--- /dev/null
+++ b/lib/files/filesystem.php
@@ -0,0 +1,658 @@
+<?php
+/**
+ * Copyright (c) 2012 Robin Appelman <icewind@owncloud.com>
+ * This file is licensed under the Affero General Public License version 3 or
+ * later.
+ * See the COPYING-README file.
+ */
+
+/**
+ * Class for abstraction of filesystem functions
+ * This class won't call any filesystem functions for itself but but will pass them to the correct OC_Filestorage object
+ * this class should also handle all the file permission related stuff
+ *
+ * Hooks provided:
+ * read(path)
+ * write(path, &run)
+ * post_write(path)
+ * create(path, &run) (when a file is created, both create and write will be emitted in that order)
+ * post_create(path)
+ * delete(path, &run)
+ * post_delete(path)
+ * rename(oldpath,newpath, &run)
+ * post_rename(oldpath,newpath)
+ * copy(oldpath,newpath, &run) (if the newpath doesn't exists yes, copy, create and write will be emitted in that order)
+ * post_rename(oldpath,newpath)
+ *
+ * the &run parameter can be set to false to prevent the operation from occurring
+ */
+
+namespace OC\Files;
+
+class Filesystem {
+ static private $storages = array();
+ static private $mounts = array();
+ public static $loaded = false;
+ /**
+ * @var \OC\Files\View $defaultInstance
+ */
+ static private $defaultInstance;
+
+
+ /**
+ * classname which used for hooks handling
+ * used as signalclass in OC_Hooks::emit()
+ */
+ const CLASSNAME = 'OC_Filesystem';
+
+ /**
+ * signalname emitted before file renaming
+ *
+ * @param string $oldpath
+ * @param string $newpath
+ */
+ const signal_rename = 'rename';
+
+ /**
+ * signal emitted after file renaming
+ *
+ * @param string $oldpath
+ * @param string $newpath
+ */
+ const signal_post_rename = 'post_rename';
+
+ /**
+ * signal emitted before file/dir creation
+ *
+ * @param string $path
+ * @param bool $run changing this flag to false in hook handler will cancel event
+ */
+ const signal_create = 'create';
+
+ /**
+ * signal emitted after file/dir creation
+ *
+ * @param string $path
+ * @param bool $run changing this flag to false in hook handler will cancel event
+ */
+ const signal_post_create = 'post_create';
+
+ /**
+ * signal emits before file/dir copy
+ *
+ * @param string $oldpath
+ * @param string $newpath
+ * @param bool $run changing this flag to false in hook handler will cancel event
+ */
+ const signal_copy = 'copy';
+
+ /**
+ * signal emits after file/dir copy
+ *
+ * @param string $oldpath
+ * @param string $newpath
+ */
+ const signal_post_copy = 'post_copy';
+
+ /**
+ * signal emits before file/dir save
+ *
+ * @param string $path
+ * @param bool $run changing this flag to false in hook handler will cancel event
+ */
+ const signal_write = 'write';
+
+ /**
+ * signal emits after file/dir save
+ *
+ * @param string $path
+ */
+ const signal_post_write = 'post_write';
+
+ /**
+ * signal emits when reading file/dir
+ *
+ * @param string $path
+ */
+ const signal_read = 'read';
+
+ /**
+ * signal emits when removing file/dir
+ *
+ * @param string $path
+ */
+ const signal_delete = 'delete';
+
+ /**
+ * parameters definitions for signals
+ */
+ const signal_param_path = 'path';
+ const signal_param_oldpath = 'oldpath';
+ const signal_param_newpath = 'newpath';
+
+ /**
+ * run - changing this flag to false in hook handler will cancel event
+ */
+ const signal_param_run = 'run';
+
+ /**
+ * get the mountpoint of the storage object for a path
+ ( note: because a storage is not always mounted inside the fakeroot, the returned mountpoint is relative to the absolute root of the filesystem and doesn't take the chroot into account
+ *
+ * @param string $path
+ * @return string
+ */
+ static public function getMountPoint($path) {
+ \OC_Hook::emit(self::CLASSNAME, 'get_mountpoint', array('path' => $path));
+ if (!$path) {
+ $path = '/';
+ }
+ if ($path[0] !== '/') {
+ $path = '/' . $path;
+ }
+ $path = str_replace('//', '/', $path);
+ $foundMountPoint = '';
+ $mountPoints = array_keys(self::$mounts);
+ foreach ($mountPoints as $mountpoint) {
+ if ($mountpoint == $path) {
+ return $mountpoint;
+ }
+ if (strpos($path, $mountpoint) === 0 and strlen($mountpoint) > strlen($foundMountPoint)) {
+ $foundMountPoint = $mountpoint;
+ }
+ }
+ return $foundMountPoint;
+ }
+
+ /**
+ * get a list of all mount points in a directory
+ *
+ * @param string $path
+ * @return string[]
+ */
+ static public function getMountPoints($path) {
+ $path = self::normalizePath($path);
+ if (strlen($path) > 1) {
+ $path .= '/';
+ }
+ $pathLength = strlen($path);
+
+ $mountPoints = array_keys(self::$mounts);
+ $result = array();
+ foreach ($mountPoints as $mountPoint) {
+ if (substr($mountPoint, 0, $pathLength) === $path and strlen($mountPoint) > $pathLength) {
+ $result[] = $mountPoint;
+ }
+ }
+ return $result;
+ }
+
+ /**
+ * get the storage mounted at $mountPoint
+ *
+ * @param string $mountPoint
+ * @return \OC\Files\Storage\Storage
+ */
+ public static function getStorage($mountPoint) {
+ if (!isset(self::$storages[$mountPoint])) {
+ $mount = self::$mounts[$mountPoint];
+ self::$storages[$mountPoint] = self::createStorage($mount['class'], $mount['arguments']);
+ }
+ return self::$storages[$mountPoint];
+ }
+
+ /**
+ * resolve a path to a storage and internal path
+ *
+ * @param string $path
+ * @return array consisting of the storage and the internal path
+ */
+ static public function resolvePath($path) {
+ $mountpoint = self::getMountPoint($path);
+ if ($mountpoint) {
+ $storage = self::getStorage($mountpoint);
+ if ($mountpoint === $path) {
+ $internalPath = '';
+ } else {
+ $internalPath = substr($path, strlen($mountpoint));
+ }
+ return array($storage, $internalPath);
+ } else {
+ return array(null, null);
+ }
+ }
+
+ static public function init($root) {
+ if (self::$defaultInstance) {
+ return false;
+ }
+ self::$defaultInstance = new View($root);
+
+ //load custom mount config
+ if (is_file(\OC::$SERVERROOT . '/config/mount.php')) {
+ $mountConfig = include 'config/mount.php';
+ if (isset($mountConfig['global'])) {
+ foreach ($mountConfig['global'] as $mountPoint => $options) {
+ self::mount($options['class'], $options['options'], $mountPoint);
+ }
+ }
+
+ if (isset($mountConfig['group'])) {
+ foreach ($mountConfig['group'] as $group => $mounts) {
+ if (\OC_Group::inGroup(\OC_User::getUser(), $group)) {
+ foreach ($mounts as $mountPoint => $options) {
+ $mountPoint = self::setUserVars($mountPoint);
+ foreach ($options as &$option) {
+ $option = self::setUserVars($option);
+ }
+ self::mount($options['class'], $options['options'], $mountPoint);
+ }
+ }
+ }
+ }
+
+ if (isset($mountConfig['user'])) {
+ foreach ($mountConfig['user'] as $user => $mounts) {
+ if ($user === 'all' or strtolower($user) === strtolower(\OC_User::getUser())) {
+ foreach ($mounts as $mountPoint => $options) {
+ $mountPoint = self::setUserVars($mountPoint);
+ foreach ($options as &$option) {
+ $option = self::setUserVars($option);
+ }
+ self::mount($options['class'], $options['options'], $mountPoint);
+ }
+ }
+ }
+ }
+ }
+
+ self::$loaded = true;
+
+ return true;
+ }
+
+ /**
+ * fill in the correct values for $user, and $password placeholders
+ *
+ * @param string $input
+ * @return string
+ */
+ private static function setUserVars($input) {
+ return str_replace('$user', \OC_User::getUser(), $input);
+ }
+
+ /**
+ * get the default filesystem view
+ *
+ * @return View
+ */
+ static public function getView() {
+ return self::$defaultInstance;
+ }
+
+ /**
+ * tear down the filesystem, removing all storage providers
+ */
+ static public function tearDown() {
+ self::$storages = array();
+ }
+
+ /**
+ * create a new storage of a specific type
+ *
+ * @param string $type
+ * @param array $arguments
+ * @return \OC\Files\Storage\Storage
+ */
+ static private function createStorage($class, $arguments) {
+ if (class_exists($class)) {
+ try {
+ return new $class($arguments);
+ } catch (\Exception $exception) {
+ \OC_Log::write('core', $exception->getMessage(), \OC_Log::ERROR);
+ return false;
+ }
+ } else {
+ \OC_Log::write('core', 'storage backend ' . $class . ' not found', \OC_Log::ERROR);
+ return false;
+ }
+ }
+
+ /**
+ * @brief get the relative path of the root data directory for the current user
+ * @return string
+ *
+ * Returns path like /admin/files
+ */
+ static public function getRoot() {
+ return self::$defaultInstance->getRoot();
+ }
+
+ /**
+ * clear all mounts and storage backends
+ */
+ public static function clearMounts() {
+ self::$mounts = array();
+ self::$storages = array();
+ }
+
+ /**
+ * mount an \OC\Files\Storage\Storage in our virtual filesystem
+ *
+ * @param \OC\Files\Storage\Storage|string $class
+ * @param array $arguments
+ * @param string $mountpoint
+ */
+ static public function mount($class, $arguments, $mountpoint) {
+ $mountpoint = self::normalizePath($mountpoint);
+ if (strlen($mountpoint) > 1) {
+ $mountpoint .= '/';
+ }
+
+ if ($class instanceof \OC\Files\Storage\Storage) {
+ self::$mounts[$mountpoint] = array('class' => get_class($class), 'arguments' => $arguments);
+ self::$storages[$mountpoint] = $class;
+ } else {
+ self::$mounts[$mountpoint] = array('class' => $class, 'arguments' => $arguments);
+ }
+ }
+
+ /**
+ * return the path to a local version of the file
+ * we need this because we can't know if a file is stored local or not from outside the filestorage and for some purposes a local file is needed
+ *
+ * @param string $path
+ * @return string
+ */
+ static public function getLocalFile($path) {
+ return self::$defaultInstance->getLocalFile($path);
+ }
+
+ /**
+ * @param string $path
+ * @return string
+ */
+ static public function getLocalFolder($path) {
+ return self::$defaultInstance->getLocalFolder($path);
+ }
+
+ /**
+ * return path to file which reflects one visible in browser
+ *
+ * @param string $path
+ * @return string
+ */
+ static public function getLocalPath($path) {
+ $datadir = \OC_User::getHome(\OC_User::getUser()) . '/files';
+ $newpath = $path;
+ if (strncmp($newpath, $datadir, strlen($datadir)) == 0) {
+ $newpath = substr($path, strlen($datadir));
+ }
+ return $newpath;
+ }
+
+ /**
+ * check if the requested path is valid
+ *
+ * @param string $path
+ * @return bool
+ */
+ static public function isValidPath($path) {
+ if (!$path || $path[0] !== '/') {
+ $path = '/' . $path;
+ }
+ if (strstr($path, '/../') || strrchr($path, '/') === '/..') {
+ return false;
+ }
+ return true;
+ }
+
+ /**
+ * checks if a file is blacklisted for storage in the filesystem
+ * Listens to write and rename hooks
+ *
+ * @param array $data from hook
+ */
+ static public function isBlacklisted($data) {
+ $blacklist = array('.htaccess');
+ if (isset($data['path'])) {
+ $path = $data['path'];
+ } else if (isset($data['newpath'])) {
+ $path = $data['newpath'];
+ }
+ if (isset($path)) {
+ $filename = strtolower(basename($path));
+ if (in_array($filename, $blacklist)) {
+ $data['run'] = false;
+ }
+ }
+ }
+
+ /**
+ * following functions are equivalent to their php builtin equivalents for arguments/return values.
+ */
+ static public function mkdir($path) {
+ return self::$defaultInstance->mkdir($path);
+ }
+
+ static public function rmdir($path) {
+ return self::$defaultInstance->rmdir($path);
+ }
+
+ static public function opendir($path) {
+ return self::$defaultInstance->opendir($path);
+ }
+
+ static public function readdir($path) {
+ return self::$defaultInstance->readdir($path);
+ }
+
+ static public function is_dir($path) {
+ return self::$defaultInstance->is_dir($path);
+ }
+
+ static public function is_file($path) {
+ return self::$defaultInstance->is_file($path);
+ }
+
+ static public function stat($path) {
+ return self::$defaultInstance->stat($path);
+ }
+
+ static public function filetype($path) {
+ return self::$defaultInstance->filetype($path);
+ }
+
+ static public function filesize($path) {
+ return self::$defaultInstance->filesize($path);
+ }
+
+ static public function readfile($path) {
+ return self::$defaultInstance->readfile($path);
+ }
+
+ static public function isCreatable($path) {
+ return self::$defaultInstance->isCreatable($path);
+ }
+
+ static public function isReadable($path) {
+ return self::$defaultInstance->isReadable($path);
+ }
+
+ static public function isUpdatable($path) {
+ return self::$defaultInstance->isUpdatable($path);
+ }
+
+ static public function isDeletable($path) {
+ return self::$defaultInstance->isDeletable($path);
+ }
+
+ static public function isSharable($path) {
+ return self::$defaultInstance->isSharable($path);
+ }
+
+ static public function file_exists($path) {
+ return self::$defaultInstance->file_exists($path);
+ }
+
+ static public function filemtime($path) {
+ return self::$defaultInstance->filemtime($path);
+ }
+
+ static public function touch($path, $mtime = null) {
+ return self::$defaultInstance->touch($path, $mtime);
+ }
+
+ static public function file_get_contents($path) {
+ return self::$defaultInstance->file_get_contents($path);
+ }
+
+ static public function file_put_contents($path, $data) {
+ return self::$defaultInstance->file_put_contents($path, $data);
+ }
+
+ static public function unlink($path) {
+ return self::$defaultInstance->unlink($path);
+ }
+
+ static public function rename($path1, $path2) {
+ return self::$defaultInstance->rename($path1, $path2);
+ }
+
+ static public function copy($path1, $path2) {
+ return self::$defaultInstance->copy($path1, $path2);
+ }
+
+ static public function fopen($path, $mode) {
+ return self::$defaultInstance->fopen($path, $mode);
+ }
+
+ static public function toTmpFile($path) {
+ return self::$defaultInstance->toTmpFile($path);
+ }
+
+ static public function fromTmpFile($tmpFile, $path) {
+ return self::$defaultInstance->fromTmpFile($tmpFile, $path);
+ }
+
+ static public function getMimeType($path) {
+ return self::$defaultInstance->getMimeType($path);
+ }
+
+ static public function hash($type, $path, $raw = false) {
+ return self::$defaultInstance->hash($type, $path, $raw);
+ }
+
+ static public function free_space($path = '/') {
+ return self::$defaultInstance->free_space($path);
+ }
+
+ static public function search($query) {
+ return self::$defaultInstance->search($query);
+ }
+
+ /**
+ * check if a file or folder has been updated since $time
+ *
+ * @param int $time
+ * @return bool
+ */
+ static public function hasUpdated($path, $time) {
+ return self::$defaultInstance->hasUpdated($path, $time);
+ }
+
+ static public function removeETagHook($params, $root = false) {
+ if (isset($params['path'])) {
+ $path = $params['path'];
+ } else {
+ $path = $params['oldpath'];
+ }
+
+ if ($root) { // reduce path to the required part of it (no 'username/files')
+ $fakeRootView = new View($root);
+ $count = 1;
+ $path = str_replace(\OC_App::getStorage("files")->getAbsolutePath(''), "", $fakeRootView->getAbsolutePath($path), $count);
+ }
+
+ $path = self::normalizePath($path);
+ \OC_Connector_Sabre_Node::removeETagPropertyForPath($path);
+ }
+
+ /**
+ * normalize a path
+ *
+ * @param string $path
+ * @param bool $stripTrailingSlash
+ * @return string
+ */
+ public static function normalizePath($path, $stripTrailingSlash = true) {
+ if ($path == '') {
+ return '/';
+ }
+//no windows style slashes
+ $path = str_replace('\\', '/', $path);
+//add leading slash
+ if ($path[0] !== '/') {
+ $path = '/' . $path;
+ }
+//remove duplicate slashes
+ while (strpos($path, '//') !== false) {
+ $path = str_replace('//', '/', $path);
+ }
+//remove trailing slash
+ if ($stripTrailingSlash and strlen($path) > 1 and substr($path, -1, 1) === '/') {
+ $path = substr($path, 0, -1);
+ }
+//normalize unicode if possible
+ if (class_exists('Normalizer')) {
+ $path = \Normalizer::normalize($path);
+ }
+ return $path;
+ }
+
+ /**
+ * get the filesystem info
+ *
+ * @param string $path
+ * @return array
+ *
+ * returns an associative array with the following keys:
+ * - size
+ * - mtime
+ * - mimetype
+ * - encrypted
+ * - versioned
+ */
+ public static function getFileInfo($path) {
+ return self::$defaultInstance->getFileInfo($path);
+ }
+
+ /**
+ * change file metadata
+ *
+ * @param string $path
+ * @param array $data
+ * @return int
+ *
+ * returns the fileid of the updated file
+ */
+ public static function putFileInfo($path, $data) {
+ return self::$defaultInstance->putFileInfo($path, $data);
+ }
+
+ /**
+ * get the content of a directory
+ *
+ * @param string $directory path under datadirectory
+ * @return array
+ */
+ public static function getDirectoryContent($directory, $mimetype_filter = '') {
+ return self::$defaultInstance->getDirectoryContent($directory, $mimetype_filter);
+ }
+}
+
+\OC_Hook::connect('OC_Filesystem', 'post_write', 'OC_Filesystem', 'removeETagHook');
+\OC_Hook::connect('OC_Filesystem', 'post_delete', 'OC_Filesystem', 'removeETagHook');
+\OC_Hook::connect('OC_Filesystem', 'post_rename', 'OC_Filesystem', 'removeETagHook');
+
+\OC_Util::setupFS();
diff --git a/lib/files/storage/common.php b/lib/files/storage/common.php
new file mode 100644
index 00000000000..e22264d0da9
--- /dev/null
+++ b/lib/files/storage/common.php
@@ -0,0 +1,270 @@
+<?php
+/**
+ * Copyright (c) 2012 Robin Appelman <icewind@owncloud.com>
+ * This file is licensed under the Affero General Public License version 3 or
+ * later.
+ * See the COPYING-README file.
+ */
+
+namespace OC\Files\Storage;
+
+/**
+ * Storage backend class for providing common filesystem operation methods
+ * which are not storage-backend specific.
+ *
+ * \OC\Files\Storage\Common is never used directly; it is extended by all other
+ * storage backends, where its methods may be overridden, and additional
+ * (backend-specific) methods are defined.
+ *
+ * Some \OC\Files\Storage\Common methods call functions which are first defined
+ * in classes which extend it, e.g. $this->stat() .
+ */
+
+abstract class Common implements \OC\Files\Storage\Storage {
+
+ public function __construct($parameters) {}
+ abstract public function getId();
+ abstract public function mkdir($path);
+ abstract public function rmdir($path);
+ abstract public function opendir($path);
+ public function is_dir($path) {
+ return $this->filetype($path)=='dir';
+ }
+ public function is_file($path) {
+ return $this->filetype($path)=='file';
+ }
+ abstract public function stat($path);
+ abstract public function filetype($path);
+ public function filesize($path) {
+ if($this->is_dir($path)) {
+ return 0;//by definition
+ }else{
+ $stat = $this->stat($path);
+ return $stat['size'];
+ }
+ }
+ public function isCreatable($path) {
+ return $this->isUpdatable($path);
+ }
+ abstract public function isReadable($path);
+ abstract public function isUpdatable($path);
+ public function isDeletable($path) {
+ return $this->isUpdatable($path);
+ }
+ public function isSharable($path) {
+ return $this->isReadable($path);
+ }
+ public function getPermissions($path){
+ $permissions = 0;
+ if($this->isCreatable($path)){
+ $permissions |= \OCP\Share::PERMISSION_CREATE;
+ }
+ if($this->isReadable($path)){
+ $permissions |= \OCP\Share::PERMISSION_READ;
+ }
+ if($this->isUpdatable($path)){
+ $permissions |= \OCP\Share::PERMISSION_UPDATE;
+ }
+ if($this->isDeletable($path)){
+ $permissions |= \OCP\Share::PERMISSION_DELETE;
+ }
+ if($this->isSharable($path)){
+ $permissions |= \OCP\Share::PERMISSION_SHARE;
+ }
+ return $permissions;
+ }
+ abstract public function file_exists($path);
+ public function filemtime($path) {
+ $stat = $this->stat($path);
+ return $stat['mtime'];
+ }
+ public function fileatime($path) {
+ $stat = $this->stat($path);
+ return $stat['atime'];
+ }
+ public function file_get_contents($path) {
+ $handle = $this->fopen($path, "r");
+ if(!$handle) {
+ return false;
+ }
+ $size=$this->filesize($path);
+ if($size==0) {
+ return '';
+ }
+ return fread($handle, $size);
+ }
+ public function file_put_contents($path,$data) {
+ $handle = $this->fopen($path, "w");
+ return fwrite($handle, $data);
+ }
+ abstract public function unlink($path);
+ public function rename($path1,$path2) {
+ if($this->copy($path1,$path2)) {
+ return $this->unlink($path1);
+ }else{
+ return false;
+ }
+ }
+ public function copy($path1,$path2) {
+ $source=$this->fopen($path1,'r');
+ $target=$this->fopen($path2,'w');
+ $count=\OC_Helper::streamCopy($source,$target);
+ return $count>0;
+ }
+ abstract public function fopen($path,$mode);
+
+ /**
+ * @brief Deletes all files and folders recursively within a directory
+ * @param string $directory The directory whose contents will be deleted
+ * @param bool $empty Flag indicating whether directory will be emptied
+ * @returns bool
+ *
+ * @note By default the directory specified by $directory will be
+ * deleted together with its contents. To avoid this set $empty to true
+ */
+ public function deleteAll( $directory, $empty = false ) {
+ $directory = trim($directory,'/');
+
+ if ( !$this->file_exists( \OCP\USER::getUser() . '/' . $directory ) || !$this->is_dir( \OCP\USER::getUser() . '/' . $directory ) ) {
+ return false;
+ } elseif( !$this->isReadable( \OCP\USER::getUser() . '/' . $directory ) ) {
+ return false;
+ } else {
+ $directoryHandle = $this->opendir( \OCP\USER::getUser() . '/' . $directory );
+ while ( $contents = readdir( $directoryHandle ) ) {
+ if ( $contents != '.' && $contents != '..') {
+ $path = $directory . "/" . $contents;
+ if ( $this->is_dir( $path ) ) {
+ $this->deleteAll( $path );
+ } else {
+ $this->unlink( \OCP\USER::getUser() .'/' . $path ); // TODO: make unlink use same system path as is_dir
+ }
+ }
+ }
+ //$this->closedir( $directoryHandle ); // TODO: implement closedir in OC_FSV
+ if ( $empty == false ) {
+ if ( !$this->rmdir( $directory ) ) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ }
+ public function getMimeType($path) {
+ if(!$this->file_exists($path)) {
+ return false;
+ }
+ if($this->is_dir($path)) {
+ return 'httpd/unix-directory';
+ }
+ $source=$this->fopen($path,'r');
+ if(!$source) {
+ return false;
+ }
+ $head=fread($source,8192);//8kb should suffice to determine a mimetype
+ if($pos=strrpos($path,'.')) {
+ $extension=substr($path,$pos);
+ }else{
+ $extension='';
+ }
+ $tmpFile=\OC_Helper::tmpFile($extension);
+ file_put_contents($tmpFile,$head);
+ $mime=\OC_Helper::getMimeType($tmpFile);
+ unlink($tmpFile);
+ return $mime;
+ }
+ public function hash($type,$path,$raw = false) {
+ $tmpFile=$this->getLocalFile($path);
+ $hash=hash($type,$tmpFile,$raw);
+ unlink($tmpFile);
+ return $hash;
+ }
+ abstract public function free_space($path);
+ public function search($query) {
+ return $this->searchInDir($query);
+ }
+ public function getLocalFile($path) {
+ return $this->toTmpFile($path);
+ }
+ private function toTmpFile($path) {//no longer in the storage api, still useful here
+ $source=$this->fopen($path,'r');
+ if(!$source) {
+ return false;
+ }
+ if($pos=strrpos($path,'.')) {
+ $extension=substr($path,$pos);
+ }else{
+ $extension='';
+ }
+ $tmpFile=\OC_Helper::tmpFile($extension);
+ $target=fopen($tmpFile,'w');
+ \OC_Helper::streamCopy($source,$target);
+ return $tmpFile;
+ }
+ public function getLocalFolder($path) {
+ $baseDir=\OC_Helper::tmpFolder();
+ $this->addLocalFolder($path,$baseDir);
+ return $baseDir;
+ }
+ private function addLocalFolder($path,$target) {
+ if($dh=$this->opendir($path)) {
+ while($file=readdir($dh)) {
+ if($file!=='.' and $file!=='..') {
+ if($this->is_dir($path.'/'.$file)) {
+ mkdir($target.'/'.$file);
+ $this->addLocalFolder($path.'/'.$file,$target.'/'.$file);
+ }else{
+ $tmp=$this->toTmpFile($path.'/'.$file);
+ rename($tmp,$target.'/'.$file);
+ }
+ }
+ }
+ }
+ }
+ abstract public function touch($path, $mtime=null);
+
+ protected function searchInDir($query,$dir='') {
+ $files=array();
+ $dh=$this->opendir($dir);
+ if($dh) {
+ while($item=readdir($dh)) {
+ if ($item == '.' || $item == '..') continue;
+ if(strstr(strtolower($item), strtolower($query))!==false) {
+ $files[]=$dir.'/'.$item;
+ }
+ if($this->is_dir($dir.'/'.$item)) {
+ $files=array_merge($files,$this->searchInDir($query,$dir.'/'.$item));
+ }
+ }
+ }
+ return $files;
+ }
+
+ /**
+ * check if a file or folder has been updated since $time
+ * @param string $path
+ * @param int $time
+ * @return bool
+ */
+ public function hasUpdated($path,$time) {
+ return $this->filemtime($path)>$time;
+ }
+
+ public function getCache(){
+ return new \OC\Files\Cache\Cache($this);
+ }
+
+ public function getScanner(){
+ return new \OC\Files\Cache\Scanner($this);
+ }
+
+ /**
+ * get the owner of a path
+ * @param string $path The path to get the owner
+ * @return string uid or false
+ */
+ public function getOwner($path) {
+ return \OC_User::getUser();
+ }
+}
diff --git a/lib/files/storage/commontest.php b/lib/files/storage/commontest.php
new file mode 100644
index 00000000000..2b42cfe1156
--- /dev/null
+++ b/lib/files/storage/commontest.php
@@ -0,0 +1,80 @@
+<?php
+
+/**
+* ownCloud
+*
+* @author Robin Appelman
+* @copyright 2012 Robin Appelman icewind@owncloud.com
+*
+* This library is free software; you can redistribute it and/or
+* modify it under the terms of the GNU AFFERO GENERAL PUBLIC LICENSE
+* License as published by the Free Software Foundation; either
+* version 3 of the License, or any later version.
+*
+* This library 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 along with this library. If not, see <http://www.gnu.org/licenses/>.
+*
+*/
+
+/**
+ * test implementation for \OC\Files\Storage\Common with \OC\Files\Storage\Local
+ */
+
+namespace OC\Files\Storage;
+
+class CommonTest extends \OC\Files\Storage\Common{
+ /**
+ * underlying local storage used for missing functions
+ * @var \OC\Files\Storage\Local
+ */
+ private $storage;
+
+ public function __construct($params) {
+ $this->storage=new \OC\Files\Storage\Local($params);
+ }
+
+ public function getId(){
+ return 'test::'.$this->storage->getId();
+ }
+ public function mkdir($path) {
+ return $this->storage->mkdir($path);
+ }
+ public function rmdir($path) {
+ return $this->storage->rmdir($path);
+ }
+ public function opendir($path) {
+ return $this->storage->opendir($path);
+ }
+ public function stat($path) {
+ return $this->storage->stat($path);
+ }
+ public function filetype($path) {
+ return $this->storage->filetype($path);
+ }
+ public function isReadable($path) {
+ return $this->storage->isReadable($path);
+ }
+ public function isUpdatable($path) {
+ return $this->storage->isUpdatable($path);
+ }
+ public function file_exists($path) {
+ return $this->storage->file_exists($path);
+ }
+ public function unlink($path) {
+ return $this->storage->unlink($path);
+ }
+ public function fopen($path,$mode) {
+ return $this->storage->fopen($path,$mode);
+ }
+ public function free_space($path) {
+ return $this->storage->free_space($path);
+ }
+ public function touch($path, $mtime=null) {
+ return $this->storage->touch($path,$mtime);
+ }
+} \ No newline at end of file
diff --git a/lib/files/storage/local.php b/lib/files/storage/local.php
new file mode 100644
index 00000000000..71f3bedad39
--- /dev/null
+++ b/lib/files/storage/local.php
@@ -0,0 +1,208 @@
+<?php
+/**
+ * Copyright (c) 2012 Robin Appelman <icewind@owncloud.com>
+ * This file is licensed under the Affero General Public License version 3 or
+ * later.
+ * See the COPYING-README file.
+ */
+
+namespace OC\Files\Storage;
+
+/**
+ * for local filestore, we only have to map the paths
+ */
+class Local extends \OC\Files\Storage\Common{
+ protected $datadir;
+ public function __construct($arguments) {
+ $this->datadir=$arguments['datadir'];
+ if(substr($this->datadir,-1)!=='/') {
+ $this->datadir.='/';
+ }
+ }
+ public function getId(){
+ return 'local::'.$this->datadir;
+ }
+ public function mkdir($path) {
+ return @mkdir($this->datadir.$path);
+ }
+ public function rmdir($path) {
+ return @rmdir($this->datadir.$path);
+ }
+ public function opendir($path) {
+ return opendir($this->datadir.$path);
+ }
+ public function is_dir($path) {
+ if(substr($path,-1)=='/') {
+ $path=substr($path,0,-1);
+ }
+ return is_dir($this->datadir.$path);
+ }
+ public function is_file($path) {
+ return is_file($this->datadir.$path);
+ }
+ public function stat($path) {
+ return stat($this->datadir.$path);
+ }
+ public function filetype($path) {
+ $filetype=filetype($this->datadir.$path);
+ if($filetype=='link') {
+ $filetype=filetype(realpath($this->datadir.$path));
+ }
+ return $filetype;
+ }
+ public function filesize($path) {
+ if($this->is_dir($path)) {
+ return 0;
+ }else{
+ return filesize($this->datadir.$path);
+ }
+ }
+ public function isReadable($path) {
+ return is_readable($this->datadir.$path);
+ }
+ public function isUpdatable($path) {
+ return is_writable($this->datadir.$path);
+ }
+ public function file_exists($path) {
+ return file_exists($this->datadir.$path);
+ }
+ public function filemtime($path) {
+ return filemtime($this->datadir.$path);
+ }
+ public function touch($path, $mtime=null) {
+ // sets the modification time of the file to the given value.
+ // If mtime is nil the current time is set.
+ // note that the access time of the file always changes to the current time.
+ if(!is_null($mtime)) {
+ $result=touch( $this->datadir.$path, $mtime );
+ }else{
+ $result=touch( $this->datadir.$path);
+ }
+ if( $result ) {
+ clearstatcache( true, $this->datadir.$path );
+ }
+
+ return $result;
+ }
+ public function file_get_contents($path) {
+ return file_get_contents($this->datadir.$path);
+ }
+ public function file_put_contents($path,$data) {
+ return file_put_contents($this->datadir.$path,$data);
+ }
+ public function unlink($path) {
+ return $this->delTree($path);
+ }
+ public function rename($path1,$path2) {
+ if (!$this->isUpdatable($path1)) {
+ \OC_Log::write('core','unable to rename, file is not writable : '.$path1,\OC_Log::ERROR);
+ return false;
+ }
+ if(! $this->file_exists($path1)) {
+ \OC_Log::write('core','unable to rename, file does not exists : '.$path1,\OC_Log::ERROR);
+ return false;
+ }
+
+ if($return=rename($this->datadir.$path1,$this->datadir.$path2)) {
+ }
+ return $return;
+ }
+ public function copy($path1,$path2) {
+ if($this->is_dir($path2)) {
+ if(!$this->file_exists($path2)) {
+ $this->mkdir($path2);
+ }
+ $source=substr($path1, strrpos($path1,'/')+1);
+ $path2.=$source;
+ }
+ return copy($this->datadir.$path1,$this->datadir.$path2);
+ }
+ public function fopen($path,$mode) {
+ if($return=fopen($this->datadir.$path,$mode)) {
+ switch($mode) {
+ case 'r':
+ break;
+ case 'r+':
+ case 'w+':
+ case 'x+':
+ case 'a+':
+ break;
+ case 'w':
+ case 'x':
+ case 'a':
+ break;
+ }
+ }
+ return $return;
+ }
+
+ public function getMimeType($path) {
+ if($this->isReadable($path)) {
+ return \OC_Helper::getMimeType($this->datadir.$path);
+ }else{
+ return false;
+ }
+ }
+
+ private function delTree($dir) {
+ $dirRelative=$dir;
+ $dir=$this->datadir.$dir;
+ if (!file_exists($dir)) return true;
+ if (!is_dir($dir) || is_link($dir)) return unlink($dir);
+ foreach (scandir($dir) as $item) {
+ if ($item == '.' || $item == '..') continue;
+ if(is_file($dir.'/'.$item)) {
+ if(unlink($dir.'/'.$item)) {
+ }
+ }elseif(is_dir($dir.'/'.$item)) {
+ if (!$this->delTree($dirRelative. "/" . $item)) {
+ return false;
+ };
+ }
+ }
+ if($return=rmdir($dir)) {
+ }
+ return $return;
+ }
+
+ public function hash($path,$type,$raw=false) {
+ return hash_file($type,$this->datadir.$path,$raw);
+ }
+
+ public function free_space($path) {
+ return @disk_free_space($this->datadir.$path);
+ }
+
+ public function search($query) {
+ return $this->searchInDir($query);
+ }
+ public function getLocalFile($path) {
+ return $this->datadir.$path;
+ }
+ public function getLocalFolder($path) {
+ return $this->datadir.$path;
+ }
+
+ protected function searchInDir($query,$dir='') {
+ $files=array();
+ foreach (scandir($this->datadir.$dir) as $item) {
+ if ($item == '.' || $item == '..') continue;
+ if(strstr(strtolower($item), strtolower($query))!==false) {
+ $files[]=$dir.'/'.$item;
+ }
+ if(is_dir($this->datadir.$dir.'/'.$item)) {
+ $files=array_merge($files,$this->searchInDir($query,$dir.'/'.$item));
+ }
+ }
+ return $files;
+ }
+
+ /**
+ * check if a file or folder has been updated since $time
+ * @param int $time
+ * @return bool
+ */
+ public function hasUpdated($path,$time) {
+ return $this->filemtime($path)>$time;
+ }
+}
diff --git a/lib/files/storage/storage.php b/lib/files/storage/storage.php
new file mode 100644
index 00000000000..1f5c9356294
--- /dev/null
+++ b/lib/files/storage/storage.php
@@ -0,0 +1,66 @@
+<?php
+/**
+ * Copyright (c) 2012 Robin Appelman <icewind@owncloud.com>
+ * This file is licensed under the Affero General Public License version 3 or
+ * later.
+ * See the COPYING-README file.
+ */
+
+namespace OC\Files\Storage;
+
+/**
+ * Provide a common interface to all different storage options
+ */
+interface Storage{
+ public function __construct($parameters);
+ public function getId();
+ public function mkdir($path);
+ public function rmdir($path);
+ public function opendir($path);
+ public function is_dir($path);
+ public function is_file($path);
+ public function stat($path);
+ public function filetype($path);
+ public function filesize($path);
+ public function isCreatable($path);
+ public function isReadable($path);
+ public function isUpdatable($path);
+ public function isDeletable($path);
+ public function isSharable($path);
+ public function getPermissions($path);
+ public function file_exists($path);
+ public function filemtime($path);
+ public function file_get_contents($path);
+ public function file_put_contents($path,$data);
+ public function unlink($path);
+ public function rename($path1,$path2);
+ public function copy($path1,$path2);
+ public function fopen($path,$mode);
+ public function getMimeType($path);
+ public function hash($type,$path,$raw = false);
+ public function free_space($path);
+ public function search($query);
+ public function touch($path, $mtime=null);
+ public function getLocalFile($path);// get a path to a local version of the file, whether the original file is local or remote
+ public function getLocalFolder($path);// get a path to a local version of the folder, whether the original file is local or remote
+ /**
+ * check if a file or folder has been updated since $time
+ * @param int $time
+ * @return bool
+ *
+ * hasUpdated for folders should return at least true if a file inside the folder is add, removed or renamed.
+ * returning true for other changes in the folder is optional
+ */
+ public function hasUpdated($path,$time);
+
+ /**
+ * @return \OC\Files\Cache\Cache
+ */
+ public function getCache();
+ /**
+ * @return \OC\Files\Cache\Scanner
+ */
+ public function getScanner();
+
+ public function getOwner($path);
+}
diff --git a/lib/files/storage/temporary.php b/lib/files/storage/temporary.php
new file mode 100644
index 00000000000..ffc55e27507
--- /dev/null
+++ b/lib/files/storage/temporary.php
@@ -0,0 +1,26 @@
+<?php
+/**
+ * Copyright (c) 2012 Robin Appelman <icewind@owncloud.com>
+ * This file is licensed under the Affero General Public License version 3 or
+ * later.
+ * See the COPYING-README file.
+ */
+
+namespace OC\Files\Storage;
+
+/**
+ * local storage backnd in temporary folder for testing purpores
+ */
+class Temporary extends Local{
+ public function __construct($arguments) {
+ $this->datadir=\OC_Helper::tmpFolder();
+ }
+
+ public function cleanUp() {
+ \OC_Helper::rmdirr($this->datadir);
+ }
+
+ public function __destruct() {
+ $this->cleanUp();
+ }
+}
diff --git a/lib/files/view.php b/lib/files/view.php
new file mode 100644
index 00000000000..82455d582eb
--- /dev/null
+++ b/lib/files/view.php
@@ -0,0 +1,817 @@
+<?php
+/**
+ * Copyright (c) 2012 Robin Appelman <icewind@owncloud.com>
+ * This file is licensed under the Affero General Public License version 3 or
+ * later.
+ * See the COPYING-README file.
+ */
+
+/**
+ * Class to provide access to ownCloud filesystem via a "view", and methods for
+ * working with files within that view (e.g. read, write, delete, etc.). Each
+ * view is restricted to a set of directories via a virtual root. The default view
+ * uses the currently logged in user's data directory as root (parts of
+ * OC_Filesystem are merely a wrapper for OC_FilesystemView).
+ *
+ * Apps that need to access files outside of the user data folders (to modify files
+ * belonging to a user other than the one currently logged in, for example) should
+ * use this class directly rather than using OC_Filesystem, or making use of PHP's
+ * built-in file manipulation functions. This will ensure all hooks and proxies
+ * are triggered correctly.
+ *
+ * Filesystem functions are not called directly; they are passed to the correct
+ * \OC\Files\Storage\Storage object
+ */
+
+namespace OC\Files;
+
+class View {
+ private $fakeRoot = '';
+ private $internal_path_cache = array();
+ private $storage_cache = array();
+
+ public function __construct($root) {
+ $this->fakeRoot = $root;
+ }
+
+ public function getAbsolutePath($path) {
+ if (!$path) {
+ $path = '/';
+ }
+ if ($path[0] !== '/') {
+ $path = '/' . $path;
+ }
+ return $this->fakeRoot . $path;
+ }
+
+ /**
+ * change the root to a fake root
+ *
+ * @param string $fakeRoot
+ * @return bool
+ */
+ public function chroot($fakeRoot) {
+ if (!$fakeRoot == '') {
+ if ($fakeRoot[0] !== '/') {
+ $fakeRoot = '/' . $fakeRoot;
+ }
+ }
+ $this->fakeRoot = $fakeRoot;
+ }
+
+ /**
+ * get the fake root
+ *
+ * @return string
+ */
+ public function getRoot() {
+ return $this->fakeRoot;
+ }
+
+ /**
+ * get path relative to the root of the view
+ *
+ * @param string $path
+ * @return string
+ */
+ public function getRelativePath($path) {
+ if ($this->fakeRoot == '') {
+ return $path;
+ }
+ if (strpos($path, $this->fakeRoot) !== 0) {
+ return null;
+ } else {
+ $path = substr($path, strlen($this->fakeRoot));
+ if (strlen($path) === 0) {
+ return '/';
+ } else {
+ return $path;
+ }
+ }
+ }
+
+ /**
+ * get the mountpoint of the storage object for a path
+ ( note: because a storage is not always mounted inside the fakeroot, the returned mountpoint is relative to the absolute root of the filesystem and doesn't take the chroot into account
+ *
+ * @param string $path
+ * @return string
+ */
+ public function getMountPoint($path) {
+ return Filesystem::getMountPoint($this->getAbsolutePath($path));
+ }
+
+ /**
+ * return the path to a local version of the file
+ * we need this because we can't know if a file is stored local or not from outside the filestorage and for some purposes a local file is needed
+ *
+ * @param string $path
+ * @return string
+ */
+ public function getLocalFile($path) {
+ $parent = substr($path, 0, strrpos($path, '/'));
+ list($storage, $internalPath) = Filesystem::resolvePath($path);
+ if (Filesystem::isValidPath($parent) and $storage) {
+ return $storage->getLocalFile($internalPath);
+ } else {
+ return null;
+ }
+ }
+
+ /**
+ * @param string $path
+ * @return string
+ */
+ public function getLocalFolder($path) {
+ $parent = substr($path, 0, strrpos($path, '/'));
+ list($storage, $internalPath) = Filesystem::resolvePath($path);
+ if (Filesystem::isValidPath($parent) and $storage) {
+ return $storage->getLocalFolder($internalPath);
+ } else {
+ return null;
+ }
+ }
+
+ /**
+ * the following functions operate with arguments and return values identical
+ * to those of their PHP built-in equivalents. Mostly they are merely wrappers
+ * for \OC\Files\Storage\Storage via basicOperation().
+ */
+ public function mkdir($path) {
+ return $this->basicOperation('mkdir', $path, array('create', 'write'));
+ }
+
+ public function rmdir($path) {
+ return $this->basicOperation('rmdir', $path, array('delete'));
+ }
+
+ public function opendir($path) {
+ return $this->basicOperation('opendir', $path, array('read'));
+ }
+
+ public function readdir($handle) {
+ $fsLocal = new Storage\Local(array('datadir' => '/'));
+ return $fsLocal->readdir($handle);
+ }
+
+ public function is_dir($path) {
+ if ($path == '/') {
+ return true;
+ }
+ return $this->basicOperation('is_dir', $path);
+ }
+
+ public function is_file($path) {
+ if ($path == '/') {
+ return false;
+ }
+ return $this->basicOperation('is_file', $path);
+ }
+
+ public function stat($path) {
+ return $this->basicOperation('stat', $path);
+ }
+
+ public function filetype($path) {
+ return $this->basicOperation('filetype', $path);
+ }
+
+ public function filesize($path) {
+ return $this->basicOperation('filesize', $path);
+ }
+
+ public function readfile($path) {
+ @ob_end_clean();
+ $handle = $this->fopen($path, 'rb');
+ if ($handle) {
+ $chunkSize = 8192; // 8 MB chunks
+ while (!feof($handle)) {
+ echo fread($handle, $chunkSize);
+ flush();
+ }
+ $size = $this->filesize($path);
+ return $size;
+ }
+ return false;
+ }
+
+ public function isCreatable($path) {
+ return $this->basicOperation('isCreatable', $path);
+ }
+
+ public function isReadable($path) {
+ return $this->basicOperation('isReadable', $path);
+ }
+
+ public function isUpdatable($path) {
+ return $this->basicOperation('isUpdatable', $path);
+ }
+
+ public function isDeletable($path) {
+ return $this->basicOperation('isDeletable', $path);
+ }
+
+ public function isSharable($path) {
+ return $this->basicOperation('isSharable', $path);
+ }
+
+ public function file_exists($path) {
+ if ($path == '/') {
+ return true;
+ }
+ return $this->basicOperation('file_exists', $path);
+ }
+
+ public function filemtime($path) {
+ return $this->basicOperation('filemtime', $path);
+ }
+
+ public function touch($path, $mtime = null) {
+ if (!is_null($mtime) and !is_numeric($mtime)) {
+ $mtime = strtotime($mtime);
+ }
+ return $this->basicOperation('touch', $path, array('write'), $mtime);
+ }
+
+ public function file_get_contents($path) {
+ return $this->basicOperation('file_get_contents', $path, array('read'));
+ }
+
+ public function file_put_contents($path, $data) {
+ if (is_resource($data)) { //not having to deal with streams in file_put_contents makes life easier
+ $absolutePath = Filesystem::normalizePath($this->getAbsolutePath($path));
+ if (\OC_FileProxy::runPreProxies('file_put_contents', $absolutePath, $data) && Filesystem::isValidPath($path)) {
+ $path = $this->getRelativePath($absolutePath);
+ $exists = $this->file_exists($path);
+ $run = true;
+ if ($this->fakeRoot == Filesystem::getRoot()) {
+ if (!$exists) {
+ \OC_Hook::emit(
+ Filesystem::CLASSNAME,
+ Filesystem::signal_create,
+ array(
+ Filesystem::signal_param_path => $path,
+ Filesystem::signal_param_run => &$run
+ )
+ );
+ }
+ \OC_Hook::emit(
+ Filesystem::CLASSNAME,
+ Filesystem::signal_write,
+ array(
+ Filesystem::signal_param_path => $path,
+ Filesystem::signal_param_run => &$run
+ )
+ );
+ }
+ if (!$run) {
+ return false;
+ }
+ $target = $this->fopen($path, 'w');
+ if ($target) {
+ $count = \OC_Helper::streamCopy($data, $target);
+ fclose($target);
+ fclose($data);
+ if ($this->fakeRoot == Filesystem::getRoot()) {
+ if (!$exists) {
+ \OC_Hook::emit(
+ Filesystem::CLASSNAME,
+ Filesystem::signal_post_create,
+ array(Filesystem::signal_param_path => $path)
+ );
+ }
+ \OC_Hook::emit(
+ Filesystem::CLASSNAME,
+ Filesystem::signal_post_write,
+ array(Filesystem::signal_param_path => $path)
+ );
+ }
+ \OC_FileProxy::runPostProxies('file_put_contents', $absolutePath, $count);
+ return $count > 0;
+ } else {
+ return false;
+ }
+ } else {
+ return false;
+ }
+ } else {
+ return $this->basicOperation('file_put_contents', $path, array('create', 'write'), $data);
+ }
+ }
+
+ public function unlink($path) {
+ return $this->basicOperation('unlink', $path, array('delete'));
+ }
+
+ public function deleteAll($directory, $empty = false) {
+ return $this->basicOperation('deleteAll', $directory, array('delete'), $empty);
+ }
+
+ public function rename($path1, $path2) {
+ $postFix1 = (substr($path1, -1, 1) === '/') ? '/' : '';
+ $postFix2 = (substr($path2, -1, 1) === '/') ? '/' : '';
+ $absolutePath1 = Filesystem::normalizePath($this->getAbsolutePath($path1));
+ $absolutePath2 = Filesystem::normalizePath($this->getAbsolutePath($path2));
+ if (\OC_FileProxy::runPreProxies('rename', $absolutePath1, $absolutePath2) and Filesystem::isValidPath($path2)) {
+ $path1 = $this->getRelativePath($absolutePath1);
+ $path2 = $this->getRelativePath($absolutePath2);
+
+ if ($path1 == null or $path2 == null) {
+ return false;
+ }
+ $run = true;
+ if ($this->fakeRoot == Filesystem::getRoot()) {
+ \OC_Hook::emit(
+ Filesystem::CLASSNAME, Filesystem::signal_rename,
+ array(
+ Filesystem::signal_param_oldpath => $path1,
+ Filesystem::signal_param_newpath => $path2,
+ Filesystem::signal_param_run => &$run
+ )
+ );
+ }
+ if ($run) {
+ $mp1 = $this->getMountPoint($path1 . $postFix1);
+ $mp2 = $this->getMountPoint($path2 . $postFix2);
+ if ($mp1 == $mp2) {
+ list($storage, $internalPath1) = Filesystem::resolvePath($path1 . $postFix1);
+ list(, $internalPath2) = Filesystem::resolvePath($path2 . $postFix2);
+ if ($storage) {
+ $result = $storage->rename($internalPath1, $internalPath2);
+ } else {
+ $result = false;
+ }
+ } else {
+ $source = $this->fopen($path1 . $postFix1, 'r');
+ $target = $this->fopen($path2 . $postFix2, 'w');
+ $count = \OC_Helper::streamCopy($source, $target);
+ list($storage1, $internalPath1) = Filesystem::resolvePath($path1 . $postFix1);
+ $storage1->unlink($internalPath1);
+ $result = $count > 0;
+ }
+ if ($this->fakeRoot == Filesystem::getRoot()) {
+ \OC_Hook::emit(
+ Filesystem::CLASSNAME,
+ Filesystem::signal_post_rename,
+ array(
+ Filesystem::signal_param_oldpath => $path1,
+ Filesystem::signal_param_newpath => $path2
+ )
+ );
+ }
+ return $result;
+ } else {
+ return false;
+ }
+ } else {
+ return false;
+ }
+ }
+
+ public function copy($path1, $path2) {
+ $postFix1 = (substr($path1, -1, 1) === '/') ? '/' : '';
+ $postFix2 = (substr($path2, -1, 1) === '/') ? '/' : '';
+ $absolutePath1 = Filesystem::normalizePath($this->getAbsolutePath($path1));
+ $absolutePath2 = Filesystem::normalizePath($this->getAbsolutePath($path2));
+ if (\OC_FileProxy::runPreProxies('copy', $absolutePath1, $absolutePath2) and Filesystem::isValidPath($path2)) {
+ $path1 = $this->getRelativePath($absolutePath1);
+ $path2 = $this->getRelativePath($absolutePath2);
+
+ if ($path1 == null or $path2 == null) {
+ return false;
+ }
+ $run = true;
+ $exists = $this->file_exists($path2);
+ if ($this->fakeRoot == Filesystem::getRoot()) {
+ \OC_Hook::emit(
+ Filesystem::CLASSNAME,
+ Filesystem::signal_copy,
+ array(
+ Filesystem::signal_param_oldpath => $path1,
+ Filesystem::signal_param_newpath => $path2,
+ Filesystem::signal_param_run => &$run
+ )
+ );
+ if ($run and !$exists) {
+ \OC_Hook::emit(
+ Filesystem::CLASSNAME,
+ Filesystem::signal_create,
+ array(
+ Filesystem::signal_param_path => $path2,
+ Filesystem::signal_param_run => &$run
+ )
+ );
+ }
+ if ($run) {
+ \OC_Hook::emit(
+ Filesystem::CLASSNAME,
+ Filesystem::signal_write,
+ array(
+ Filesystem::signal_param_path => $path2,
+ Filesystem::signal_param_run => &$run
+ )
+ );
+ }
+ }
+ if ($run) {
+ $mp1 = $this->getMountPoint($path1 . $postFix1);
+ $mp2 = $this->getMountPoint($path2 . $postFix2);
+ if ($mp1 == $mp2) {
+ list($storage, $internalPath1) = Filesystem::resolvePath($path1 . $postFix1);
+ list(, $internalPath2) = Filesystem::resolvePath($path2 . $postFix2);
+ if ($storage) {
+ $result = $storage->copy($internalPath1, $internalPath2);
+ } else {
+ $result = false;
+ }
+ } else {
+ $source = $this->fopen($path1 . $postFix1, 'r');
+ $target = $this->fopen($path2 . $postFix2, 'w');
+ $result = \OC_Helper::streamCopy($source, $target);
+ }
+ if ($this->fakeRoot == Filesystem::getRoot()) {
+ \OC_Hook::emit(
+ Filesystem::CLASSNAME,
+ Filesystem::signal_post_copy,
+ array(
+ Filesystem::signal_param_oldpath => $path1,
+ Filesystem::signal_param_newpath => $path2
+ )
+ );
+ if (!$exists) {
+ \OC_Hook::emit(
+ Filesystem::CLASSNAME,
+ Filesystem::signal_post_create,
+ array(Filesystem::signal_param_path => $path2)
+ );
+ }
+ \OC_Hook::emit(
+ Filesystem::CLASSNAME,
+ Filesystem::signal_post_write,
+ array(Filesystem::signal_param_path => $path2)
+ );
+ } else { // no real copy, file comes from somewhere else, e.g. version rollback -> just update the file cache and the webdav properties without all the other post_write actions
+ Filesystem::removeETagHook(array("path" => $path2), $this->fakeRoot);
+ }
+ return $result;
+ } else {
+ return false;
+ }
+ } else {
+ return false;
+ }
+ }
+
+ public function fopen($path, $mode) {
+ $hooks = array();
+ switch ($mode) {
+ case 'r':
+ case 'rb':
+ $hooks[] = 'read';
+ break;
+ case 'r+':
+ case 'rb+':
+ case 'w+':
+ case 'wb+':
+ case 'x+':
+ case 'xb+':
+ case 'a+':
+ case 'ab+':
+ $hooks[] = 'read';
+ $hooks[] = 'write';
+ break;
+ case 'w':
+ case 'wb':
+ case 'x':
+ case 'xb':
+ case 'a':
+ case 'ab':
+ $hooks[] = 'write';
+ break;
+ default:
+ \OC_Log::write('core', 'invalid mode (' . $mode . ') for ' . $path, \OC_Log::ERROR);
+ }
+
+ return $this->basicOperation('fopen', $path, $hooks, $mode);
+ }
+
+ public function toTmpFile($path) {
+ if (Filesystem::isValidPath($path)) {
+ $source = $this->fopen($path, 'r');
+ if ($source) {
+ $extension = '';
+ $extOffset = strpos($path, '.');
+ if ($extOffset !== false) {
+ $extension = substr($path, strrpos($path, '.'));
+ }
+ $tmpFile = \OC_Helper::tmpFile($extension);
+ file_put_contents($tmpFile, $source);
+ return $tmpFile;
+ } else {
+ return false;
+ }
+ } else {
+ return false;
+ }
+ }
+
+ public function fromTmpFile($tmpFile, $path) {
+ if (Filesystem::isValidPath($path)) {
+ if (!$tmpFile) {
+ debug_print_backtrace();
+ }
+ $source = fopen($tmpFile, 'r');
+ if ($source) {
+ $this->file_put_contents($path, $source);
+ unlink($tmpFile);
+ return true;
+ } else {
+ return false;
+ }
+ } else {
+ return false;
+ }
+ }
+
+ public function getMimeType($path) {
+ return $this->basicOperation('getMimeType', $path);
+ }
+
+ public function hash($type, $path, $raw = false) {
+ $postFix = (substr($path, -1, 1) === '/') ? '/' : '';
+ $absolutePath = Filesystem::normalizePath($this->getAbsolutePath($path));
+ if (\OC_FileProxy::runPreProxies('hash', $absolutePath) && Filesystem::isValidPath($path)) {
+ $path = $this->getRelativePath($absolutePath);
+ if ($path == null) {
+ return false;
+ }
+ if (Filesystem::$loaded && $this->fakeRoot == Filesystem::getRoot()) {
+ \OC_Hook::emit(
+ Filesystem::CLASSNAME,
+ Filesystem::signal_read,
+ array(Filesystem::signal_param_path => $path)
+ );
+ }
+ list($storage, $internalPath) = Filesystem::resolvePath($path . $postFix);
+ if ($storage) {
+ $result = $storage->hash($type, $internalPath, $raw);
+ $result = \OC_FileProxy::runPostProxies('hash', $absolutePath, $result);
+ return $result;
+ }
+ }
+ return null;
+ }
+
+ public function free_space($path = '/') {
+ return $this->basicOperation('free_space', $path);
+ }
+
+ /**
+ * @brief abstraction layer for basic filesystem functions: wrapper for \OC\Files\Storage\Storage
+ * @param string $operation
+ * @param string $path
+ * @param array $hooks (optional)
+ * @param mixed $extraParam (optional)
+ * @return mixed
+ *
+ * This method takes requests for basic filesystem functions (e.g. reading & writing
+ * files), processes hooks and proxies, sanitises paths, and finally passes them on to
+ * \OC\Files\Storage\Storage for delegation to a storage backend for execution
+ */
+ private function basicOperation($operation, $path, $hooks = array(), $extraParam = null) {
+ $postFix = (substr($path, -1, 1) === '/') ? '/' : '';
+ $absolutePath = Filesystem::normalizePath($this->getAbsolutePath($path));
+ if (\OC_FileProxy::runPreProxies($operation, $absolutePath, $extraParam) and Filesystem::isValidPath($path)) {
+ $path = $this->getRelativePath($absolutePath);
+ if ($path == null) {
+ return false;
+ }
+ $run = $this->runHooks($hooks, $path);
+ list($storage, $internalPath) = Filesystem::resolvePath($path . $postFix);
+ if ($run and $storage) {
+ if (!is_null($extraParam)) {
+ $result = $storage->$operation($internalPath, $extraParam);
+ } else {
+ $result = $storage->$operation($internalPath);
+ }
+ $result = \OC_FileProxy::runPostProxies($operation, $this->getAbsolutePath($path), $result);
+ if (Filesystem::$loaded and $this->fakeRoot == Filesystem::getRoot()) {
+ if ($operation != 'fopen') { //no post hooks for fopen, the file stream is still open
+ $this->runHooks($hooks, $path, true);
+ }
+ }
+ return $result;
+ }
+ }
+ return null;
+ }
+
+ private function runHooks($hooks, $path, $post = false) {
+ $prefix = ($post) ? 'post_' : '';
+ $run = true;
+ if (Filesystem::$loaded and $this->fakeRoot == Filesystem::getRoot()) {
+ foreach ($hooks as $hook) {
+ if ($hook != 'read') {
+ \OC_Hook::emit(
+ Filesystem::CLASSNAME,
+ $prefix . $hook,
+ array(
+ Filesystem::signal_param_run => &$run,
+ Filesystem::signal_param_path => $path
+ )
+ );
+ } elseif (!$post) {
+ \OC_Hook::emit(
+ Filesystem::CLASSNAME,
+ $prefix . $hook,
+ array(
+ Filesystem::signal_param_path => $path
+ )
+ );
+ }
+ }
+ }
+ return $run;
+ }
+
+ /**
+ * check if a file or folder has been updated since $time
+ *
+ * @param string $path
+ * @param int $time
+ * @return bool
+ */
+ public function hasUpdated($path, $time) {
+ return $this->basicOperation('hasUpdated', $path, array(), $time);
+ }
+
+ /**
+ * get the filesystem info
+ *
+ * @param string $path
+ * @return array
+ *
+ * returns an associative array with the following keys:
+ * - size
+ * - mtime
+ * - mimetype
+ * - encrypted
+ * - versioned
+ */
+ public function getFileInfo($path) {
+ $path = Filesystem::normalizePath($this->fakeRoot . '/' . $path);
+ /**
+ * @var \OC\Files\Storage\Storage $storage
+ * @var string $internalPath
+ */
+ list($storage, $internalPath) = Filesystem::resolvePath($path);
+ $cache = $storage->getCache();
+
+ if (!$cache->inCache($internalPath)) {
+ $scanner = $storage->getScanner();
+ $scanner->scan($internalPath, Cache\Scanner::SCAN_SHALLOW);
+ }
+
+ $data = $cache->get($internalPath);
+
+ if ($data['mimetype'] === 'httpd/unix-directory') {
+ //add the sizes of other mountpoints to the folder
+ $mountPoints = Filesystem::getMountPoints($path);
+ foreach ($mountPoints as $mountPoint) {
+ $subStorage = Filesystem::getStorage($mountPoint);
+ $subCache = $subStorage->getCache();
+ $rootEntry = $subCache->get('');
+
+ $data['size'] += $rootEntry['size'];
+ }
+ }
+
+ $data['permissions'] = Cache\Permissions::get($data['fileid'], \OC_User::getUser());
+
+ return $data;
+ }
+
+ /**
+ * get the content of a directory
+ *
+ * @param string $directory path under datadirectory
+ * @return array
+ */
+ public function getDirectoryContent($directory, $mimetype_filter = '') {
+ $path = Filesystem::normalizePath($this->fakeRoot . '/' . $directory);
+ /**
+ * @var \OC\Files\Storage\Storage $storage
+ * @var string $internalPath
+ */
+ list($storage, $internalPath) = Filesystem::resolvePath($path);
+ $cache = $storage->getCache();
+
+ if (!$cache->inCache($internalPath)) {
+ $scanner = $storage->getScanner();
+ $scanner->scan($internalPath, Cache\Scanner::SCAN_SHALLOW);
+ }
+
+ $files = $cache->getFolderContents($internalPath); //TODO: mimetype_filter
+
+ //add a folder for any mountpoint in this directory and add the sizes of other mountpoints to the folders
+ $mountPoints = Filesystem::getMountPoints($path);
+ $dirLength = strlen($path);
+ foreach ($mountPoints as $mountPoint) {
+ $subStorage = Filesystem::getStorage($mountPoint);
+ $subCache = $subStorage->getCache();
+ $rootEntry = $subCache->get('');
+
+ $relativePath = trim(substr($mountPoint, $dirLength), '/');
+ if ($pos = strpos($relativePath, '/')) { //mountpoint inside subfolder add size to the correct folder
+ $entryName = substr($relativePath, 0, $pos);
+ foreach ($files as &$entry) {
+ if ($entry['name'] === $entryName) {
+ $entry['size'] += $rootEntry['size'];
+ }
+ }
+ } else { //mountpoint in this folder, add an entry for it
+ $rootEntry['name'] = $relativePath;
+ $files[] = $rootEntry;
+ }
+ }
+
+ $ids = array();
+
+ foreach ($files as $i => $file) {
+ $files[$i]['type'] = $file['mimetype'] === 'httpd/unix-directory' ? 'dir' : 'file';
+ $ids[] = $file['fileid'];
+ }
+
+ $permissions = Cache\Permissions::getMultiple($ids, \OC_User::getUser());
+ foreach ($files as $i => $file) {
+ $files[$i]['permissions'] = $permissions[$file['fileid']];
+ }
+
+ usort($files, "fileCmp"); //TODO: remove this once ajax is merged
+ return $files;
+ }
+
+ /**
+ * change file metadata
+ *
+ * @param string $path
+ * @param array $data
+ * @return int
+ *
+ * returns the fileid of the updated file
+ */
+ public function putFileInfo($path, $data) {
+ $path = Filesystem::normalizePath($this->fakeRoot . '/' . $path);
+ /**
+ * @var \OC\Files\Storage\Storage $storage
+ * @var string $internalPath
+ */
+ list($storage, $internalPath) = Filesystem::resolvePath($path);
+ $cache = $storage->getCache();
+
+ if (!$cache->inCache($internalPath)) {
+ $scanner = $storage->getScanner();
+ $scanner->scan($internalPath, Cache\Scanner::SCAN_SHALLOW);
+ }
+
+ return $cache->put($internalPath, $data);
+ }
+
+ /**
+ * search for files with the name matching $query
+ *
+ * @param string $query
+ * @return array
+ */
+ public function search($query) {
+ $files = array();
+ $rootLength = strlen($this->fakeRoot);
+
+ $mountPoint = Filesystem::getMountPoint($this->fakeRoot);
+ $storage = Filesystem::getStorage($mountPoint);
+ $cache = $storage->getCache();
+
+ $results = $cache->search('%' . $query . '%');
+ foreach ($results as $result) {
+ if (substr($mountPoint . $result['path'], 0, $rootLength) === $this->fakeRoot) {
+ $result['path'] = substr($mountPoint . $result['path'], $rootLength);
+ $files[] = $result;
+ }
+ }
+
+ $mountPoints = Filesystem::getMountPoints($this->fakeRoot);
+ foreach ($mountPoints as $mountPoint) {
+ $storage = Filesystem::getStorage($mountPoint);
+ $cache = $storage->getCache();
+
+ $relativeMountPoint = substr($mountPoint, $rootLength);
+ $results = $cache->search('%' . $query . '%');
+ foreach ($results as $result) {
+ $result['path'] = $relativeMountPoint . $result['path'];
+ $files[] = $result;
+ }
+ }
+
+ return $files;
+ }
+}
generated by cgit v1.2.3 (git 2.39.1) at 2025-06-02 20:28:29 +0000