No OneTemporary
Actions

Authored By

Unknown

Size

40 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/file_api.php b/lib/file_api.php
	index 392c433..c7c9b43 100644
	--- a/lib/file_api.php
	+++ b/lib/file_api.php
	@@ -1,397 +1,421 @@
	<?php

	class file_api
	{
	const ERROR_CODE = 500;
	const OUTPUT_JSON = 'application/json';
	const OUTPUT_HTML = 'text/html';

	const PATH_SEPARATOR = '/';

	private $app_name = 'Kolab File API';
	private $api;
	private $output_type = self::OUTPUT_JSON;
	private $config = array(
	'date_format' => 'Y-m-d H:i',
	'language' => 'en_US',
	);

	public function __construct()
	{
	}

	/**
	* Initialise backend class
	*/
	protected function api_init()
	{
	if ($this->api) {
	return;
	}

	// @TODO: config
	$driver = 'kolab';
	$class = $driver . '_file_storage';

	require_once $driver . '/' . $class . '.php';

	$this->api = new $class;
	}

	/**
	* Process the request and dispatch it to the requested service
	*/
	public function run()
	{
	$request = strtolower($_GET['method']);

	// Check the session, authenticate the user
	if (!$this->session_validate()) {
	@session_destroy();

	if ($request == 'authenticate') {
	session_start();

	if ($username = $this->authenticate()) {
	$_SESSION['user'] = $username;
	$_SESSION['time'] = time();
	$_SESSION['config'] = $this->config;

	- $this->output_success(array('token' => session_id()));
	+ $this->output_success(array(
	+ 'token' => session_id(),
	+ 'capabilities' => $this->capabilities(),
	+ ));
	}
	}

	throw new Exception("Invalid session", 403);
	}

	// Call service method
	$result = $this->request($request);

	// Send success response, errors should be handled by driver class
	// by throwing exceptions or sending output by itself
	$this->output_success($result);
	}

	/**
	* Session validation check
	*/
	private function session_validate()
	{
	$sess_id = rcube_utils::request_header('X-Session-Token') ?: $_REQUEST['token'];

	if (empty($sess_id)) {
	return false;
	}

	session_id($sess_id);
	session_start();

	if (empty($_SESSION['user'])) {
	return false;
	}

	// Session timeout
	// $timeout = $this->config->get('kolab_wap', 'session_timeout');
	$timeout = 3600;
	if ($timeout && $_SESSION['time'] && $_SESSION['time'] < time() - $timeout) {
	return false;
	}
	// update session time
	$_SESSION['time'] = time();

	return true;
	}

	/**
	* Authentication request handler (HTTP Auth)
	*/
	private function authenticate()
	{
	if (isset($_POST['username'])) {
	$username = $_POST['username'];
	$password = $_POST['password'];
	}
	else if (!empty($_SERVER['PHP_AUTH_USER'])) {
	$username = $_SERVER['PHP_AUTH_USER'];
	$password = $_SERVER['PHP_AUTH_PW'];
	}
	// when used with (f)cgi no PHP_AUTH* variables are available without defining a special rewrite rule
	else if (!isset($_SERVER['PHP_AUTH_USER'])) {
	// "Basic didhfiefdhfu4fjfjdsa34drsdfterrde..."
	if (isset($_SERVER["REMOTE_USER"])) {
	$basicAuthData = base64_decode(substr($_SERVER["REMOTE_USER"], 6));
	}
	else if (isset($_SERVER["REDIRECT_REMOTE_USER"])) {
	$basicAuthData = base64_decode(substr($_SERVER["REDIRECT_REMOTE_USER"], 6));
	}
	else if (isset($_SERVER["Authorization"])) {
	$basicAuthData = base64_decode(substr($_SERVER["Authorization"], 6));
	}
	else if (isset($_SERVER["HTTP_AUTHORIZATION"])) {
	$basicAuthData = base64_decode(substr($_SERVER["HTTP_AUTHORIZATION"], 6));
	}

	if (isset($basicAuthData) && !empty($basicAuthData)) {
	list($username, $password) = explode(":", $basicAuthData);
	}
	}

	if (!empty($username)) {
	$this->api_init();
	$result = $this->api->authenticate($username, $password);
	}

	if (empty($result)) {
	/*
	header('WWW-Authenticate: Basic realm="' . $this->app_name .'"');
	header('HTTP/1.1 401 Unauthorized');
	exit;
	*/
	throw new Exception("Invalid password or username", file_api::ERROR_CODE);
	}

	return $username;
	}

	/**
	* Storage driver method caller
	*/
	private function request($request)
	{
	if ($request == 'ping') {
	return array();
	}

	$this->api_init();

	switch ($request) {
	case 'file_list':
	$params = array('reverse' => !empty($_GET['reverse']) && rcube_utils::get_boolean($_GET['reverse']));
	if (!empty($_GET['sort'])) {
	$params['sort'] = strtolower($_GET['sort']);
	}

	if (!empty($_GET['search'])) {
	$params['search'] = $_GET['search'];
	if (!is_array($params['search'])) {
	$params['search'] = array('name' => $params['search']);
	}
	}

	return $this->api->file_list($_GET['folder'], $params);

	case 'file_create':
	// for Opera upload frame response cannot be application/json
	$this->output_type = self::OUTPUT_HTML;

	if (!isset($_GET['folder']) \|\| $_GET['folder'] === '') {
	throw new Exception("Missing folder name", file_api::ERROR_CODE);
	}

	$uploads = $this->upload();
	$result = array();

	foreach ($uploads as $file) {
	$this->api->file_create($_GET['folder'] . self::PATH_SEPARATOR . $file['name'], $file);
	unset($file['path']);
	$result[$file['name']] = array(
	'type' => $file['type'],
	'size' => $file['size'],
	);
	}

	return $result;

	case 'file_delete':
	$files = (array) $_GET['file'];

	if (empty($files)) {
	throw new Exception("Missing file name", file_api::ERROR_CODE);
	}

	foreach ($files as $file) {
	$this->api->file_delete($file);
	}
	return;

	case 'file_info':
	if (!isset($_GET['file']) \|\| $_GET['file'] === '') {
	throw new Exception("Missing file name", file_api::ERROR_CODE);
	}

	return $this->api->file_info($_GET['file']);

	case 'file_get':
	$this->output_type = self::OUTPUT_HTML;

	if (!isset($_GET['file']) \|\| $_GET['file'] === '') {
	header("HTTP/1.0 ".file_api::ERROR_CODE." Missing file name");
	}

	$params = array(
	'force-download' => !empty($_GET['force-download']) && rcube_utils::get_boolean($_GET['force-download'])
	);

	try {
	$this->api->file_get($_GET['file'], $params);
	}
	catch (Exception $e) {
	header("HTTP/1.0 " . file_api::ERROR_CODE . " " . $e->getMessage());
	}
	exit;

	case 'file_move':
	if (!isset($_GET['file']) \|\| $_GET['file'] === '') {
	throw new Exception("Missing file name", file_api::ERROR_CODE);
	}

	if (is_array($_GET['file'])) {
	if (empty($_GET['file'])) {
	throw new Exception("Missing file name", file_api::ERROR_CODE);
	}
	}
	else {
	if (!isset($_GET['new']) \|\| $_GET['new'] === '') {
	throw new Exception("Missing new file name", file_api::ERROR_CODE);
	}
	$_GET['file'] = array($_GET['file'] => $_GET['new']);
	}

	$files = (array) $_GET['file'];

	foreach ($files as $file => $new_file) {
	if ($new_file === '') {
	throw new Exception("Missing new file name", file_api::ERROR_CODE);
	}
	if ($new_file === $file) {
	throw new Exception("Old and new file name is the same", file_api::ERROR_CODE);
	}

	$this->api->file_move($file, $new_file);
	}

	return;

	case 'folder_create':
	if (!isset($_GET['folder']) \|\| $_GET['folder'] === '') {
	throw new Exception("Missing folder name", file_api::ERROR_CODE);
	}
	return $this->api->folder_create($_GET['folder']);

	case 'folder_delete':
	if (!isset($_GET['folder']) \|\| $_GET['folder'] === '') {
	throw new Exception("Missing folder name", file_api::ERROR_CODE);
	}
	return $this->api->folder_delete($_GET['folder']);

	case 'folder_rename':
	if (!isset($_GET['folder']) \|\| $_GET['folder'] === '') {
	throw new Exception("Missing source folder name", file_api::ERROR_CODE);
	}
	if (!isset($_GET['new']) \|\| $_GET['new'] === '') {
	throw new Exception("Missing destination folder name", file_api::ERROR_CODE);
	}
	if ($_GET['new'] === $_GET['folder']) {
	return;
	}
	return $this->api->folder_rename($_GET['folder'], $_GET['new']);

	case 'folder_list':
	return $this->api->folder_list();

	case 'quit':
	@session_destroy();
	return array();

	case 'configure':
	foreach (array_keys($this->config) as $name) {
	if (isset($_GET[$name])) {
	$this->config[$name] = $_GET[$name];
	}
	}
	$_SESSION['config'] = $this->config;

	return $this->config;
	+
	+ case 'capabilities':
	+ return $this->capabilities();
	}

	if ($request) {
	throw new Exception("Unknown method", 501);
	}
	}

	/**
	* File uploads handler
	*/
	protected function upload()
	{
	$files = array();

	if (is_array($_FILES['file']['tmp_name'])) {
	foreach ($_FILES['file']['tmp_name'] as $i => $filepath) {
	if ($err = $_FILES['file']['error'][$i]) {
	if ($err == UPLOAD_ERR_INI_SIZE \|\| $err == UPLOAD_ERR_FORM_SIZE) {
	throw new Exception("Maximum file size exceeded", file_api::ERROR_CODE);
	}
	throw new Exception("File upload failed", file_api::ERROR_CODE);
	}

	$files[] = array(
	'path' => $filepath,
	'name' => $_FILES['file']['name'][$i],
	'size' => filesize($filepath),
	'type' => rcube_mime::file_content_type($filepath, $_FILES['file']['name'][$i], $_FILES['file']['type']),
	);
	}
	}
	else if ($_SERVER['REQUEST_METHOD'] == 'POST') {
	throw new Exception("File upload failed", file_api::ERROR_CODE);
	}

	return $files;
	}

	+ /*
	+ * Returns storage (driver) capabilities
	+ */
	+ protected function capabilities()
	+ {
	+ $this->api_init();
	+
	+ $caps = array();
	+ foreach ($this->api->capabilities() as $name => $value) {
	+ // skip disabled capabilities
	+ if ($value !== false) {
	+ $caps[$name] = $value;
	+ }
	+ }
	+
	+ return $caps;
	+ }
	+
	/**
	* Send success response
	*
	* @param mixed $data Data
	*/
	public function output_success($data)
	{
	if (!is_array($data)) {
	$data = array();
	}

	$this->output_send(array('status' => 'OK', 'result' => $data));
	}

	/**
	* Send error response
	*
	* @param mixed $data Data
	*/
	public function output_error($errdata, $code = null)
	{
	if (is_string($errdata)) {
	$errdata = array('reason' => $errdata);
	}

	if (!$code) {
	$code = file_api::ERROR_CODE;
	}

	$this->output_send(array('status' => 'ERROR', 'code' => $code) + $errdata);
	}

	/**
	* Send response
	*
	* @param mixed $data Data
	*/
	protected function output_send($data)
	{
	// Send response
	header("Content-Type: {$this->output_type}; charset=utf-8");
	echo json_encode($data);
	exit;
	}
	}
	diff --git a/lib/file_storage.php b/lib/file_storage.php
	index 379d62c..0332894 100644
	--- a/lib/file_storage.php
	+++ b/lib/file_storage.php
	@@ -1,119 +1,129 @@
	<?php

	interface file_storage
	{
	+ const CAPS_MAX_UPLOAD = 'MAX_UPLOAD';
	+ const CAPS_ACL = 'ACL';
	+
	/**
	- * Authenticates a user
	- *
	- * @param string $username User name
	- * @param string $password User password
	- *
	- * @param bool True on success, False on failure
	- */
	+ * Authenticates a user
	+ *
	+ * @param string $username User name
	+ * @param string $password User password
	+ *
	+ * @return bool True on success, False on failure
	+ */
	public function authenticate($username, $password);

	+ /**
	+ * Storage driver capabilities
	+ *
	+ * @return array List of capabilities
	+ */
	+ public function capabilities();
	+
	/**
	* Create a file.
	*
	* @param string $file_name Name of a file (with folder path)
	* @param array $file File data (path, type)
	*
	* @throws Exception
	*/
	public function file_create($file_name, $file);

	/**
	* Delete a file.
	*
	* @param string $file_name Name of a file (with folder path)
	*
	* @throws Exception
	*/
	public function file_delete($file_name);

	/**
	* Returns file body.
	*
	* @param string $file_name Name of a file (with folder path)
	* @param array $params Parameters (force-download)
	*
	* @throws Exception
	*/
	public function file_get($file_name, $params = array());

	/**
	* Move (or rename) a file.
	*
	* @param string $file_name Name of a file (with folder path)
	* @param string $new_name New name of a file (with folder path)
	*
	* @throws Exception
	*/
	public function file_move($file_name, $new_name);

	/**
	* Copy a file.
	*
	* @param string $file_name Name of a file (with folder path)
	* @param string $new_name New name of a file (with folder path)
	*
	* @throws Exception
	*/
	public function file_copy($file_name, $new_name);

	/**
	* Returns file metadata.
	*
	* @param string $file_name Name of a file (with folder path)
	*
	* @throws Exception
	*/
	public function file_info($file_name);

	/**
	* List files in a folder.
	*
	* @param string $folder_name Name of a folder with full path
	* @param array $params List parameters ('sort', 'reverse', 'search')
	*
	* @return array List of files (file properties array indexed by filename)
	* @throws Exception
	*/
	public function file_list($folder_name, $params = array());

	/**
	* Create a folder.
	*
	* @param string $folder_name Name of a folder with full path
	*
	* @throws Exception
	*/
	public function folder_create($folder_name);

	/**
	* Delete a folder.
	*
	* @param string $folder_name Name of a folder with full path
	*
	* @throws Exception
	*/
	public function folder_delete($folder_name);

	/**
	* Rename a folder.
	*
	* @param string $folder_name Name of a folder with full path
	* @param string $new_name New name of a folder with full path
	*
	* @throws Exception
	*/
	public function folder_rename($folder_name, $new_name);

	/**
	* Returns list of folders.
	*
	* @return array List of folders
	* @throws Exception
	*/
	public function folder_list();
	}
	diff --git a/lib/kolab/kolab_file_storage.php b/lib/kolab/kolab_file_storage.php
	index 4aab670..d26a7a2 100644
	--- a/lib/kolab/kolab_file_storage.php
	+++ b/lib/kolab/kolab_file_storage.php
	@@ -1,694 +1,713 @@
	<?php

	class kolab_file_storage implements file_storage
	{
	/**
	* @var rcube
	*/
	protected $rc;

	/**
	* @var array
	*/
	protected $folders;


	/**
	* Class constructor
	*/
	public function __construct()
	{
	$include_path = RCUBE_INSTALL_PATH . '/lib/kolab' . PATH_SEPARATOR;
	$include_path .= ini_get('include_path');
	set_include_path($include_path);

	$this->rc = rcube::get_instance();

	// Get list of plugins
	// WARNING: We can use only plugins that are prepared for this
	// e.g. are not using output or rcmail objects or
	// doesn't throw errors when using them
	$plugins = (array)$this->rc->config->get('fileapi_plugins', array('kolab_auth', 'kolab_folders'));
	$required = array('libkolab', 'kolab_folders');

	// Initialize/load plugins
	$this->rc->plugins = kolab_file_plugin_api::get_instance();
	$this->rc->plugins->init($this, '');
	$this->rc->plugins->load_plugins($plugins, $required);

	$this->init();
	}

	/**
	* Authenticates a user
	*
	* @param string $username User name
	* @param string $password User password
	*
	* @param bool True on success, False on failure
	*/
	public function authenticate($username, $password)
	{
	$auth = $this->rc->plugins->exec_hook('authenticate', array(
	'host' => $this->select_host($username),
	'user' => $username,
	'pass' => $password,
	'valid' => true,
	));

	// Authenticate - get Roundcube user ID
	if ($auth['valid'] && !$auth['abort']
	&& ($this->login($auth['user'], $auth['pass'], $auth['host']))) {
	return true;
	}

	$this->rc->plugins->exec_hook('login_failed', array(
	'host' => $auth['host'],
	'user' => $auth['user'],
	));
	}

	/**
	* Storage host selection
	*/
	private function select_host($username)
	{
	// Get IMAP host
	$host = $this->rc->config->get('default_host');

	if (is_array($host)) {
	list($user, $domain) = explode('@', $username);

	// try to select host by mail domain
	if (!empty($domain)) {
	foreach ($host as $storage_host => $mail_domains) {
	if (is_array($mail_domains) && in_array_nocase($domain, $mail_domains)) {
	$host = $storage_host;
	break;
	}
	else if (stripos($storage_host, $domain) !== false \|\| stripos(strval($mail_domains), $domain) !== false) {
	$host = is_numeric($storage_host) ? $mail_domains : $storage_host;
	break;
	}
	}
	}

	// take the first entry if $host is not found
	if (is_array($host)) {
	list($key, $val) = each($default_host);
	$host = is_numeric($key) ? $val : $key;
	}
	}

	return rcube_utils::parse_host($host);
	}

	/**
	* Authenticates a user in IMAP
	*/
	private function login($username, $password, $host)
	{
	if (empty($username)) {
	return false;
	}

	$login_lc = $this->rc->config->get('login_lc');
	$default_port = $this->rc->config->get('default_port', 143);

	// parse $host
	$a_host = parse_url($host);
	if ($a_host['host']) {
	$host = $a_host['host'];
	$ssl = (isset($a_host['scheme']) && in_array($a_host['scheme'], array('ssl','imaps','tls'))) ? $a_host['scheme'] : null;
	if (!empty($a_host['port'])) {
	$port = $a_host['port'];
	}
	else if ($ssl && $ssl != 'tls' && (!$default_port \|\| $default_port == 143)) {
	$port = 993;
	}
	}

	if (!$port) {
	$port = $default_port;
	}

	// Convert username to lowercase. If storage backend
	// is case-insensitive we need to store always the same username
	if ($login_lc) {
	if ($login_lc == 2 \|\| $login_lc === true) {
	$username = mb_strtolower($username);
	}
	else if (strpos($username, '@')) {
	// lowercase domain name
	list($local, $domain) = explode('@', $username);
	$username = $local . '@' . mb_strtolower($domain);
	}
	}

	// Here we need IDNA ASCII
	// Only rcube_contacts class is using domain names in Unicode
	$host = rcube_utils::idn_to_ascii($host);
	$username = rcube_utils::idn_to_ascii($username);

	// user already registered?
	if ($user = rcube_user::query($username, $host)) {
	$username = $user->data['username'];
	}

	// authenticate user in IMAP
	$storage = $this->rc->get_storage();
	if (!$storage->connect($host, $username, $password, $port, $ssl)) {
	return false;
	}

	// No user in database, but IMAP auth works
	if (!is_object($user)) {
	if ($this->rc->config->get('auto_create_user')) {
	// create a new user record
	$user = rcube_user::create($username, $host);

	if (!$user) {
	rcube::raise_error(array(
	'code' => 620, 'type' => 'php', 'file' => __FILE__, 'line' => __LINE__,
	'message' => "Failed to create a user record",
	), true, false);
	return false;
	}
	}
	else {
	rcube::raise_error(array(
	'code' => 620, 'type' => 'php', 'file' => __FILE__, 'line' => __LINE__,
	'message' => "Access denied for new user $username. 'auto_create_user' is disabled",
	), true, false);
	return false;
	}
	}
	// set session vars
	$_SESSION['user_id'] = $user->ID;
	$_SESSION['username'] = $user->data['username'];
	$_SESSION['storage_host'] = $host;
	$_SESSION['storage_port'] = $port;
	$_SESSION['storage_ssl'] = $ssl;
	$_SESSION['password'] = $this->rc->encrypt($password);

	$this->init($user);

	// force reloading of mailboxes list/data
	$storage->clear_cache('mailboxes', true);

	return true;
	}

	protected function init($user = null)
	{
	if ($_SESSION['user_id'] \|\| $user) {
	// overwrite config with user preferences
	$this->rc->user = $user ? $user : new rcube_user($_SESSION['user_id']);
	$this->rc->config->set_user_prefs((array)$this->rc->user->get_prefs());

	$storage = $this->rc->get_storage();
	$storage->set_charset($this->rc->config->get('default_charset', RCUBE_CHARSET));

	setlocale(LC_ALL, 'en_US.utf8', 'en_US.UTF-8');
	}
	}

	+ /**
	+ * Storage driver capabilities
	+ *
	+ * @return array List of capabilities
	+ */
	+ public function capabilities()
	+ {
	+ // find max filesize value
	+ $max_filesize = parse_bytes(ini_get('upload_max_filesize'));
	+ $max_postsize = parse_bytes(ini_get('post_max_size'));
	+ if ($max_postsize && $max_postsize < $max_filesize) {
	+ $max_filesize = $max_postsize;
	+ }
	+
	+ return array(
	+ file_storage::CAPS_MAX_UPLOAD => $max_filesize,
	+ );
	+ }
	+
	/**
	* Create a file.
	*
	* @param string $file_name Name of a file (with folder path)
	* @param array $file File data (path, type)
	*
	* @throws Exception
	*/
	public function file_create($file_name, $file)
	{
	$exists = $this->get_file_object($file_name, $folder);
	if (!empty($exists)) {
	throw new Exception("Storage error. File exists.", file_api::ERROR_CODE);
	}

	$object = $this->to_file_object(array(
	'name' => $file_name,
	'type' => $file['type'],
	'path' => $file['path'],
	));

	// save the file object in IMAP
	$saved = $folder->save($object, 'file');
	if (!$saved) {
	rcube::raise_error(array(
	'code' => 600, 'type' => 'php',
	'file' => __FILE__, 'line' => __LINE__,
	'message' => "Error saving object to Kolab server"),
	true, false);

	throw new Exception("Storage error. Saving object failed.", file_api::ERROR_CODE);
	}
	}

	/**
	* Delete a file.
	*
	* @param string $file_name Name of a file (with folder path)
	*
	* @throws Exception
	*/
	public function file_delete($file_name)
	{
	$file = $this->get_file_object($file_name, $folder);
	if (empty($file)) {
	throw new Exception("Storage error. File not found.", file_api::ERROR_CODE);
	}

	$deleted = $folder->delete($file);
	if (!$deleted) {
	rcube::raise_error(array(
	'code' => 600, 'type' => 'php',
	'file' => __FILE__, 'line' => __LINE__,
	'message' => "Error deleting object from Kolab server"),
	true, false);

	throw new Exception("Storage error. Deleting object failed.", file_api::ERROR_CODE);
	}
	}

	/**
	* Return file body.
	*
	* @param string $file_name Name of a file (with folder path)
	* @param array $params Parameters (force-download)
	*
	* @throws Exception
	*/
	public function file_get($file_name, $params = array())
	{
	$file = $this->get_file_object($file_name, $folder);
	if (empty($file)) {
	throw new Exception("Storage error. File not found.", file_api::ERROR_CODE);
	}

	$file = $this->from_file_object($file);

	if (!empty($params['force-download'])) {
	$disposition = 'attachment';
	header("Content-Type: application/octet-stream");
	// @TODO
	// if ($browser->ie)
	// header("Content-Type: application/force-download");
	}
	else {
	$disposition = 'inline';
	header("Content-Transfer-Encoding: binary");
	header("Content-Type: " . $file['type']);
	}

	$filename = addcslashes($file['name'], '"');

	// Workaround for nasty IE bug (#1488844)
	// If Content-Disposition header contains string "attachment" e.g. in filename
	// IE handles data as attachment not inline
	/*
	@TODO
	if ($disposition == 'inline' && $browser->ie && $browser->ver < 9) {
	$filename = str_ireplace('attachment', 'attach', $filename);
	}
	*/
	header("Content-Length: " . $file['size']);
	header("Content-Disposition: $disposition; filename=\"$filename\"");

	$folder->get_attachment($file['_msguid'], $file['fileid'], $file['_mailbox'], true);
	}

	/**
	* Returns file metadata.
	*
	* @param string $file_name Name of a file (with folder path)
	*
	* @throws Exception
	*/
	public function file_info($file_name)
	{
	$file = $this->get_file_object($file_name, $folder);
	if (empty($file)) {
	throw new Exception("Storage error. File not found.", file_api::ERROR_CODE);
	}

	$file = $this->from_file_object($file);

	return $file;
	}

	/**
	* List files in a folder.
	*
	* @param string $folder_name Name of a folder with full path
	* @param array $params List parameters ('sort', 'reverse', 'search')
	*
	* @return array List of files (file properties array indexed by filename)
	* @throws Exception
	*/
	public function file_list($folder_name, $params = array())
	{
	$filter = array(array('type', '=', 'file'));

	if (!empty($params['search'])) {
	foreach ($params['search'] as $idx => $value) {
	switch ($idx) {
	case 'name':
	// we keep filename in 'words' column, remember?
	$filter[] = array('words', '~', $value);
	break;
	}
	}
	}

	// get files list
	$folder = $this->get_folder_object($folder_name);
	$files = $folder->select($filter);
	$result = array();

	// convert to kolab_storage files list data format
	foreach ($files as $idx => $file) {
	$file = $this->from_file_object($file);

	if (!isset($file['name'])) {
	continue;
	}

	$filename = $folder_name . file_api::PATH_SEPARATOR . $file['name'];

	$result[$filename] = array(
	'name' => $file['name'],
	'size' => (int) $file['size'],
	'type' => (string) $file['type'],
	'mtime' => $file['changed']->format($_SESSION['config']['date_format']),
	);
	unset($files[$idx]);
	}

	// @TODO: pagination, search (by filename, mimetype)

	// Sorting
	$sort = !empty($params['sort']) ? $params['sort'] : 'name';
	$index = array();

	if (in_array($sort, array('name', 'size'))) {
	foreach ($result as $key => $val) {
	$index[$key] = $val[$sort];
	}
	array_multisort($index, SORT_ASC, SORT_NUMERIC, $result);
	}
	else if ($sort == 'mtime') {
	foreach ($result as $key => $val) {
	$index[$key] = strtotime($val['mtime']);
	}
	array_multisort($index, SORT_ASC, SORT_NUMERIC, $result);
	}

	if ($params['reverse']) {
	$result = array_reverse($result, true);
	}

	return $result;
	}

	/**
	* Copy a file.
	*
	* @param string $file_name Name of a file (with folder path)
	* @param string $new_name New name of a file (with folder path)
	*
	* @throws Exception
	*/
	public function file_copy($file_name, $new_name)
	{
	$file = $this->get_file_object($file_name, $folder);
	if (empty($file)) {
	throw new Exception("Storage error. File not found.", file_api::ERROR_CODE);
	}

	$new = $this->get_file_object($new_name, $new_folder);
	if (!empty($new)) {
	throw new Exception("Storage error. File exists.", file_api::ERROR_CODE);
	}
	// @TODO
	}

	/**
	* Move (or rename) a file.
	*
	* @param string $file_name Name of a file (with folder path)
	* @param string $new_name New name of a file (with folder path)
	*
	* @throws Exception
	*/
	public function file_move($file_name, $new_name)
	{
	$file = $this->get_file_object($file_name, $folder);
	if (empty($file)) {
	throw new Exception("Storage error. File not found.", file_api::ERROR_CODE);
	}

	$new = $this->get_file_object($new_name, $new_folder);
	if (!empty($new)) {
	throw new Exception("Storage error. File exists.", file_api::ERROR_CODE);
	}

	// Move the file
	if ($folder->name != $new_folder->name) {
	$saved = $folder->move($file['uid'], $new_folder->name);
	if (!$saved) {
	rcube::raise_error(array(
	'code' => 600, 'type' => 'php',
	'file' => __FILE__, 'line' => __LINE__,
	'message' => "Error moving object on Kolab server"),
	true, false);

	throw new Exception("Storage error. File move failed.", file_api::ERROR_CODE);
	}

	$folder = $new_folder;
	}

	if ($file_name === $new_name) {
	return;
	}

	// Save to temp file
	$temp_dir = unslashify($this->rc->config->get('temp_dir'));
	$file_path = tempnam($temp_dir, 'rcmAttmnt');
	$fh = fopen($file_path, 'w');

	if (!$fh) {
	throw new Exception("Storage error. File rename failed.", file_api::ERROR_CODE);
	}

	$folder->get_attachment($file['_msguid'], $file['fileid'], $file['_mailbox'], false, $fh);
	fclose($fh);

	if (!file_exists($file_path)) {
	throw new Exception("Storage error. File rename failed.", file_api::ERROR_CODE);
	}

	// Update object (changing the name)
	$cid = key($file['_attachments']);
	$file['_attachments'][$cid]['name'] = $new_name;
	$file['_attachments'][$cid]['path'] = $file_path;
	$file['_attachments'][0] = $file['_attachments'][$cid];
	$file['_attachments'][$cid] = false;

	$saved = $folder->save($file);
	if (!$saved) {
	rcube::raise_error(array(
	'code' => 600, 'type' => 'php',
	'file' => __FILE__, 'line' => __LINE__,
	'message' => "Error updating object on Kolab server"),
	true, false);

	throw new Exception("Storage error. File rename failed.", file_api::ERROR_CODE);
	}
	}

	/**
	* Create a folder.
	*
	* @param string $folder_name Name of a folder with full path
	*
	* @throws Exception on error
	*/
	public function folder_create($folder_name)
	{
	$folder_name = rcube_charset::convert($folder_name, RCUBE_CHARSET, 'UTF7-IMAP');
	$success = kolab_storage::folder_create($folder_name, 'file');

	if (!$success) {
	throw new Exception("Storage error. Unable to create folder", file_api::ERROR_CODE);
	}
	}

	/**
	* Delete a folder.
	*
	* @param string $folder_name Name of a folder with full path
	*
	* @throws Exception on error
	*/
	public function folder_delete($folder_name)
	{
	$folder_name = rcube_charset::convert($folder_name, RCUBE_CHARSET, 'UTF7-IMAP');
	$success = kolab_storage::folder_delete($folder_name);

	if (!$success) {
	throw new Exception("Storage error. Unable to delete folder.", file_api::ERROR_CODE);
	}
	}

	/**
	* Rename a folder.
	*
	* @param string $folder_name Name of a folder with full path
	* @param string $new_name New name of a folder with full path
	*
	* @throws Exception on error
	*/
	public function folder_rename($folder_name, $new_name)
	{
	$folder_name = rcube_charset::convert($folder_name, RCUBE_CHARSET, 'UTF7-IMAP');
	$new_name = rcube_charset::convert($new_name, RCUBE_CHARSET, 'UTF7-IMAP');
	$success = kolab_storage::folder_rename($folder_name, $new_name);

	if (!$success) {
	throw new Exception("Storage error. Unable to rename folder", file_api::ERROR_CODE);
	}
	}

	/**
	* Returns list of folders.
	*
	* @return array List of folders
	* @throws Exception
	*/
	public function folder_list()
	{
	$storage = $this->rc->get_storage();
	$folders = $storage->list_folders('', '*', 'file');

	if (!is_array($folders)) {
	throw new Exception("Storage error. Unable to get folders list.", file_api::ERROR_CODE);
	}

	foreach ($folders as $folder) {
	$folder = rcube_charset::convert($folder_name, 'UTF7-IMAP', RCUBE_CHARSET);
	}

	return $folders;
	}

	/**
	* Get file object.
	*
	* @param string $file_name Name of a file (with folder path)
	* @param kolab_storage_folder $folder Reference to folder object
	*
	* @return array File data
	* @throws Exception
	*/
	protected function get_file_object(&$file_name, &$folder = null)
	{
	// extract file path and file name
	$path = explode(file_api::PATH_SEPARATOR, $file_name);
	$file_name = array_pop($path);
	$folder_name = implode(file_api::PATH_SEPARATOR, $path);

	if ($folder_name === '') {
	throw new Exception("Missing folder name", file_api::ERROR_CODE);
	}

	// get folder object
	$folder = $this->get_folder_object($folder_name);
	$files = $folder->select(array(
	array('type', '=', 'file'),
	array('words', '=', ' ' . $file_name . ' ') // @TODO: this looks like a hack
	));

	return array_shift($files);
	}

	/**
	* Get folder object.
	*
	* @param string $folder_name Name of a folder with full path
	*
	* @return kolab_storage_folder Folder object
	* @throws Exception
	*/
	protected function get_folder_object($folder_name)
	{
	if ($folder_name === null \|\| $folder_name === '') {
	throw new Exception("Missing folder name", file_api::ERROR_CODE);
	}

	if (empty($this->folders[$folder_name])) {
	$storage = $this->rc->get_storage();
	$separator = $storage->get_hierarchy_delimiter();
	$folder_name = str_replace(file_api::PATH_SEPARATOR, $separator, $folder_name);
	$imap_name = rcube_charset::convert($folder_name, RCUBE_CHARSET, 'UTF7-IMAP');
	$folder = kolab_storage::get_folder($imap_name);

	if (!$folder) {
	throw new Exception("Storage error. Folder not found.", file_api::ERROR_CODE);
	}

	$this->folders[$folder_name] = $folder;
	}

	return $this->folders[$folder_name];
	}

	/**
	* Simplify internal structure of the file object
	*/
	protected function from_file_object($file)
	{
	if (empty($file['_attachments'])) {
	return $file;
	}

	$attachment = array_shift($file['_attachments']);

	$file['name'] = $attachment['name'];
	$file['size'] = $attachment['size'];
	$file['type'] = $attachment['mimetype'];
	$file['fileid'] = $attachment['id'];

	unset($file['_attachments']);

	return $file;
	}

	/**
	* Convert to kolab_format internal structure of the file object
	*/
	protected function to_file_object($file)
	{
	// @TODO if path is empty and fileid exists it is an update
	// get attachment body and save it in path

	$file['_attachments'] = array(
	0 => array(
	'name' => $file['name'],
	'path' => $file['path'],
	'mimetype' => $file['type'],
	'size' => $file['size'],
	));

	unset($file['name']);
	unset($file['size']);
	unset($file['type']);
	unset($file['path']);
	unset($file['fileid']);

	return $file;
	}
	}

File Metadata

Mime Type: text/x-diff
Expires: Sat, Apr 4, 3:24 AM (1 d, 16 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 18822399
Default Alt Text: (40 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions