No OneTemporary
Actions

Size

870 KB

Referenced Files

None

Subscribers

None

View Options

This file is larger than 256 KB, so syntax highlighting was skipped.

	diff --git a/index.php b/index.php
	index bec39cffc..cfb397231 100644
	--- a/index.php
	+++ b/index.php
	@@ -1,332 +1,336 @@
	<?php
	/**
	+-------------------------------------------------------------------------+
	\| Roundcube Webmail IMAP Client \|
	\| Version 1.5-git \|
	\| \|
	\| Copyright (C) The Roundcube Dev Team \|
	\| \|
	\| This program is free software: you can redistribute it and/or modify \|
	\| it under the terms of the GNU General Public License (with exceptions \|
	\| for skins & plugins) as published by the Free Software Foundation, \|
	\| either version 3 of the License, or (at your option) any later version. \|
	\| \|
	\| This file forms part of the Roundcube Webmail Software for which the \|
	\| following exception is added: Plugins and Skins which merely make \|
	\| function calls to the Roundcube Webmail Software, and for that purpose \|
	\| include it by reference shall not be considered modifications of \|
	\| the software. \|
	\| \|
	\| If you wish to use this file in another project or create a modified \|
	\| version that will not be part of the Roundcube Webmail Software, you \|
	\| may remove the exception above and use this source code under the \|
	\| original version of the license. \|
	\| \|
	\| This program is distributed in the hope that it will be useful, \|
	\| but WITHOUT ANY WARRANTY; without even the implied warranty of \|
	\| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the \|
	\| GNU General Public License for more details. \|
	\| \|
	\| You should have received a copy of the GNU General Public License \|
	\| along with this program. If not, see http://www.gnu.org/licenses/. \|
	\| \|
	+-------------------------------------------------------------------------+
	\| Author: Thomas Bruederli <roundcube@gmail.com> \|
	\| Author: Aleksander Machniak <alec@alec.pl> \|
	+-------------------------------------------------------------------------+
	*/

	// include environment
	require_once 'program/include/iniset.php';

	// init application, start session, init output class, etc.
	$RCMAIL = rcmail::get_instance(0, $GLOBALS['env']);

	// Make the whole PHP output non-cacheable (#1487797)
	$RCMAIL->output->nocacheing_headers();
	$RCMAIL->output->common_headers(!empty($_SESSION['user_id']));

	// turn on output buffering
	ob_start();

	// check if config files had errors
	if ($err_str = $RCMAIL->config->get_error()) {
	rcmail::raise_error(array(
	'code' => 601,
	'type' => 'php',
	'message' => $err_str), false, true);
	}

	// check DB connections and exit on failure
	if ($err_str = $RCMAIL->db->is_error()) {
	rcmail::raise_error(array(
	'code' => 603,
	'type' => 'db',
	'message' => $err_str), false, true);
	}

	// error steps
	if ($RCMAIL->action == 'error' && !empty($_GET['_code'])) {
	rcmail::raise_error(array('code' => hexdec($_GET['_code'])), false, true);
	}

	// check if https is required (for login) and redirect if necessary
	if (empty($_SESSION['user_id']) && ($force_https = $RCMAIL->config->get('force_https', false))) {
	// force_https can be true, <hostname>, <hostname>:<port>, <port>
	if (!is_bool($force_https)) {
	list($host, $port) = explode(':', $force_https);

	if (is_numeric($host) && empty($port)) {
	$port = $host;
	$host = '';
	}
	}

	if (!rcube_utils::https_check($port ?: 443)) {
	if (empty($host)) {
	$host = preg_replace('/:[0-9]+$/', '', $_SERVER['HTTP_HOST']);
	}
	if ($port && $port != 443) {
	$host .= ':' . $port;
	}

	header('Location: https://' . $host . $_SERVER['REQUEST_URI']);
	exit;
	}
	}

	// trigger startup plugin hook
	$startup = $RCMAIL->plugins->exec_hook('startup', array('task' => $RCMAIL->task, 'action' => $RCMAIL->action));
	$RCMAIL->set_task($startup['task']);
	$RCMAIL->action = $startup['action'];

	// try to log in
	if ($RCMAIL->task == 'login' && $RCMAIL->action == 'login') {
	$request_valid = $_SESSION['temp'] && $RCMAIL->check_request();
	$pass_charset = $RCMAIL->config->get('password_charset', 'UTF-8');

	// purge the session in case of new login when a session already exists
	if ($request_valid) {
	$RCMAIL->kill_session();
	}

	$auth = $RCMAIL->plugins->exec_hook('authenticate', array(
	'host' => $RCMAIL->autoselect_host(),
	'user' => trim(rcube_utils::get_input_value('_user', rcube_utils::INPUT_POST)),
	'pass' => rcube_utils::get_input_value('_pass', rcube_utils::INPUT_POST, true, $pass_charset),
	'valid' => $request_valid,
	'cookiecheck' => true,
	));

	// Login
	if ($auth['valid'] && !$auth['abort']
	&& $RCMAIL->login($auth['user'], $auth['pass'], $auth['host'], $auth['cookiecheck'])
	) {
	// create new session ID, don't destroy the current session
	// it was destroyed already by $RCMAIL->kill_session() above
	$RCMAIL->session->remove('temp');
	$RCMAIL->session->regenerate_id(false);

	// send auth cookie if necessary
	$RCMAIL->session->set_auth_cookie();

	// log successful login
	$RCMAIL->log_login();

	// restore original request parameters
	$query = array();
	if ($url = rcube_utils::get_input_value('_url', rcube_utils::INPUT_POST)) {
	parse_str($url, $query);

	// prevent endless looping on login page
	if ($query['_task'] == 'login') {
	unset($query['_task']);
	}

	// prevent redirect to compose with specified ID (#1488226)
	- if ($query['_action'] == 'compose' && !empty($query['_id'])) {
	+ if (!empty($query['_action']) && $query['_action'] == 'compose' && !empty($query['_id'])) {
	$query = array('_action' => 'compose');
	}
	}

	// allow plugins to control the redirect url after login success
	$redir = $RCMAIL->plugins->exec_hook('login_after', $query + array('_task' => 'mail'));
	unset($redir['abort'], $redir['_err']);

	// send redirect
	$OUTPUT->redirect($redir, 0, true);
	}
	else {
	if (!$auth['valid']) {
	$error_code = rcmail::ERROR_INVALID_REQUEST;
	}
	else {
	$error_code = is_numeric($auth['error']) ? $auth['error'] : $RCMAIL->login_error();
	}

	$error_labels = array(
	rcmail::ERROR_STORAGE => 'storageerror',
	rcmail::ERROR_COOKIES_DISABLED => 'cookiesdisabled',
	rcmail::ERROR_INVALID_REQUEST => 'invalidrequest',
	rcmail::ERROR_INVALID_HOST => 'invalidhost',
	rcmail::ERROR_RATE_LIMIT => 'accountlocked',
	);

	$error_message = !empty($auth['error']) && !is_numeric($auth['error']) ? $auth['error'] : ($error_labels[$error_code] ?: 'loginfailed');

	$OUTPUT->show_message($error_message, 'warning');

	// log failed login
	$RCMAIL->log_login($auth['user'], true, $error_code);

	$RCMAIL->plugins->exec_hook('login_failed', array(
	'code' => $error_code, 'host' => $auth['host'], 'user' => $auth['user']));

	if (!isset($_SESSION['user_id'])) {
	$RCMAIL->kill_session();
	}
	}
	}

	// handle oauth login requests
	else if ($RCMAIL->task == 'login' && $RCMAIL->action == 'oauth' && $RCMAIL->oauth->is_enabled()) {
	include INSTALL_PATH . 'program/steps/login/oauth.inc';
	}

	// end session
	else if ($RCMAIL->task == 'logout' && isset($_SESSION['user_id'])) {
	$RCMAIL->request_security_check(rcube_utils::INPUT_GET \| rcube_utils::INPUT_POST);

	$userdata = array(
	'user' => $_SESSION['username'],
	'host' => $_SESSION['storage_host'],
	'lang' => $RCMAIL->user->language,
	);

	$OUTPUT->show_message('loggedout');

	$RCMAIL->logout_actions();
	$RCMAIL->kill_session();
	$RCMAIL->plugins->exec_hook('logout_after', $userdata);
	}

	// check session and auth cookie
	else if ($RCMAIL->task != 'login' && $_SESSION['user_id']) {
	if (!$RCMAIL->session->check_auth()) {
	$RCMAIL->kill_session();
	$session_error = 'sessionerror';
	}
	}

	// not logged in -> show login page
	if (empty($RCMAIL->user->ID)) {
	- if ($session_error \|\| $_REQUEST['_err'] === 'session' \|\| ($session_error = $RCMAIL->session_error())) {
	+ if (
	+ !empty($session_error)
	+ \|\| (!empty($_REQUEST['_err']) && $_REQUEST['_err'] === 'session')
	+ \|\| ($session_error = $RCMAIL->session_error())
	+ ) {
	$OUTPUT->show_message($session_error ?: 'sessionerror', 'error', null, true, -1);
	}

	if ($OUTPUT->ajax_call \|\| $OUTPUT->get_env('framed')) {
	$OUTPUT->command('session_error', $RCMAIL->url(array('_err' => 'session')));
	$OUTPUT->send('iframe');
	}

	// check if installer is still active
	if ($RCMAIL->config->get('enable_installer') && is_readable('./installer/index.php')) {
	$OUTPUT->add_footer(html::div(array('id' => 'login-addon', 'style' => "background:#ef9398; border:2px solid #dc5757; padding:0.5em; margin:2em auto; width:50em"),
	html::tag('h2', array('style' => "margin-top:0.2em"), "Installer script is still accessible") .
	html::p(null, "The install script of your Roundcube installation is still stored in its default location!") .
	html::p(null, "Please <b>remove</b> the whole <tt>installer</tt> folder from the Roundcube directory because
	these files may expose sensitive configuration data like server passwords and encryption keys
	to the public. Make sure you cannot access the <a href=\"./installer/\">installer script</a> from your browser.")
	));
	}

	$plugin = $RCMAIL->plugins->exec_hook('unauthenticated', array(
	'task' => 'login',
	'error' => $session_error,
	// Return 401 only on failed logins (#7010)
	'http_code' => empty($session_error) && !empty($error_message) ? 401 : 200
	));

	$RCMAIL->set_task($plugin['task']);

	if ($plugin['http_code'] == 401) {
	header('HTTP/1.0 401 Unauthorized');
	}

	$OUTPUT->send($plugin['task']);
	}
	else {
	// CSRF prevention
	$RCMAIL->request_security_check();

	// check access to disabled actions
	$disabled_actions = (array) $RCMAIL->config->get('disabled_actions');
	if (in_array($RCMAIL->task . '.' . ($RCMAIL->action ?: 'index'), $disabled_actions)) {
	rcube::raise_error(array(
	'code' => 404, 'type' => 'php',
	'message' => "Action disabled"), true, true);
	}
	}

	// we're ready, user is authenticated and the request is safe
	$plugin = $RCMAIL->plugins->exec_hook('ready', array('task' => $RCMAIL->task, 'action' => $RCMAIL->action));
	$RCMAIL->set_task($plugin['task']);
	$RCMAIL->action = $plugin['action'];

	// handle special actions
	if ($RCMAIL->action == 'keep-alive') {
	$OUTPUT->reset();
	$RCMAIL->plugins->exec_hook('keep_alive', array());
	$OUTPUT->send();
	}
	else if ($RCMAIL->action == 'save-pref') {
	include INSTALL_PATH . 'program/steps/utils/save_pref.inc';
	}


	// include task specific functions
	if (is_file($incfile = INSTALL_PATH . 'program/steps/'.$RCMAIL->task.'/func.inc')) {
	include_once $incfile;
	}

	// allow 5 "redirects" to another action
	$redirects = 0;
	while ($redirects < 5) {
	// execute a plugin action
	if (preg_match('/^plugin\./', $RCMAIL->action)) {
	$RCMAIL->plugins->exec_action($RCMAIL->action);
	break;
	}
	// execute action registered to a plugin task
	else if ($RCMAIL->plugins->is_plugin_task($RCMAIL->task)) {
	if (!$RCMAIL->action) $RCMAIL->action = 'index';
	$RCMAIL->plugins->exec_action($RCMAIL->task.'.'.$RCMAIL->action);
	break;
	}
	// try to include the step file
	else if (($stepfile = $RCMAIL->get_action_file())
	&& is_file($incfile = INSTALL_PATH . 'program/steps/'.$RCMAIL->task.'/'.$stepfile)
	) {
	// include action file only once (in case it don't exit)
	include_once $incfile;
	$redirects++;
	}
	else {
	break;
	}
	}

	if ($RCMAIL->action == 'refresh') {
	$RCMAIL->plugins->exec_hook('refresh', array('last' => intval(rcube_utils::get_input_value('_last', rcube_utils::INPUT_GPC))));
	}

	// parse main template (default)
	$OUTPUT->send($RCMAIL->task);

	// if we arrive here, something went wrong
	rcmail::raise_error(array(
	'code' => 404,
	'type' => 'php',
	'line' => __LINE__,
	'file' => __FILE__,
	'message' => "Invalid request"), true, true);
	diff --git a/plugins/enigma/lib/enigma_engine.php b/plugins/enigma/lib/enigma_engine.php
	index 90ca606b7..06e0cac09 100644
	--- a/plugins/enigma/lib/enigma_engine.php
	+++ b/plugins/enigma/lib/enigma_engine.php
	@@ -1,1437 +1,1439 @@
	<?php

	/**
	+-------------------------------------------------------------------------+
	\| Engine of the Enigma Plugin \|
	\| \|
	\| Copyright (C) The Roundcube Dev Team \|
	\| \|
	\| Licensed under the GNU General Public License version 3 or \|
	\| any later version with exceptions for skins & plugins. \|
	\| See the README file for a full license statement. \|
	+-------------------------------------------------------------------------+
	\| Author: Aleksander Machniak <alec@alec.pl> \|
	+-------------------------------------------------------------------------+
	*/

	/**
	* Enigma plugin engine.
	*
	* RFC2440: OpenPGP Message Format
	* RFC3156: MIME Security with OpenPGP
	* RFC3851: S/MIME
	*/
	class enigma_engine
	{
	private $rc;
	private $enigma;
	private $pgp_driver;
	private $smime_driver;
	private $password_time;
	private $cache = array();

	public $decryptions = array();
	public $signatures = array();
	public $encrypted_parts = array();

	const ENCRYPTED_PARTIALLY = 100;

	const SIGN_MODE_BODY = 1;
	const SIGN_MODE_SEPARATE = 2;
	const SIGN_MODE_MIME = 4;

	const ENCRYPT_MODE_BODY = 1;
	const ENCRYPT_MODE_MIME = 2;
	const ENCRYPT_MODE_SIGN = 4;


	/**
	* Plugin initialization.
	*/
	function __construct($enigma)
	{
	$this->rc = rcmail::get_instance();
	$this->enigma = $enigma;

	$this->password_time = $this->rc->config->get('enigma_password_time') * 60;

	// this will remove passwords from session after some time
	if ($this->password_time) {
	$this->get_passwords();
	}
	}

	/**
	* PGP driver initialization.
	*/
	function load_pgp_driver()
	{
	if ($this->pgp_driver) {
	return;
	}

	$driver = 'enigma_driver_' . $this->rc->config->get('enigma_pgp_driver', 'gnupg');
	$username = $this->rc->user->get_username();

	// Load driver
	$this->pgp_driver = new $driver($username);

	if (!$this->pgp_driver) {
	rcube::raise_error(array(
	'code' => 600, 'type' => 'php',
	'file' => __FILE__, 'line' => __LINE__,
	'message' => "Enigma plugin: Unable to load PGP driver: $driver"
	), true, true);
	}

	// Initialise driver
	$result = $this->pgp_driver->init();

	if ($result instanceof enigma_error) {
	self::raise_error($result, __LINE__, true);
	}
	}

	/**
	* S/MIME driver initialization.
	*/
	function load_smime_driver()
	{
	if ($this->smime_driver) {
	return;
	}

	$driver = 'enigma_driver_' . $this->rc->config->get('enigma_smime_driver', 'phpssl');
	$username = $this->rc->user->get_username();

	// Load driver
	$this->smime_driver = new $driver($username);

	if (!$this->smime_driver) {
	rcube::raise_error(array(
	'code' => 600, 'type' => 'php',
	'file' => __FILE__, 'line' => __LINE__,
	'message' => "Enigma plugin: Unable to load S/MIME driver: $driver"
	), true, true);
	}

	// Initialise driver
	$result = $this->smime_driver->init();

	if ($result instanceof enigma_error) {
	self::raise_error($result, __LINE__, true);
	}
	}

	/**
	* Handler for message signing
	*
	* @param Mail_mime Original message
	* @param int Encryption mode
	*
	* @return enigma_error On error returns error object
	*/
	function sign_message(&$message, $mode = null)
	{
	$mime = new enigma_mime_message($message, enigma_mime_message::PGP_SIGNED);
	$from = $mime->getFromAddress();

	// find private key
	$key = $this->find_key($from, true);

	if (empty($key)) {
	return new enigma_error(enigma_error::KEYNOTFOUND);
	}

	// check if we have password for this key
	$passwords = $this->get_passwords();
	$pass = $passwords[$key->id];

	if ($pass === null) {
	// ask for password
	$error = array('missing' => array($key->id => $key->name));
	return new enigma_error(enigma_error::BADPASS, '', $error);
	}

	$key->password = $pass;

	// select mode
	switch ($mode) {
	case self::SIGN_MODE_BODY:
	$pgp_mode = Crypt_GPG::SIGN_MODE_CLEAR;
	break;

	case self::SIGN_MODE_MIME:
	$pgp_mode = Crypt_GPG::SIGN_MODE_DETACHED;
	break;

	default:
	if ($mime->isMultipart()) {
	$pgp_mode = Crypt_GPG::SIGN_MODE_DETACHED;
	}
	else {
	$pgp_mode = Crypt_GPG::SIGN_MODE_CLEAR;
	}
	}

	// get message body
	if ($pgp_mode == Crypt_GPG::SIGN_MODE_CLEAR) {
	// in this mode we'll replace text part
	// with the one containing signature
	$body = $message->getTXTBody();

	$text_charset = $message->getParam('text_charset');
	$line_length = $this->rc->config->get('line_length', 72);

	// We can't use format=flowed for signed messages
	if (strpos($text_charset, 'format=flowed')) {
	list($charset, $params) = explode(';', $text_charset);
	$body = rcube_mime::unfold_flowed($body);
	$body = rcube_mime::wordwrap($body, $line_length, "\r\n", false, $charset);

	$text_charset = str_replace(";\r\n format=flowed", '', $text_charset);
	}
	}
	else {
	// here we'll build PGP/MIME message
	$body = $mime->getOrigBody();
	}

	// sign the body
	$result = $this->pgp_sign($body, $key, $pgp_mode);

	if ($result !== true) {
	if ($result->getCode() == enigma_error::BADPASS) {
	// ask for password
	$error = array('bad' => array($key->id => $key->name));
	return new enigma_error(enigma_error::BADPASS, '', $error);
	}

	return $result;
	}

	// replace message body
	if ($pgp_mode == Crypt_GPG::SIGN_MODE_CLEAR) {
	$message->setTXTBody($body);
	if (!empty($text_charset)) {
	$message->setParam('text_charset', $text_charset);
	}
	}
	else {
	$mime->addPGPSignature($body, $this->pgp_driver->signature_algorithm());
	$message = $mime;
	}
	}

	/**
	* Handler for message encryption
	*
	* @param Mail_mime Original message
	* @param int Encryption mode
	* @param bool Is draft-save action - use only sender's key for encryption
	*
	* @return enigma_error On error returns error object
	*/
	function encrypt_message(&$message, $mode = null, $is_draft = false)
	{
	$mime = new enigma_mime_message($message, enigma_mime_message::PGP_ENCRYPTED);

	// always use sender's key
	$from = $mime->getFromAddress();

	$sign_key = null;
	$keys = array();

	// check senders key for signing
	if ($mode & self::ENCRYPT_MODE_SIGN) {
	$sign_key = $this->find_key($from, true);

	if (empty($sign_key)) {
	return new enigma_error(enigma_error::KEYNOTFOUND);
	}

	// check if we have password for this key
	$passwords = $this->get_passwords();
	$sign_pass = $passwords[$sign_key->id];

	if ($sign_pass === null) {
	// ask for password
	$error = array('missing' => array($sign_key->id => $sign_key->name));
	return new enigma_error(enigma_error::BADPASS, '', $error);
	}

	$sign_key->password = $sign_pass;
	}

	$recipients = array($from);

	// if it's not a draft we add all recipients' keys
	if (!$is_draft) {
	$recipients = array_merge($recipients, $mime->getRecipients());
	}

	$recipients = array_unique($recipients);

	// find recipient public keys
	foreach ((array) $recipients as $email) {
	if ($email == $from && $sign_key) {
	$key = $sign_key;
	}
	else {
	$key = $this->find_key($email);
	}

	if (empty($key)) {
	return new enigma_error(enigma_error::KEYNOTFOUND, '', array(
	'missing' => $email
	));
	}

	$keys[] = $key;
	}

	// select mode
	if ($mode & self::ENCRYPT_MODE_BODY) {
	$encrypt_mode = $mode;
	}
	else if ($mode & self::ENCRYPT_MODE_MIME) {
	$encrypt_mode = $mode;
	}
	else {
	$encrypt_mode = $mime->isMultipart() ? self::ENCRYPT_MODE_MIME : self::ENCRYPT_MODE_BODY;
	}

	// get message body
	if ($encrypt_mode == self::ENCRYPT_MODE_BODY) {
	// in this mode we'll replace text part
	// with the one containing encrypted message
	$body = $message->getTXTBody();
	}
	else {
	// here we'll build PGP/MIME message
	$body = $mime->getOrigBody();
	}

	// sign the body
	$result = $this->pgp_encrypt($body, $keys, $sign_key);

	if ($result !== true) {
	if ($result->getCode() == enigma_error::BADPASS) {
	// ask for password
	$error = array('bad' => array($sign_key->id => $sign_key->name));
	return new enigma_error(enigma_error::BADPASS, '', $error);
	}

	return $result;
	}

	// replace message body
	if ($encrypt_mode == self::ENCRYPT_MODE_BODY) {
	$message->setTXTBody($body);
	}
	else {
	$mime->setPGPEncryptedBody($body);
	$message = $mime;
	}
	}

	/**
	* Handler for attaching public key to a message
	*
	* @param Mail_mime Original message
	*
	* @return bool True on success, False on failure
	*/
	function attach_public_key(&$message)
	{
	$headers = $message->headers();
	$from = rcube_mime::decode_address_list($headers['From'], 1, false, null, true);
	$from = $from[1];

	// find my key
	if ($from && ($key = $this->find_key($from, true))) {
	$pubkey_armor = $this->export_key($key->id);

	if (!$pubkey_armor instanceof enigma_error) {
	$pubkey_name = '0x' . enigma_key::format_id($key->id) . '.asc';
	$message->addAttachment($pubkey_armor, 'application/pgp-keys', $pubkey_name, false, '7bit');
	return true;
	}
	}

	return false;
	}

	/**
	* Handler for message_part_structure hook.
	* Called for every part of the message.
	*
	* @param array Original parameters
	* @param string Part body (will be set if used internally)
	*
	* @return array Modified parameters
	*/
	function part_structure($p, $body = null)
	{
	static $got_content = false;

	// Prevent from "decryption oracle" [CVE-2019-10740] (#6638)
	// On mail compose (edit/reply/forward) we support encrypted content only
	// in the first "content part" of the message.
	if ($got_content && $this->rc->task == 'mail' && $this->rc->action == 'compose') {
	return;
	}

	// Don't be tempted to support encryption in text/html parts
	// Because of EFAIL vulnerability we should never support this (#6289)

	if ($p['mimetype'] == 'text/plain' \|\| $p['mimetype'] == 'application/pgp') {
	$this->parse_plain($p, $body);
	$got_content = true;
	}
	else if ($p['mimetype'] == 'multipart/signed') {
	$this->parse_signed($p, $body);
	$got_content = true;
	}
	else if ($p['mimetype'] == 'multipart/encrypted') {
	$this->parse_encrypted($p);
	$got_content = true;
	}
	else if ($p['mimetype'] == 'application/pkcs7-mime') {
	$this->parse_encrypted($p);
	$got_content = true;
	}
	else {
	$got_content = $p['structure']->type === 'content';
	}

	return $p;
	}

	/**
	* Handler for message_part_body hook.
	*
	* @param array Original parameters
	*
	* @return array Modified parameters
	*/
	function part_body($p)
	{
	// encrypted attachment, see parse_plain_encrypted()
	if ($p['part']->need_decryption && $p['part']->body === null) {
	$this->load_pgp_driver();

	$storage = $this->rc->get_storage();
	$body = $storage->get_message_part($p['object']->uid, $p['part']->mime_id, $p['part'], null, null, true, 0, false);
	$result = $this->pgp_decrypt($body);

	// @TODO: what to do on error?
	if ($result === true) {
	$p['part']->body = $body;
	$p['part']->size = strlen($body);
	$p['part']->body_modified = true;
	}
	}

	return $p;
	}

	/**
	* Handler for plain/text message.
	*
	* @param array Reference to hook's parameters
	* @param string Part body (will be set if used internally)
	*/
	function parse_plain(&$p, $body = null)
	{
	$part = $p['structure'];

	// Get message body from IMAP server
	if ($body === null) {
	$body = $this->get_part_body($p['object'], $part);
	}

	// In this way we can use fgets on string as on file handle
	// Don't use php://temp for security (body may come from an encrypted part)
	$fd = fopen('php://memory', 'r+');
	if (!$fd) {
	return;
	}

	fwrite($fd, $body);
	rewind($fd);

	$body = '';
	$prefix = '';
	$mode = '';
	$tokens = array(
	'BEGIN PGP SIGNED MESSAGE' => 'signed-start',
	'END PGP SIGNATURE' => 'signed-end',
	'BEGIN PGP MESSAGE' => 'encrypted-start',
	'END PGP MESSAGE' => 'encrypted-end',
	);
	$regexp = '/^-----(' . implode('\|', array_keys($tokens)) . ')-----[\r\n]*/';

	while (($line = fgets($fd)) !== false) {
	if ($line[0] === '-' && $line[4] === '-' && preg_match($regexp, $line, $m)) {
	switch ($tokens[$m[1]]) {
	case 'signed-start':
	$body = $line;
	$mode = 'signed';
	break;

	case 'signed-end':
	if ($mode === 'signed') {
	$body .= $line;
	}
	break 2; // ignore anything after this line

	case 'encrypted-start':
	$body = $line;
	$mode = 'encrypted';
	break;

	case 'encrypted-end':
	if ($mode === 'encrypted') {
	$body .= $line;
	}
	break 2; // ignore anything after this line
	}

	continue;
	}

	if ($mode === 'signed') {
	$body .= $line;
	}
	else if ($mode === 'encrypted') {
	$body .= $line;
	}
	else {
	$prefix .= $line;
	}
	}

	fclose($fd);

	if ($mode === 'signed') {
	$this->parse_plain_signed($p, $body, $prefix);
	}
	else if ($mode === 'encrypted') {
	$this->parse_plain_encrypted($p, $body, $prefix);
	}
	}

	/**
	* Handler for multipart/signed message.
	*
	* @param array Reference to hook's parameters
	* @param string Part body (will be set if used internally)
	*/
	function parse_signed(&$p, $body = null)
	{
	$struct = $p['structure'];

	// S/MIME
	if ($struct->parts[1] && $struct->parts[1]->mimetype == 'application/pkcs7-signature') {
	$this->parse_smime_signed($p, $body);
	}
	// PGP/MIME: RFC3156
	// The multipart/signed body MUST consist of exactly two parts.
	// The first part contains the signed data in MIME canonical format,
	// including a set of appropriate content headers describing the data.
	// The second body MUST contain the PGP digital signature. It MUST be
	// labeled with a content type of "application/pgp-signature".
	else if (count($struct->parts) == 2
	&& $struct->parts[1] && $struct->parts[1]->mimetype == 'application/pgp-signature'
	) {
	$this->parse_pgp_signed($p, $body);
	}
	}

	/**
	* Handler for multipart/encrypted message.
	*
	* @param array Reference to hook's parameters
	*/
	function parse_encrypted(&$p)
	{
	$struct = $p['structure'];

	// S/MIME
	if ($p['mimetype'] == 'application/pkcs7-mime') {
	$this->parse_smime_encrypted($p);
	}
	// PGP/MIME: RFC3156
	// The multipart/encrypted MUST consist of exactly two parts. The first
	// MIME body part must have a content type of "application/pgp-encrypted".
	// This body contains the control information.
	// The second MIME body part MUST contain the actual encrypted data. It
	// must be labeled with a content type of "application/octet-stream".
	else if (count($struct->parts) == 2
	&& $struct->parts[0] && $struct->parts[0]->mimetype == 'application/pgp-encrypted'
	&& $struct->parts[1] && $struct->parts[1]->mimetype == 'application/octet-stream'
	) {
	$this->parse_pgp_encrypted($p);
	}
	}

	/**
	* Handler for plain signed message.
	* Excludes message and signature bodies and verifies signature.
	*
	* @param array Reference to hook's parameters
	* @param string Message (part) body
	* @param string Body prefix (additional text before the encrypted block)
	*/
	private function parse_plain_signed(&$p, $body, $prefix = '')
	{
	if (!$this->rc->config->get('enigma_signatures', true)) {
	return;
	}

	$this->load_pgp_driver();
	$part = $p['structure'];

	// Verify signature
	if ($this->rc->action == 'show' \|\| $this->rc->action == 'preview' \|\| $this->rc->action == 'print') {
	$sig = $this->pgp_verify($body);
	}

	// In this way we can use fgets on string as on file handle
	// Don't use php://temp for security (body may come from an encrypted part)
	$fd = fopen('php://memory', 'r+');
	if (!$fd) {
	return;
	}

	fwrite($fd, $body);
	rewind($fd);

	$body = $part->body = null;
	$part->body_modified = true;

	// Extract body (and signature?)
	while (($line = fgets($fd, 1024)) !== false) {
	if ($part->body === null)
	$part->body = '';
	else if (preg_match('/^-----BEGIN PGP SIGNATURE-----/', $line))
	break;
	else
	$part->body .= $line;
	}

	fclose($fd);

	// Remove "Hash" Armor Headers
	$part->body = preg_replace('/^.\r\n\r*\n/', '', $part->body);
	// de-Dash-Escape (RFC2440)
	$part->body = preg_replace('/(^\|\n)- -/', '\\1-', $part->body);

	if ($prefix) {
	$part->body = $prefix . $part->body;
	}

	// Store signature data for display
	if (!empty($sig)) {
	$sig->partial = !empty($prefix);
	$this->signatures[$part->mime_id] = $sig;
	}
	}

	/**
	* Handler for PGP/MIME signed message.
	* Verifies signature.
	*
	* @param array Reference to hook's parameters
	* @param string Part body (will be set if used internally)
	*/
	private function parse_pgp_signed(&$p, $body = null)
	{
	if (!$this->rc->config->get('enigma_signatures', true)) {
	return;
	}

	if ($this->rc->action != 'show' && $this->rc->action != 'preview' && $this->rc->action != 'print') {
	return;
	}

	$this->load_pgp_driver();
	$struct = $p['structure'];

	$msg_part = $struct->parts[0];
	$sig_part = $struct->parts[1];

	// Get bodies
	if ($body === null) {
	if (!$struct->body_modified) {
	$body = $this->get_part_body($p['object'], $struct);
	}
	}

	$boundary = $struct->ctype_parameters['boundary'];

	// when it is a signed message forwarded as attachment
	// ctype_parameters property will not be set
	if (!$boundary && $struct->headers['content-type']
	&& preg_match('/boundary="?([a-zA-Z0-9\'()+_,-.\/:=?]+)"?/', $struct->headers['content-type'], $m)
	) {
	$boundary = $m[1];
	}

	// set signed part body
	list($msg_body, $sig_body) = $this->explode_signed_body($body, $boundary);

	// Verify
	if ($sig_body && $msg_body) {
	$sig = $this->pgp_verify($msg_body, $sig_body);

	// Store signature data for display
	$this->signatures[$struct->mime_id] = $sig;
	$this->signatures[$msg_part->mime_id] = $sig;
	}
	}

	/**
	* Handler for S/MIME signed message.
	* Verifies signature.
	*
	* @param array Reference to hook's parameters
	* @param string Part body (will be set if used internally)
	*/
	private function parse_smime_signed(&$p, $body = null)
	{
	if (!$this->rc->config->get('enigma_signatures', true)) {
	return;
	}

	// @TODO
	}

	/**
	* Handler for plain encrypted message.
	*
	* @param array Reference to hook's parameters
	* @param string Message (part) body
	* @param string Body prefix (additional text before the encrypted block)
	*/
	private function parse_plain_encrypted(&$p, $body, $prefix = '')
	{
	if (!$this->rc->config->get('enigma_decryption', true)) {
	return;
	}

	$this->load_pgp_driver();
	$part = $p['structure'];

	// Decrypt
	$result = $this->pgp_decrypt($body, $signature);

	// Store decryption status
	$this->decryptions[$part->mime_id] = $result;

	// Store signature data for display
	if ($signature) {
	$this->signatures[$part->mime_id] = $signature;
	}

	// find parent part ID
	if (strpos($part->mime_id, '.')) {
	$items = explode('.', $part->mime_id);
	array_pop($items);
	$parent = implode('.', $items);
	}
	else {
	$parent = 0;
	}

	// Parse decrypted message
	if ($result === true) {
	$part->body = $prefix . $body;
	$part->body_modified = true;

	// it maybe PGP signed inside, verify signature
	$this->parse_plain($p, $body);

	// Remember it was decrypted
	$this->encrypted_parts[] = $part->mime_id;

	// Inform the user that only a part of the body was encrypted
	if ($prefix) {
	$this->decryptions[$part->mime_id] = self::ENCRYPTED_PARTIALLY;
	}

	// Encrypted plain message may contain encrypted attachments
	// in such case attachments have .pgp extension and type application/octet-stream.
	// This is what happens when you select "Encrypt each attachment separately
	// and send the message using inline PGP" in Thunderbird's Enigmail.

	if ($p['object']->mime_parts[$parent]) {
	foreach ((array)$p['object']->mime_parts[$parent]->parts as $p) {
	if ($p->disposition == 'attachment' && $p->mimetype == 'application/octet-stream'
	&& preg_match('/^(.*)\.pgp$/i', $p->filename, $m)
	) {
	// modify filename
	$p->filename = $m[1];
	// flag the part, it will be decrypted when needed
	$p->need_decryption = true;
	// disable caching
	$p->body_modified = true;
	}
	}
	}
	}
	// decryption failed, but the message may have already
	// been cached with the modified parts (see above),
	// let's bring the original state back
	else if ($p['object']->mime_parts[$parent]) {
	foreach ((array)$p['object']->mime_parts[$parent]->parts as $p) {
	if ($p->need_decryption && !preg_match('/^(.*)\.pgp$/i', $p->filename, $m)) {
	// modify filename
	$p->filename .= '.pgp';
	// flag the part, it will be decrypted when needed
	unset($p->need_decryption);
	}
	}
	}
	}

	/**
	* Handler for PGP/MIME encrypted message.
	*
	* @param array Reference to hook's parameters
	*/
	private function parse_pgp_encrypted(&$p)
	{
	if (!$this->rc->config->get('enigma_decryption', true)) {
	return;
	}

	$this->load_pgp_driver();

	$struct = $p['structure'];
	$part = $struct->parts[1];

	// Get body
	$body = $this->get_part_body($p['object'], $part);

	// Decrypt
	$result = $this->pgp_decrypt($body, $signature);

	if ($result === true) {
	// Parse decrypted message
	$struct = $this->parse_body($body);

	// Modify original message structure
	$this->modify_structure($p, $struct, strlen($body));

	// Parse the structure (there may be encrypted/signed parts inside
	$this->part_structure(array(
	'object' => $p['object'],
	'structure' => $struct,
	'mimetype' => $struct->mimetype
	), $body);

	// Attach the decryption message to all parts
	$this->decryptions[$struct->mime_id] = $result;
	foreach ((array) $struct->parts as $sp) {
	$this->decryptions[$sp->mime_id] = $result;
	if ($signature) {
	$this->signatures[$sp->mime_id] = $signature;
	}
	}
	}
	else {
	$this->decryptions[$part->mime_id] = $result;

	// Make sure decryption status message will be displayed
	$part->type = 'content';
	$p['object']->parts[] = $part;

	// don't show encrypted part on attachments list
	// don't show "cannot display encrypted message" text
	$p['abort'] = true;
	}
	}

	/**
	* Handler for S/MIME encrypted message.
	*
	* @param array Reference to hook's parameters
	*/
	private function parse_smime_encrypted(&$p)
	{
	if (!$this->rc->config->get('enigma_decryption', true)) {
	return;
	}

	// @TODO
	}

	/**
	* PGP signature verification.
	*
	* @param mixed Message body
	* @param mixed Signature body (for MIME messages)
	*
	* @return mixed enigma_signature or enigma_error
	*/
	private function pgp_verify(&$msg_body, $sig_body = null)
	{
	// @TODO: Handle big bodies using (temp) files
	$sig = $this->pgp_driver->verify($msg_body, $sig_body);

	if (($sig instanceof enigma_error) && $sig->getCode() != enigma_error::KEYNOTFOUND) {
	self::raise_error($sig, __LINE__);
	}

	return $sig;
	}

	/**
	* PGP message decryption.
	*
	* @param mixed &$msg_body Message body
	* @param enigma_signature &$signature Signature verification result
	*
	* @return mixed True or enigma_error
	*/
	private function pgp_decrypt(&$msg_body, &$signature = null)
	{
	// @TODO: Handle big bodies using (temp) files
	$keys = $this->get_passwords();
	$result = $this->pgp_driver->decrypt($msg_body, $keys, $signature);

	if ($result instanceof enigma_error) {
	if ($result->getCode() != enigma_error::KEYNOTFOUND) {
	self::raise_error($result, __LINE__);
	}

	return $result;
	}

	$msg_body = $result;

	return true;
	}

	/**
	* PGP message signing
	*
	* @param mixed Message body
	* @param enigma_key The key (with passphrase)
	* @param int Signing mode
	*
	* @return mixed True or enigma_error
	*/
	private function pgp_sign(&$msg_body, $key, $mode = null)
	{
	// @TODO: Handle big bodies using (temp) files
	$result = $this->pgp_driver->sign($msg_body, $key, $mode);

	if ($result instanceof enigma_error) {
	if ($result->getCode() != enigma_error::KEYNOTFOUND) {
	self::raise_error($result, __LINE__);
	}

	return $result;
	}

	$msg_body = $result;

	return true;
	}

	/**
	* PGP message encrypting
	*
	* @param mixed Message body
	* @param array Keys (array of enigma_key objects)
	* @param string Optional signing Key ID
	* @param string Optional signing Key password
	*
	* @return mixed True or enigma_error
	*/
	private function pgp_encrypt(&$msg_body, $keys, $sign_key = null, $sign_pass = null)
	{
	// @TODO: Handle big bodies using (temp) files
	$result = $this->pgp_driver->encrypt($msg_body, $keys, $sign_key, $sign_pass);

	if ($result instanceof enigma_error) {
	if ($result->getCode() != enigma_error::KEYNOTFOUND) {
	self::raise_error($result, __LINE__);
	}

	return $result;
	}

	$msg_body = $result;

	return true;
	}

	/**
	* PGP keys listing.
	*
	* @param mixed Key ID/Name pattern
	*
	* @return mixed Array of keys or enigma_error
	*/
	function list_keys($pattern = '')
	{
	$this->load_pgp_driver();
	$result = $this->pgp_driver->list_keys($pattern);

	if ($result instanceof enigma_error) {
	self::raise_error($result, __LINE__);
	}

	return $result;
	}

	/**
	* Find PGP private/public key
	*
	* @param string E-mail address
	* @param bool Need a key for signing?
	*
	* @return enigma_key The key
	*/
	function find_key($email, $can_sign = false)
	{
	if ($can_sign && array_key_exists($email, $this->cache)) {
	return $this->cache[$email];
	}

	$this->load_pgp_driver();
	$result = $this->pgp_driver->list_keys($email);

	if ($result instanceof enigma_error) {
	self::raise_error($result, __LINE__);
	return;
	}

	$mode = $can_sign ? enigma_key::CAN_SIGN : enigma_key::CAN_ENCRYPT;
	$ret = null;

	// check key validity and type
	foreach ($result as $key) {
	if (($subkey = $key->find_subkey($email, $mode))
	&& (!$can_sign \|\| $key->get_type() == enigma_key::TYPE_KEYPAIR)
	) {
	$ret = $key;
	break;
	}
	}

	// cache private key info for better performance
	// we can skip one list_keys() call when signing and attaching a key
	if ($can_sign) {
	$this->cache[$email] = $ret;
	}

	return $ret;
	}

	/**
	* PGP key details.
	*
	* @param mixed Key ID
	*
	* @return mixed enigma_key or enigma_error
	*/
	function get_key($keyid)
	{
	$this->load_pgp_driver();
	$result = $this->pgp_driver->get_key($keyid);

	if ($result instanceof enigma_error) {
	self::raise_error($result, __LINE__);
	}

	return $result;
	}

	/**
	* PGP key delete.
	*
	* @param string Key ID
	*
	* @return enigma_error\|bool True on success
	*/
	function delete_key($keyid)
	{
	$this->load_pgp_driver();
	$result = $this->pgp_driver->delete_key($keyid);

	if ($result instanceof enigma_error) {
	self::raise_error($result, __LINE__);
	}

	return $result;
	}

	/**
	* PGP keys pair generation.
	*
	* @param array Key pair parameters
	*
	* @return mixed enigma_key or enigma_error
	*/
	function generate_key($data)
	{
	$this->load_pgp_driver();
	$result = $this->pgp_driver->gen_key($data);

	if ($result instanceof enigma_error) {
	self::raise_error($result, __LINE__);
	}

	return $result;
	}

	/**
	* PGP keys/certs import.
	*
	* @param mixed Import file name or content
	* @param boolean True if first argument is a filename
	*
	* @return mixed Import status data array or enigma_error
	*/
	function import_key($content, $isfile = false)
	{
	$this->load_pgp_driver();
	$result = $this->pgp_driver->import($content, $isfile, $this->get_passwords());

	if ($result instanceof enigma_error) {
	self::raise_error($result, __LINE__);
	}
	else {
	$result['imported'] = $result['public_imported'] + $result['private_imported'];
	$result['unchanged'] = $result['public_unchanged'] + $result['private_unchanged'];
	}

	return $result;
	}

	/**
	* PGP keys/certs export.
	*
	* @param string Key ID
	* @param resource Optional output stream
	* @param bool Include private key
	*
	* @return mixed Key content or enigma_error
	*/
	function export_key($key, $fp = null, $include_private = false)
	{
	$this->load_pgp_driver();
	$result = $this->pgp_driver->export($key, $include_private, $this->get_passwords());

	if ($result instanceof enigma_error) {
	self::raise_error($result, __LINE__);
	return $result;
	}

	if ($fp) {
	fwrite($fp, $result);
	}
	else {
	return $result;
	}
	}

	/**
	* Registers password for specified key/cert sent by the password prompt.
	*/
	function password_handler()
	{
	$keyid = rcube_utils::get_input_value('_keyid', rcube_utils::INPUT_POST);
	$passwd = rcube_utils::get_input_value('_passwd', rcube_utils::INPUT_POST, true);

	if ($keyid && $passwd !== null && strlen($passwd)) {
	$this->save_password(strtoupper($keyid), $passwd);
	}
	}

	/**
	* Saves key/cert password in user session
	*/
	function save_password($keyid, $password)
	{
	// we store passwords in session for specified time
	if ($config = $_SESSION['enigma_pass']) {
	$config = $this->rc->decrypt($config);
	$config = @unserialize($config);
	}

	$config[$keyid] = array($password, time());

	$_SESSION['enigma_pass'] = $this->rc->encrypt(serialize($config));
	}

	/**
	* Returns currently stored passwords
	*/
	function get_passwords()
	{
	- if ($config = $_SESSION['enigma_pass']) {
	- $config = $this->rc->decrypt($config);
	+ if (!empty($_SESSION['enigma_pass'])) {
	+ $config = $this->rc->decrypt($_SESSION['enigma_pass']);
	$config = @unserialize($config);
	}

	$threshold = $this->password_time ? time() - $this->password_time : 0;
	$keys = array();

	// delete expired passwords
	- foreach ((array) $config as $key => $value) {
	- if ($threshold && $value[1] < $threshold) {
	- unset($config[$key]);
	- $modified = true;
	- }
	- else {
	- $keys[$key] = $value[0];
	+ if (!empty($config)) {
	+ foreach ($config as $key => $value) {
	+ if ($threshold && $value[1] < $threshold) {
	+ unset($config[$key]);
	+ $modified = true;
	+ }
	+ else {
	+ $keys[$key] = $value[0];
	+ }
	}
	}

	if (!empty($modified)) {
	$_SESSION['enigma_pass'] = $this->rc->encrypt(serialize($config));
	}

	return $keys;
	}

	/**
	* Get message part body.
	*
	* @param rcube_message Message object
	* @param rcube_message_part Message part
	*/
	private function get_part_body($msg, $part)
	{
	// @TODO: Handle big bodies using file handles

	// This is a special case when we want to get the whole body
	// using direct IMAP access, in other cases we prefer
	// rcube_message::get_part_body() as the body may be already in memory
	if (!$part->mime_id) {
	// fake the size which may be empty for multipart/* parts
	// otherwise get_message_part() below will fail
	if (!$part->size) {
	$reset = true;
	$part->size = 1;
	}

	$storage = $this->rc->get_storage();
	$body = $storage->get_message_part($msg->uid, $part->mime_id, $part,
	null, null, true, 0, false);

	if (!empty($reset)) {
	$part->size = 0;
	}
	}
	else {
	$body = $msg->get_part_body($part->mime_id, false);

	// Convert charset to get rid of possible non-ascii characters (#5962)
	if ($part->charset && stripos($part->charset, 'ASCII') === false) {
	$body = rcube_charset::convert($body, $part->charset, 'US-ASCII');
	}
	}

	return $body;
	}

	/**
	* Parse decrypted message body into structure
	*
	* @param string Message body
	*
	* @return array Message structure
	*/
	private function parse_body(&$body)
	{
	// Mail_mimeDecode need \r\n end-line, but gpg may return \n
	$body = preg_replace('/\r?\n/', "\r\n", $body);

	// parse the body into structure
	$struct = rcube_mime::parse_message($body);

	return $struct;
	}

	/**
	* Replace message encrypted structure with decrypted message structure
	*
	* @param array Hook arguments
	* @param rcube_message_part Part structure
	* @param int Part size
	*/
	private function modify_structure(&$p, $struct, $size = 0)
	{
	// modify mime_parts property of the message object
	$old_id = $p['structure']->mime_id;

	foreach (array_keys($p['object']->mime_parts) as $idx) {
	if (!$old_id \|\| $idx == $old_id \|\| strpos($idx, $old_id . '.') === 0) {
	unset($p['object']->mime_parts[$idx]);
	}
	}

	// set some part params used by Roundcube core
	$struct->headers = array_merge($p['structure']->headers, $struct->headers);
	$struct->size = $size;
	$struct->filename = $p['structure']->filename;

	// modify the new structure to be correctly handled by Roundcube
	$this->modify_structure_part($struct, $p['object'], $old_id);

	// replace old structure with the new one
	$p['structure'] = $struct;
	$p['mimetype'] = $struct->mimetype;
	}

	/**
	* Modify decrypted message part
	*
	* @param rcube_message_part
	* @param rcube_message
	*/
	private function modify_structure_part($part, $msg, $old_id)
	{
	// never cache the body
	$part->body_modified = true;
	$part->encoding = 'stream';

	// modify part identifier
	if ($old_id) {
	$part->mime_id = !$part->mime_id ? $old_id : ($old_id . '.' . $part->mime_id);
	}

	// Cache the fact it was decrypted
	$this->encrypted_parts[] = $part->mime_id;
	$msg->mime_parts[$part->mime_id] = $part;

	// modify sub-parts
	foreach ((array) $part->parts as $p) {
	$this->modify_structure_part($p, $msg, $old_id);
	}
	}

	/**
	* Extracts body and signature of multipart/signed message body
	*/
	private function explode_signed_body($body, $boundary)
	{
	if (!$body) {
	return array();
	}

	$boundary = '--' . $boundary;
	$boundary_len = strlen($boundary) + 2;

	// Find boundaries
	$start = strpos($body, $boundary) + $boundary_len;
	$end = strpos($body, $boundary, $start);

	// Get signed body and signature
	$sig = substr($body, $end + $boundary_len);
	$body = substr($body, $start, $end - $start - 2);

	// Cleanup signature
	$sig = substr($sig, strpos($sig, "\r\n\r\n") + 4);
	$sig = substr($sig, 0, strpos($sig, $boundary));

	return array($body, $sig);
	}

	/**
	* Checks if specified message part is a PGP-key or S/MIME cert data
	*
	* @param rcube_message_part Part object
	*
	* @return boolean True if part is a key/cert
	*/
	public function is_keys_part($part)
	{
	// @TODO: S/MIME
	return (
	// Content-Type: application/pgp-keys
	$part->mimetype == 'application/pgp-keys'
	);
	}

	/**
	* Removes all user keys and assigned data
	*
	* @param string Username
	*
	* @return bool True on success, False on failure
	*/
	public function delete_user_data($username)
	{
	$homedir = $this->rc->config->get('enigma_pgp_homedir', INSTALL_PATH . 'plugins/enigma/home');
	$homedir .= DIRECTORY_SEPARATOR . $username;

	return file_exists($homedir) ? self::delete_dir($homedir) : true;
	}

	/**
	* Recursive method to remove directory with its content
	*
	* @param string Directory
	*/
	public static function delete_dir($dir)
	{
	// This code can be executed from command line, make sure
	// we have permissions to delete keys directory
	if (!is_writable($dir)) {
	rcube::raise_error("Unable to delete $dir", false, true);
	return false;
	}

	if ($content = scandir($dir)) {
	foreach ($content as $filename) {
	if ($filename != '.' && $filename != '..') {
	$filename = $dir . DIRECTORY_SEPARATOR . $filename;

	if (is_dir($filename)) {
	self::delete_dir($filename);
	}
	else {
	unlink($filename);
	}
	}
	}

	rmdir($dir);
	}

	return true;
	}

	/**
	* Check if specified driver feature is supported
	*/
	public function is_supported($feature)
	{
	$this->load_pgp_driver();

	return in_array($feature, $this->pgp_driver->capabilities());
	}

	/**
	* Raise/log (relevant) errors
	*/
	protected static function raise_error($result, $line, $abort = false)
	{
	if ($result->getCode() != enigma_error::BADPASS) {
	rcube::raise_error(array(
	'code' => 600,
	'file' => __FILE__,
	'line' => $line,
	'message' => "Enigma plugin: " . $result->getMessage()
	), true, $abort);
	}
	}
	}
	diff --git a/plugins/jqueryui/jqueryui.php b/plugins/jqueryui/jqueryui.php
	index 23d7e8e7d..77149b147 100644
	--- a/plugins/jqueryui/jqueryui.php
	+++ b/plugins/jqueryui/jqueryui.php
	@@ -1,156 +1,156 @@
	<?php

	/**
	* jQuery UI
	*
	* Provide the jQuery UI library with according themes.
	*
	* @version 1.12.0
	* @author Cor Bosman <roundcube@wa.ter.net>
	* @author Thomas Bruederli <roundcube@gmail.com>
	* @author Aleksander Machniak <alec@alec.pl>
	* @license GNU GPLv3+
	*/
	class jqueryui extends rcube_plugin
	{
	public $noajax = true;
	public $version = '1.12.0';

	private static $features = array();
	private static $ui_theme;
	private static $skin_map = array(
	'larry' => 'larry',
	'default' => 'elastic',
	);

	public function init()
	{
	$rcmail = rcmail::get_instance();

	// the plugin might have been force-loaded so do some sanity check first
	if ($rcmail->output->type != 'html' \|\| self::$ui_theme) {
	return;
	}

	$this->load_config();

	// include UI scripts
	$this->include_script("js/jquery-ui.min.js");

	// include UI stylesheet
	$skin = $rcmail->config->get('skin');
	$ui_map = $rcmail->config->get('jquery_ui_skin_map', self::$skin_map);
	$skins = array_keys($rcmail->output->skins);
	$skins[] = 'elastic';

	foreach ($skins as $skin) {
	- self::$ui_theme = $ui_theme = $ui_map[$skin] ?: $skin;
	+ self::$ui_theme = $ui_theme = !empty($ui_map[$skin]) ? $ui_map[$skin] : $skin;

	if (self::asset_exists("themes/$ui_theme/jquery-ui.css")) {
	$this->include_stylesheet("themes/$ui_theme/jquery-ui.css");
	break;
	}
	}

	// jquery UI localization
	$jquery_ui_i18n = $rcmail->config->get('jquery_ui_i18n', array('datepicker'));
	if (count($jquery_ui_i18n) > 0) {
	$lang_l = str_replace('_', '-', substr($_SESSION['language'], 0, 5));
	$lang_s = substr($_SESSION['language'], 0, 2);

	foreach ($jquery_ui_i18n as $package) {
	if (self::asset_exists("js/i18n/jquery.ui.$package-$lang_l.js", false)) {
	$this->include_script("js/i18n/jquery.ui.$package-$lang_l.js");
	}
	else if ($lang_s != 'en' && self::asset_exists("js/i18n/jquery.ui.$package-$lang_s.js", false)) {
	$this->include_script("js/i18n/jquery.ui.$package-$lang_s.js");
	}
	}
	}

	// Date format for datepicker
	$date_format = $date_format_localized = $rcmail->config->get('date_format', 'Y-m-d');
	$date_format = strtr($date_format, array(
	'y' => 'y',
	'Y' => 'yy',
	'm' => 'mm',
	'n' => 'm',
	'd' => 'dd',
	'j' => 'd',
	));

	$replaces = array('Y' => 'yyyy', 'y' => 'yy', 'm' => 'mm', 'd' => 'dd', 'j' => 'd', 'n' => 'm');

	foreach (array_keys($replaces) as $key) {
	if ($rcmail->text_exists("dateformat$key")) {
	$replaces[$key] = $rcmail->gettext("dateformat$key");
	}
	}

	$date_format_localized = strtr($date_format_localized, $replaces);

	$rcmail->output->set_env('date_format', $date_format);
	$rcmail->output->set_env('date_format_localized', $date_format_localized);
	}

	public static function miniColors()
	{
	if (in_array('miniColors', self::$features)) {
	return;
	}

	self::$features[] = 'miniColors';

	$ui_theme = self::$ui_theme;
	$rcube = rcube::get_instance();
	$script = 'plugins/jqueryui/js/jquery.minicolors.min.js';
	$css = "themes/$ui_theme/jquery.minicolors.css";

	if (!self::asset_exists($css)) {
	$css = "themes/larry/jquery.minicolors.css";
	}

	$colors_theme = $rcube->config->get('jquery_ui_colors_theme', 'default');
	$config = array('theme' => $colors_theme);
	$config_str = rcube_output::json_serialize($config);

	$rcube->output->include_css('plugins/jqueryui/' . $css);
	$rcube->output->include_script($script, 'head', false);
	$rcube->output->add_script('$.fn.miniColors = $.fn.minicolors; $("input.colors").minicolors(' . $config_str . ')', 'docready');
	$rcube->output->set_env('minicolors_config', $config);
	}

	public static function tagedit()
	{
	if (in_array('tagedit', self::$features)) {
	return;
	}

	self::$features[] = 'tagedit';

	$script = 'plugins/jqueryui/js/jquery.tagedit.js';
	$rcube = rcube::get_instance();
	$ui_theme = self::$ui_theme;
	$css = "themes/$ui_theme/tagedit.css";

	if (!array_key_exists('elastic', (array) $rcube->output->skins)) {
	if (!self::asset_exists($css)) {
	$css = "themes/larry/tagedit.css";
	}

	$rcube->output->include_css('plugins/jqueryui/' . $css);
	}

	$rcube->output->include_script($script, 'head', false);
	}

	/**
	* Checks if an asset file exists in specified location (with assets_dir support)
	*/
	protected static function asset_exists($path, $minified = true)
	{
	$rcube = rcube::get_instance();

	return $rcube->find_asset('/plugins/jqueryui/' . $path, $minified) !== null;
	}
	}
	diff --git a/plugins/markasjunk/markasjunk.php b/plugins/markasjunk/markasjunk.php
	index 009f0c24a..70f16438d 100644
	--- a/plugins/markasjunk/markasjunk.php
	+++ b/plugins/markasjunk/markasjunk.php
	@@ -1,344 +1,349 @@
	<?php

	/**
	* MarkAsJunk
	*
	* A plugin that adds a new button to the mailbox toolbar
	* to mark the selected messages as Junk and move them to the Junk folder
	* or to move messages in the Junk folder to the inbox - moving only the
	* attachment if it is a Spamassassin spam report email
	*
	* @author Philip Weir
	* @author Thomas Bruederli
	*
	* Copyright (C) The Roundcube Dev Team
	* Copyright (C) Philip Weir
	*
	* This program is a Roundcube (https://roundcube.net) plugin.
	* For more information see README.md.
	* For configuration see config.inc.php.dist.
	*
	* This program is free software: you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation, either version 3 of the License, or
	* (at your option) any later version.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with Roundcube. If not, see https://www.gnu.org/licenses/.
	*/
	class markasjunk extends rcube_plugin
	{
	public $task = 'mail';

	private $rcube;
	private $spam_mbox;
	private $ham_mbox;
	private $flags = array(
	'JUNK' => 'Junk',
	'NONJUNK' => 'NonJunk'
	);
	private $driver;


	public function init()
	{
	$this->register_action('plugin.markasjunk.junk', array($this, 'mark_message'));
	$this->register_action('plugin.markasjunk.not_junk', array($this, 'mark_message'));

	$this->rcube = rcube::get_instance();
	$this->load_config();
	$this->_load_host_config();

	// Host exceptions
	$hosts = $this->rcube->config->get('markasjunk_allowed_hosts');
	if (!empty($hosts) && !in_array($_SESSION['storage_host'], (array) $hosts)) {
	return;
	}

	$this->ham_mbox = $this->rcube->config->get('markasjunk_ham_mbox', 'INBOX');
	$this->spam_mbox = $this->rcube->config->get('markasjunk_spam_mbox', $this->rcube->config->get('junk_mbox'));
	$toolbar = $this->rcube->config->get('markasjunk_toolbar', true);
	$this->_init_flags();

	if ($this->rcube->action == '' \|\| $this->rcube->action == 'show') {
	$this->include_script('markasjunk.js');
	$this->add_texts('localization', true);
	$this->include_stylesheet($this->local_skin_path() . '/markasjunk.css');

	if ($toolbar) {
	// add the buttons to the main toolbar
	$this->add_button(array(
	'command' => 'plugin.markasjunk.junk',
	'type' => 'link',
	'class' => 'button buttonPas junk disabled',
	'classact' => 'button junk',
	'classsel' => 'button junk pressed',
	'title' => 'markasjunk.buttonjunk',
	'innerclass' => 'inner',
	'label' => 'junk'
	), 'toolbar');

	$this->add_button(array(
	'command' => 'plugin.markasjunk.not_junk',
	'type' => 'link',
	'class' => 'button buttonPas notjunk disabled',
	'classact' => 'button notjunk',
	'classsel' => 'button notjunk pressed',
	'title' => 'markasjunk.buttonnotjunk',
	'innerclass' => 'inner',
	'label' => 'markasjunk.notjunk'
	), 'toolbar');
	}
	else {
	// add the buttons to the mark message menu
	$this->add_button(array(
	'command' => 'plugin.markasjunk.junk',
	'type' => 'link-menuitem',
	'label' => 'markasjunk.asjunk',
	'id' => 'markasjunk',
	'class' => 'icon junk disabled',
	'classact' => 'icon junk active',
	'innerclass' => 'icon junk'
	), 'markmenu');

	$this->add_button(array(
	'command' => 'plugin.markasjunk.not_junk',
	'type' => 'link-menuitem',
	'label' => 'markasjunk.asnotjunk',
	'id' => 'markasnotjunk',
	'class' => 'icon notjunk disabled',
	'classact' => 'icon notjunk active',
	'innerclass' => 'icon notjunk'
	), 'markmenu');
	}

	// add markasjunk folder settings to the env for JS
	$this->rcube->output->set_env('markasjunk_ham_mailbox', $this->ham_mbox);
	$this->rcube->output->set_env('markasjunk_spam_mailbox', $this->spam_mbox);
	$this->rcube->output->set_env('markasjunk_move_spam', $this->rcube->config->get('markasjunk_move_spam', false));
	$this->rcube->output->set_env('markasjunk_move_ham', $this->rcube->config->get('markasjunk_move_ham', false));
	$this->rcube->output->set_env('markasjunk_permanently_remove', $this->rcube->config->get('markasjunk_permanently_remove', false));
	$this->rcube->output->set_env('markasjunk_spam_only', $this->rcube->config->get('markasjunk_spam_only', false));
	}

	// init learning driver
	$this->_init_driver();
	}

	public function mark_message()
	{
	$this->add_texts('localization');

	$is_spam = $this->rcube->action == 'plugin.markasjunk.junk' ? true : false;
	$uids = rcube_utils::get_input_value('_uid', rcube_utils::INPUT_POST);
	$mbox_name = rcube_utils::get_input_value('_mbox', rcube_utils::INPUT_POST);
	$messageset = rcmail::get_uids($uids, $mbox_name, $multifolder);
	$dest_mbox = $is_spam ? $this->spam_mbox : $this->ham_mbox;

	// special case when select all is used, uid is '*', and not in multi folder mode and we are using a driver
	// rcmail::get_uids does not handle this
	if ($uids == '*' && !$multifolder && is_object($this->driver)) {
	$storage = $this->rcube->get_storage();
	$result_index = $storage->index($mbox_name);
	$messageset = array($mbox_name => $result_index->get());
	}

	$result = $is_spam ? $this->_spam($messageset, $dest_mbox) : $this->_ham($messageset, $dest_mbox);
	if ($result) {
	if ($dest_mbox && ($mbox_name !== $dest_mbox \|\| $multifolder)) {
	$this->rcube->output->command('markasjunk_move', $dest_mbox, $this->_messageset_to_uids($messageset, $multifolder));
	}
	else {
	$this->rcube->output->command('command', 'list', $mbox_name);
	}

	$this->rcube->output->command('display_message', $is_spam ? $this->gettext('reportedasjunk') : $this->gettext('reportedasnotjunk'), 'confirmation');
	}

	$this->rcube->output->send();
	}

	public function set_flags($p)
	{
	- $p['message_flags'] = array_merge((array) $p['message_flags'], $this->flags);
	+ if (!empty($p['message_flags'])) {
	+ $p['message_flags'] = array_merge((array) $p['message_flags'], $this->flags);
	+ }
	+ else {
	+ $p['message_flags'] = $this->flags;
	+ }

	return $p;
	}

	private function _spam(&$messageset, $dest_mbox = null)
	{
	$storage = $this->rcube->get_storage();
	$result = true;

	foreach ($messageset as $source_mbox => &$uids) {
	$storage->set_folder($source_mbox);

	$result = $this->_call_driver('spam', $uids, $source_mbox, $dest_mbox);

	// abort function of the driver says so
	if (!$result) {
	break;
	}

	if ($this->rcube->config->get('markasjunk_read_spam', false)) {
	$storage->set_flag($uids, 'SEEN', $source_mbox);
	}

	if (array_key_exists('JUNK', $this->flags)) {
	$storage->set_flag($uids, 'JUNK', $source_mbox);
	}

	if (array_key_exists('NONJUNK', $this->flags)) {
	$storage->unset_flag($uids, 'NONJUNK', $source_mbox);
	}
	}

	return $result;
	}

	private function _ham(&$messageset, $dest_mbox = null)
	{
	$storage = $this->rcube->get_storage();
	$result = true;

	foreach ($messageset as $source_mbox => &$uids) {
	$storage->set_folder($source_mbox);

	$result = $this->_call_driver('ham', $uids, $source_mbox, $dest_mbox);

	// abort function of the driver says so
	if (!$result) {
	break;
	}

	if ($this->rcube->config->get('markasjunk_unread_ham', false)) {
	$storage->unset_flag($uids, 'SEEN', $source_mbox);
	}

	if (array_key_exists('JUNK', $this->flags)) {
	$storage->unset_flag($uids, 'JUNK', $source_mbox);
	}

	if (array_key_exists('NONJUNK', $this->flags)) {
	$storage->set_flag($uids, 'NONJUNK', $source_mbox);
	}
	}

	return $result;
	}

	private function _call_driver($action, &$uids = null, $source_mbox = null, $dest_mbox = null)
	{
	// already initialized
	if (!is_object($this->driver)) {
	return true;
	}

	if ($action == 'spam') {
	$this->driver->spam($uids, $source_mbox, $dest_mbox);
	}
	elseif ($action == 'ham') {
	$this->driver->ham($uids, $source_mbox, $dest_mbox);
	}

	return $this->driver->is_error ? false : true;
	}

	private function _messageset_to_uids($messageset, $multifolder)
	{
	$a_uids = array();

	foreach ($messageset as $mbox => $uids) {
	if (is_array($uids)) {
	foreach ($uids as $uid) {
	$a_uids[] = $multifolder ? $uid . '-' . $mbox : $uid;
	}
	}
	}

	return $a_uids;
	}

	private function _load_host_config()
	{
	$configs = $this->rcube->config->get('markasjunk_host_config');
	if (empty($configs) \|\| !array_key_exists($_SESSION['storage_host'], (array) $configs)) {
	return;
	}

	$file = $configs[$_SESSION['storage_host']];
	$this->load_config($file);
	}

	private function _init_flags()
	{
	$spam_flag = $this->rcube->config->get('markasjunk_spam_flag');
	$ham_flag = $this->rcube->config->get('markasjunk_ham_flag');

	if ($spam_flag === false) {
	unset($this->flags['JUNK']);
	}
	elseif (!empty($spam_flag)) {
	$this->flags['JUNK'] = $spam_flag;
	}

	if ($ham_flag === false) {
	unset($this->flags['NONJUNK']);
	}
	elseif (!empty($ham_flag)) {
	$this->flags['NONJUNK'] = $ham_flag;
	}

	if (count($this->flags) > 0) {
	// register the ham/spam flags with the core
	$this->add_hook('storage_init', array($this, 'set_flags'));
	}
	}

	private function _init_driver()
	{
	$driver_name = $this->rcube->config->get('markasjunk_learning_driver');

	if (empty($driver_name)) {
	return;
	}

	$driver = $this->home . "/drivers/$driver_name.php";
	$class = "markasjunk_$driver_name";

	if (!is_readable($driver)) {
	rcube::raise_error(array(
	'code' => 600,
	'type' => 'php',
	'file' => __FILE__,
	'line' => __LINE__,
	'message' => "markasjunk plugin: Unable to open driver file $driver"
	), true, false);
	}

	include_once $driver;

	if (!class_exists($class, false) \|\| !method_exists($class, 'spam') \|\| !method_exists($class, 'ham')) {
	rcube::raise_error(array(
	'code' => 600,
	'type' => 'php',
	'file' => __FILE__,
	'line' => __LINE__,
	'message' => "markasjunk plugin: Broken driver: $driver"
	), true, false);
	}

	// call the relevant function from the driver
	$this->driver = new $class();

	// method_exists check here for backwards compatibility
	if (method_exists($this->driver, 'init')) {
	$this->driver->init();
	}
	}
	}
	diff --git a/program/include/rcmail.php b/program/include/rcmail.php
	index 0945a9b5c..7d30673ad 100644
	--- a/program/include/rcmail.php
	+++ b/program/include/rcmail.php
	@@ -1,2819 +1,2828 @@
	<?php

	/**
	+-----------------------------------------------------------------------+
	\| This file is part of the Roundcube Webmail client \|
	\| \|
	\| Copyright (C) The Roundcube Dev Team \|
	\| Copyright (C) Kolab Systems AG \|
	\| \|
	\| Licensed under the GNU General Public License version 3 or \|
	\| any later version with exceptions for skins & plugins. \|
	\| See the README file for a full license statement. \|
	\| \|
	\| PURPOSE: \|
	\| Application class providing core functions and holding \|
	\| instances of all 'global' objects like db- and imap-connections \|
	+-----------------------------------------------------------------------+
	\| Author: Thomas Bruederli <roundcube@gmail.com> \|
	\| Author: Aleksander Machniak <alec@alec.pl> \|
	+-----------------------------------------------------------------------+
	*/

	/**
	* Application class of Roundcube Webmail
	* implemented as singleton
	*
	* @package Webmail
	*/
	class rcmail extends rcube
	{
	/**
	* Main tasks.
	*
	* @var array
	*/
	static public $main_tasks = array('mail','settings','addressbook','login','logout','utils','oauth','dummy');

	/**
	* Current task.
	*
	* @var string
	*/
	public $task;

	/**
	* Current action.
	*
	* @var string
	*/
	public $action = '';
	public $comm_path = './';
	public $filename = '';
	public $default_skin;
	public $login_error;

	private $address_books = array();
	private $action_map = array();


	const ERROR_STORAGE = -2;
	const ERROR_INVALID_REQUEST = 1;
	const ERROR_INVALID_HOST = 2;
	const ERROR_COOKIES_DISABLED = 3;
	const ERROR_RATE_LIMIT = 4;


	/**
	* This implements the 'singleton' design pattern
	*
	* @param integer $mode Ignored rcube::get_instance() argument
	* @param string $env Environment name to run (e.g. live, dev, test)
	*
	* @return rcmail The one and only instance
	*/
	static function get_instance($mode = 0, $env = '')
	{
	if (!self::$instance \|\| !is_a(self::$instance, 'rcmail')) {
	// In cli-server mode env=test
	if ($env === null && php_sapi_name() == 'cli-server') {
	$env = 'test';
	}

	self::$instance = new rcmail($env);
	// init AFTER object was linked with self::$instance
	self::$instance->startup();
	}

	return self::$instance;
	}

	/**
	* Initial startup function
	* to register session, create database and imap connections
	*/
	protected function startup()
	{
	$this->init(self::INIT_WITH_DB \| self::INIT_WITH_PLUGINS);

	// set filename if not index.php
	if (($basename = basename($_SERVER['SCRIPT_FILENAME'])) && $basename != 'index.php') {
	$this->filename = $basename;
	}

	// load all configured plugins
	$plugins = (array) $this->config->get('plugins', array());
	$required_plugins = array('filesystem_attachments', 'jqueryui');
	$this->plugins->load_plugins($plugins, $required_plugins);

	// start session
	$this->session_init();

	// Remember default skin, before it's replaced by user prefs
	$this->default_skin = $this->config->get('skin');

	// create user object
	$this->set_user(new rcube_user(isset($_SESSION['user_id']) ? $_SESSION['user_id'] : null));

	// set task and action properties
	$this->set_task(rcube_utils::get_input_value('_task', rcube_utils::INPUT_GPC));
	$this->action = asciiwords(rcube_utils::get_input_value('_action', rcube_utils::INPUT_GPC));

	// reset some session parameters when changing task
	if ($this->task != 'utils') {
	// we reset list page when switching to another task
	// but only to the main task interface - empty action (#1489076, #1490116)
	// this will prevent from unintentional page reset on cross-task requests
	- if ($this->session && $_SESSION['task'] != $this->task && empty($this->action)) {
	+ if ($this->session && empty($this->action)
	+ && (empty($_SESSION['task']) \|\| $_SESSION['task'] != $this->task)
	+ ) {
	$this->session->remove('page');

	// set current task to session
	$_SESSION['task'] = $this->task;
	}
	}

	// init output class (not in CLI mode)
	if (!empty($_REQUEST['_remote'])) {
	$GLOBALS['OUTPUT'] = $this->json_init();
	}
	else if (!empty($_SERVER['REMOTE_ADDR'])) {
	$GLOBALS['OUTPUT'] = $this->load_gui(!empty($_REQUEST['_framed']));
	}

	// load oauth manager
	$this->oauth = rcmail_oauth::get_instance();

	// run init method on all the plugins
	$this->plugins->init($this, $this->task);
	}

	/**
	* Setter for application task
	*
	* @param string $task Task to set
	*/
	public function set_task($task)
	{
	if (php_sapi_name() == 'cli') {
	$task = 'cli';
	}
	else if (!$this->user \|\| !$this->user->ID) {
	$task = 'login';
	}
	else {
	$task = asciiwords($task, true) ?: 'mail';
	}

	// Re-initialize plugins if task is changing
	if (!empty($this->task) && $this->task != $task) {
	$this->plugins->init($this, $task);
	}

	$this->task = $task;
	$this->comm_path = $this->url(array('task' => $this->task));

	if (!empty($_REQUEST['_framed'])) {
	$this->comm_path .= '&_framed=1';
	}

	if ($this->output) {
	$this->output->set_env('task', $this->task);
	$this->output->set_env('comm_path', $this->comm_path);
	}
	}

	/**
	* Setter for system user object
	*
	* @param rcube_user $user Current user instance
	*/
	public function set_user($user)
	{
	parent::set_user($user);

	$session_lang = isset($_SESSION['language']) ? $_SESSION['language'] : null;
	$lang = $this->language_prop($this->config->get('language', $session_lang));
	$_SESSION['language'] = $this->user->language = $lang;

	// set localization
	setlocale(LC_ALL, $lang . '.utf8', $lang . '.UTF-8', 'en_US.utf8', 'en_US.UTF-8');

	// Workaround for http://bugs.php.net/bug.php?id=18556
	// Also strtoupper/strtolower and other methods are locale-aware
	// for these locales it is problematic (#1490519)
	if (in_array($lang, array('tr_TR', 'ku', 'az_AZ'))) {
	setlocale(LC_CTYPE, 'en_US.utf8', 'en_US.UTF-8', 'C');
	}
	}

	/**
	* Return instance of the internal address book class
	*
	* @param string $id Address book identifier. It accepts also special values:
	* - rcube_addressbook::TYPE_CONTACT (or 'sql') for the SQL addressbook
	* - rcube_addressbook::TYPE_DEFAULT for the default addressbook
	* @param boolean $writeable True if the address book needs to be writeable
	*
	* @return rcube_contacts Address book object
	*/
	public function get_address_book($id, $writeable = false)
	{
	$contacts = null;
	$ldap_config = (array)$this->config->get('ldap_public');
	$default = false;

	// 'sql' is the alias for '0' used by autocomplete
	if ($id == 'sql') {
	$id = rcube_addressbook::TYPE_CONTACT;
	}
	else if ($id == rcube_addressbook::TYPE_DEFAULT \|\| $id == -1) { // -1 for BC
	$id = $this->config->get('default_addressbook');
	$default = true;
	}

	$id = (string) $id;

	// use existing instance
	if (isset($this->address_books[$id]) && ($this->address_books[$id] instanceof rcube_addressbook)) {
	$contacts = $this->address_books[$id];
	}
	else if ($id && $ldap_config[$id]) {
	$domain = $this->config->mail_domain($_SESSION['storage_host']);
	$contacts = new rcube_ldap($ldap_config[$id], $this->config->get('ldap_debug'), $domain);
	}
	else if ($id === (string) rcube_addressbook::TYPE_CONTACT) {
	$contacts = new rcube_contacts($this->db, $this->get_user_id());
	}
	else if ($id === (string) rcube_addressbook::TYPE_RECIPIENT \|\| $id === (string) rcube_addressbook::TYPE_TRUSTED_SENDER) {
	$contacts = new rcube_addresses($this->db, $this->get_user_id(), (int) $id);
	}
	else {
	$plugin = $this->plugins->exec_hook('addressbook_get', array('id' => $id, 'writeable' => $writeable));

	// plugin returned instance of a rcube_addressbook
	if ($plugin['instance'] instanceof rcube_addressbook) {
	$contacts = $plugin['instance'];
	}
	}

	// when user requested default writeable addressbook
	// we need to check if default is writeable, if not we
	// will return first writeable book (if any exist)
	if ($contacts && $default && $contacts->readonly && $writeable) {
	$contacts = null;
	}

	// Get first addressbook from the list if configured default doesn't exist
	// This can happen when user deleted the addressbook (e.g. Kolab folder)
	if (!$contacts && (!$id \|\| $default)) {
	$source = reset($this->get_address_sources($writeable, !$default));
	if (!empty($source)) {
	$contacts = $this->get_address_book($source['id']);
	if ($contacts) {
	$id = $source['id'];
	}
	}
	}

	if (!$contacts) {
	// there's no default, just return
	if ($default) {
	return null;
	}

	self::raise_error(array(
	'code' => 700,
	'file' => __FILE__,
	'line' => __LINE__,
	'message' => "Addressbook source ($id) not found!"
	),
	true, true);
	}

	// add to the 'books' array for shutdown function
	$this->address_books[$id] = $contacts;

	if ($writeable && $contacts->readonly) {
	return null;
	}

	// set configured sort order
	if ($sort_col = $this->config->get('addressbook_sort_col')) {
	$contacts->set_sort_order($sort_col);
	}

	return $contacts;
	}

	/**
	* Return identifier of the address book object
	*
	* @param rcube_addressbook $object Addressbook source object
	*
	* @return string Source identifier
	*/
	public function get_address_book_id($object)
	{
	foreach ($this->address_books as $index => $book) {
	if ($book === $object) {
	return $index;
	}
	}
	}

	/**
	* Return address books list
	*
	* @param boolean $writeable True if the address book needs to be writeable
	* @param boolean $skip_hidden True if the address book needs to be not hidden
	*
	* @return array Address books array
	*/
	public function get_address_sources($writeable = false, $skip_hidden = false)
	{
	$abook_type = strtolower((string) $this->config->get('address_book_type', 'sql'));
	$ldap_config = (array) $this->config->get('ldap_public');
	$list = array();

	// SQL-based (built-in) address book
	if ($abook_type === 'sql') {
	$list[rcube_addressbook::TYPE_CONTACT] = array(
	'id' => (string) rcube_addressbook::TYPE_CONTACT,
	'name' => $this->gettext('personaladrbook'),
	'groups' => true,
	'readonly' => false,
	'undelete' => $this->config->get('undo_timeout') > 0,
	);
	}

	// LDAP address book(s)
	if (!empty($ldap_config)) {
	foreach ($ldap_config as $id => $prop) {
	// handle misconfiguration
	if (empty($prop) \|\| !is_array($prop)) {
	continue;
	}

	$list[$id] = array(
	'id' => $id,
	'name' => html::quote($prop['name']),
	'groups' => !empty($prop['groups']) \|\| !empty($prop['group_filters']),
	'readonly' => !$prop['writable'],
	'hidden' => $prop['hidden'],
	);
	}
	}

	$collected_recipients = $this->config->get('collected_recipients');
	$collected_senders = $this->config->get('collected_senders');

	if ($collected_recipients === (string) rcube_addressbook::TYPE_RECIPIENT) {
	$list[rcube_addressbook::TYPE_RECIPIENT] = array(
	'id' => (string) rcube_addressbook::TYPE_RECIPIENT,
	'name' => $this->gettext('collectedrecipients'),
	'groups' => false,
	'readonly' => true,
	'undelete' => false,
	'deletable' => true,
	);
	}

	if ($collected_senders === (string) rcube_addressbook::TYPE_TRUSTED_SENDER) {
	$list[rcube_addressbook::TYPE_TRUSTED_SENDER] = array(
	'id' => (string) rcube_addressbook::TYPE_TRUSTED_SENDER,
	'name' => $this->gettext('trustedsenders'),
	'groups' => false,
	'readonly' => true,
	'undelete' => false,
	'deletable' => true,
	);
	}

	// Plugins can also add address books, or re-order the list
	$plugin = $this->plugins->exec_hook('addressbooks_list', array('sources' => $list));
	$list = $plugin['sources'];

	foreach ($list as $idx => $item) {
	// remove from list if not writeable as requested
	if ($writeable && $item['readonly']) {
	unset($list[$idx]);
	}
	// remove from list if hidden as requested
	else if ($skip_hidden && $item['hidden']) {
	unset($list[$idx]);
	}
	}

	return $list;
	}

	/**
	* Getter for compose responses.
	* These are stored in local config and user preferences.
	*
	* @param boolean $sorted True to sort the list alphabetically
	* @param boolean $user_only True if only this user's responses shall be listed
	*
	* @return array List of the current user's stored responses
	*/
	public function get_compose_responses($sorted = false, $user_only = false)
	{
	$responses = array();

	if (!$user_only) {
	foreach ($this->config->get('compose_responses_static', array()) as $response) {
	if (empty($response['key'])) {
	$response['key'] = substr(md5($response['name']), 0, 16);
	}

	$response['static'] = true;
	$response['class'] = 'readonly';

	$k = $sorted ? '0000-' . mb_strtolower($response['name']) : $response['key'];
	$responses[$k] = $response;
	}
	}

	foreach ($this->config->get('compose_responses', array()) as $response) {
	if (empty($response['key'])) {
	$response['key'] = substr(md5($response['name']), 0, 16);
	}

	$k = $sorted ? mb_strtolower($response['name']) : $response['key'];
	$responses[$k] = $response;
	}

	// sort list by name
	if ($sorted) {
	ksort($responses, SORT_LOCALE_STRING);
	}

	$responses = array_values($responses);

	$hook = $this->plugins->exec_hook('get_compose_responses', array(
	'list' => $responses,
	'sorted' => $sorted,
	'user_only' => $user_only,
	));

	return $hook['list'];
	}

	/**
	* Init output object for GUI and add common scripts.
	* This will instantiate a rcmail_output_html object and set
	* environment vars according to the current session and configuration
	*
	* @param boolean $framed True if this request is loaded in a (i)frame
	*
	* @return rcube_output Reference to HTML output object
	*/
	public function load_gui($framed = false)
	{
	// init output page
	if (!($this->output instanceof rcmail_output_html)) {
	$this->output = new rcmail_output_html($this->task, $framed);
	}

	// set refresh interval
	$this->output->set_env('refresh_interval', $this->config->get('refresh_interval', 0));
	$this->output->set_env('session_lifetime', $this->config->get('session_lifetime', 0) * 60);

	if ($framed) {
	$this->comm_path .= '&_framed=1';
	$this->output->set_env('framed', true);
	}

	$this->output->set_env('task', $this->task);
	$this->output->set_env('action', $this->action);
	$this->output->set_env('comm_path', $this->comm_path);
	$this->output->set_charset(RCUBE_CHARSET);

	if ($this->user && $this->user->ID) {
	$this->output->set_env('user_id', $this->user->get_hash());
	}

	// set compose mode for all tasks (message compose step can be triggered from everywhere)
	$this->output->set_env('compose_extwin', $this->config->get('compose_extwin',false));

	// add some basic labels to client
	$this->output->add_label('loading', 'servererror', 'connerror', 'requesttimedout',
	'refreshing', 'windowopenerror', 'uploadingmany', 'uploading', 'close', 'save', 'cancel',
	'alerttitle', 'confirmationtitle', 'delete', 'continue', 'ok');

	return $this->output;
	}

	/**
	* Create an output object for JSON responses
	*
	* @return rcube_output Reference to JSON output object
	*/
	public function json_init()
	{
	if (!($this->output instanceof rcmail_output_json)) {
	$this->output = new rcmail_output_json($this->task);
	}

	return $this->output;
	}

	/**
	* Create session object and start the session.
	*/
	public function session_init()
	{
	parent::session_init();

	// set initial session vars
	if (empty($_SESSION['user_id'])) {
	$_SESSION['temp'] = true;
	}
	}

	/**
	* Perform login to the mail server and to the webmail service.
	* This will also create a new user entry if auto_create_user is configured.
	*
	* @param string $username Mail storage (IMAP) user name
	* @param string $password Mail storage (IMAP) password
	* @param string $host Mail storage (IMAP) host
	* @param bool $cookiecheck Enables cookie check
	*
	* @return boolean True on success, False on failure
	*/
	function login($username, $password, $host = null, $cookiecheck = false)
	{
	$this->login_error = null;

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

	if ($cookiecheck && empty($_COOKIE)) {
	$this->login_error = self::ERROR_COOKIES_DISABLED;
	return false;
	}

	$default_host = $this->config->get('default_host');
	$default_port = $this->config->get('default_port');
	$username_domain = $this->config->get('username_domain');
	$login_lc = $this->config->get('login_lc', 2);

	// check username input validity
	if (!$this->login_input_checks($username, $password)) {
	$this->login_error = self::ERROR_INVALID_REQUEST;
	return false;
	}

	// host is validated in rcmail::autoselect_host(), so here
	// we'll only handle unset host (if possible)
	if (!$host && !empty($default_host)) {
	if (is_array($default_host)) {
	$key = key($default_host);
	$host = is_numeric($key) ? $default_host[$key] : $key;
	}
	else {
	$host = $default_host;
	}

	$host = rcube_utils::parse_host($host);
	}

	if (!$host) {
	$this->login_error = self::ERROR_INVALID_HOST;
	return false;
	}

	// parse $host URL
	$a_host = parse_url($host);
	$ssl = false;
	if (!empty($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 (empty($port)) {
	$port = $default_port;
	}

	// Check if we need to add/force domain to username
	if (!empty($username_domain)) {
	$domain = is_array($username_domain) ? $username_domain[$host] : $username_domain;

	if ($domain = rcube_utils::parse_host((string)$domain, $host)) {
	$pos = strpos($username, '@');

	// force configured domains
	if ($pos !== false && $this->config->get('username_domain_forced')) {
	$username = substr($username, 0, $pos) . '@' . $domain;
	}
	// just add domain if not specified
	else if ($pos === false) {
	$username .= '@' . $domain;
	}
	}
	}

	// Convert username to lowercase. If storage backend
	// is case-insensitive we need to store always the same username (#1487113)
	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);
	}
	}

	// try to resolve email address from virtuser table
	if (strpos($username, '@') && ($virtuser = rcube_user::email2user($username))) {
	$username = $virtuser;
	}

	// Here we need IDNA ASCII
	// Only rcube_contacts class is using domain names in Unicode
	$host = rcube_utils::idn_to_ascii($host);
	if (strpos($username, '@')) {
	$username = rcube_utils::idn_to_ascii($username);
	}

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

	// Brute-force prevention
	if ($user->is_locked()) {
	$this->login_error = self::ERROR_RATE_LIMIT;
	return false;
	}
	}

	$storage = $this->get_storage();

	// try to log in
	if (!$storage->connect($host, $username, $password, $port, $ssl)) {
	if ($user) {
	$user->failed_login();
	}

	// Wait a second to slow down brute-force attacks (#1490549)
	sleep(1);
	return false;
	}

	// user already registered -> update user's record
	if (is_object($user)) {
	// update last login timestamp
	$user->touch();
	}
	// create new system user
	else if ($this->config->get('auto_create_user')) {
	if ($created = rcube_user::create($username, $host)) {
	$user = $created;
	}
	else {
	self::raise_error(array(
	'code' => 620,
	'file' => __FILE__,
	'line' => __LINE__,
	'message' => "Failed to create a user record. Maybe aborted by a plugin?"
	),
	true, false);
	}
	}
	else {
	self::raise_error(array(
	'code' => 621,
	'file' => __FILE__,
	'line' => __LINE__,
	'message' => "Access denied for new user $username. 'auto_create_user' is disabled"
	),
	true, false);
	}

	// login succeeded
	if (is_object($user) && $user->ID) {
	// Configure environment
	$this->set_user($user);
	$this->set_storage_prop();

	// 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->encrypt($password);
	$_SESSION['login_time'] = time();

	$timezone = rcube_utils::get_input_value('_timezone', rcube_utils::INPUT_GPC);
	if ($timezone && is_string($timezone) && $timezone != '_default_') {
	$_SESSION['timezone'] = $timezone;
	}

	// fix some old settings according to namespace prefix
	$this->fix_namespace_settings($user);

	// set/create special folders
	$this->set_special_folders();

	// clear all mailboxes related cache(s)
	$storage->clear_cache('mailboxes', true);

	return true;
	}

	return false;
	}

	/**
	* Returns error code of last login operation
	*
	* @return int Error code
	*/
	public function login_error()
	{
	if ($this->login_error) {
	return $this->login_error;
	}

	if ($this->storage && $this->storage->get_error_code() < -1) {
	return self::ERROR_STORAGE;
	}
	}

	/**
	* Validate username input
	*
	* @param string $username User name
	* @param string $password User password
	*
	* @return bool True if valid, False otherwise
	*/
	private function login_input_checks($username, $password)
	{
	$username_filter = $this->config->get('login_username_filter');
	$username_maxlen = $this->config->get('login_username_maxlen', 1024);
	$password_maxlen = $this->config->get('login_password_maxlen', 1024);

	if ($username_maxlen && strlen($username) > $username_maxlen) {
	return false;
	}

	if ($password_maxlen && strlen($password) > $password_maxlen) {
	return false;
	}

	if ($username_filter) {
	$is_email = strtolower($username_filter) == 'email';

	if ($is_email && !rcube_utils::check_email($username, false)) {
	return false;
	}

	if (!$is_email && !preg_match($username_filter, $username)) {
	return false;
	}
	}

	return true;
	}

	/**
	* Detects session errors
	*
	* @return string Error label
	*/
	public function session_error()
	{
	// log session failures
	$task = rcube_utils::get_input_value('_task', rcube_utils::INPUT_GPC);

	if ($task && !in_array($task, array('login', 'logout')) && ($sess_id = $_COOKIE[ini_get('session.name')])) {
	$log = "Aborted session $sess_id; no valid session data found";
	$error = 'sessionerror';

	// In rare cases web browser might end up with multiple cookies of the same name
	// but different params, e.g. domain (webmail.domain.tld and .webmail.domain.tld).
	// In such case browser will send both cookies in the request header
	// problem is that PHP session handler can use only one and if that one session
	// does not exist we'll end up here
	$cookie = rcube_utils::request_header('Cookie');
	$cookie_sessid = $this->config->get('session_name') ?: 'roundcube_sessid';
	$cookie_sessauth = $this->config->get('session_auth_name') ?: 'roundcube_sessauth';

	if (substr_count($cookie, $cookie_sessid.'=') > 1 \|\| substr_count($cookie, $cookie_sessauth.'=') > 1) {
	$log .= ". Cookies mismatch";
	$error = 'cookiesmismatch';
	}

	$this->session->log($log);

	return $error;
	}
	}

	/**
	* Auto-select IMAP host based on the posted login information
	*
	* @return string Selected IMAP host
	*/
	public function autoselect_host()
	{
	$default_host = $this->config->get('default_host');
	$host = null;

	if (is_array($default_host)) {
	$post_host = rcube_utils::get_input_value('_host', rcube_utils::INPUT_POST);
	$post_user = rcube_utils::get_input_value('_user', rcube_utils::INPUT_POST);

	list(, $domain) = explode('@', $post_user);

	// direct match in default_host array
	if ($default_host[$post_host] \|\| in_array($post_host, array_values($default_host))) {
	$host = $post_host;
	}
	// try to select host by mail domain
	else if (!empty($domain)) {
	foreach ($default_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 still not set
	if (empty($host)) {
	$key = key($default_host);
	$host = is_numeric($key) ? $default_host[$key] : $key;
	}
	}
	else if (empty($default_host)) {
	$host = rcube_utils::get_input_value('_host', rcube_utils::INPUT_POST);
	}
	else {
	$host = rcube_utils::parse_host($default_host);
	}

	return $host;
	}

	/**
	* Destroy session data and remove cookie
	*/
	public function kill_session()
	{
	$this->plugins->exec_hook('session_destroy');

	$this->session->kill();
	$_SESSION = array('language' => $this->user->language, 'temp' => true);
	$this->user->reset();

	if ($this->config->get('skin') != $this->default_skin && method_exists($this->output, 'set_skin')) {
	$this->output->set_skin($this->default_skin);
	}
	}

	/**
	* Do server side actions on logout
	*/
	public function logout_actions()
	{
	$storage = $this->get_storage();
	$logout_expunge = $this->config->get('logout_expunge');
	$logout_purge = $this->config->get('logout_purge');
	$trash_mbox = $this->config->get('trash_mbox');

	if ($logout_purge && !empty($trash_mbox)) {
	$storage->clear_folder($trash_mbox);
	}

	if ($logout_expunge) {
	$storage->expunge_folder('INBOX');
	}

	// Try to save unsaved user preferences
	if (!empty($_SESSION['preferences'])) {
	$this->user->save_prefs(unserialize($_SESSION['preferences']));
	}
	}

	/**
	* Build a valid URL to this instance of Roundcube
	*
	* @param mixed $p Either a string with the action or
	* url parameters as key-value pairs
	* @param boolean $absolute Build a URL absolute to document root
	* @param boolean $full Create fully qualified URL including http(s):// and hostname
	* @param bool $secure Return absolute URL in secure location
	*
	* @return string Valid application URL
	*/
	public function url($p, $absolute = false, $full = false, $secure = false)
	{
	if (!is_array($p)) {
	if (strpos($p, 'http') === 0) {
	return $p;
	}

	$p = array('_action' => @func_get_arg(0));
	}

	$task = $this->task;
	if (!empty($p['_task'])) {
	$task = $p['_task'];
	}
	else if (!empty($p['task'])) {
	$task = $p['task'];
	}

	unset($p['task'], $p['_task']);

	$pre = array('_task' => $task);
	$url = $this->filename;
	$delm = '?';

	foreach (array_merge($pre, $p) as $key => $val) {
	if ($val !== '' && $val !== null) {
	$par = $key[0] == '_' ? $key : '_'.$key;
	$url .= $delm.urlencode($par).'='.urlencode($val);
	$delm = '&';
	}
	}

	$base_path = '';
	if (!empty($_SERVER['REDIRECT_SCRIPT_URL'])) {
	$base_path = $_SERVER['REDIRECT_SCRIPT_URL'];
	}
	else if (!empty($_SERVER['SCRIPT_NAME'])) {
	$base_path = $_SERVER['SCRIPT_NAME'];
	}
	$base_path = preg_replace('![^/]+$!', '', $base_path);

	if ($secure && ($token = $this->get_secure_url_token(true))) {
	// add token to the url
	$url = $token . '/' . $url;

	// remove old token from the path
	$base_path = rtrim($base_path, '/');
	$base_path = preg_replace('/\/[a-zA-Z0-9]{' . strlen($token) . '}$/', '', $base_path);

	// this need to be full url to make redirects work
	$absolute = true;
	}
	else if ($secure && ($token = $this->get_request_token()))
	$url .= $delm . '_token=' . urlencode($token);

	if ($absolute \|\| $full) {
	// add base path to this Roundcube installation
	if ($base_path == '') $base_path = '/';
	$prefix = $base_path;

	// prepend protocol://hostname:port
	if ($full) {
	$prefix = rcube_utils::resolve_url($prefix);
	}

	$prefix = rtrim($prefix, '/') . '/';
	}
	else {
	$prefix = './';
	}

	return $prefix . $url;
	}

	/**
	* Function to be executed in script shutdown
	*/
	public function shutdown()
	{
	parent::shutdown();

	foreach ($this->address_books as $book) {
	if (is_object($book) && is_a($book, 'rcube_addressbook')) {
	$book->close();
	}
	}

	// write performance stats to logs/console
	if ($this->config->get('devel_mode') \|\| $this->config->get('performance_stats')) {
	// we have to disable per_user_logging to make sure stats end up in the main console log
	$this->config->set('per_user_logging', false);

	// make sure logged numbers use unified format
	setlocale(LC_NUMERIC, 'en_US.utf8', 'en_US.UTF-8', 'en_US', 'C');

	if (function_exists('memory_get_usage')) {
	$mem = round(memory_get_usage() / 1024 /1024, 1);

	if (function_exists('memory_get_peak_usage')) {
	$mem .= '/'. round(memory_get_peak_usage() / 1024 / 1024, 1);
	}
	}

	$log = $this->task . ($this->action ? '/'.$this->action : '') . (isset($mem) ? " [$mem]" : '');

	if (defined('RCMAIL_START')) {
	self::print_timer(RCMAIL_START, $log);
	}
	else {
	self::console($log);
	}
	}
	}

	/**
	* CSRF attack prevention code. Raises error when check fails.
	*
	* @param int $mode Request mode
	*/
	public function request_security_check($mode = rcube_utils::INPUT_POST)
	{
	// check request token
	if (!$this->check_request($mode)) {
	$error = array('code' => 403, 'message' => "Request security check failed");
	self::raise_error($error, false, true);
	}
	}

	/**
	* Registers action aliases for current task
	*
	* @param array $map Alias-to-filename hash array
	*/
	public function register_action_map($map)
	{
	if (is_array($map)) {
	foreach ($map as $idx => $val) {
	$this->action_map[$idx] = $val;
	}
	}
	}

	/**
	* Returns current action filename
	*
	* @param array $map Alias-to-filename hash array
	*/
	public function get_action_file()
	{
	if (!empty($this->action_map[$this->action])) {
	return $this->action_map[$this->action];
	}

	return strtr($this->action, '-', '_') . '.inc';
	}

	/**
	* Fixes some user preferences according to namespace handling change.
	* Old Roundcube versions were using folder names with removed namespace prefix.
	* Now we need to add the prefix on servers where personal namespace has prefix.
	*
	* @param rcube_user $user User object
	*/
	private function fix_namespace_settings($user)
	{
	$prefix = $this->storage->get_namespace('prefix');
	$prefix_len = strlen($prefix);

	if (!$prefix_len) {
	return;
	}

	if ($this->config->get('namespace_fixed')) {
	return;
	}

	$prefs = array();

	// Build namespace prefix regexp
	$ns = $this->storage->get_namespace();
	$regexp = array();

	foreach ($ns as $entry) {
	if (!empty($entry)) {
	foreach ($entry as $item) {
	if (strlen($item[0])) {
	$regexp[] = preg_quote($item[0], '/');
	}
	}
	}
	}
	$regexp = '/^('. implode('\|', $regexp).')/';

	// Fix preferences
	$opts = array('drafts_mbox', 'junk_mbox', 'sent_mbox', 'trash_mbox', 'archive_mbox');
	foreach ($opts as $opt) {
	if ($value = $this->config->get($opt)) {
	if ($value != 'INBOX' && !preg_match($regexp, $value)) {
	$prefs[$opt] = $prefix.$value;
	}
	}
	}

	if (($search_mods = $this->config->get('search_mods')) && !empty($search_mods)) {
	$folders = array();
	foreach ($search_mods as $idx => $value) {
	if ($idx != 'INBOX' && $idx != '*' && !preg_match($regexp, $idx)) {
	$idx = $prefix.$idx;
	}
	$folders[$idx] = $value;
	}

	$prefs['search_mods'] = $folders;
	}

	if (($threading = $this->config->get('message_threading')) && !empty($threading)) {
	$folders = array();
	foreach ($threading as $idx => $value) {
	if ($idx != 'INBOX' && !preg_match($regexp, $idx)) {
	$idx = $prefix.$idx;
	}
	$folders[$prefix.$idx] = $value;
	}

	$prefs['message_threading'] = $folders;
	}

	if ($collapsed = $this->config->get('collapsed_folders')) {
	$folders = explode('&&', $collapsed);
	$count = count($folders);
	$folders_str = '';

	if ($count) {
	$folders[0] = substr($folders[0], 1);
	$folders[$count-1] = substr($folders[$count-1], 0, -1);
	}

	foreach ($folders as $value) {
	if ($value != 'INBOX' && !preg_match($regexp, $value)) {
	$value = $prefix.$value;
	}
	$folders_str .= '&'.$value.'&';
	}

	$prefs['collapsed_folders'] = $folders_str;
	}

	$prefs['namespace_fixed'] = true;

	// save updated preferences and reset imap settings (default folders)
	$user->save_prefs($prefs);
	$this->set_storage_prop();
	}

	/**
	* Overwrite action variable
	*
	* @param string $action New action value
	*/
	public function overwrite_action($action)
	{
	$this->action = $action;
	$this->output->set_env('action', $action);
	}

	/**
	* Set environment variables for specified config options
	*
	* @param array $options List of configuration option names
	*/
	public function set_env_config($options)
	{
	foreach ((array) $options as $option) {
	if ($this->config->get($option)) {
	$this->output->set_env($option, true);
	}
	}
	}

	/**
	* Insert a contact to specified addressbook.
	*
	* @param array $contact Contact data
	* @param rcube_addressbook $source The addressbook object
	* @param string $error Filled with an error message/label on error
	*
	* @return int\|bool Contact ID on success, False otherwise
	*/
	public function contact_create($contact, $source, &$error = null)
	{
	$contact['email'] = rcube_utils::idn_to_utf8($contact['email']);

	$contact = $this->plugins->exec_hook('contact_displayname', $contact);

	if (empty($contact['name'])) {
	$contact['name'] = rcube_addressbook::compose_display_name($contact);
	}

	// validate the contact
	if (!$source->validate($contact, true)) {
	$error = $source->get_error();
	return false;
	}

	$plugin = $this->plugins->exec_hook('contact_create', array(
	'record' => $contact,
	'source' => $this->get_address_book_id($source),
	));

	$contact = $plugin['record'];

	if (!empty($plugin['abort'])) {
	$error = $plugin['message'];
	return $plugin['result'];
	}

	return $source->insert($contact);
	}

	/**
	* Find an email address in user addressbook(s)
	*
	* @param string $email Email address
	* @param int $type Addressbook type (see rcube_addressbook::TYPE_* consts)
	*
	* @return bool True if the address exists in specified addressbook(s), False otherwise
	*/
	public function contact_exists($email, $type)
	{
	if (empty($email) \|\| !is_string($email) \|\| !strpos($email, '@')) {
	return false;
	}

	// TODO: Support TYPE_READONLY filter
	$sources = [];

	if ($type & rcube_addressbook::TYPE_WRITEABLE) {
	foreach ($this->get_address_sources(true, true) as $book) {
	$sources[] = $book['id'];
	}
	}

	if ($type & rcube_addressbook::TYPE_DEFAULT) {
	if ($default = $this->get_address_book(rcube_addressbook::TYPE_DEFAULT, true)) {
	$book_id = $this->get_address_book_id($default);
	if (!in_array($book_id, $sources)) {
	$sources[] = $book_id;
	}
	}
	}

	if ($type & rcube_addressbook::TYPE_RECIPIENT) {
	$collected_recipients = $this->config->get('collected_recipients');
	if (strlen($collected_recipients) && !in_array($collected_recipients, $sources)) {
	array_unshift($sources, $collected_recipients);
	}
	}

	if ($type & rcube_addressbook::TYPE_TRUSTED_SENDER) {
	$collected_senders = $this->config->get('collected_senders');
	if (strlen($collected_senders) && !in_array($collected_senders, $sources)) {
	array_unshift($sources, $collected_senders);
	}
	}

	$plugin = $this->plugins->exec_hook('contact_exists', array(
	'email' => $email,
	'type' => $type,
	'sources' => $sources,
	));

	if (!empty($plugin['abort'])) {
	return $plugin['result'];
	}

	foreach ($plugin['sources'] as $source) {
	$contacts = $this->get_address_book($source);

	if (!$contacts) {
	continue;
	}

	$result = $contacts->search('email', $email, rcube_addressbook::SEARCH_STRICT, false);

	if ($result->count) {
	return true;
	}
	}

	return false;
	}

	/**
	* Returns RFC2822 formatted current date in user's timezone
	*
	* @return string Date
	*/
	public function user_date()
	{
	// get user's timezone
	try {
	$tz = new DateTimeZone($this->config->get('timezone'));
	$date = new DateTime('now', $tz);
	}
	catch (Exception $e) {
	$date = new DateTime();
	}

	return $date->format('r');
	}

	/**
	* Write login data (name, ID, IP address) to the 'userlogins' log file.
	*/
	public function log_login($user = null, $failed_login = false, $error_code = 0)
	{
	if (!$this->config->get('log_logins')) {
	return;
	}

	// don't log full session id for security reasons
	$session_id = session_id();
	$session_id = $session_id ? substr($session_id, 0, 16) : 'no-session';

	// failed login
	if ($failed_login) {
	// don't fill the log with complete input, which could
	// have been prepared by a hacker
	if (strlen($user) > 256) {
	$user = substr($user, 0, 256) . '...';
	}

	$message = sprintf('Failed login for %s from %s in session %s (error: %d)',
	$user, rcube_utils::remote_ip(), $session_id, $error_code);
	}
	// successful login
	else {
	$user_name = $this->get_user_name();
	$user_id = $this->get_user_id();

	if (!$user_id) {
	return;
	}

	$message = sprintf('Successful login for %s (ID: %d) from %s in session %s',
	$user_name, $user_id, rcube_utils::remote_ip(), $session_id);
	}

	// log login
	self::write_log('userlogins', $message);
	}

	/**
	* Check if specified asset file exists
	*
	* @param string $path Asset path
	* @param bool $minified Fallback to minified version of the file
	*
	* @return string Asset path if found (modified if minified file found)
	*/
	public function find_asset($path, $minified = true)
	{
	if (empty($path)) {
	return;
	}

	$assets_dir = $this->config->get('assets_dir');
	$root_path = unslashify($assets_dir ?: INSTALL_PATH) . '/';
	$full_path = $root_path . trim($path, '/');

	if (file_exists($full_path)) {
	return $path;
	}

	if ($minified && preg_match('/(?<!\.min)\.(js\|css)$/', $path)) {
	$path = preg_replace('/\.(js\|css)$/', '.min.\\1', $path);
	$full_path = $root_path . trim($path, '/');

	if (file_exists($full_path)) {
	return $path;
	}
	}
	}

	/**
	* Create a HTML table based on the given data
	*
	* @param array $attrib Named table attributes
	* @param mixed $table_data Table row data. Either a two-dimensional array
	* or a valid SQL result set
	* @param array $show_cols List of cols to show
	* @param string $id_col Name of the identifier col
	*
	* @return string HTML table code
	*/
	public function table_output($attrib, $table_data, $show_cols, $id_col)
	{
	$table = new html_table($attrib);

	// add table header
	if (!$attrib['noheader']) {
	foreach ($show_cols as $col) {
	$table->add_header($col, $this->Q($this->gettext($col)));
	}
	}

	if (!is_array($table_data)) {
	$db = $this->get_dbh();
	while ($table_data && ($sql_arr = $db->fetch_assoc($table_data))) {
	$table->add_row(array('id' => 'rcmrow' . rcube_utils::html_identifier($sql_arr[$id_col])));

	// format each col
	foreach ($show_cols as $col) {
	$table->add($col, $this->Q($sql_arr[$col]));
	}
	}
	}
	else {
	foreach ($table_data as $row_data) {
	$class = !empty($row_data['class']) ? $row_data['class'] : null;
	if (!empty($attrib['rowclass']))
	$class = trim($class . ' ' . $attrib['rowclass']);
	$rowid = 'rcmrow' . rcube_utils::html_identifier($row_data[$id_col]);

	$table->add_row(array('id' => $rowid, 'class' => $class));

	// format each col
	foreach ($show_cols as $col) {
	$val = is_array($row_data[$col]) ? $row_data[$col][0] : $row_data[$col];
	$table->add($col, empty($attrib['ishtml']) ? $this->Q($val) : $val);
	}
	}
	}

	return $table->show($attrib);
	}

	/**
	* Convert the given date to a human readable form
	* This uses the date formatting properties from config
	*
	* @param mixed $date Date representation (string, timestamp or DateTime object)
	* @param string $format Date format to use
	* @param bool $convert Enables date conversion according to user timezone
	*
	* @return string Formatted date string
	*/
	public function format_date($date, $format = null, $convert = true)
	{
	if (is_object($date) && is_a($date, 'DateTime')) {
	$timestamp = $date->format('U');
	}
	else {
	if (!empty($date)) {
	$timestamp = rcube_utils::strtotime($date);
	}

	if (empty($timestamp)) {
	return '';
	}

	try {
	$date = new DateTime("@".$timestamp);
	}
	catch (Exception $e) {
	return '';
	}
	}

	if ($convert) {
	try {
	// convert to the right timezone
	$stz = date_default_timezone_get();
	$tz = new DateTimeZone($this->config->get('timezone'));
	$date->setTimezone($tz);
	date_default_timezone_set($tz->getName());

	$timestamp = $date->format('U');
	}
	catch (Exception $e) {
	}
	}

	// define date format depending on current time
	if (!$format) {
	$now = time();
	$now_date = getdate($now);
	$today_limit = mktime(0, 0, 0, $now_date['mon'], $now_date['mday'], $now_date['year']);
	$week_limit = mktime(0, 0, 0, $now_date['mon'], $now_date['mday']-6, $now_date['year']);
	$pretty_date = $this->config->get('prettydate');

	if ($pretty_date && $timestamp > $today_limit && $timestamp <= $now) {
	$format = $this->config->get('date_today', $this->config->get('time_format', 'H:i'));
	$today = true;
	}
	else if ($pretty_date && $timestamp > $week_limit && $timestamp <= $now) {
	$format = $this->config->get('date_short', 'D H:i');
	}
	else {
	$format = $this->config->get('date_long', 'Y-m-d H:i');
	}
	}

	// strftime() format
	if (preg_match('/%[a-z]+/i', $format)) {
	$format = strftime($format, $timestamp);

	if (isset($stz)) {
	date_default_timezone_set($stz);
	}

	return !empty($today) ? ($this->gettext('today') . ' ' . $format) : $format;
	}

	// parse format string manually in order to provide localized weekday and month names
	// an alternative would be to convert the date() format string to fit with strftime()
	$out = '';
	for ($i=0; $i<strlen($format); $i++) {
	if ($format[$i] == "\\") { // skip escape chars
	continue;
	}

	// write char "as-is"
	if ($format[$i] == ' ' \|\| $format[$i-1] == "\\") {
	$out .= $format[$i];
	}
	// weekday (short)
	else if ($format[$i] == 'D') {
	$out .= $this->gettext(strtolower(date('D', $timestamp)));
	}
	// weekday long
	else if ($format[$i] == 'l') {
	$out .= $this->gettext(strtolower(date('l', $timestamp)));
	}
	// month name (short)
	else if ($format[$i] == 'M') {
	$out .= $this->gettext(strtolower(date('M', $timestamp)));
	}
	// month name (long)
	else if ($format[$i] == 'F') {
	$out .= $this->gettext('long'.strtolower(date('M', $timestamp)));
	}
	else if ($format[$i] == 'x') {
	$out .= strftime('%x %X', $timestamp);
	}
	else {
	$out .= date($format[$i], $timestamp);
	}
	}

	if (!empty($today)) {
	$label = $this->gettext('today');
	// replcae $ character with "Today" label (#1486120)
	if (strpos($out, '$') !== false) {
	$out = preg_replace('/\$/', $label, $out, 1);
	}
	else {
	$out = $label . ' ' . $out;
	}
	}

	if (isset($stz)) {
	date_default_timezone_set($stz);
	}

	return $out;
	}

	/**
	* Return folders list in HTML
	*
	* @param array $attrib Named parameters
	*
	* @return string HTML code for the gui object
	*/
	public function folder_list($attrib)
	{
	static $a_mailboxes;

	$attrib += array('maxlength' => 100, 'realnames' => false, 'unreadwrap' => ' (%s)');

	- $type = $attrib['type'] ? $attrib['type'] : 'ul';
	+ $type = !empty($attrib['type']) ? $attrib['type'] : 'ul';
	unset($attrib['type']);

	- if ($type == 'ul' && !$attrib['id']) {
	+ if ($type == 'ul' && empty($attrib['id'])) {
	$attrib['id'] = 'rcmboxlist';
	}

	if (empty($attrib['folder_name'])) {
	$attrib['folder_name'] = '*';
	}

	// get current folder
	$storage = $this->get_storage();
	$mbox_name = $storage->get_folder();
	$delimiter = $storage->get_hierarchy_delimiter();

	// build the folders tree
	if (empty($a_mailboxes)) {
	// get mailbox list
	- $a_folders = $storage->list_folders_subscribed(
	- '', $attrib['folder_name'], $attrib['folder_filter']);
	$a_mailboxes = array();
	+ $a_folders = $storage->list_folders_subscribed(
	+ '',
	+ $attrib['folder_name'],
	+ isset($attrib['folder_filter']) ? $attrib['folder_filter'] : null
	+ );

	foreach ($a_folders as $folder) {
	$this->build_folder_tree($a_mailboxes, $folder, $delimiter);
	}
	}

	// allow plugins to alter the folder tree or to localize folder names
	$hook = $this->plugins->exec_hook('render_mailboxlist', array(
	'list' => $a_mailboxes,
	'delimiter' => $delimiter,
	'type' => $type,
	'attribs' => $attrib,
	));

	$a_mailboxes = $hook['list'];
	$attrib = $hook['attribs'];

	if ($type == 'select') {
	$attrib['is_escaped'] = true;
	$select = new html_select($attrib);

	// add no-selection option
	- if ($attrib['noselection']) {
	+ if (!empty($attrib['noselection'])) {
	$select->add(html::quote($this->gettext($attrib['noselection'])), '');
	}

	- $this->render_folder_tree_select($a_mailboxes, $mbox_name, $attrib['maxlength'], $select, $attrib['realnames']);
	- $out = $select->show($attrib['default']);
	+ $maxlength = isset($attrib['maxlength']) ? $attrib['maxlength'] : null;
	+ $realnames = isset($attrib['realnames']) ? $attrib['realnames'] : null;
	+ $default = isset($attrib['default']) ? $attrib['default'] : null;
	+
	+ $this->render_folder_tree_select($a_mailboxes, $mbox_name, $maxlength, $select, $realnames);
	+ $out = $select->show($default);
	}
	else {
	$out = '';
	$js_mailboxlist = array();
	$tree = $this->render_folder_tree_html($a_mailboxes, $mbox_name, $js_mailboxlist, $attrib);

	if ($type != 'js') {
	$out = html::tag('ul', $attrib, $tree, html::$common_attrib);

	$this->output->include_script('treelist.js');
	$this->output->add_gui_object('mailboxlist', $attrib['id']);
	- $this->output->set_env('unreadwrap', $attrib['unreadwrap']);
	+ $this->output->set_env('unreadwrap', isset($attrib['unreadwrap']) ? $attrib['unreadwrap'] : false);
	$this->output->set_env('collapsed_folders', (string) $this->config->get('collapsed_folders'));
	}

	$this->output->set_env('mailboxes', $js_mailboxlist);

	// we can't use object keys in javascript because they are unordered
	// we need sorted folders list for folder-selector widget
	$this->output->set_env('mailboxes_list', array_keys($js_mailboxlist));
	}

	// add some labels to client
	$this->output->add_label('purgefolderconfirm', 'deletemessagesconfirm');

	return $out;
	}

	/**
	* Return folders list as html_select object
	*
	* @param array $p Named parameters
	*
	* @return html_select HTML drop-down object
	*/
	public function folder_selector($p = array())
	{
	$realnames = $this->config->get('show_real_foldernames');
	$p += array('maxlength' => 100, 'realnames' => $realnames, 'is_escaped' => true);
	$a_mailboxes = array();
	$storage = $this->get_storage();

	if (empty($p['folder_name'])) {
	$p['folder_name'] = '*';
	}

	if ($p['unsubscribed']) {
	$list = $storage->list_folders('', $p['folder_name'], $p['folder_filter'], $p['folder_rights']);
	}
	else {
	$list = $storage->list_folders_subscribed('', $p['folder_name'], $p['folder_filter'], $p['folder_rights']);
	}

	$delimiter = $storage->get_hierarchy_delimiter();

	if (!empty($p['exceptions'])) {
	$list = array_diff($list, (array) $p['exceptions']);
	}

	if (!empty($p['additional'])) {
	foreach ($p['additional'] as $add_folder) {
	$add_items = explode($delimiter, $add_folder);
	$folder = '';
	while (count($add_items)) {
	$folder .= array_shift($add_items);

	// @TODO: sorting
	if (!in_array($folder, $list)) {
	$list[] = $folder;
	}

	$folder .= $delimiter;
	}
	}
	}

	foreach ($list as $folder) {
	$this->build_folder_tree($a_mailboxes, $folder, $delimiter);
	}

	// allow plugins to alter the folder tree or to localize folder names
	$hook = $this->plugins->exec_hook('render_folder_selector', array(
	'list' => $a_mailboxes,
	'delimiter' => $delimiter,
	'attribs' => $p,
	));

	$a_mailboxes = $hook['list'];
	$p = $hook['attribs'];

	$select = new html_select($p);

	if ($p['noselection']) {
	$select->add(html::quote($p['noselection']), '');
	}

	$this->render_folder_tree_select($a_mailboxes, $mbox, $p['maxlength'], $select, $p['realnames'], 0, $p);

	return $select;
	}

	/**
	* Create a hierarchical array of the mailbox list
	*/
	public function build_folder_tree(&$arrFolders, $folder, $delm = '/', $path = '')
	{
	// Handle namespace prefix
	$prefix = '';
	if (!$path) {
	$n_folder = $folder;
	$folder = $this->storage->mod_folder($folder);

	if ($n_folder != $folder) {
	$prefix = substr($n_folder, 0, -strlen($folder));
	}
	}

	$pos = strpos($folder, $delm);

	if ($pos !== false) {
	$subFolders = substr($folder, $pos+1);
	$currentFolder = substr($folder, 0, $pos);

	// sometimes folder has a delimiter as the last character
	if (!strlen($subFolders)) {
	$virtual = false;
	}
	else if (!isset($arrFolders[$currentFolder])) {
	$virtual = true;
	}
	else {
	$virtual = $arrFolders[$currentFolder]['virtual'];
	}
	}
	else {
	$subFolders = false;
	$currentFolder = $folder;
	$virtual = false;
	}

	$path .= $prefix . $currentFolder;

	if (!isset($arrFolders[$currentFolder])) {
	$arrFolders[$currentFolder] = array(
	'id' => $path,
	'name' => rcube_charset::convert($currentFolder, 'UTF7-IMAP'),
	'virtual' => $virtual,
	'folders' => array()
	);
	}
	else {
	$arrFolders[$currentFolder]['virtual'] = $virtual;
	}

	if (strlen($subFolders)) {
	$this->build_folder_tree($arrFolders[$currentFolder]['folders'], $subFolders, $delm, $path.$delm);
	}
	}

	/**
	* Return html for a structured list <ul> for the mailbox tree
	*/
	public function render_folder_tree_html(&$arrFolders, &$mbox_name, &$jslist, $attrib, $nestLevel = 0)
	{
	$maxlength = intval($attrib['maxlength']);
	$realnames = (bool)$attrib['realnames'];
	$msgcounts = $this->storage->get_cache('messagecount');
	$collapsed = $this->config->get('collapsed_folders');
	$realnames = $this->config->get('show_real_foldernames');

	$out = '';
	foreach ($arrFolders as $folder) {
	$title = null;
	$folder_class = $this->folder_classname($folder['id']);
	$is_collapsed = strpos($collapsed, '&'.rawurlencode($folder['id']).'&') !== false;
	$unread = $msgcounts ? intval($msgcounts[$folder['id']]['UNSEEN']) : 0;

	if ($folder_class && !$realnames && $this->text_exists($folder_class)) {
	$foldername = $this->gettext($folder_class);
	}
	else {
	$foldername = $folder['name'];

	// shorten the folder name to a given length
	if ($maxlength && $maxlength > 1) {
	$fname = abbreviate_string($foldername, $maxlength);
	if ($fname != $foldername) {
	$title = $foldername;
	}
	$foldername = $fname;
	}
	}

	// make folder name safe for ids and class names
	$folder_id = rcube_utils::html_identifier($folder['id'], true);
	$classes = array('mailbox');

	// set special class for Sent, Drafts, Trash and Junk
	if ($folder_class) {
	$classes[] = $folder_class;
	}

	if ($folder['id'] == $mbox_name) {
	$classes[] = 'selected';
	}

	if ($folder['virtual']) {
	$classes[] = 'virtual';
	}
	else if ($unread) {
	$classes[] = 'unread';
	}

	$js_name = $this->JQ($folder['id']);
	$html_name = $this->Q($foldername) . ($unread ? html::span('unreadcount skip-content', sprintf($attrib['unreadwrap'], $unread)) : '');
	$link_attrib = $folder['virtual'] ? array() : array(
	'href' => $this->url(array('_mbox' => $folder['id'])),
	'onclick' => sprintf("return %s.command('list','%s',this,event)", rcmail_output::JS_OBJECT_NAME, $js_name),
	'rel' => $folder['id'],
	'title' => $title,
	);

	$out .= html::tag('li', array(
	'id' => "rcmli" . $folder_id,
	'class' => implode(' ', $classes),
	'noclose' => true
	),
	html::a($link_attrib, $html_name));

	if (!empty($folder['folders'])) {
	$out .= html::div('treetoggle ' . ($is_collapsed ? 'collapsed' : 'expanded'), ' ');
	}

	$jslist[$folder['id']] = array(
	'id' => $folder['id'],
	'name' => $foldername,
	'virtual' => $folder['virtual'],
	);

	if (!empty($folder_class)) {
	$jslist[$folder['id']]['class'] = $folder_class;
	}

	if (!empty($folder['folders'])) {
	$out .= html::tag('ul', array('style' => ($is_collapsed ? "display:none;" : null)),
	$this->render_folder_tree_html($folder['folders'], $mbox_name, $jslist, $attrib, $nestLevel+1));
	}

	$out .= "</li>\n";
	}

	return $out;
	}

	/**
	* Return html for a flat list <select> for the mailbox tree
	*/
	public function render_folder_tree_select(&$arrFolders, &$mbox_name, $maxlength, &$select, $realnames = false, $nestLevel = 0, $opts = array())
	{
	$out = '';

	foreach ($arrFolders as $folder) {
	// skip exceptions (and its subfolders)
	if (!empty($opts['exceptions']) && in_array($folder['id'], $opts['exceptions'])) {
	continue;
	}

	// skip folders in which it isn't possible to create subfolders
	if (!empty($opts['skip_noinferiors'])) {
	$attrs = $this->storage->folder_attributes($folder['id']);
	if ($attrs && in_array_nocase('\\Noinferiors', $attrs)) {
	continue;
	}
	}

	if (!$realnames && ($folder_class = $this->folder_classname($folder['id'])) && $this->text_exists($folder_class)) {
	$foldername = $this->gettext($folder_class);
	}
	else {
	$foldername = $folder['name'];

	// shorten the folder name to a given length
	if ($maxlength && $maxlength > 1) {
	$foldername = abbreviate_string($foldername, $maxlength);
	}
	}

	$select->add(str_repeat(' ', $nestLevel*4) . html::quote($foldername), $folder['id']);

	if (!empty($folder['folders'])) {
	$out .= $this->render_folder_tree_select($folder['folders'], $mbox_name, $maxlength,
	$select, $realnames, $nestLevel+1, $opts);
	}
	}

	return $out;
	}

	/**
	* Returns class name for the given folder if it is a special folder
	* (including shared/other users namespace roots).
	*
	* @param string $folder_id IMAP Folder name
	*
	* @return string\|null CSS class name
	*/
	public function folder_classname($folder_id)
	{
	static $classes;

	if ($classes === null) {
	$classes = array('INBOX' => 'inbox');

	// for these mailboxes we have css classes
	foreach (array('sent', 'drafts', 'trash', 'junk') as $type) {
	if (($mbox = $this->config->get($type . '_mbox')) && !isset($classes[$mbox])) {
	$classes[$mbox] = $type;
	}
	}

	$storage = $this->get_storage();

	// add classes for shared/other user namespace roots
	foreach (array('other', 'shared') as $ns_name) {
	if ($ns = $storage->get_namespace($ns_name)) {
	foreach ($ns as $root) {
	$root = substr($root[0], 0, -1);
	if (strlen($root) && !isset($classes[$root])) {
	$classes[$root] = "ns-$ns_name";
	}
	}
	}
	}
	}

	- return $classes[$folder_id];
	+ return !empty($classes[$folder_id]) ? $classes[$folder_id] : null;
	}

	/**
	* Try to localize the given IMAP folder name.
	* UTF-7 decode it in case no localized text was found
	*
	* @param string $name Folder name
	* @param bool $with_path Enable path localization
	* @param bool $path_remove Remove the path
	*
	* @return string Localized folder name in UTF-8 encoding
	*/
	public function localize_foldername($name, $with_path = false, $path_remove = false)
	{
	$realnames = $this->config->get('show_real_foldernames');

	if (!$realnames && ($folder_class = $this->folder_classname($name)) && $this->text_exists($folder_class)) {
	return $this->gettext($folder_class);
	}

	$storage = $this->get_storage();
	$delimiter = $storage->get_hierarchy_delimiter();

	// Remove the path
	if ($path_remove) {
	if (strpos($name, $delimiter)) {
	$path = explode($delimiter, $name);
	$name = array_pop($path);
	}
	}
	// try to localize path of the folder
	else if ($with_path && !$realnames) {
	$path = explode($delimiter, $name);
	$count = count($path);

	if ($count > 1) {
	for ($i = 1; $i < $count; $i++) {
	$folder = implode($delimiter, array_slice($path, 0, -$i));
	$folder_class = $this->folder_classname($folder);

	if ($folder_class && $this->text_exists($folder_class)) {
	$name = implode($delimiter, array_slice($path, $count - $i));
	$name = rcube_charset::convert($name, 'UTF7-IMAP');

	return $this->gettext($folder_class) . $delimiter . $name;
	}
	}
	}
	}

	return rcube_charset::convert($name, 'UTF7-IMAP');
	}

	/**
	* Localize folder path
	*/
	public function localize_folderpath($path)
	{
	$protect_folders = $this->config->get('protect_default_folders');
	$delimiter = $this->storage->get_hierarchy_delimiter();
	$path = explode($delimiter, $path);
	$result = array();

	foreach ($path as $idx => $dir) {
	$directory = implode($delimiter, array_slice($path, 0, $idx+1));
	if ($protect_folders && $this->storage->is_special_folder($directory)) {
	unset($result);
	$result[] = $this->localize_foldername($directory);
	}
	else {
	$result[] = rcube_charset::convert($dir, 'UTF7-IMAP');
	}
	}

	return implode($delimiter, $result);
	}

	/**
	* Return HTML for quota indicator object
	*
	* @param array $attrib Named parameters
	*
	* @return string HTML code for the quota indicator object
	*/
	public static function quota_display($attrib)
	{
	$rcmail = rcmail::get_instance();

	- if (!$attrib['id']) {
	+ if (empty($attrib['id'])) {
	$attrib['id'] = 'rcmquotadisplay';
	}

	$_SESSION['quota_display'] = !empty($attrib['display']) ? $attrib['display'] : 'text';

	$rcmail->output->add_gui_object('quotadisplay', $attrib['id']);

	$quota = $rcmail->quota_content($attrib);

	$rcmail->output->add_script('rcmail.set_quota('.rcube_output::json_serialize($quota).');', 'docready');

	return html::span($attrib, ' ');
	}

	/**
	* Return (parsed) quota information
	*
	* @param array $attrib Named parameters
	* @param array $folder Current folder
	*
	* @return array Quota information
	*/
	public function quota_content($attrib = null, $folder = null)
	{
	$quota = $this->storage->get_quota($folder);
	$quota = $this->plugins->exec_hook('quota', $quota);

	$quota_result = (array) $quota;
	$quota_result['type'] = isset($_SESSION['quota_display']) ? $_SESSION['quota_display'] : '';
	$quota_result['folder'] = $folder !== null && $folder !== '' ? $folder : 'INBOX';

	if ($quota['total'] > 0) {
	if (!isset($quota['percent'])) {
	$quota_result['percent'] = min(100, round(($quota['used']/max(1,$quota['total']))*100));
	}

	$title = $this->gettext('quota') . ': ' . sprintf('%s / %s (%.0f%%)',
	$this->show_bytes($quota['used'] * 1024),
	$this->show_bytes($quota['total'] * 1024),
	$quota_result['percent']
	);

	$quota_result['title'] = $title;

	- if ($attrib['width']) {
	+ if (!empty($attrib['width'])) {
	$quota_result['width'] = $attrib['width'];
	}
	- if ($attrib['height']) {
	+ if (!empty($attrib['height'])) {
	$quota_result['height'] = $attrib['height'];
	}

	// build a table of quota types/roots info
	if (($root_cnt = count($quota_result['all'])) > 1 \|\| count($quota_result['all'][key($quota_result['all'])]) > 1) {
	$table = new html_table(array('cols' => 3, 'class' => 'quota-info'));

	$table->add_header(null, self::Q($this->gettext('quotatype')));
	$table->add_header(null, self::Q($this->gettext('quotatotal')));
	$table->add_header(null, self::Q($this->gettext('quotaused')));

	foreach ($quota_result['all'] as $root => $data) {
	if ($root_cnt > 1 && $root) {
	$table->add(array('colspan' => 3, 'class' => 'root'), self::Q($root));
	}

	if ($storage = $data['storage']) {
	$percent = min(100, round(($storage['used']/max(1,$storage['total']))*100));

	$table->add('name', self::Q($this->gettext('quotastorage')));
	$table->add(null, $this->show_bytes($storage['total'] * 1024));
	$table->add(null, sprintf('%s (%.0f%%)', $this->show_bytes($storage['used'] * 1024), $percent));
	}
	if ($message = $data['message']) {
	$percent = min(100, round(($message['used']/max(1,$message['total']))*100));

	$table->add('name', self::Q($this->gettext('quotamessage')));
	$table->add(null, intval($message['total']));
	$table->add(null, sprintf('%d (%.0f%%)', $message['used'], $percent));
	}
	}

	$quota_result['table'] = $table->show();
	}
	}
	else {
	$unlimited = $this->config->get('quota_zero_as_unlimited');
	$quota_result['title'] = $this->gettext($unlimited ? 'unlimited' : 'unknown');
	$quota_result['percent'] = 0;
	}

	// cleanup
	unset($quota_result['abort']);
	if (empty($quota_result['table'])) {
	unset($quota_result['all']);
	}

	return $quota_result;
	}

	/**
	* Outputs error message according to server error/response codes
	*
	* @param string $fallback Fallback message label
	* @param array $fallback_args Fallback message label arguments
	* @param string $suffix Message label suffix
	* @param array $params Additional parameters (type, prefix)
	*/
	public function display_server_error($fallback = null, $fallback_args = null, $suffix = '', $params = array())
	{
	$err_code = $this->storage->get_error_code();
	$res_code = $this->storage->get_response_code();
	$args = array();

	if ($res_code == rcube_storage::NOPERM) {
	$error = 'errornoperm';
	}
	else if ($res_code == rcube_storage::READONLY) {
	$error = 'errorreadonly';
	}
	else if ($res_code == rcube_storage::OVERQUOTA) {
	$error = 'erroroverquota';
	}
	else if ($err_code && ($err_str = $this->storage->get_error_str())) {
	// try to detect access rights problem and display appropriate message
	if (stripos($err_str, 'Permission denied') !== false) {
	$error = 'errornoperm';
	}
	// try to detect full mailbox problem and display appropriate message
	// there can be e.g. "Quota exceeded" / "quotum would exceed" / "Over quota"
	else if (stripos($err_str, 'quot') !== false && preg_match('/exceed\|over/i', $err_str)) {
	$error = 'erroroverquota';
	}
	else {
	$error = 'servererrormsg';
	$args = array('msg' => rcube::Q($err_str));
	}
	}
	else if ($err_code < 0) {
	$error = 'storageerror';
	}
	else if ($fallback) {
	$error = $fallback;
	$args = $fallback_args;
	$params['prefix'] = false;
	}

	if (!empty($error)) {
	if ($suffix && $this->text_exists($error . $suffix)) {
	$error .= $suffix;
	}

	$msg = $this->gettext(array('name' => $error, 'vars' => $args));

	if ($params['prefix'] && $fallback) {
	$msg = $this->gettext(array('name' => $fallback, 'vars' => $fallback_args)) . ' ' . $msg;
	}

	$this->output->show_message($msg, $params['type'] ?: 'error');
	}
	}

	/**
	* Displays an error message on storage fatal errors
	*/
	public function storage_fatal_error()
	{
	$err_code = $this->storage->get_error_code();
	switch ($err_code) {
	// Not all are really fatal, but these should catch
	// connection/authentication errors the best we can
	case rcube_imap_generic::ERROR_NO:
	case rcube_imap_generic::ERROR_BAD:
	case rcube_imap_generic::ERROR_BYE:
	$this->display_server_error();
	}
	}

	/**
	* Output HTML editor scripts
	*
	* @param string $mode Editor mode
	*/
	public function html_editor($mode = '')
	{
	$spellcheck = intval($this->config->get('enable_spellcheck'));
	$spelldict = intval($this->config->get('spellcheck_dictionary'));
	$disabled_plugins = array();
	$disabled_buttons = array();
	$extra_plugins = array();
	$extra_buttons = array();

	if (!$spellcheck) {
	$disabled_plugins[] = 'spellchecker';
	}

	$hook = $this->plugins->exec_hook('html_editor', array(
	'mode' => $mode,
	'disabled_plugins' => $disabled_plugins,
	'disabled_buttons' => $disabled_buttons,
	'extra_plugins' => $extra_plugins,
	'extra_buttons' => $extra_buttons,
	));

	if ($hook['abort']) {
	return;
	}

	$lang_codes = array($_SESSION['language']);
	$assets_dir = $this->config->get('assets_dir') ?: INSTALL_PATH;
	$skin_path = $this->output->get_skin_path();

	if ($pos = strpos($_SESSION['language'], '_')) {
	$lang_codes[] = substr($_SESSION['language'], 0, $pos);
	}

	foreach ($lang_codes as $code) {
	if (file_exists("$assets_dir/program/js/tinymce/langs/$code.js")) {
	$lang = $code;
	break;
	}
	}

	if (empty($lang)) {
	$lang = 'en';
	}

	$config = array(
	'mode' => $mode,
	'lang' => $lang,
	'skin_path' => $skin_path,
	'spellcheck' => $spellcheck, // deprecated
	'spelldict' => $spelldict,
	'content_css' => 'program/resources/tinymce/content.css',
	'disabled_plugins' => $hook['disabled_plugins'],
	'disabled_buttons' => $hook['disabled_buttons'],
	'extra_plugins' => $hook['extra_plugins'],
	'extra_buttons' => $hook['extra_buttons'],
	);

	if ($path = $this->config->get('editor_css_location')) {
	if ($path = $this->find_asset($skin_path . $path)) {
	$config['content_css'] = $path;
	}
	}

	$font_family = $this->output->get_env('default_font');
	$font_size = $this->output->get_env('default_font_size');
	$style = array();

	if ($font_family) {
	$style[] = "font-family: $font_family;";
	}
	if ($font_size) {
	$style[] = "font-size: $font_size;";
	}
	if (!empty($style)) {
	$config['content_style'] = "body {" . implode(' ', $style) . "}";
	}

	$this->output->set_env('editor_config', $config);
	$this->output->add_label('selectimage', 'addimage', 'selectmedia', 'addmedia', 'close');

	if ($path = $this->config->get('media_browser_css_location', 'program/resources/tinymce/browser.css')) {
	if ($path != 'none' && ($path = $this->find_asset($path))) {
	$this->output->include_css($path);
	}
	}

	$this->output->include_script('tinymce/tinymce.min.js');
	$this->output->include_script('editor.js');
	}

	/**
	* File upload progress handler.
	*
	* @deprecated We're using HTML5 upload progress
	*/
	public function upload_progress()
	{
	// NOOP
	$this->output->send();
	}

	/**
	* Initializes file uploading interface.
	*
	* @param int $max_size Optional maximum file size in bytes
	*
	* @return string Human-readable file size limit
	*/
	public function upload_init($max_size = null)
	{
	// find max filesize value
	$max_filesize = rcube_utils::max_upload_size();
	if ($max_size && $max_size < $max_filesize) {
	$max_filesize = $max_size;
	}

	$max_filesize_txt = $this->show_bytes($max_filesize);
	$this->output->set_env('max_filesize', $max_filesize);
	$this->output->set_env('filesizeerror', $this->gettext(array(
	'name' => 'filesizeerror', 'vars' => array('size' => $max_filesize_txt))));

	if ($max_filecount = ini_get('max_file_uploads')) {
	$this->output->set_env('max_filecount', $max_filecount);
	$this->output->set_env('filecounterror', $this->gettext(array(
	'name' => 'filecounterror', 'vars' => array('count' => $max_filecount))));
	}

	$this->output->add_label('uploadprogress', 'GB', 'MB', 'KB', 'B');

	return $max_filesize_txt;
	}

	/**
	* Upload form object
	*
	* @param array $attrib Object attributes
	* @param string $name Form object name
	* @param string $action Form action name
	* @param array $input_attr File input attributes
	* @param int $max_size Maximum upload size
	*
	* @return string HTML output
	*/
	public function upload_form($attrib, $name, $action, $input_attr = array(), $max_size = null)
	{
	// Get filesize, enable upload progress bar
	$max_filesize = $this->upload_init($max_size);

	$hint = html::div('hint', $this->gettext(array('name' => 'maxuploadsize', 'vars' => array('size' => $max_filesize))));

	- if ($attrib['mode'] == 'hint') {
	+ if (!empty($attrib['mode']) && $attrib['mode'] == 'hint') {
	return $hint;
	}

	// set defaults
	$attrib += array('id' => 'rcmUploadbox', 'buttons' => 'yes');

	$event = rcmail_output::JS_OBJECT_NAME . ".command('$action', this.form)";
	$form_id = $attrib['id'] . 'Frm';

	// Default attributes of file input and form
	$input_attr += array(
	'id' => $attrib['id'] . 'Input',
	'type' => 'file',
	'name' => '_attachments[]',
	'class' => 'form-control',
	);

	$form_attr = array(
	'id' => $form_id,
	'name' => $name,
	'method' => 'post',
	'enctype' => 'multipart/form-data'
	);

	- if ($attrib['mode'] == 'smart') {
	+ if (!empty($attrib['mode']) && $attrib['mode'] == 'smart') {
	unset($attrib['buttons']);
	$form_attr['class'] = 'smart-upload';
	$input_attr = array_merge($input_attr, array(
	// #5854: Chrome does not execute onchange when selecting the same file.
	// To fix this we reset the input using null value.
	'onchange' => "$event; this.value=null",
	'class' => 'smart-upload',
	'tabindex' => '-1',
	));
	}

	$input = new html_inputfield($input_attr);
	$content = $attrib['prefix'] . $input->show();

	- if ($attrib['mode'] != 'smart') {
	+ if (empty($attrib['mode']) \|\| $attrib['mode'] != 'smart') {
	$content = html::div(null, $content . $hint);
	}

	if (rcube_utils::get_boolean($attrib['buttons'])) {
	$button = new html_inputfield(array('type' => 'button'));
	$content .= html::div('buttons',
	$button->show($this->gettext('close'), array('class' => 'button', 'onclick' => "$('#{$attrib['id']}').hide()")) . ' ' .
	$button->show($this->gettext('upload'), array('class' => 'button mainaction', 'onclick' => $event))
	);
	}

	$this->output->add_gui_object($name, $form_id);

	return html::div($attrib, $this->output->form_tag($form_attr, $content));
	}

	/**
	* Outputs uploaded file content (with image thumbnails support
	*
	* @param array $file Upload file data
	*/
	public function display_uploaded_file($file)
	{
	if (empty($file)) {
	return;
	}

	$file = $this->plugins->exec_hook('attachment_display', $file);

	if ($file['status']) {
	if (empty($file['size'])) {
	$file['size'] = $file['data'] ? strlen($file['data']) : @filesize($file['path']);
	}

	// generate image thumbnail for file browser in HTML editor
	if (!empty($_GET['_thumbnail'])) {
	$thumbnail_size = 80;
	$mimetype = $file['mimetype'];
	$file_ident = $file['id'] . ':' . $file['mimetype'] . ':' . $file['size'];
	$thumb_name = 'thumb' . md5($file_ident . ':' . $this->user->ID . ':' . $thumbnail_size);
	$cache_file = rcube_utils::temp_filename($thumb_name, false, false);

	// render thumbnail image if not done yet
	if (!is_file($cache_file)) {
	if (!$file['path']) {
	$orig_name = $filename = $cache_file . '.tmp';
	file_put_contents($orig_name, $file['data']);
	}
	else {
	$filename = $file['path'];
	}

	$image = new rcube_image($filename);
	if ($imgtype = $image->resize($thumbnail_size, $cache_file, true)) {
	$mimetype = 'image/' . $imgtype;

	if (!empty($orig_name)) {
	unlink($orig_name);
	}
	}
	}

	if (is_file($cache_file)) {
	// cache for 1h
	$this->output->future_expire_header(3600);
	header('Content-Type: ' . $mimetype);
	header('Content-Length: ' . filesize($cache_file));

	readfile($cache_file);
	exit;
	}
	}

	header('Content-Type: ' . $file['mimetype']);
	header('Content-Length: ' . $file['size']);

	if ($file['data']) {
	echo $file['data'];
	}
	else if ($file['path']) {
	readfile($file['path']);
	}
	}
	}

	/**
	* Initializes client-side autocompletion.
	*/
	public function autocomplete_init()
	{
	static $init;

	if ($init) {
	return;
	}

	$init = 1;

	if (($threads = (int)$this->config->get('autocomplete_threads')) > 0) {
	$book_types = (array) $this->config->get('autocomplete_addressbooks', 'sql');
	if (count($book_types) > 1) {
	$this->output->set_env('autocomplete_threads', $threads);
	$this->output->set_env('autocomplete_sources', $book_types);
	}
	}

	$this->output->set_env('autocomplete_max', (int)$this->config->get('autocomplete_max', 15));
	$this->output->set_env('autocomplete_min_length', $this->config->get('autocomplete_min_length'));
	$this->output->add_label('autocompletechars', 'autocompletemore');
	}

	/**
	* Returns supported font-family specifications
	*
	* @param string $font Font name
	*
	* @param string\|array Font-family specification array or string (if $font is used)
	*/
	public static function font_defs($font = null)
	{
	$fonts = array(
	'Andale Mono' => '"Andale Mono",Times,monospace',
	'Arial' => 'Arial,Helvetica,sans-serif',
	'Arial Black' => '"Arial Black","Avant Garde",sans-serif',
	'Book Antiqua' => '"Book Antiqua",Palatino,serif',
	'Courier New' => '"Courier New",Courier,monospace',
	'Georgia' => 'Georgia,Palatino,serif',
	'Helvetica' => 'Helvetica,Arial,sans-serif',
	'Impact' => 'Impact,Chicago,sans-serif',
	'Tahoma' => 'Tahoma,Arial,Helvetica,sans-serif',
	'Terminal' => 'Terminal,Monaco,monospace',
	'Times New Roman' => '"Times New Roman",Times,serif',
	'Trebuchet MS' => '"Trebuchet MS",Geneva,sans-serif',
	'Verdana' => 'Verdana,Geneva,sans-serif',
	);

	if ($font) {
	return $fonts[$font];
	}

	return $fonts;
	}

	/**
	* Create a human readable string for a number of bytes
	*
	* @param int $bytes Number of bytes
	* @param string &$unit Size unit
	*
	* @return string Byte string
	*/
	public function show_bytes($bytes, &$unit = null)
	{
	// Plugins may want to display different units
	- $plugin = $this->plugins->exec_hook('show_bytes', array('bytes' => $bytes));
	+ $plugin = $this->plugins->exec_hook('show_bytes', array('bytes' => $bytes, 'unit' => null));

	$unit = $plugin['unit'];

	- if ($plugin['result'] !== null) {
	+ if (isset($plugin['result'])) {
	return $plugin['result'];
	}

	if ($bytes >= 1073741824) {
	$unit = 'GB';
	$gb = $bytes/1073741824;
	$str = sprintf($gb >= 10 ? "%d " : "%.1f ", $gb) . $this->gettext($unit);
	}
	else if ($bytes >= 1048576) {
	$unit = 'MB';
	$mb = $bytes/1048576;
	$str = sprintf($mb >= 10 ? "%d " : "%.1f ", $mb) . $this->gettext($unit);
	}
	else if ($bytes >= 1024) {
	$unit = 'KB';
	$str = sprintf("%d ", round($bytes/1024)) . $this->gettext($unit);
	}
	else {
	$unit = 'B';
	$str = sprintf('%d ', $bytes) . $this->gettext($unit);
	}

	return $str;
	}

	/**
	* Returns real size (calculated) of the message part
	*
	* @param rcube_message_part $part Message part
	*
	* @return string Part size (and unit)
	*/
	public function message_part_size($part)
	{
	if (isset($part->d_parameters['size'])) {
	$size = $this->show_bytes((int)$part->d_parameters['size']);
	}
	else {
	$size = $part->size;

	if ($size === 0) {
	$part->exact_size = true;
	}

	if ($part->encoding == 'base64') {
	$size = $size / 1.33;
	}

	$size = $this->show_bytes($size);
	}

	if (!$part->exact_size) {
	$size = '~' . $size;
	}

	return $size;
	}

	/**
	* Returns message UID(s) and IMAP folder(s) from GET/POST data
	*
	* @param string $uids UID value to decode
	* @param string $mbox Default mailbox value (if not encoded in UIDs)
	* @param bool $is_multifolder Will be set to True if multi-folder request
	* @param int $mode Request mode. Default: rcube_utils::INPUT_GPC.
	*
	* @return array List of message UIDs per folder
	*/
	public static function get_uids($uids = null, $mbox = null, &$is_multifolder = false, $mode = null)
	{
	// message UID (or comma-separated list of IDs) is provided in
	// the form of <ID>-<MBOX>[,<ID>-<MBOX>]*

	$_uid = $uids ?: rcube_utils::get_input_value('_uid', $mode ?: rcube_utils::INPUT_GPC);
	$_mbox = $mbox ?: (string) rcube_utils::get_input_value('_mbox', $mode ?: rcube_utils::INPUT_GPC);

	// already a hash array
	if (is_array($_uid) && !isset($_uid[0])) {
	return $_uid;
	}

	$result = array();

	// special case: *
	if ($_uid == '*' && is_object($_SESSION['search'][1]) && $_SESSION['search'][1]->multi) {
	$is_multifolder = true;
	// extract the full list of UIDs per folder from the search set
	foreach ($_SESSION['search'][1]->sets as $subset) {
	$mbox = $subset->get_parameters('MAILBOX');
	$result[$mbox] = $subset->get();
	}
	}
	else {
	if (is_string($_uid)) {
	$_uid = explode(',', $_uid);
	}

	// create a per-folder UIDs array
	foreach ((array)$_uid as $uid) {
	list($uid, $mbox) = explode('-', $uid, 2);
	if (!strlen($mbox)) {
	$mbox = $_mbox;
	}
	else {
	$is_multifolder = true;
	}

	if ($uid == '*') {
	$result[$mbox] = $uid;
	}
	else if (preg_match('/^[0-9:.]+$/', $uid)) {
	$result[$mbox][] = $uid;
	}
	}
	}

	return $result;
	}

	/**
	* Get resource file content (with assets_dir support)
	*
	* @param string $name File name
	*
	* @return string File content
	*/
	public function get_resource_content($name)
	{
	if (!strpos($name, '/')) {
	$name = "program/resources/$name";
	}

	$assets_dir = $this->config->get('assets_dir');

	if ($assets_dir) {
	$path = slashify($assets_dir) . $name;
	if (@file_exists($path)) {
	$name = $path;
	}
	}

	return file_get_contents($name, false);
	}

	/**
	* Converts HTML content into plain text
	*
	* @param string $html HTML content
	* @param array $options Conversion parameters (width, links, charset)
	*
	* @return string Plain text
	*/
	public function html2text($html, $options = array())
	{
	$default_options = array(
	'links' => true,
	'width' => 75,
	'body' => $html,
	'charset' => RCUBE_CHARSET,
	);

	$options = array_merge($default_options, (array) $options);

	// Plugins may want to modify HTML in another/additional way
	$options = $this->plugins->exec_hook('html2text', $options);

	// Convert to text
	if (!$options['abort']) {
	$converter = new rcube_html2text($options['body'],
	false, $options['links'], $options['width'], $options['charset']);

	$options['body'] = rtrim($converter->get_text());
	}

	return $options['body'];
	}

	/**
	* Connect to the mail storage server with stored session data
	*
	* @return bool True on success, False on error
	*/
	public function storage_connect()
	{
	$storage = $this->get_storage();

	if ($_SESSION['storage_host'] && !$storage->is_connected()) {
	$host = $_SESSION['storage_host'];
	$user = $_SESSION['username'];
	$port = $_SESSION['storage_port'];
	$ssl = $_SESSION['storage_ssl'];
	$pass = $this->decrypt($_SESSION['password']);

	if (!$storage->connect($host, $user, $pass, $port, $ssl)) {
	if (is_object($this->output)) {
	$this->output->show_message('storageerror', 'error');
	}
	}
	else {
	$this->set_storage_prop();
	}
	}

	return $storage->is_connected();
	}
	}
	diff --git a/program/include/rcmail_output_html.php b/program/include/rcmail_output_html.php
	index 6a9108c16..903723d57 100644
	--- a/program/include/rcmail_output_html.php
	+++ b/program/include/rcmail_output_html.php
	@@ -1,2570 +1,2613 @@
	<?php

	/**
	+-----------------------------------------------------------------------+
	\| This file is part of the Roundcube Webmail client \|
	\| \|
	\| Copyright (C) The Roundcube Dev Team \|
	\| \|
	\| Licensed under the GNU General Public License version 3 or \|
	\| any later version with exceptions for skins & plugins. \|
	\| See the README file for a full license statement. \|
	\| \|
	\| PURPOSE: \|
	\| Class to handle HTML page output using a skin template. \|
	+-----------------------------------------------------------------------+
	\| Author: Thomas Bruederli <roundcube@gmail.com> \|
	+-----------------------------------------------------------------------+
	*/

	/**
	* Class to create HTML page output using a skin template
	*
	* @package Webmail
	* @subpackage View
	*/
	class rcmail_output_html extends rcmail_output
	{
	public $type = 'html';

	protected $message;
	protected $template_name;
	protected $objects = array();
	protected $js_env = array();
	protected $js_labels = array();
	protected $js_commands = array();
	protected $skin_paths = array();
	protected $skin_name = '';
	protected $scripts_path = '';
	protected $script_files = array();
	protected $css_files = array();
	protected $scripts = array();
	protected $meta_tags = array();
	protected $link_tags = array('shortcut icon' => '');
	protected $header = '';
	protected $footer = '';
	protected $body = '';
	protected $base_path = '';
	protected $assets_path;
	protected $assets_dir = RCUBE_INSTALL_PATH;
	protected $devel_mode = false;
	protected $default_template = "<html>\n<head><title></title></head>\n<body></body>\n</html>";

	// deprecated names of templates used before 0.5
	protected $deprecated_templates = array(
	'contact' => 'showcontact',
	'contactadd' => 'addcontact',
	'contactedit' => 'editcontact',
	'identityedit' => 'editidentity',
	'messageprint' => 'printmessage',
	);

	// deprecated names of template objects used before 1.4
	protected $deprecated_template_objects = array(
	'addressframe' => 'contentframe',
	'messagecontentframe' => 'contentframe',
	'prefsframe' => 'contentframe',
	'folderframe' => 'contentframe',
	'identityframe' => 'contentframe',
	'responseframe' => 'contentframe',
	'keyframe' => 'contentframe',
	'filterframe' => 'contentframe',
	);

	/**
	* Constructor
	*/
	public function __construct($task = null, $framed = false)
	{
	parent::__construct();

	$this->devel_mode = $this->config->get('devel_mode');

	$this->set_env('task', $task);
	$this->set_env('standard_windows', (bool) $this->config->get('standard_windows'));
	$this->set_env('locale', !empty($_SESSION['language']) ? $_SESSION['language'] : 'en_US');
	$this->set_env('devel_mode', $this->devel_mode);

	// Version number e.g. 1.4.2 will be 10402
	$version = explode('.', preg_replace('/[^0-9.].*/', '', RCMAIL_VERSION));
	$this->set_env('rcversion', $version[0] * 10000 + $version[1] * 100 + (isset($version[2]) ? $version[2] : 0));

	// add cookie info
	$this->set_env('cookie_domain', ini_get('session.cookie_domain'));
	$this->set_env('cookie_path', ini_get('session.cookie_path'));
	$this->set_env('cookie_secure', filter_var(ini_get('session.cookie_secure'), FILTER_VALIDATE_BOOLEAN));

	// Easy way to change skin via GET argument, for developers
	if ($this->devel_mode && !empty($_GET['skin']) && preg_match('/^[a-z0-9-_]+$/i', $_GET['skin'])) {
	if ($this->check_skin($_GET['skin'])) {
	$this->set_skin($_GET['skin']);
	$this->app->user->save_prefs(array('skin' => $_GET['skin']));
	}
	}

	// load and setup the skin
	$this->set_skin($this->config->get('skin'));
	$this->set_assets_path($this->config->get('assets_path'), $this->config->get('assets_dir'));

	if (!empty($_REQUEST['_extwin']))
	$this->set_env('extwin', 1);
	if ($this->framed \|\| $framed)
	$this->set_env('framed', 1);

	$lic = <<<EOF
	/*
	@licstart The following is the entire license notice for the
	JavaScript code in this page.

	Copyright (C) The Roundcube Dev Team

	The JavaScript code in this page is free software: you can redistribute
	it and/or modify it under the terms of the GNU General Public License
	as published by the Free Software Foundation, either version 3 of
	the License, or (at your option) any later version.

	The code is distributed WITHOUT ANY WARRANTY; without even the implied
	warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
	See the GNU GPL for more details.

	@licend The above is the entire license notice
	for the JavaScript code in this page.
	*/
	EOF;
	// add common javascripts
	$this->add_script($lic, 'head_top');
	$this->add_script('var '.self::JS_OBJECT_NAME.' = new rcube_webmail();', 'head_top');

	// don't wait for page onload. Call init at the bottom of the page (delayed)
	$this->add_script(self::JS_OBJECT_NAME.'.init();', 'docready');

	$this->scripts_path = 'program/js/';
	$this->include_script('jquery.min.js');
	$this->include_script('common.js');
	$this->include_script('app.js');

	// register common UI objects
	$this->add_handlers(array(
	'loginform' => array($this, 'login_form'),
	'preloader' => array($this, 'preloader'),
	'username' => array($this, 'current_username'),
	'message' => array($this, 'message_container'),
	'charsetselector' => array($this, 'charset_selector'),
	'aboutcontent' => array($this, 'about_content'),
	));

	// set blankpage (watermark) url
	$blankpage = $this->config->get('blankpage_url', '/watermark.html');
	$this->set_env('blankpage', $blankpage);
	}

	/**
	* Set environment variable
	*
	* @param string $name Property name
	* @param mixed $value Property value
	* @param boolean $addtojs True if this property should be added
	* to client environment
	*/
	public function set_env($name, $value, $addtojs = true)
	{
	$this->env[$name] = $value;

	if ($addtojs \|\| isset($this->js_env[$name])) {
	$this->js_env[$name] = $value;
	}
	}

	/**
	* Parse and set assets path
	*
	* @param string $path Assets path URL (relative or absolute)
	* @param string $fs_dif Assets path in filesystem
	*/
	public function set_assets_path($path, $fs_dir = null)
	{
	if (empty($path)) {
	return;
	}

	$path = rtrim($path, '/') . '/';

	// handle relative assets path
	if (!preg_match('\|^https?://\|', $path) && $path[0] != '/') {
	// save the path to search for asset files later
	$this->assets_dir = $path;

	$base = preg_replace('/[?#&].*$/', '', $_SERVER['REQUEST_URI']);
	$base = rtrim($base, '/');

	// remove url token if exists
	if ($len = intval($this->config->get('use_secure_urls'))) {
	$_base = explode('/', $base);
	$last = count($_base) - 1;
	$length = $len > 1 ? $len : 16; // as in rcube::get_secure_url_token()

	// we can't use real token here because it
	// does not exists in unauthenticated state,
	// hope this will not produce false-positive matches
	if ($last > -1 && preg_match('/^[a-f0-9]{' . $length . '}$/', $_base[$last])) {
	$path = '../' . $path;
	}
	}
	}

	// set filesystem path for assets
	if ($fs_dir) {
	if ($fs_dir[0] != '/') {
	$fs_dir = realpath(RCUBE_INSTALL_PATH . $fs_dir);
	}
	// ensure the path ends with a slash
	$this->assets_dir = rtrim($fs_dir, '/') . '/';
	}

	$this->assets_path = $path;
	$this->set_env('assets_path', $path);
	}

	/**
	* Getter for the current page title
	*
	* @param bool $full Prepend title with product/user name
	*
	* @return string The page title
	*/
	protected function get_pagetitle($full = true)
	{
	if (!empty($this->pagetitle)) {
	$title = $this->pagetitle;
	}
	else if ($this->env['task'] == 'login') {
	$title = $this->app->gettext(array(
	'name' => 'welcome',
	'vars' => array('product' => $this->config->get('product_name')
	)));
	}
	else {
	$title = ucfirst($this->env['task']);
	}

	if ($full) {
	if ($this->devel_mode && !empty($_SESSION['username'])) {
	$title = $_SESSION['username'] . ' :: ' . $title;
	}
	else if ($prod_name = $this->config->get('product_name')) {
	$title = $prod_name . ' :: ' . $title;
	}
	}

	return $title;
	}

	/**
	* Getter for the current skin path property
	*/
	public function get_skin_path()
	{
	return $this->skin_paths[0];
	}

	/**
	* Set skin
	*
	* @param string $skin Skin name
	*/
	public function set_skin($skin)
	{
	if (!$this->check_skin($skin)) {
	// If the skin does not exist (could be removed or invalid),
	// fallback to the skin set in the system configuration (#7271)
	$skin = $this->config->system_skin;
	}

	$skin_path = 'skins/' . $skin;

	$this->config->set('skin_path', $skin_path);
	$this->base_path = $skin_path;

	// register skin path(s)
	$this->skin_paths = array();
	$this->skins = array();
	$this->load_skin($skin_path);

	$this->skin_name = $skin;
	$this->set_env('skin', $skin);
	}

	/**
	* Check skin validity/existence
	*
	* @param string $skin Skin name
	*
	* @return bool True if the skin exist and is readable, False otherwise
	*/
	public function check_skin($skin)
	{
	// Sanity check to prevent from path traversal vulnerability (#1490620)
	if (strpos($skin, '/') !== false \|\| strpos($skin, "\\") !== false) {
	rcube::raise_error(array(
	'file' => __FILE__,
	'line' => __LINE__,
	'message' => 'Invalid skin name'
	), true, false);

	return false;
	}

	$skins_allowed = $this->config->get('skins_allowed');

	if (!empty($skins_allowed) && !in_array($skin, (array) $skins_allowed)) {
	return false;
	}

	$path = RCUBE_INSTALL_PATH . 'skins/';

	return !empty($skin) && is_dir($path . $skin) && is_readable($path . $skin);
	}

	/**
	* Helper method to recursively read skin meta files and register search paths
	*/
	private function load_skin($skin_path)
	{
	$this->skin_paths[] = $skin_path;

	// read meta file and check for dependencies
	$meta = @file_get_contents(RCUBE_INSTALL_PATH . $skin_path . '/meta.json');
	$meta = @json_decode($meta, true);

	$meta['path'] = $skin_path;
	$path_elements = explode('/', $skin_path);
	$skin_id = end($path_elements);

	if (empty($meta['name'])) {
	$meta['name'] = $skin_id;
	}

	$this->skins[$skin_id] = $meta;

	// Keep skin config for ajax requests (#6613)
	$_SESSION['skin_config'] = array();

	if (!empty($meta['extends'])) {
	$path = RCUBE_INSTALL_PATH . 'skins/';
	if (is_dir($path . $meta['extends']) && is_readable($path . $meta['extends'])) {
	$_SESSION['skin_config'] = $this->load_skin('skins/' . $meta['extends']);
	}
	}

	if (!empty($meta['config'])) {
	foreach ($meta['config'] as $key => $value) {
	$this->config->set($key, $value, true);
	$_SESSION['skin_config'][$key] = $value;
	}

	$value = array_merge((array) $this->config->get('dont_override'), array_keys($meta['config']));
	$this->config->set('dont_override', $value, true);
	}

	if (!empty($meta['localization'])) {
	$locdir = $meta['localization'] === true ? 'localization' : $meta['localization'];
	if ($texts = $this->app->read_localization(RCUBE_INSTALL_PATH . $skin_path . '/' . $locdir)) {
	$this->app->load_language($_SESSION['language'], $texts);
	}
	}

	// Use array_merge() here to allow for global default and extended skins
	if (!empty($meta['meta'])) {
	$this->meta_tags = array_merge($this->meta_tags, (array) $meta['meta']);
	}
	if (!empty($meta['links'])) {
	$this->link_tags = array_merge($this->link_tags, (array) $meta['links']);
	}

	return $_SESSION['skin_config'];
	}

	/**
	* Check if a specific template exists
	*
	* @param string $name Template name
	*
	* @return boolean True if template exists
	*/
	public function template_exists($name)
	{
	foreach ($this->skin_paths as $skin_path) {
	$filename = RCUBE_INSTALL_PATH . $skin_path . '/templates/' . $name . '.html';
	if ((is_file($filename) && is_readable($filename))
	\|\| ($this->deprecated_templates[$name] && $this->template_exists($this->deprecated_templates[$name]))
	) {
	return true;
	}
	}

	return false;
	}

	/**
	* Find the given file in the current skin path stack
	*
	* @param string $file File name/path to resolve (starting with /)
	* @param string &$skin_path Reference to the base path of the matching skin
	* @param string $add_path Additional path to search in
	* @param bool $minified Fallback to a minified version of the file
	*
	* @return mixed Relative path to the requested file or False if not found
	*/
	public function get_skin_file($file, &$skin_path = null, $add_path = null, $minified = false)
	{
	$skin_paths = $this->skin_paths;

	if ($add_path) {
	array_unshift($skin_paths, $add_path);
	$skin_paths = array_unique($skin_paths);
	}

	if ($skin_path = $this->find_file_path($file, $skin_paths)) {
	return $skin_path . $file;
	}

	if ($minified && preg_match('/(?<!\.min)\.(js\|css)$/', $file)) {
	$file = preg_replace('/\.(js\|css)$/', '.min.\\1', $file);

	if ($skin_path = $this->find_file_path($file, $skin_paths)) {
	return $skin_path . $file;
	}
	}

	return false;
	}

	/**
	* Find path of the asset file
	*/
	protected function find_file_path($file, $skin_paths)
	{
	foreach ($skin_paths as $skin_path) {
	if ($this->assets_dir != RCUBE_INSTALL_PATH) {
	if (realpath($this->assets_dir . $skin_path . $file)) {
	return $skin_path;
	}
	}

	if (realpath(RCUBE_INSTALL_PATH . $skin_path . $file)) {
	return $skin_path;
	}
	}
	}

	/**
	* Register a GUI object to the client script
	*
	* @param string $obj Object name
	* @param string $id Object ID
	*/
	public function add_gui_object($obj, $id)
	{
	$this->add_script(self::JS_OBJECT_NAME.".gui_object('$obj', '$id');");
	}

	/**
	* Call a client method
	*
	* @param string Method to call
	* @param ... Additional arguments
	*/
	public function command()
	{
	$cmd = func_get_args();
	if (strpos($cmd[0], 'plugin.') !== false)
	$this->js_commands[] = array('triggerEvent', $cmd[0], $cmd[1]);
	else
	$this->js_commands[] = $cmd;
	}

	/**
	* Add a localized label to the client environment
	*/
	public function add_label()
	{
	$args = func_get_args();

	if (count($args) == 1 && is_array($args[0])) {
	$args = $args[0];
	}

	foreach ($args as $name) {
	$this->js_labels[$name] = $this->app->gettext($name);
	}
	}

	/**
	* Invoke display_message command
	*
	* @param string $message Message to display
	* @param string $type Message type [notice\|confirm\|error]
	* @param array $vars Key-value pairs to be replaced in localized text
	* @param boolean $override Override last set message
	* @param int $timeout Message display time in seconds
	*
	* @uses self::command()
	*/
	public function show_message($message, $type='notice', $vars=null, $override=true, $timeout=0)
	{
	if ($override \|\| !$this->message) {
	if ($this->app->text_exists($message)) {
	if (!empty($vars)) {
	$vars = array_map(array('rcube','Q'), $vars);
	}

	$msgtext = $this->app->gettext(array('name' => $message, 'vars' => $vars));
	}
	else {
	$msgtext = $message;
	}

	$this->message = $message;
	$this->command('display_message', $msgtext, $type, $timeout * 1000);
	}
	}

	/**
	* Delete all stored env variables and commands
	*
	* @param bool $all Reset all env variables (including internal)
	*/
	public function reset($all = false)
	{
	$framed = $this->framed;
	$task = $this->env['task'];
	$env = $all ? null : array_intersect_key($this->env, array('extwin'=>1, 'framed'=>1));

	// keep jQuery-UI files
	$css_files = $script_files = array();

	foreach ($this->css_files as $file) {
	if (strpos($file, 'plugins/jqueryui') === 0) {
	$css_files[] = $file;
	}
	}

	foreach ($this->script_files as $position => $files) {
	foreach ($files as $file) {
	if (strpos($file, 'plugins/jqueryui') === 0) {
	$script_files[$position][] = $file;
	}
	}
	}

	parent::reset();

	// let some env variables survive
	$this->env = $this->js_env = $env;
	$this->framed = $framed \|\| $this->env['framed'];
	$this->js_labels = array();
	$this->js_commands = array();
	$this->scripts = array();
	$this->header = '';
	$this->footer = '';
	$this->body = '';
	$this->css_files = array();
	$this->script_files = array();

	// load defaults
	if (!$all) {
	$this->__construct();
	}

	// Note: we merge jQuery-UI scripts after jQuery...
	$this->css_files = array_merge($this->css_files, $css_files);
	$this->script_files = array_merge_recursive($this->script_files, $script_files);

	$this->set_env('orig_task', $task);
	}

	/**
	* Redirect to a certain url
	*
	* @param mixed $p Either a string with the action or url parameters as key-value pairs
	* @param int $delay Delay in seconds
	* @param bool $secure Redirect to secure location (see rcmail::url())
	*/
	public function redirect($p = array(), $delay = 1, $secure = false)
	{
	- if ($this->env['extwin'])
	+ if (!empty($this->env['extwin'])) {
	$p['extwin'] = 1;
	+ }
	+
	$location = $this->app->url($p, false, false, $secure);
	header('Location: ' . $location);
	exit;
	}

	/**
	* Send the request output to the client.
	* This will either parse a skin template.
	*
	* @param string $templ Template name
	* @param boolean $exit True if script should terminate (default)
	*/
	public function send($templ = null, $exit = true)
	{
	if ($templ != 'iframe') {
	// prevent from endless loops
	if ($exit != 'recur' && $this->app->plugins->is_processing('render_page')) {
	rcube::raise_error(array('code' => 505, 'type' => 'php',
	'file' => __FILE__, 'line' => __LINE__,
	'message' => 'Recursion alert: ignoring output->send()'), true, false);
	return;
	}
	$this->parse($templ, false);
	}
	else {
	$this->framed = true;
	$this->write();
	}

	// set output asap
	ob_flush();
	flush();

	if ($exit) {
	exit;
	}
	}

	/**
	* Process template and write to stdOut
	*
	* @param string $template HTML template content
	*/
	public function write($template = '')
	{
	if (!empty($this->script_files)) {
	$this->set_env('request_token', $this->app->get_request_token());
	}

	// Fix assets path on blankpage
	if ($this->js_env['blankpage']) {
	$this->js_env['blankpage'] = $this->asset_url($this->abs_url($this->js_env['blankpage'], true));
	}

	$commands = $this->get_js_commands($framed);

	// if all js commands go to parent window we can ignore all
	// script files and skip rcube_webmail initialization (#1489792)
	// but not on error pages where skins may need jQuery, etc.
	if ($framed && empty($this->js_env['server_error'])) {
	$this->scripts = array();
	$this->script_files = array();
	$this->header = '';
	$this->footer = '';
	}

	// write all javascript commands
	if (!empty($commands)) {
	$this->add_script($commands, 'head_top');
	}

	$this->page_headers();

	// call super method
	$this->_write($template);
	}

	/**
	* Send common page headers
	* For now it only (re)sets X-Frame-Options when needed
	*/
	public function page_headers()
	{
	if (headers_sent()) {
	return;
	}

	// allow (legal) iframe content to be loaded
	- $framed = $this->framed \|\| $this->env['framed'];
	+ $framed = $this->framed \|\| !empty($this->env['framed']);
	if ($framed && ($xopt = $this->app->config->get('x_frame_options', 'sameorigin'))) {
	if (strtolower($xopt) === 'deny') {
	header('X-Frame-Options: sameorigin', true);
	}
	}
	}

	/**
	* Parse a specific skin template and deliver to stdout (or return)
	*
	* @param string $name Template name
	* @param boolean $exit Exit script
	* @param boolean $write Don't write to stdout, return parsed content instead
	*
	* @link http://php.net/manual/en/function.exit.php
	*/
	function parse($name = 'main', $exit = true, $write = true)
	{
	$plugin = false;
	$realname = $name;
	$skin_dir = '';
	$plugin_skin_paths = array();

	$this->template_name = $realname;

	$temp = explode('.', $name, 2);
	if (count($temp) > 1) {
	$plugin = $temp[0];
	$name = $temp[1];
	$skin_dir = $plugin . '/skins/' . $this->config->get('skin');

	// apply skin search escalation list to plugin directory
	foreach ($this->skin_paths as $skin_path) {
	$plugin_skin_paths[] = $this->app->plugins->url . $plugin . '/' . $skin_path;
	}

	// prepend plugin skin paths to search list
	$this->skin_paths = array_merge($plugin_skin_paths, $this->skin_paths);
	}

	// find skin template
	$path = false;
	foreach ($this->skin_paths as $skin_path) {
	// when requesting a plugin template ignore global skin path(s)
	if ($plugin && strpos($skin_path, $this->app->plugins->url) !== 0) {
	continue;
	}

	$path = RCUBE_INSTALL_PATH . "$skin_path/templates/$name.html";

	// fallback to deprecated template names
	if (!is_readable($path) && ($dname = $this->deprecated_templates[$realname])) {
	$path = RCUBE_INSTALL_PATH . "$skin_path/templates/$dname.html";

	if (is_readable($path)) {
	rcube::raise_error(array(
	'code' => 502, 'file' => __FILE__, 'line' => __LINE__,
	'message' => "Using deprecated template '$dname' in $skin_path/templates. Please rename to '$realname'"
	), true, false);
	}
	}

	if (is_readable($path)) {
	$this->config->set('skin_path', $skin_path);
	// set base_path to core skin directory (not plugin's skin)
	$this->base_path = preg_replace('!plugins/\w+/!', '', $skin_path);
	$skin_dir = preg_replace('!^plugins/!', '', $skin_path);
	break;
	}
	else {
	$path = false;
	}
	}

	// read template file
	if (!$path \|\| ($templ = @file_get_contents($path)) === false) {
	rcube::raise_error(array(
	'code' => 404,
	'type' => 'php',
	'line' => __LINE__,
	'file' => __FILE__,
	'message' => 'Error loading template for '.$realname
	), true, $write);

	$this->skin_paths = array_slice($this->skin_paths, count($plugin_skin_paths));
	return false;
	}

	// replace all path references to plugins/... with the configured plugins dir
	// and /this/ to the current plugin skin directory
	if ($plugin) {
	$templ = preg_replace(
	array('/\bplugins\//', '/(["\']?)\/this\//'),
	array($this->app->plugins->url, '\\1'.$this->app->plugins->url.$skin_dir.'/'),
	$templ
	);
	}

	// parse for specialtags
	$output = $this->parse_conditions($templ);
	$output = $this->parse_xml($output);

	// trigger generic hook where plugins can put additional content to the page
	$hook = $this->app->plugins->exec_hook("render_page", array(
	'template' => $realname, 'content' => $output, 'write' => $write));

	// save some memory
	$output = $hook['content'];
	unset($hook['content']);

	// remove plugin skin paths from current context
	$this->skin_paths = array_slice($this->skin_paths, count($plugin_skin_paths));

	if (!$write) {
	return $this->postrender($output);
	}

	$this->write(trim($output));

	if ($exit) {
	exit;
	}
	}

	/**
	* Return executable javascript code for all registered commands
	*/
	protected function get_js_commands(&$framed = null)
	{
	$out = '';
	$parent_commands = 0;
	$parent_prefix = '';
	$top_commands = array();

	// these should be always on top,
	// e.g. hide_message() below depends on env.framed
	if (!$this->framed && !empty($this->js_env)) {
	$top_commands[] = array('set_env', $this->js_env);
	}
	if (!empty($this->js_labels)) {
	$top_commands[] = array('add_label', $this->js_labels);
	}

	// unlock interface after iframe load
	- $unlock = preg_replace('/[^a-z0-9]/i', '', $_REQUEST['_unlock']);
	+ $unlock = isset($_REQUEST['_unlock']) ? preg_replace('/[^a-z0-9]/i', '', $_REQUEST['_unlock']) : 0;
	if ($this->framed) {
	$top_commands[] = array('iframe_loaded', $unlock);
	}
	else if ($unlock) {
	$top_commands[] = array('hide_message', $unlock);
	}

	$commands = array_merge($top_commands, $this->js_commands);

	foreach ($commands as $i => $args) {
	$method = array_shift($args);
	$parent = $this->framed \|\| preg_match('/^parent\./', $method);

	foreach ($args as $i => $arg) {
	$args[$i] = self::json_serialize($arg, $this->devel_mode);
	}

	if ($parent) {
	$parent_commands++;
	$method = preg_replace('/^parent\./', '', $method);
	$parent_prefix = 'if (window.parent && parent.' . self::JS_OBJECT_NAME . ') parent.';
	$method = $parent_prefix . self::JS_OBJECT_NAME . '.' . $method;
	}
	else {
	$method = self::JS_OBJECT_NAME . '.' . $method;
	}

	$out .= sprintf("%s(%s);\n", $method, implode(',', $args));
	}

	$framed = $parent_prefix && $parent_commands == count($commands);

	// make the output more compact if all commands go to parent window
	if ($framed) {
	$out = "if (window.parent && parent." . self::JS_OBJECT_NAME . ") {\n"
	. str_replace($parent_prefix, "\tparent.", $out)
	. "}\n";
	}

	return $out;
	}

	/**
	* Make URLs starting with a slash point to skin directory
	*
	* @param string $str Input string
	* @param bool $search_path True if URL should be resolved using the current skin path stack
	*
	* @return string URL
	*/
	public function abs_url($str, $search_path = false)
	{
	if ($str[0] == '/') {
	if ($search_path && ($file_url = $this->get_skin_file($str))) {
	return $file_url;
	}

	return $this->base_path . $str;
	}

	return $str;
	}

	/**
	* Show error page and terminate script execution
	*
	* @param int $code Error code
	* @param string $message Error message
	*/
	public function raise_error($code, $message)
	{
	global $__page_content, $ERROR_CODE, $ERROR_MESSAGE;

	$ERROR_CODE = $code;
	$ERROR_MESSAGE = $message;

	include RCUBE_INSTALL_PATH . 'program/steps/utils/error.inc';
	exit;
	}

	/**
	* Modify path by adding URL prefix if configured
	*
	* @param string $path Asset path
	* @param bool $abs_url Pass to self::abs_url() first
	*
	* @return string Asset path
	*/
	public function asset_url($path, $abs_url = false)
	{
	// iframe content can't be in a different domain
	// @TODO: check if assests are on a different domain

	if ($abs_url) {
	$path = $this->abs_url($path, true);
	}

	if (!$this->assets_path \|\| in_array($path[0], array('?', '/', '.')) \|\| strpos($path, '://')) {
	return $path;
	}

	return $this->assets_path . $path;
	}


	/*** Template parsing methods ***/

	/**
	* Replace all strings ($varname)
	* with the content of the according global variable.
	*/
	protected function parse_with_globals($input)
	{
	$GLOBALS['__version'] = html::quote(RCMAIL_VERSION);
	$GLOBALS['__comm_path'] = html::quote($this->app->comm_path);
	$GLOBALS['__skin_path'] = html::quote($this->base_path);

	return preg_replace_callback('/\$(__[a-z0-9_\-]+)/',
	array($this, 'globals_callback'), $input);
	}

	/**
	* Callback function for preg_replace_callback() in parse_with_globals()
	*/
	protected function globals_callback($matches)
	{
	return $GLOBALS[$matches[1]];
	}

	/**
	* Correct absolute paths in images and other tags (add cache busters)
	*/
	protected function fix_paths($output)
	{
	return preg_replace_callback(
	'!(src\|href\|background\|data-src-[a-z]+)=(["\']?)([a-z0-9/_.-]+)(["\'\s>])!i',
	array($this, 'file_callback'), $output);
	}

	/**
	* Callback function for preg_replace_callback in fix_paths()
	*
	* @return string Parsed string
	*/
	protected function file_callback($matches)
	{
	$file = $matches[3];
	$file = preg_replace('!^/this/!', '/', $file);

	// correct absolute paths
	if ($file[0] == '/') {
	$this->get_skin_file($file, $skin_path, $this->base_path);
	$file = ($skin_path ?: $this->base_path) . $file;
	}

	// add file modification timestamp
	if (preg_match('/\.(js\|css\|less\|ico\|png\|svg\|jpeg)$/', $file)) {
	$file = $this->file_mod($file);
	}

	return $matches[1] . '=' . $matches[2] . $file . $matches[4];
	}

	/**
	* Correct paths of asset files according to assets_path
	*/
	protected function fix_assets_paths($output)
	{
	return preg_replace_callback(
	'!(src\|href\|background)=(["\']?)([a-z0-9/_.?=-]+)(["\'\s>])!i',
	array($this, 'assets_callback'), $output);
	}

	/**
	* Callback function for preg_replace_callback in fix_assets_paths()
	*
	* @return string Parsed string
	*/
	protected function assets_callback($matches)
	{
	$file = $this->asset_url($matches[3]);

	return $matches[1] . '=' . $matches[2] . $file . $matches[4];
	}

	/**
	* Modify file by adding mtime indicator
	*/
	protected function file_mod($file)
	{
	$fs = false;
	$ext = substr($file, strrpos($file, '.') + 1);

	// use minified file if exists (not in development mode)
	if (!$this->devel_mode && !preg_match('/\.min\.' . $ext . '$/', $file)) {
	$minified_file = substr($file, 0, strlen($ext) * -1) . 'min.' . $ext;
	if ($fs = @filemtime($this->assets_dir . $minified_file)) {
	return $minified_file . '?s=' . $fs;
	}
	}

	if ($fs = @filemtime($this->assets_dir . $file)) {
	$file .= '?s=' . $fs;
	}

	return $file;
	}

	/**
	* Public wrapper to dipp into template parsing.
	*
	* @param string $input Template content
	*
	* @return string
	* @uses rcmail_output_html::parse_xml()
	* @since 0.1-rc1
	*/
	public function just_parse($input)
	{
	$input = $this->parse_conditions($input);
	$input = $this->parse_xml($input);
	$input = $this->postrender($input);

	return $input;
	}

	/**
	* Parse for conditional tags
	*/
	protected function parse_conditions($input)
	{
	while (preg_match('/<roundcube:if\s+[^>]+>(((?!<roundcube:(if\|endif)).))<roundcube:endif[^>]>/is', $input, $conditions)) {
	$result = $this->eval_condition($conditions[0]);
	$input = str_replace($conditions[0], $result, $input);
	}

	return $input;
	}

	/**
	* Process & evaluate conditional tags
	*/
	protected function eval_condition($input)
	{
	$matches = preg_split('/<roundcube:(if\|elseif\|else\|endif)\s([^>])>\n?/is', $input, 2, PREG_SPLIT_DELIM_CAPTURE);
	if ($matches && count($matches) == 4) {
	if (preg_match('/^(else\|endif)$/i', $matches[1])) {
	return $matches[0] . $this->eval_condition($matches[3]);
	}

	$attrib = html::parse_attrib_string($matches[2]);

	if (isset($attrib['condition'])) {
	$condmet = $this->check_condition($attrib['condition']);
	$condparts = preg_split('/<roundcube:((elseif\|else\|endif)[^>]*)>\n?/is', $matches[3], 2, PREG_SPLIT_DELIM_CAPTURE);

	if ($condmet) {
	$result = $condparts[0];
	if ($condparts[2] != 'endif') {
	$result .= preg_replace('/.<roundcube:endif[^>]>\n?/Uis', '', $condparts[3], 1);
	}
	else {
	$result .= $condparts[3];
	}
	}
	else {
	$result = "<roundcube:$condparts[1]>" . $condparts[3];
	}

	return $matches[0] . $this->eval_condition($result);
	}

	rcube::raise_error(array(
	'code' => 500, 'line' => __LINE__, 'file' => __FILE__,
	'message' => "Unable to parse conditional tag " . $matches[2]
	), true, false);
	}

	return $input;
	}

	/**
	* Determines if a given condition is met
	*
	* @param string $condition Condition statement
	*
	* @return boolean True if condition is met, False if not
	* @todo Extend this to allow real conditions, not just "set"
	*/
	protected function check_condition($condition)
	{
	return $this->eval_expression($condition);
	}

	/**
	* Inserts hidden field with CSRF-prevention-token into POST forms
	*/
	protected function alter_form_tag($matches)
	{
	$out = $matches[0];
	$attrib = html::parse_attrib_string($matches[1]);

	if (strtolower($attrib['method']) == 'post') {
	$hidden = new html_hiddenfield(array('name' => '_token', 'value' => $this->app->get_request_token()));
	$out .= "\n" . $hidden->show();
	}

	return $out;
	}

	/**
	* Parse & evaluate a given expression and return its result.
	*
	* @param string $expression Expression statement
	*
	* @return mixed Expression result
	*/
	protected function eval_expression($expression)
	{
	$expression = preg_replace(
	array(
	'/session:([a-z0-9_]+)/i',
	'/config:([a-z0-9_]+)(:([a-z0-9_]+))?/i',
	'/env:([a-z0-9_]+)/i',
	'/request:([a-z0-9_]+)/i',
	'/cookie:([a-z0-9_]+)/i',
	'/browser:([a-z0-9_]+)/i',
	'/template:name/i',
	),
	array(
	- "\$_SESSION['\\1']",
	+ "(isset(\$_SESSION['\\1']) ? \$_SESSION['\\1'] : null)",
	"\$this->app->config->get('\\1',rcube_utils::get_boolean('\\3'))",
	- "\$this->env['\\1']",
	+ "(isset(\$this->env['\\1']) ? \$this->env['\\1'] : null)",
	"rcube_utils::get_input_value('\\1', rcube_utils::INPUT_GPC)",
	- "\$_COOKIE['\\1']",
	- "\$this->browser->{'\\1'}",
	+ "(isset(\$_COOKIE['\\1']) ? \$_COOKIE['\\1'] : null)",
	+ "(isset(\$this->browser->{'\\1'}) ? \$this->browser->{'\\1'} : null)",
	"'{$this->template_name}'",
	),
	$expression
	);

	// Note: We used create_function() before but it's deprecated in PHP 7.2
	// and really it was just a wrapper on eval().
	return eval("return ($expression);");
	}

	/**
	* Parse variable strings
	*
	* @param string $type Variable type (env, config etc)
	* @param string $name Variable name
	*
	* @return mixed Variable value
	*/
	protected function parse_variable($type, $name)
	{
	$value = '';

	switch ($type) {
	case 'env':
	$value = $this->env[$name];
	break;
	case 'config':
	$value = $this->config->get($name);
	if (is_array($value) && $value[$_SESSION['storage_host']]) {
	$value = $value[$_SESSION['storage_host']];
	}
	break;
	case 'request':
	$value = rcube_utils::get_input_value($name, rcube_utils::INPUT_GPC);
	break;
	case 'session':
	$value = $_SESSION[$name];
	break;
	case 'cookie':
	$value = htmlspecialchars($_COOKIE[$name], ENT_COMPAT \| ENT_HTML401, RCUBE_CHARSET);
	break;
	case 'browser':
	$value = $this->browser->{$name};
	break;
	}

	return $value;
	}

	/**
	* Search for special tags in input and replace them
	* with the appropriate content
	*
	* @param string $input Input string to parse
	*
	* @return string Altered input string
	* @todo Use DOM-parser to traverse template HTML
	* @todo Maybe a cache.
	*/
	protected function parse_xml($input)
	{
	return preg_replace_callback('/<roundcube:([-_a-z]+)\s+((?:[^>]\|\\\\>)+)(?<!\\\\)>/Ui', array($this, 'xml_command'), $input);
	}

	/**
	* Callback function for parsing an xml command tag
	* and turn it into real html content
	*
	* @param array $matches Matches array of preg_replace_callback
	*
	* @return string Tag/Object content
	*/
	protected function xml_command($matches)
	{
	$command = strtolower($matches[1]);
	$attrib = html::parse_attrib_string($matches[2]);

	// empty output if required condition is not met
	if (!empty($attrib['condition']) && !$this->check_condition($attrib['condition'])) {
	return '';
	}

	// localize title and summary attributes
	if ($command != 'button' && !empty($attrib['title']) && $this->app->text_exists($attrib['title'])) {
	$attrib['title'] = $this->app->gettext($attrib['title']);
	}
	if ($command != 'button' && !empty($attrib['summary']) && $this->app->text_exists($attrib['summary'])) {
	$attrib['summary'] = $this->app->gettext($attrib['summary']);
	}

	// execute command
	switch ($command) {
	// return a button
	case 'button':
	- if ($attrib['name'] \|\| $attrib['command']) {
	+ if (!empty($attrib['name']) \|\| !empty($attrib['command'])) {
	return $this->button($attrib);
	}
	break;

	// frame
	case 'frame':
	return $this->frame($attrib);
	break;

	// show a label
	case 'label':
	- if ($attrib['expression'])
	+ if (!empty($attrib['expression'])) {
	$attrib['name'] = $this->eval_expression($attrib['expression']);
	+ }

	- if ($attrib['name'] \|\| $attrib['command']) {
	+ if (!empty($attrib['name']) \|\| !empty($attrib['command'])) {
	$vars = $attrib + array('product' => $this->config->get('product_name'));
	unset($vars['name'], $vars['command']);

	$label = $this->app->gettext($attrib + array('vars' => $vars));
	- $quoting = !empty($attrib['quoting']) ? strtolower($attrib['quoting']) : (rcube_utils::get_boolean((string)$attrib['html']) ? 'no' : '');
	+ $quoting = null;
	+
	+ if (!empty($attrib['quoting'])) {
	+ $quoting = strtolower($attrib['quoting']);
	+ }
	+ else if (isset($attrib['html'])) {
	+ $quoting = rcube_utils::get_boolean((string) $attrib['html']) ? 'no' : '';
	+ }

	// 'noshow' can be used in skins to define new labels
	- if ($attrib['noshow']) {
	+ if (!empty($attrib['noshow'])) {
	return '';
	}

	switch ($quoting) {
	case 'no':
	case 'raw':
	break;
	case 'javascript':
	case 'js':
	$label = rcube::JQ($label);
	break;
	default:
	$label = html::quote($label);
	break;
	}

	return $label;
	}
	break;

	case 'add_label':
	$this->add_label($attrib['name']);
	break;

	// include a file
	case 'include':
	- if ($attrib['condition'] && !$this->check_condition($attrib['condition'])) {
	+ if (!empty($attrib['condition']) && !$this->check_condition($attrib['condition'])) {
	break;
	}

	if ($attrib['file'][0] != '/') {
	$attrib['file'] = '/templates/' . $attrib['file'];
	}

	- $old_base_path = $this->base_path;
	- $include = '';
	+ $old_base_path = $this->base_path;
	+ $include = '';
	+ $attr_skin_path = !empty($attrib['skinpath']) ? $attrib['skinpath'] : null;

	if (!empty($attrib['skin_path'])) {
	- $attrib['skinpath'] = $attrib['skin_path'];
	+ $attr_skin_path = $attrib['skin_path'];
	}

	- if ($path = $this->get_skin_file($attrib['file'], $skin_path, $attrib['skinpath'])) {
	+ if ($path = $this->get_skin_file($attrib['file'], $skin_path, $attr_skin_path)) {
	// set base_path to core skin directory (not plugin's skin)
	$this->base_path = preg_replace('!plugins/\w+/!', '', $skin_path);
	$path = realpath(RCUBE_INSTALL_PATH . $path);
	}

	if (is_readable($path)) {
	$allow_php = $this->config->get('skin_include_php');
	$include = $allow_php ? $this->include_php($path) : file_get_contents($path);
	$include = $this->parse_conditions($include);
	$include = $this->parse_xml($include);
	$include = $this->fix_paths($include);
	}

	$this->base_path = $old_base_path;

	return $include;

	case 'plugin.include':
	$hook = $this->app->plugins->exec_hook("template_plugin_include", $attrib);
	return $hook['content'];

	// define a container block
	case 'container':
	if ($attrib['name'] && $attrib['id']) {
	$this->command('gui_container', $attrib['name'], $attrib['id']);
	// let plugins insert some content here
	$hook = $this->app->plugins->exec_hook("template_container", $attrib);
	return $hook['content'];
	}
	break;

	// return code for a specific application object
	case 'object':
	$object = strtolower($attrib['name']);
	$content = '';
	+ $handler = null;

	// correct deprecated object names
	- if ($this->deprecated_template_objects[$object]) {
	+ if (!empty($this->deprecated_template_objects[$object])) {
	$object = $this->deprecated_template_objects[$object];
	}

	- $handler = $this->object_handlers[$object];
	+ if (!empty($this->object_handlers[$object])) {
	+ $handler = $this->object_handlers[$object];
	+ }

	// execute object handler function
	if (is_callable($handler)) {
	$this->prepare_object_attribs($attrib);

	// We assume that objects with src attribute are internal (in most
	// cases this is a watermark frame). We need this to make sure assets_path
	// is added to the internal assets paths
	$external = empty($attrib['src']);
	$content = call_user_func($handler, $attrib);
	}
	else if ($object == 'doctype') {
	$content = html::doctype($attrib['value']);
	}
	else if ($object == 'logo') {
	$attrib += array('alt' => $this->xml_command(array('', 'object', 'name="productname"')));

	// 'type' attribute added in 1.4 was renamed 'logo-type' in 1.5
	// check both for backwards compatibility
	- if (($template_logo = $this->get_template_logo($attrib['logo-type'] ?: $attrib['type'], $attrib['logo-match'])) !== null) {
	+ $logo_type = !empty($attrib['logo-type']) ? $attrib['logo-type'] : null;
	+ $logo_match = !empty($attrib['logo-match']) ? $attrib['logo-match'] : null;
	+ if (!empty($attrib['type']) && empty($logo_type)) {
	+ $logo_type = $attrib['type'];
	+ }
	+
	+ if (($template_logo = $this->get_template_logo($logo_type, $logo_match)) !== null) {
	$attrib['src'] = $template_logo;
	}

	$additional_logos = array();
	$logo_types = (array) $this->config->get('additional_logo_types');
	+
	foreach ($logo_types as $type) {
	if (($template_logo = $this->get_template_logo($type)) !== null) {
	$additional_logos[$type] = $this->abs_url($template_logo);
	}
	}

	if (!empty($additional_logos)) {
	$this->set_env('additional_logos', $additional_logos);
	}

	- if ($attrib['src']) {
	+ if (!empty($attrib['src'])) {
	$content = html::img($attrib);
	}
	}
	else if ($object == 'productname') {
	$name = $this->config->get('product_name', 'Roundcube Webmail');
	$content = html::quote($name);
	}
	else if ($object == 'version') {
	$ver = (string)RCMAIL_VERSION;
	if (is_file(RCUBE_INSTALL_PATH . '.svn/entries')) {
	if (preg_match('/Revision:\s(\d+)/', @shell_exec('svn info'), $regs))
	$ver .= ' [SVN r'.$regs[1].']';
	}
	else if (is_file(RCUBE_INSTALL_PATH . '.git/index')) {
	if (preg_match('/Date:\s+([^\n]+)/', @shell_exec('git log -1'), $regs)) {
	if ($date = date('Ymd.Hi', strtotime($regs[1]))) {
	$ver .= ' [GIT '.$date.']';
	}
	}
	}
	$content = html::quote($ver);
	}
	else if ($object == 'steptitle') {
	$content = html::quote($this->get_pagetitle(false));
	}
	else if ($object == 'pagetitle') {
	// Deprecated, <title> will be added automatically
	$content = html::quote($this->get_pagetitle());
	}
	else if ($object == 'contentframe') {
	if (empty($attrib['id'])) {
	$attrib['id'] = 'rcm' . $this->env['task'] . 'frame';
	}

	// parse variables
	if (preg_match('/^(config\|env):([a-z0-9_]+)$/i', $attrib['src'], $matches)) {
	$attrib['src'] = $this->parse_variable($matches[1], $matches[2]);
	}

	$content = $this->frame($attrib, true);
	}
	else if ($object == 'meta' \|\| $object == 'links') {
	if ($object == 'meta') {
	$source = 'meta_tags';
	$tag = 'meta';
	$key = 'name';
	$param = 'content';
	}
	else {
	$source = 'link_tags';
	$tag = 'link';
	$key = 'rel';
	$param = 'href';
	}

	foreach ($this->$source as $name => $vars) {
	// $vars can be in many forms:
	// - string
	// - array('key' => 'val')
	// - array(string, string)
	// - array(array(), string)
	// - array(array('key' => 'val'), array('key' => 'val'))
	// normalise this for processing by checking for string array keys
	$vars = is_array($vars) ? (count(array_filter(array_keys($vars), 'is_string')) > 0 ? array($vars) : $vars) : array($vars);

	foreach ($vars as $args) {
	// skip unset headers e.g. when extending a skin and removing a header defined in the parent
	if ($args === false) {
	continue;
	}

	$args = is_array($args) ? $args : array($param => $args);

	// special handling for favicon
	if ($object == 'links' && $name == 'shortcut icon' && empty($args[$param])) {
	if ($href = $this->get_template_logo('favicon')) {
	$args[$param] = $href;
	}
	else if ($href = $this->config->get('favicon', '/images/favicon.ico')) {
	$args[$param] = $href;
	}
	}

	$content .= html::tag($tag, array($key => $name, 'nl' => true) + $args);
	}
	}
	}

	// exec plugin hooks for this template object
	$hook = $this->app->plugins->exec_hook("template_object_$object", $attrib + array('content' => $content));

	if (strlen($hook['content']) && !empty($external)) {
	$object_id = uniqid('TEMPLOBJECT:', true);
	$this->objects[$object_id] = $hook['content'];
	$hook['content'] = $object_id;
	}

	return $hook['content'];

	// return <link> element
	case 'link':
	if ($attrib['condition'] && !$this->check_condition($attrib['condition'])) {
	break;
	}

	unset($attrib['condition']);

	return html::tag('link', $attrib);


	// return code for a specified eval expression
	case 'exp':
	return html::quote($this->eval_expression($attrib['expression']));

	// return variable
	case 'var':
	$var = explode(':', $attrib['name']);
	$value = $this->parse_variable($var[0], $var[1]);

	if (is_array($value)) {
	$value = implode(', ', $value);
	}

	return html::quote($value);

	case 'form':
	return $this->form_tag($attrib);
	}
	return '';
	}

	/**
	* Prepares template object attributes
	*
	* @param array &$attribs Attributes
	*/
	protected function prepare_object_attribs(&$attribs)
	{
	foreach ($attribs as $key => &$value) {
	if (strpos($key, 'data-label-') === 0) {
	// Localize data-label-* attributes
	$value = $this->app->gettext($value);
	}
	elseif ($key[0] == ':') {
	// Evaluate attributes with expressions and remove special character from attribute name
	$attribs[substr($key, 1)] = $this->eval_expression($value);
	unset($attribs[$key]);
	}
	}
	}

	/**
	* Include a specific file and return it's contents
	*
	* @param string $file File path
	*
	* @return string Contents of the processed file
	*/
	protected function include_php($file)
	{
	ob_start();
	include $file;
	$out = ob_get_contents();
	ob_end_clean();

	return $out;
	}

	/**
	* Put objects' content back into template output
	*/
	protected function postrender($output)
	{
	// insert objects' contents
	foreach ($this->objects as $key => $val) {
	$output = str_replace($key, $val, $output, $count);
	if ($count) {
	$this->objects[$key] = null;
	}
	}

	// make sure all <form> tags have a valid request token
	$output = preg_replace_callback('/<form\s+([^>]+)>/Ui', array($this, 'alter_form_tag'), $output);

	return $output;
	}

	/**
	* Create and register a button
	*
	* @param array $attrib Named button attributes
	*
	* @return string HTML button
	* @todo Remove all inline JS calls and use jQuery instead.
	* @todo Remove all sprintf()'s - they are pretty, but also slow.
	*/
	public function button($attrib)
	{
	static $s_button_count = 100;
	static $disabled_actions = null;

	// these commands can be called directly via url
	$a_static_commands = array('compose', 'list', 'preferences', 'folders', 'identities');

	- if (!($attrib['command'] \|\| $attrib['name'] \|\| $attrib['href'])) {
	+ if (empty($attrib['command']) && empty($attrib['name']) && empty($attrib['href'])) {
	return '';
	}

	- // try to find out the button type
	- if ($attrib['type']) {
	- $attrib['type'] = strtolower($attrib['type']);
	- if (strpos($attrib['type'], '-menuitem')) {
	- $attrib['type'] = substr($attrib['type'], 0, -9);
	- $menuitem = true;
	- }
	- }
	- else {
	- $attrib['type'] = ($attrib['image'] \|\| $attrib['imagepas'] \|\| $attrib['imageact']) ? 'image' : 'button';
	- }
	+ $command = !empty($attrib['command']) ? $attrib['command'] : null;
	+ $action = $command ?: (!empty($attrib['name']) ? $attrib['name'] : null);

	- $command = $attrib['command'];
	- $action = $command ?: $attrib['name'];
	-
	- if ($attrib['task']) {
	+ if (!empty($attrib['task'])) {
	$command = $attrib['task'] . '.' . $command;
	$element = $attrib['task'] . '.' . $action;
	}
	else {
	$element = ($this->env['task'] ? $this->env['task'] . '.' : '') . $action;
	}

	if ($disabled_actions === null) {
	$disabled_actions = (array) $this->config->get('disabled_actions');
	}

	// remove buttons for disabled actions
	if (in_array($element, $disabled_actions) \|\| in_array($action, $disabled_actions)) {
	return '';
	}

	- if (!$attrib['image']) {
	- $attrib['image'] = $attrib['imagepas'] ? $attrib['imagepas'] : $attrib['imageact'];
	+ // try to find out the button type
	+ if (!empty($attrib['type'])) {
	+ $attrib['type'] = strtolower($attrib['type']);
	+ if (strpos($attrib['type'], '-menuitem')) {
	+ $attrib['type'] = substr($attrib['type'], 0, -9);
	+ $menuitem = true;
	+ }
	+ }
	+ else if (!empty($attrib['image']) \|\| !empty($attrib['imagepas']) \|\| !empty($attrib['imageact'])) {
	+ $attrib['type'] = 'image';
	+ }
	+ else {
	+ $attrib['type'] = 'button';
	+ }
	+
	+ if (empty($attrib['image'])) {
	+ if (!empty($attrib['imagepas'])) {
	+ $attrib['image'] = $attrib['imagepas'];
	+ }
	+ else if (!empty($attrib['imageact'])) {
	+ $attrib['image'] = $attrib['imageact'];
	+ }
	}

	- if (!$attrib['id']) {
	+ if (empty($attrib['id'])) {
	// ensure auto generated IDs are unique between main window and content frame
	// Elastic skin duplicates buttons between the two on smaller screens (#7618)
	- $prefix = ($this->framed \|\| $this->env['framed']) ? 'frm' : '';
	+ $prefix = ($this->framed \|\| !empty($this->env['framed'])) ? 'frm' : '';
	$attrib['id'] = sprintf('rcmbtn%s%d', $prefix, $s_button_count++);
	}

	// get localized text for labels and titles
	- if ($attrib['title']) {
	- $attrib['title'] = html::quote($this->app->gettext($attrib['title'], $attrib['domain']));
	+ $domain = !empty($attrib['domain']) ? $attrib['domain'] : null;
	+ if (!empty($attrib['title'])) {
	+ $attrib['title'] = html::quote($this->app->gettext($attrib['title'], $domain));
	}
	- if ($attrib['label']) {
	- $attrib['label'] = html::quote($this->app->gettext($attrib['label'], $attrib['domain']));
	+ if (!empty($attrib['label'])) {
	+ $attrib['label'] = html::quote($this->app->gettext($attrib['label'], $domain));
	}
	- if ($attrib['alt']) {
	- $attrib['alt'] = html::quote($this->app->gettext($attrib['alt'], $attrib['domain']));
	+ if (!empty($attrib['alt'])) {
	+ $attrib['alt'] = html::quote($this->app->gettext($attrib['alt'], $domain));
	}

	// set accessibility attributes
	- if (!$attrib['role']) {
	+ if (empty($attrib['role'])) {
	$attrib['role'] = 'button';
	}
	if (!empty($attrib['class']) && !empty($attrib['classact']) \|\| !empty($attrib['imagepas']) && !empty($attrib['imageact'])) {
	if (array_key_exists('tabindex', $attrib)) {
	$attrib['data-tabindex'] = $attrib['tabindex'];
	}
	- $attrib['tabindex'] = '-1'; // disable button by default
	+ $attrib['tabindex'] = '-1'; // disable button by default
	$attrib['aria-disabled'] = 'true';
	}

	// set title to alt attribute for IE browsers
	- if ($this->browser->ie && !$attrib['title'] && $attrib['alt']) {
	+ if ($this->browser->ie && empty($attrib['title']) && !empty($attrib['alt'])) {
	$attrib['title'] = $attrib['alt'];
	}

	// add empty alt attribute for XHTML compatibility
	if (!isset($attrib['alt'])) {
	$attrib['alt'] = '';
	}

	// register button in the system
	- if ($attrib['command']) {
	+ if (!empty($attrib['command'])) {
	$this->add_script(sprintf(
	"%s.register_button('%s', '%s', '%s', '%s', '%s', '%s');",
	self::JS_OBJECT_NAME,
	$command,
	$attrib['id'],
	$attrib['type'],
	- $attrib['imageact'] ? $this->abs_url($attrib['imageact']) : $attrib['classact'],
	- $attrib['imagesel'] ? $this->abs_url($attrib['imagesel']) : $attrib['classsel'],
	- $attrib['imageover'] ? $this->abs_url($attrib['imageover']) : ''
	+ !empty($attrib['imageact']) ? $this->abs_url($attrib['imageact']) : (!empty($attrib['classact']) ? $attrib['classact'] : ''),
	+ !empty($attrib['imagesel']) ? $this->abs_url($attrib['imagesel']) : (!empty($attrib['classsel']) ? $attrib['classsel'] : ''),
	+ !empty($attrib['imageover']) ? $this->abs_url($attrib['imageover']) : ''
	));

	// make valid href to specific buttons
	if (in_array($attrib['command'], rcmail::$main_tasks)) {
	$attrib['href'] = $this->app->url(array('task' => $attrib['command']));
	$attrib['onclick'] = sprintf("return %s.command('switch-task','%s',this,event)", self::JS_OBJECT_NAME, $attrib['command']);
	}
	- else if ($attrib['task'] && in_array($attrib['task'], rcmail::$main_tasks)) {
	+ else if (!empty($attrib['task']) && in_array($attrib['task'], rcmail::$main_tasks)) {
	$attrib['href'] = $this->app->url(array('action' => $attrib['command'], 'task' => $attrib['task']));
	}
	else if (in_array($attrib['command'], $a_static_commands)) {
	$attrib['href'] = $this->app->url(array('action' => $attrib['command']));
	}
	else if (($attrib['command'] == 'permaurl' \|\| $attrib['command'] == 'extwin') && !empty($this->env['permaurl'])) {
	$attrib['href'] = $this->env['permaurl'];
	}
	}

	// overwrite attributes
	- if (!$attrib['href']) {
	+ if (empty($attrib['href'])) {
	$attrib['href'] = '#';
	}

	- if ($attrib['task']) {
	- if ($attrib['classact']) {
	+ if (!empty($attrib['task'])) {
	+ if (!empty($attrib['classact'])) {
	$attrib['class'] = $attrib['classact'];
	}
	}
	- else if ($command && !$attrib['onclick']) {
	+ else if ($command && empty($attrib['onclick'])) {
	$attrib['onclick'] = sprintf(
	"return %s.command('%s','%s',this,event)",
	self::JS_OBJECT_NAME,
	$command,
	- $attrib['prop']
	+ !empty($attrib['prop']) ? $attrib['prop'] : ''
	);
	}

	- $out = '';
	+ $out = '';
	$btn_content = null;
	$link_attrib = array();

	// generate image tag
	if ($attrib['type'] == 'image') {
	$attrib_str = html::attrib_string(
	$attrib,
	array(
	'style', 'class', 'id', 'width', 'height', 'border', 'hspace',
	'vspace', 'align', 'alt', 'tabindex', 'title'
	)
	);
	$btn_content = sprintf('<img src="%s"%s />', $this->abs_url($attrib['image']), $attrib_str);
	- if ($attrib['label']) {
	+ if (!empty($attrib['label'])) {
	$btn_content .= ' '.$attrib['label'];
	}
	$link_attrib = array('href', 'onclick', 'onmouseover', 'onmouseout', 'onmousedown', 'onmouseup', 'target');
	}
	else if ($attrib['type'] == 'link') {
	- $btn_content = isset($attrib['content']) ? $attrib['content'] : ($attrib['label'] ? $attrib['label'] : $attrib['command']);
	+ $btn_content = isset($attrib['content']) ? $attrib['content'] : (!empty($attrib['label']) ? $attrib['label'] : $attrib['command']);
	$link_attrib = array_merge(html::$common_attrib, array('href', 'onclick', 'tabindex', 'target', 'rel'));
	- if ($attrib['innerclass']) {
	+ if (!empty($attrib['innerclass'])) {
	$btn_content = html::span($attrib['innerclass'], $btn_content);
	}
	}
	else if ($attrib['type'] == 'input') {
	$attrib['type'] = 'button';

	- if ($attrib['label']) {
	+ if (!empty($attrib['label'])) {
	$attrib['value'] = $attrib['label'];
	}
	- if ($attrib['command']) {
	+ if (!empty($attrib['command'])) {
	$attrib['disabled'] = 'disabled';
	}

	$out = html::tag('input', $attrib, null, array('type', 'value', 'onclick', 'id', 'class', 'style', 'tabindex', 'disabled'));
	}
	else {
	- if ($attrib['label']) {
	+ if (!empty($attrib['label'])) {
	$attrib['value'] = $attrib['label'];
	}
	- if ($attrib['command']) {
	+ if (!empty($attrib['command'])) {
	$attrib['disabled'] = 'disabled';
	}

	$content = isset($attrib['content']) ? $attrib['content'] : $attrib['label'];
	$out = html::tag('button', $attrib, $content, array('type', 'value', 'onclick', 'id', 'class', 'style', 'tabindex', 'disabled'));
	}

	// generate html code for button
	if ($btn_content) {
	$attrib_str = html::attrib_string($attrib, $link_attrib);
	$out = sprintf('<a%s>%s</a>', $attrib_str, $btn_content);
	}

	- if ($attrib['wrapper']) {
	+ if (!empty($attrib['wrapper'])) {
	$out = html::tag($attrib['wrapper'], null, $out);
	}

	if (!empty($menuitem)) {
	- $class = $attrib['menuitem-class'] ? ' class="' . $attrib['menuitem-class'] . '"' : '';
	+ $class = !empty($attrib['menuitem-class']) ? ' class="' . $attrib['menuitem-class'] . '"' : '';
	$out = '<li role="menuitem"' . $class . '>' . $out . '</li>';
	}

	return $out;
	}

	/**
	* Link an external script file
	*
	* @param string $file File URL
	* @param string $position Target position [head\|head_bottom\|foot]
	*/
	public function include_script($file, $position = 'head', $add_path = true)
	{
	if ($add_path && !preg_match('\|^https?://\|i', $file) && $file[0] != '/') {
	$file = $this->file_mod($this->scripts_path . $file);
	}

	if (!isset($this->script_files[$position]) \|\| !is_array($this->script_files[$position])) {
	$this->script_files[$position] = array();
	}

	if (!in_array($file, $this->script_files[$position])) {
	$this->script_files[$position][] = $file;
	}
	}

	/**
	* Add inline javascript code
	*
	* @param string $script JS code snippet
	* @param string $position Target position [head\|head_top\|foot\|docready]
	*/
	public function add_script($script, $position = 'head')
	{
	if (!isset($this->scripts[$position])) {
	$this->scripts[$position] = rtrim($script);
	}
	else {
	$this->scripts[$position] .= "\n" . rtrim($script);
	}
	}

	/**
	* Link an external css file
	*
	* @param string $file File URL
	*/
	public function include_css($file)
	{
	$this->css_files[] = $file;
	}

	/**
	* Add HTML code to the page header
	*
	* @param string $str HTML code
	*/
	public function add_header($str)
	{
	$this->header .= "\n" . $str;
	}

	/**
	* Add HTML code to the page footer
	* To be added right befor </body>
	*
	* @param string $str HTML code
	*/
	public function add_footer($str)
	{
	$this->footer .= "\n" . $str;
	}

	/**
	* Process template and write to stdOut
	*
	* @param string $output HTML output
	*/
	protected function _write($output = '')
	{
	$output = trim($output);

	if (empty($output)) {
	$output = html::doctype('html5') . "\n" . $this->default_template;
	$is_empty = true;
	}

	$merge_script_files = function($output, $script) {
	return $output . html::script($script);
	};

	$merge_scripts = function($output, $script) {
	return $output . html::script(array(), $script);
	};

	// put docready commands into page footer
	if (!empty($this->scripts['docready'])) {
	$this->add_script("\$(function() {\n" . $this->scripts['docready'] . "\n});", 'foot');
	}

	$page_header = '';
	$page_footer = '';
	$meta = '';

	// declare page language
	if (!empty($_SESSION['language'])) {
	$lang = substr($_SESSION['language'], 0, 2);
	$output = preg_replace('/<html/', '<html lang="' . html::quote($lang) . '"', $output, 1);

	if (!headers_sent()) {
	header('Content-Language: ' . $lang);
	}
	}

	// include meta tag with charset
	if (!empty($this->charset)) {
	if (!headers_sent()) {
	header('Content-Type: text/html; charset=' . $this->charset);
	}

	$meta .= html::tag('meta', array(
	'http-equiv' => 'content-type',
	'content' => "text/html; charset={$this->charset}",
	'nl' => true
	));
	}

	// include page title (after charset specification)
	$meta .= '<title>' . html::quote($this->get_pagetitle()) . "</title>\n";

	$output = preg_replace('/(<head[^>]>)\n/i', "\\1\n{$meta}", $output, 1, $count);
	if (!$count) {
	$page_header .= $meta;
	}

	// include scripts into header/footer
	$page_header .= array_reduce((array) $this->script_files['head'], $merge_script_files);
	$page_header .= array_reduce(array($this->scripts['head_top'] . $this->scripts['head']), $merge_scripts);
	$page_header .= $this->header . "\n";
	$page_header .= array_reduce((array) $this->script_files['head_bottom'], $merge_script_files);

	- $page_footer .= array_reduce((array) $this->script_files['foot'], $merge_script_files);
	+ if (!empty($this->script_files['foot'])) {
	+ $page_footer .= array_reduce((array) $this->script_files['foot'], $merge_script_files);
	+ }
	$page_footer .= $this->footer . "\n";
	- $page_footer .= array_reduce((array) $this->scripts['foot'], $merge_scripts);
	+ if (!empty($this->scripts['foot'])) {
	+ $page_footer .= array_reduce((array) $this->scripts['foot'], $merge_scripts);
	+ }

	// find page header
	if ($hpos = stripos($output, '</head>')) {
	$page_header .= "\n";
	}
	else {
	if (!is_numeric($hpos)) {
	$hpos = stripos($output, '<body');
	}
	if (!is_numeric($hpos) && ($hpos = stripos($output, '<html'))) {
	while ($output[$hpos] != '>') {
	$hpos++;
	}
	$hpos++;
	}
	$page_header = "<head>\n$page_header\n</head>\n";
	}

	// add page hader
	if ($hpos) {
	$output = substr_replace($output, $page_header, $hpos, 0);
	}
	else {
	$output = $page_header . $output;
	}

	// add page footer
	if (($fpos = strripos($output, '</body>')) \|\| ($fpos = strripos($output, '</html>'))) {
	// for Elastic: put footer content before "footer scripts"
	while (($npos = strripos($output, "\n", -strlen($output) + $fpos - 1))
	&& $npos != $fpos
	&& ($chunk = substr($output, $npos, $fpos - $npos)) !== ''
	&& (trim($chunk) === '' \|\| preg_match('/\s<script[^>]+><\/script>\s/', $chunk))
	) {
	$fpos = $npos;
	}

	$output = substr_replace($output, $page_footer."\n", $fpos, 0);
	}
	else {
	$output .= "\n".$page_footer;
	}

	// add css files in head, before scripts, for speed up with parallel downloads
	if (!empty($this->css_files) && empty($is_empty)
	&& (($pos = stripos($output, '<script ')) \|\| ($pos = stripos($output, '</head>')))
	) {
	$css = '';
	foreach ($this->css_files as $file) {
	$is_less = substr_compare($file, '.less', -5, 5, true) === 0;
	$css .= html::tag('link', array(
	'rel' => $is_less ? 'stylesheet/less' : 'stylesheet',
	'type' => 'text/css',
	'href' => $file,
	'nl' => true,
	));
	}
	$output = substr_replace($output, $css, $pos, 0);
	}

	$output = $this->parse_with_globals($this->fix_paths($output));

	if ($this->assets_path) {
	$output = $this->fix_assets_paths($output);
	}

	$output = $this->postrender($output);

	// trigger hook with final HTML content to be sent
	$hook = $this->app->plugins->exec_hook("send_page", array('content' => $output));
	if (!$hook['abort']) {
	if ($this->charset != RCUBE_CHARSET) {
	echo rcube_charset::convert($hook['content'], RCUBE_CHARSET, $this->charset);
	}
	else {
	echo $hook['content'];
	}
	}
	}

	/**
	* Returns iframe object, registers some related env variables
	*
	* @param array $attrib HTML attributes
	* @param boolean $is_contentframe Register this iframe as the 'contentframe' gui object
	*
	* @return string IFRAME element
	*/
	public function frame($attrib, $is_contentframe = false)
	{
	static $idcount = 0;

	- if (!$attrib['id']) {
	+ if (empty($attrib['id'])) {
	$attrib['id'] = 'rcmframe' . ++$idcount;
	}

	$attrib['name'] = $attrib['id'];
	- $attrib['src'] = $attrib['src'] ? $this->abs_url($attrib['src'], true) : 'about:blank';
	+ $attrib['src'] = !empty($attrib['src']) ? $this->abs_url($attrib['src'], true) : 'about:blank';

	// register as 'contentframe' object
	- if ($is_contentframe \|\| $attrib['contentframe']) {
	- $this->set_env('contentframe', $attrib['contentframe'] ? $attrib['contentframe'] : $attrib['name']);
	+ if ($is_contentframe \|\| !empty($attrib['contentframe'])) {
	+ $this->set_env('contentframe', !empty($attrib['contentframe']) ? $attrib['contentframe'] : $attrib['name']);
	}

	return html::iframe($attrib);
	}


	/* *********** common functions delivering gui objects ************ */

	/**
	* Create a form tag with the necessary hidden fields
	*
	* @param array $attrib Named tag parameters
	* @param string $content HTML content of the form
	*
	* @return string HTML code for the form
	*/
	public function form_tag($attrib, $content = null)
	{
	$hidden = '';

	- if ($this->env['extwin']) {
	+ if (!empty($this->env['extwin'])) {
	$hiddenfield = new html_hiddenfield(array('name' => '_extwin', 'value' => '1'));
	$hidden = $hiddenfield->show();
	}
	- else if ($this->framed \|\| $this->env['framed']) {
	+ else if ($this->framed \|\| !empty($this->env['framed'])) {
	$hiddenfield = new html_hiddenfield(array('name' => '_framed', 'value' => '1'));
	$hidden = $hiddenfield->show();
	}

	if (!$content) {
	$attrib['noclose'] = true;
	}

	return html::tag('form',
	$attrib + array('action' => $this->app->comm_path, 'method' => "get"),
	$hidden . $content,
	array('id','class','style','name','method','action','enctype','onsubmit')
	);
	}

	/**
	* Build a form tag with a unique request token
	*
	* @param array $attrib Named tag parameters including 'action' and 'task' values
	* which will be put into hidden fields
	* @param string $content Form content
	*
	* @return string HTML code for the form
	*/
	public function request_form($attrib, $content = '')
	{
	$hidden = new html_hiddenfield();
	if ($attrib['task']) {
	$hidden->add(array('name' => '_task', 'value' => $attrib['task']));
	}
	if ($attrib['action']) {
	$hidden->add(array('name' => '_action', 'value' => $attrib['action']));
	}

	// we already have a <form> tag
	if ($attrib['form']) {
	if ($this->framed \|\| $this->env['framed']) {
	$hidden->add(array('name' => '_framed', 'value' => '1'));
	}

	return $hidden->show() . $content;
	}

	unset($attrib['task'], $attrib['request']);
	$attrib['action'] = './';

	return $this->form_tag($attrib, $hidden->show() . $content);
	}

	/**
	* GUI object 'username'
	* Showing IMAP username of the current session
	*
	* @param array $attrib Named tag parameters (currently not used)
	*
	* @return string HTML code for the gui object
	*/
	public function current_username($attrib)
	{
	static $username;

	// alread fetched
	if (!empty($username)) {
	return $username;
	}

	// Current username is an e-mail address
	if (strpos($_SESSION['username'], '@')) {
	$username = $_SESSION['username'];
	}
	// get e-mail address from default identity
	else if ($sql_arr = $this->app->user->get_identity()) {
	$username = $sql_arr['email'];
	}
	else {
	$username = $this->app->user->get_username();
	}

	$username = rcube_utils::idn_to_utf8($username);

	return html::quote($username);
	}

	/**
	* GUI object 'loginform'
	* Returns code for the webmail login form
	*
	* @param array $attrib Named parameters
	*
	* @return string HTML code for the gui object
	*/
	protected function login_form($attrib)
	{
	$default_host = $this->config->get('default_host');
	$autocomplete = (int) $this->config->get('login_autocomplete');
	$username_filter = $this->config->get('login_username_filter');
	$_SESSION['temp'] = true;

	// save original url
	$url = rcube_utils::get_input_value('_url', rcube_utils::INPUT_POST);
	if (empty($url) && !preg_match('/_(task\|action)=logout/', $_SERVER['QUERY_STRING'])) {
	$url = $_SERVER['QUERY_STRING'];
	}

	// Disable autocapitalization on iPad/iPhone (#1488609)
	$attrib['autocapitalize'] = 'off';

	$form_name = !empty($attrib['form']) ? $attrib['form'] : 'form';

	// set atocomplete attribute
	$user_attrib = $autocomplete > 0 ? array() : array('autocomplete' => 'off');
	$host_attrib = $autocomplete > 0 ? array() : array('autocomplete' => 'off');
	$pass_attrib = $autocomplete > 1 ? array() : array('autocomplete' => 'off');

	if ($username_filter && strtolower($username_filter) == 'email') {
	$user_attrib['type'] = 'email';
	}

	$input_task = new html_hiddenfield(array('name' => '_task', 'value' => 'login'));
	$input_action = new html_hiddenfield(array('name' => '_action', 'value' => 'login'));
	$input_tzone = new html_hiddenfield(array('name' => '_timezone', 'id' => 'rcmlogintz', 'value' => '_default_'));
	$input_url = new html_hiddenfield(array('name' => '_url', 'id' => 'rcmloginurl', 'value' => $url));
	$input_user = new html_inputfield(array('name' => '_user', 'id' => 'rcmloginuser', 'required' => 'required')
	+ $attrib + $user_attrib);
	$input_pass = new html_passwordfield(array('name' => '_pass', 'id' => 'rcmloginpwd', 'required' => 'required')
	+ $attrib + $pass_attrib);
	$input_host = null;
	$hide_host = false;

	if (is_array($default_host) && count($default_host) > 1) {
	$input_host = new html_select(array('name' => '_host', 'id' => 'rcmloginhost', 'class' => 'custom-select'));

	foreach ($default_host as $key => $value) {
	if (!is_array($value)) {
	$input_host->add($value, (is_numeric($key) ? $value : $key));
	}
	else {
	$input_host = null;
	break;
	}
	}
	}
	else if (is_array($default_host) && ($host = key($default_host)) !== null) {
	$hide_host = true;
	$input_host = new html_hiddenfield(array(
	'name' => '_host', 'id' => 'rcmloginhost', 'value' => is_numeric($host) ? $default_host[$host] : $host) + $attrib);
	}
	else if (empty($default_host)) {
	$input_host = new html_inputfield(array('name' => '_host', 'id' => 'rcmloginhost', 'class' => 'form-control')
	+ $attrib + $host_attrib);
	}

	$this->add_gui_object('loginform', $form_name);

	// create HTML table with two cols
	$table = new html_table(array('cols' => 2));

	$table->add('title', html::label('rcmloginuser', html::quote($this->app->gettext('username'))));
	$table->add('input', $input_user->show(rcube_utils::get_input_value('_user', rcube_utils::INPUT_GPC)));

	$table->add('title', html::label('rcmloginpwd', html::quote($this->app->gettext('password'))));
	$table->add('input', $input_pass->show());

	// add host selection row
	if (is_object($input_host) && !$hide_host) {
	$table->add('title', html::label('rcmloginhost', html::quote($this->app->gettext('server'))));
	$table->add('input', $input_host->show(rcube_utils::get_input_value('_host', rcube_utils::INPUT_GPC)));
	}

	$out = $input_task->show();
	$out .= $input_action->show();
	$out .= $input_tzone->show();
	$out .= $input_url->show();
	$out .= $table->show();

	if ($hide_host) {
	$out .= $input_host->show();
	}

	if (rcube_utils::get_boolean($attrib['submit'])) {
	$button_attr = array('type' => 'submit', 'id' => 'rcmloginsubmit', 'class' => 'button mainaction submit');
	$out .= html::p('formbuttons', html::tag('button', $button_attr, $this->app->gettext('login')));
	}

	// add oauth login button
	if ($this->config->get('oauth_auth_uri') && $this->config->get('oauth_provider')) {
	$link_attr = array('href' => $this->app->url(array('action' => 'oauth')), 'id' => 'rcmloginoauth', 'class' => 'button oauth ' . $this->config->get('oauth_provider'));
	$out .= html::p('oauthlogin', html::a($link_attr, $this->app->gettext(array('name' => 'oauthlogin', 'vars' => array('provider' => $this->config->get('oauth_provider_name', 'OAuth'))))));
	}

	// surround html output with a form tag
	if (empty($attrib['form'])) {
	$out = $this->form_tag(array('name' => $form_name, 'method' => 'post'), $out);
	}

	// include script for timezone detection
	$this->include_script('jstz.min.js');

	return $out;
	}

	/**
	* GUI object 'preloader'
	* Loads javascript code for images preloading
	*
	* @param array $attrib Named parameters
	* @return void
	*/
	protected function preloader($attrib)
	{
	$images = preg_split('/[\s\t\n,]+/', $attrib['images'], -1, PREG_SPLIT_NO_EMPTY);
	$images = array_map(array($this, 'abs_url'), $images);
	$images = array_map(array($this, 'asset_url'), $images);

	if (empty($images) \|\| $_REQUEST['_task'] == 'logout') {
	return;
	}

	$this->add_script('var images = ' . self::json_serialize($images, $this->devel_mode) .';
	for (var i=0; i<images.length; i++) {
	img = new Image();
	img.src = images[i];
	}', 'docready');
	}

	/**
	* GUI object 'searchform'
	* Returns code for search function
	*
	* @param array $attrib Named parameters
	*
	* @return string HTML code for the gui object
	*/
	public function search_form($attrib)
	{
	// add some labels to client
	$this->add_label('searching');

	$attrib['name'] = '_q';
	- $attrib['class'] = trim($attrib['class'] . ' no-bs');
	+ $attrib['class'] = trim((!empty($attrib['class']) ? $attrib['class'] : '') . ' no-bs');

	if (empty($attrib['id'])) {
	$attrib['id'] = 'rcmqsearchbox';
	}
	- if ($attrib['type'] == 'search' && !$this->browser->khtml) {
	+ if (isset($attrib['type']) && $attrib['type'] == 'search' && !$this->browser->khtml) {
	unset($attrib['type'], $attrib['results']);
	}
	if (empty($attrib['placeholder'])) {
	$attrib['placeholder'] = $this->app->gettext('searchplaceholder');
	}

	$label = html::label(array('for' => $attrib['id'], 'class' => 'voice'), rcube::Q($this->app->gettext('arialabelsearchterms')));
	$input_q = new html_inputfield($attrib);
	$out = $label . $input_q->show();

	// Support for multiple searchforms on the same page
	- if ($attrib['gui-object'] !== false && $attrib['gui-object'] !== 'false') {
	+ if (isset($attrib['gui-object']) && $attrib['gui-object'] !== false && $attrib['gui-object'] !== 'false') {
	$this->add_gui_object($attrib['gui-object'] ?: 'qsearchbox', $attrib['id']);
	}

	// add form tag around text field
	if (empty($attrib['form']) && empty($attrib['no-form'])) {
	$out = $this->form_tag(array(
	- 'name' => $attrib['form-name'] ?: 'rcmqsearchform',
	- 'onsubmit' => sprintf("%s.command('%s'); return false", self::JS_OBJECT_NAME, $attrib['command'] ?: 'search'),
	+ 'name' => !empty($attrib['form-name']) ? $attrib['form-name'] : 'rcmqsearchform',
	+ 'onsubmit' => sprintf(
	+ "%s.command('%s'); return false",
	+ self::JS_OBJECT_NAME,
	+ !empty($attrib['command']) ? $attrib['command'] : 'search'
	+ ),
	// 'style' => "display:inline"
	), $out);
	}

	if (!empty($attrib['wrapper'])) {
	$options_button = '';
	- $header_label = $this->app->gettext('arialabel' . $attrib['label'], $attrib['label-domain']);
	+
	+ $ariatag = !empty($attrib['ariatag']) ? $attrib['ariatag'] : 'h2';
	+ $domain = !empty($attrib['label-domain']) ? $attrib['label-domain'] : null;
	+ $options = !empty($attrib['options']) ? $attrib['options'] : null;
	+
	+ $header_label = $this->app->gettext('arialabel' . $attrib['label'], $domain);
	$header_attrs = array(
	'id' => 'aria-label-' . $attrib['label'],
	'class' => 'voice'
	);

	- $header = html::tag($attrib['ariatag'] ?: 'h2', $header_attrs, rcube::Q($header_label));
	+ $header = html::tag($ariatag, $header_attrs, rcube::Q($header_label));

	if ($attrib['options']) {
	$options_button = $this->button(array(
	'type' => 'link',
	'href' => '#search-filter',
	'class' => 'button options',
	'label' => 'options',
	'title' => 'options',
	'tabindex' => '0',
	'innerclass' => 'inner',
	- 'data-target' => $attrib['options']
	+ 'data-target' => $options
	));
	}

	$search_button = $this->button(array(
	'type' => 'link',
	'href' => '#search',
	'class' => 'button search',
	'label' => $attrib['buttontitle'],
	'title' => $attrib['buttontitle'],
	'tabindex' => '0',
	'innerclass' => 'inner',
	));

	$reset_button = $this->button(array(
	'type' => 'link',
	- 'command' => $attrib['reset-command'] ?: 'reset-search',
	+ 'command' => !empty($attrib['reset-command']) ? $attrib['reset-command'] : 'reset-search',
	'class' => 'button reset',
	'label' => 'resetsearch',
	'title' => 'resetsearch',
	'tabindex' => '0',
	'innerclass' => 'inner',
	));

	$out = html::div(array(
	'role' => 'search',
	- 'aria-labelledby' => $attrib['label'] ? 'aria-label-' . $attrib['label'] : null,
	+ 'aria-labelledby' => !empty($attrib['label']) ? 'aria-label-' . $attrib['label'] : null,
	'class' => $attrib['wrapper'],
	), "$header$out\n$reset_button\n$options_button\n$search_button");
	}

	return $out;
	}

	/**
	* Builder for GUI object 'message'
	*
	* @param array Named tag parameters
	* @return string HTML code for the gui object
	*/
	protected function message_container($attrib)
	{
	if (isset($attrib['id']) === false) {
	$attrib['id'] = 'rcmMessageContainer';
	}

	$this->add_gui_object('message', $attrib['id']);

	return html::div($attrib, '');
	}

	/**
	* GUI object 'charsetselector'
	*
	* @param array $attrib Named parameters for the select tag
	*
	* @return string HTML code for the gui object
	*/
	public function charset_selector($attrib)
	{
	// pass the following attributes to the form class
	$field_attrib = array('name' => '_charset');
	foreach ($attrib as $attr => $value) {
	if (in_array($attr, array('id', 'name', 'class', 'style', 'size', 'tabindex'))) {
	$field_attrib[$attr] = $value;
	}
	}

	$charsets = array(
	'UTF-8' => 'UTF-8 ('.$this->app->gettext('unicode').')',
	'US-ASCII' => 'ASCII ('.$this->app->gettext('english').')',
	'ISO-8859-1' => 'ISO-8859-1 ('.$this->app->gettext('westerneuropean').')',
	'ISO-8859-2' => 'ISO-8859-2 ('.$this->app->gettext('easterneuropean').')',
	'ISO-8859-4' => 'ISO-8859-4 ('.$this->app->gettext('baltic').')',
	'ISO-8859-5' => 'ISO-8859-5 ('.$this->app->gettext('cyrillic').')',
	'ISO-8859-6' => 'ISO-8859-6 ('.$this->app->gettext('arabic').')',
	'ISO-8859-7' => 'ISO-8859-7 ('.$this->app->gettext('greek').')',
	'ISO-8859-8' => 'ISO-8859-8 ('.$this->app->gettext('hebrew').')',
	'ISO-8859-9' => 'ISO-8859-9 ('.$this->app->gettext('turkish').')',
	'ISO-8859-10' => 'ISO-8859-10 ('.$this->app->gettext('nordic').')',
	'ISO-8859-11' => 'ISO-8859-11 ('.$this->app->gettext('thai').')',
	'ISO-8859-13' => 'ISO-8859-13 ('.$this->app->gettext('baltic').')',
	'ISO-8859-14' => 'ISO-8859-14 ('.$this->app->gettext('celtic').')',
	'ISO-8859-15' => 'ISO-8859-15 ('.$this->app->gettext('westerneuropean').')',
	'ISO-8859-16' => 'ISO-8859-16 ('.$this->app->gettext('southeasterneuropean').')',
	'WINDOWS-1250' => 'Windows-1250 ('.$this->app->gettext('easterneuropean').')',
	'WINDOWS-1251' => 'Windows-1251 ('.$this->app->gettext('cyrillic').')',
	'WINDOWS-1252' => 'Windows-1252 ('.$this->app->gettext('westerneuropean').')',
	'WINDOWS-1253' => 'Windows-1253 ('.$this->app->gettext('greek').')',
	'WINDOWS-1254' => 'Windows-1254 ('.$this->app->gettext('turkish').')',
	'WINDOWS-1255' => 'Windows-1255 ('.$this->app->gettext('hebrew').')',
	'WINDOWS-1256' => 'Windows-1256 ('.$this->app->gettext('arabic').')',
	'WINDOWS-1257' => 'Windows-1257 ('.$this->app->gettext('baltic').')',
	'WINDOWS-1258' => 'Windows-1258 ('.$this->app->gettext('vietnamese').')',
	'ISO-2022-JP' => 'ISO-2022-JP ('.$this->app->gettext('japanese').')',
	'ISO-2022-KR' => 'ISO-2022-KR ('.$this->app->gettext('korean').')',
	'ISO-2022-CN' => 'ISO-2022-CN ('.$this->app->gettext('chinese').')',
	'EUC-JP' => 'EUC-JP ('.$this->app->gettext('japanese').')',
	'EUC-KR' => 'EUC-KR ('.$this->app->gettext('korean').')',
	'EUC-CN' => 'EUC-CN ('.$this->app->gettext('chinese').')',
	'BIG5' => 'BIG5 ('.$this->app->gettext('chinese').')',
	'GB2312' => 'GB2312 ('.$this->app->gettext('chinese').')',
	'KOI8-R' => 'KOI8-R ('.$this->app->gettext('cyrillic').')',
	);

	if ($post = rcube_utils::get_input_value('_charset', rcube_utils::INPUT_POST)) {
	$set = $post;
	}
	else if (!empty($attrib['selected'])) {
	$set = $attrib['selected'];
	}
	else {
	$set = $this->get_charset();
	}

	$set = strtoupper($set);
	if (!isset($charsets[$set]) && preg_match('/^[A-Z0-9-]+$/', $set)) {
	$charsets[$set] = $set;
	}

	$select = new html_select($field_attrib);
	$select->add(array_values($charsets), array_keys($charsets));

	return $select->show($set);
	}

	/**
	* Include content from config/about.<LANG>.html if available
	*/
	protected function about_content($attrib)
	{
	$content = '';
	$filenames = array(
	'about.' . $_SESSION['language'] . '.html',
	'about.' . substr($_SESSION['language'], 0, 2) . '.html',
	'about.html',
	);
	foreach ($filenames as $file) {
	$fn = RCUBE_CONFIG_DIR . $file;
	if (is_readable($fn)) {
	$content = file_get_contents($fn);
	$content = $this->parse_conditions($content);
	$content = $this->parse_xml($content);
	break;
	}
	}

	return $content;
	}

	/**
	* Get logo URL for current template based on skin_logo config option
	*
	* @param string $type Type of the logo to check for (e.g. 'print' or 'small')
	* default is null (no special type)
	* @param string $match (optional) 'all' = type, template or wildcard, 'template' = type or template
	* Note: when type is specified matches are limited to type only unless $match is defined
	*
	* @return string image URL
	*/
	protected function get_template_logo($type = null, $match = null)
	{
	$template_logo = null;

	if ($logo = $this->config->get('skin_logo')) {
	if (is_array($logo)) {
	$template_names = array(
	$this->skin_name . ':' . $this->template_name . '[' . $type . ']',
	$this->skin_name . ':' . $this->template_name,
	$this->skin_name . ':*[' . $type . ']',
	$this->skin_name . ':[' . $type . ']',
	$this->skin_name . ':*',
	'*:' . $this->template_name . '[' . $type . ']',
	'*:' . $this->template_name,
	':[' . $type . ']',
	'*:[' . $type . ']',
	$this->template_name . '[' . $type . ']',
	$this->template_name,
	'*[' . $type . ']',
	'[' . $type . ']',
	'*',
	);

	if (empty($type)) {
	// If no type provided then remove those options from the list
	$template_names = preg_grep("/\]$/", $template_names, PREG_GREP_INVERT);
	}
	elseif ($match === null) {
	// Type specified with no special matching requirements so remove all none type specific options from the list
	$template_names = preg_grep("/\]$/", $template_names);
	}

	if ($match == 'template') {
	// Match only specific type or template name
	$template_names = preg_grep("/\*$/", $template_names, PREG_GREP_INVERT);
	}

	foreach ($template_names as $key) {
	if (isset($logo[$key])) {
	$template_logo = $logo[$key];
	break;
	}
	}
	}
	else {
	$template_logo = $logo;
	}
	}

	return $template_logo;
	}
	}
	diff --git a/program/lib/Roundcube/db/mssql.php b/program/lib/Roundcube/db/mssql.php
	index 244f2c9cf..b96ab83df 100644
	--- a/program/lib/Roundcube/db/mssql.php
	+++ b/program/lib/Roundcube/db/mssql.php
	@@ -1,191 +1,191 @@
	<?php

	/**
	+-----------------------------------------------------------------------+
	\| This file is part of the Roundcube Webmail client \|
	\| \|
	\| Copyright (C) The Roundcube Dev Team \|
	\| \|
	\| Licensed under the GNU General Public License version 3 or \|
	\| any later version with exceptions for skins & plugins. \|
	\| See the README file for a full license statement. \|
	\| \|
	\| PURPOSE: \|
	\| Database wrapper class that implements PHP PDO functions \|
	\| for MS SQL Server database \|
	+-----------------------------------------------------------------------+
	\| Author: Aleksander Machniak <alec@alec.pl> \|
	+-----------------------------------------------------------------------+
	*/

	/**
	* Database independent query interface
	* This is a wrapper for the PHP PDO
	*
	* @package Framework
	* @subpackage Database
	*/
	class rcube_db_mssql extends rcube_db
	{
	public $db_provider = 'mssql';

	/**
	* Object constructor
	*
	* @param string $db_dsnw DSN for read/write operations
	* @param string $db_dsnr Optional DSN for read only operations
	* @param bool $pconn Enables persistent connections
	*/
	public function __construct($db_dsnw, $db_dsnr = '', $pconn = false)
	{
	parent::__construct($db_dsnw, $db_dsnr, $pconn);

	$this->options['identifier_start'] = '[';
	$this->options['identifier_end'] = ']';
	}

	/**
	* Driver-specific configuration of database connection
	*
	* @param array $dsn DSN for DB connections
	* @param PDO $dbh Connection handler
	*/
	protected function conn_configure($dsn, $dbh)
	{
	// Set date format in case of non-default language (#1488918)
	$dbh->query("SET DATEFORMAT ymd");
	}

	/**
	* Return SQL function for current time and date
	*
	* @param int $interval Optional interval (in seconds) to add/subtract
	*
	* @return string SQL function to use in query
	*/
	public function now($interval = 0)
	{
	if ($interval) {
	$interval = intval($interval);
	return "dateadd(second, $interval, getdate())";
	}

	return "getdate()";
	}

	/**
	* Return SQL statement to convert a field value into a unix timestamp
	*
	* @param string $field Field name
	*
	* @return string SQL statement to use in query
	* @deprecated
	*/
	public function unixtimestamp($field)
	{
	return "DATEDIFF(second, '19700101', $field) + DATEDIFF(second, GETDATE(), GETUTCDATE())";
	}

	/**
	* Abstract SQL statement for value concatenation
	*
	* @return string SQL statement to be used in query
	*/
	public function concat(/* col1, col2, ... */)
	{
	$args = func_get_args();

	if (is_array($args[0])) {
	$args = $args[0];
	}

	return '(' . implode('+', $args) . ')';
	}

	/**
	* Adds TOP (LIMIT,OFFSET) clause to the query
	*
	* @param string $query SQL query
	* @param int $limit Number of rows
	* @param int $offset Offset
	*
	* @return string SQL query
	*/
	protected function set_limit($query, $limit = 0, $offset = 0)
	{
	$limit = intval($limit);
	$offset = intval($offset);
	$end = $offset + $limit;

	// query without OFFSET
	if (!$offset) {
	$query = preg_replace('/^SELECT\s/i', "SELECT TOP $limit ", $query);
	return $query;
	}

	$orderby = stristr($query, 'ORDER BY');
	$offset += 1;

	if ($orderby !== false) {
	$query = trim(substr($query, 0, -1 * strlen($orderby)));
	}
	else {
	// it shouldn't happen, paging without sorting has not much sense
	// @FIXME: I don't know how to build paging query without ORDER BY
	$orderby = "ORDER BY 1";
	}

	$query = preg_replace('/^SELECT\s/i', '', $query);
	$query = "WITH paging AS (SELECT ROW_NUMBER() OVER ($orderby) AS [RowNumber], $query)"
	. " SELECT * FROM paging WHERE [RowNumber] BETWEEN $offset AND $end ORDER BY [RowNumber]";

	return $query;
	}

	/**
	* Returns PDO DSN string from DSN array
	*/
	protected function dsn_string($dsn)
	{
	$params = array();
	$result = $dsn['phptype'] . ':';

	- if ($dsn['hostspec']) {
	+ if (isset($dsn['hostspec'])) {
	$host = $dsn['hostspec'];
	- if ($dsn['port']) {
	+ if (isset($dsn['port'])) {
	$host .= ',' . $dsn['port'];
	}
	$params[] = 'host=' . $host;
	}

	- if ($dsn['database']) {
	+ if (isset($dsn['database'])) {
	$params[] = 'dbname=' . $dsn['database'];
	}

	if (!empty($params)) {
	$result .= implode(';', $params);
	}

	return $result;
	}

	/**
	* Parse SQL file and fix table names according to table prefix
	*/
	protected function fix_table_names($sql)
	{
	if (!$this->options['table_prefix']) {
	return $sql;
	}

	// replace sequence names, and other postgres-specific commands
	$sql = preg_replace_callback(
	'/((TABLE\|(?<!ON )UPDATE\|INSERT INTO\|FROM(?! deleted)\| ON(?! (DELETE\|UPDATE\|\[PRIMARY\]))'
	. '\|REFERENCES\|CONSTRAINT\|TRIGGER\|INDEX)\s+(\[dbo\]\.)?[\[\]]*)([^\[\]\( \r\n]+)/',
	array($this, 'fix_table_names_callback'),
	$sql
	);

	return $sql;
	}
	}
	diff --git a/program/lib/Roundcube/db/mysql.php b/program/lib/Roundcube/db/mysql.php
	index a7755243e..36df16b0c 100644
	--- a/program/lib/Roundcube/db/mysql.php
	+++ b/program/lib/Roundcube/db/mysql.php
	@@ -1,250 +1,250 @@
	<?php

	/**
	+-----------------------------------------------------------------------+
	\| This file is part of the Roundcube Webmail client \|
	\| \|
	\| Copyright (C) The Roundcube Dev Team \|
	\| \|
	\| Licensed under the GNU General Public License version 3 or \|
	\| any later version with exceptions for skins & plugins. \|
	\| See the README file for a full license statement. \|
	\| \|
	\| PURPOSE: \|
	\| Database wrapper class that implements PHP PDO functions \|
	\| for MySQL database \|
	+-----------------------------------------------------------------------+
	\| Author: Aleksander Machniak <alec@alec.pl> \|
	+-----------------------------------------------------------------------+
	*/

	/**
	* Database independent query interface
	*
	* This is a wrapper for the PHP PDO
	*
	* @package Framework
	* @subpackage Database
	*/
	class rcube_db_mysql extends rcube_db
	{
	public $db_provider = 'mysql';

	/**
	* Object constructor
	*
	* @param string $db_dsnw DSN for read/write operations
	* @param string $db_dsnr Optional DSN for read only operations
	* @param bool $pconn Enables persistent connections
	*/
	public function __construct($db_dsnw, $db_dsnr = '', $pconn = false)
	{
	parent::__construct($db_dsnw, $db_dsnr, $pconn);

	// SQL identifiers quoting
	$this->options['identifier_start'] = '`';
	$this->options['identifier_end'] = '`';
	}

	/**
	* Abstract SQL statement for value concatenation
	*
	* @return string SQL statement to be used in query
	*/
	public function concat(/* col1, col2, ... */)
	{
	$args = func_get_args();

	if (is_array($args[0])) {
	$args = $args[0];
	}

	return 'CONCAT(' . implode(', ', $args) . ')';
	}

	/**
	* Returns PDO DSN string from DSN array
	*
	* @param array $dsn DSN parameters
	*
	* @return string Connection string
	*/
	protected function dsn_string($dsn)
	{
	$params = array();
	$result = 'mysql:';

	- if ($dsn['database']) {
	+ if (isset($dsn['database'])) {
	$params[] = 'dbname=' . $dsn['database'];
	}

	- if ($dsn['hostspec']) {
	+ if (isset($dsn['hostspec'])) {
	$params[] = 'host=' . $dsn['hostspec'];
	}

	- if ($dsn['port']) {
	+ if (isset($dsn['port'])) {
	$params[] = 'port=' . $dsn['port'];
	}

	- if ($dsn['socket']) {
	+ if (isset($dsn['socket'])) {
	$params[] = 'unix_socket=' . $dsn['socket'];
	}

	- $params[] = 'charset=' . ($dsn['charset'] ?: 'utf8mb4');
	+ $params[] = 'charset=' . (!empty($dsn['charset']) ? $dsn['charset'] : 'utf8mb4');

	if (!empty($params)) {
	$result .= implode(';', $params);
	}

	return $result;
	}

	/**
	* Returns driver-specific connection options
	*
	* @param array $dsn DSN parameters
	*
	* @return array Connection options
	*/
	protected function dsn_options($dsn)
	{
	$result = parent::dsn_options($dsn);

	if (!empty($dsn['key'])) {
	$result[PDO::MYSQL_ATTR_SSL_KEY] = $dsn['key'];
	}

	if (!empty($dsn['cipher'])) {
	$result[PDO::MYSQL_ATTR_SSL_CIPHER] = $dsn['cipher'];
	}

	if (!empty($dsn['cert'])) {
	$result[PDO::MYSQL_ATTR_SSL_CERT] = $dsn['cert'];
	}

	if (!empty($dsn['capath'])) {
	$result[PDO::MYSQL_ATTR_SSL_CAPATH] = $dsn['capath'];
	}

	if (!empty($dsn['ca'])) {
	$result[PDO::MYSQL_ATTR_SSL_CA] = $dsn['ca'];
	}

	if (isset($dsn['verify_server_cert'])) {
	$result[PDO::MYSQL_ATTR_SSL_VERIFY_SERVER_CERT] = rcube_utils::get_boolean($dsn['verify_server_cert']);
	}

	// Always return matching (not affected only) rows count
	$result[PDO::MYSQL_ATTR_FOUND_ROWS] = true;

	// Enable AUTOCOMMIT mode (#1488902)
	$result[PDO::ATTR_AUTOCOMMIT] = true;

	return $result;
	}

	/**
	* Returns list of tables in a database
	*
	* @return array List of all tables of the current database
	*/
	public function list_tables()
	{
	// get tables if not cached
	if ($this->tables === null) {
	$q = $this->query("SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES"
	. " WHERE TABLE_SCHEMA = ? AND TABLE_TYPE = 'BASE TABLE'"
	. " ORDER BY TABLE_NAME", $this->db_dsnw_array['database']);

	$this->tables = $q ? $q->fetchAll(PDO::FETCH_COLUMN, 0) : array();
	}

	return $this->tables;
	}

	/**
	* Returns list of columns in database table
	*
	* @param string $table Table name
	*
	* @return array List of table cols
	*/
	public function list_cols($table)
	{
	$q = $this->query("SELECT COLUMN_NAME FROM INFORMATION_SCHEMA.COLUMNS"
	. " WHERE TABLE_SCHEMA = ? AND TABLE_NAME = ?",
	$this->db_dsnw_array['database'], $table);

	if ($q) {
	return $q->fetchAll(PDO::FETCH_COLUMN, 0);
	}

	return array();
	}

	/**
	* Get database runtime variables
	*
	* @param string $varname Variable name
	* @param mixed $default Default value if variable is not set
	*
	* @return mixed Variable value or default
	*/
	public function get_variable($varname, $default = null)
	{
	if (!isset($this->variables)) {
	$this->variables = array();
	}

	if (array_key_exists($varname, $this->variables)) {
	return $this->variables[$varname];
	}

	// configured value has higher prio
	$conf_value = rcube::get_instance()->config->get('db_' . $varname);
	if ($conf_value !== null) {
	return $this->variables[$varname] = $conf_value;
	}

	$result = $this->query('SHOW VARIABLES LIKE ?', $varname);

	while ($row = $this->fetch_array($result)) {
	$this->variables[$row[0]] = $row[1];
	}

	// not found, use default
	if (!isset($this->variables[$varname])) {
	$this->variables[$varname] = $default;
	}

	return $this->variables[$varname];
	}

	/**
	* INSERT ... ON DUPLICATE KEY UPDATE (or equivalent).
	* When not supported by the engine we do UPDATE and INSERT.
	*
	* @param string $table Table name
	* @param array $keys Hash array (column => value) of the unique constraint
	* @param array $columns List of columns to update
	* @param array $values List of values to update (number of elements
	* should be the same as in $columns)
	*
	* @return PDOStatement\|bool Query handle or False on error
	* @todo Multi-insert support
	*/
	public function insert_or_update($table, $keys, $columns, $values)
	{
	$table = $this->table_name($table, true);
	$columns = array_map(function($i) { return "`$i`"; }, $columns);
	$cols = implode(', ', array_map(function($i) { return "`$i`"; }, array_keys($keys)));
	$cols .= ', ' . implode(', ', $columns);
	$vals = implode(', ', array_map(function($i) { return $this->quote($i); }, $keys));
	$vals .= ', ' . rtrim(str_repeat('?, ', count($columns)), ', ');
	$update = implode(', ', array_map(function($i) { return "$i = VALUES($i)"; }, $columns));

	return $this->query("INSERT INTO $table ($cols) VALUES ($vals)"
	. " ON DUPLICATE KEY UPDATE $update", $values);
	}

	}
	diff --git a/program/lib/Roundcube/db/oracle.php b/program/lib/Roundcube/db/oracle.php
	index 40681f9fa..3a0b77477 100644
	--- a/program/lib/Roundcube/db/oracle.php
	+++ b/program/lib/Roundcube/db/oracle.php
	@@ -1,623 +1,623 @@
	<?php

	/**
	+-----------------------------------------------------------------------+
	\| This file is part of the Roundcube Webmail client \|
	\| \|
	\| Copyright (C) The Roundcube Dev Team \|
	\| \|
	\| Licensed under the GNU General Public License version 3 or \|
	\| any later version with exceptions for skins & plugins. \|
	\| See the README file for a full license statement. \|
	\| \|
	\| PURPOSE: \|
	\| Database wrapper class that implements database functions \|
	\| for Oracle database using OCI8 extension \|
	+-----------------------------------------------------------------------+
	\| Author: Aleksander Machniak <machniak@kolabsys.com> \|
	+-----------------------------------------------------------------------+
	*/

	/**
	* Database independent query interface
	*
	* @package Framework
	* @subpackage Database
	*/
	class rcube_db_oracle extends rcube_db
	{
	public $db_provider = 'oracle';


	/**
	* Create connection instance
	*/
	protected function conn_create($dsn)
	{
	// Get database specific connection options
	$dsn_options = $this->dsn_options($dsn);

	$function = $this->db_pconn ? 'oci_pconnect' : 'oci_connect';

	if (!function_exists($function)) {
	$this->db_error = true;
	$this->db_error_msg = 'OCI8 extension not loaded. See http://php.net/manual/en/book.oci8.php';

	rcube::raise_error(array('code' => 500, 'type' => 'db',
	'line' => __LINE__, 'file' => __FILE__,
	'message' => $this->db_error_msg), true, false);

	return;
	}

	// connect
	$dbh = @$function($dsn['username'], $dsn['password'], $dsn_options['database'], $dsn_options['charset']);

	if (!$dbh) {
	$error = oci_error();
	$this->db_error = true;
	$this->db_error_msg = $error['message'];

	rcube::raise_error(array('code' => 500, 'type' => 'db',
	'line' => __LINE__, 'file' => __FILE__,
	'message' => $this->db_error_msg), true, false);

	return;
	}

	// configure session
	$this->conn_configure($dsn, $dbh);

	return $dbh;
	}

	/**
	* Driver-specific configuration of database connection
	*
	* @param array $dsn DSN for DB connections
	* @param PDO $dbh Connection handler
	*/
	protected function conn_configure($dsn, $dbh)
	{
	$init_queries = array(
	"ALTER SESSION SET nls_date_format = 'YYYY-MM-DD'",
	"ALTER SESSION SET nls_timestamp_format = 'YYYY-MM-DD HH24:MI:SS'",
	);

	foreach ($init_queries as $query) {
	$stmt = oci_parse($dbh, $query);
	oci_execute($stmt);
	}
	}

	/**
	* Connection state checker
	*
	* @return boolean True if in connected state
	*/
	public function is_connected()
	{
	return empty($this->dbh) ? false : $this->db_connected;
	}

	/**
	* Execute a SQL query with limits
	*
	* @param string $query SQL query to execute
	* @param int $offset Offset for LIMIT statement
	* @param int $numrows Number of rows for LIMIT statement
	* @param array $params Values to be inserted in query
	*
	* @return PDOStatement\|bool Query handle or False on error
	*/
	protected function _query($query, $offset, $numrows, $params)
	{
	$query = ltrim($query);

	$this->db_connect($this->dsn_select($query), true);

	// check connection before proceeding
	if (!$this->is_connected()) {
	return $this->last_result = false;
	}

	if ($numrows \|\| $offset) {
	$query = $this->set_limit($query, $numrows, $offset);
	}

	// replace self::DEFAULT_QUOTE with driver-specific quoting
	$query = $this->query_parse($query);

	// Because in Roundcube we mostly use queries that are
	// executed only once, we will not use prepared queries
	$pos = 0;
	$idx = 0;
	$args = array();

	if (!empty($params)) {
	while ($pos = strpos($query, '?', $pos)) {
	if ($query[$pos+1] == '?') { // skip escaped '?'
	$pos += 2;
	}
	else {
	$val = $this->quote($params[$idx++]);

	// long strings are not allowed inline, need to be parametrized
	if (strlen($val) > 4000) {
	$key = ':param' . (count($args) + 1);
	$args[$key] = $params[$idx-1];
	$val = $key;
	}

	unset($params[$idx-1]);
	$query = substr_replace($query, $val, $pos, 1);
	$pos += strlen($val);
	}
	}
	}

	$query = rtrim($query, " \t\n\r\0\x0B;");

	// replace escaped '?' and quotes back to normal, see self::quote()
	$query = str_replace(
	array('??', self::DEFAULT_QUOTE.self::DEFAULT_QUOTE),
	array('?', self::DEFAULT_QUOTE),
	$query
	);

	// log query
	$this->debug($query);

	// destroy reference to previous result
	$this->last_result = null;
	$this->db_error_msg = null;

	// prepare query
	$result = @oci_parse($this->dbh, $query);
	$mode = $this->in_transaction ? OCI_NO_AUTO_COMMIT : OCI_COMMIT_ON_SUCCESS;

	if ($result) {
	foreach (array_keys($args) as $param) {
	oci_bind_by_name($result, $param, $args[$param], -1, SQLT_LNG);
	}
	}

	// execute query
	if (!$result \|\| !@oci_execute($result, $mode)) {
	$result = $this->handle_error($query, $result);
	}

	return $this->last_result = $result;
	}

	/**
	* Helper method to handle DB errors.
	* This by default logs the error but could be overridden by a driver implementation
	*
	* @param string Query that triggered the error
	* @return mixed Result to be stored and returned
	*/
	protected function handle_error($query, $result = null)
	{
	$error = oci_error(is_resource($result) ? $result : $this->dbh);

	// @TODO: Find error codes for key errors
	if (empty($this->options['ignore_key_errors']) \|\| !in_array($error['code'], array('23000', '23505'))) {
	$this->db_error = true;
	$this->db_error_msg = sprintf('[%s] %s', $error['code'], $error['message']);

	rcube::raise_error(array('code' => 500, 'type' => 'db',
	'line' => __LINE__, 'file' => __FILE__,
	'message' => $this->db_error_msg . " (SQL Query: $query)"
	), true, false);
	}

	return false;
	}

	/**
	* Get last inserted record ID
	*
	* @param string $table Table name (to find the incremented sequence)
	*
	* @return mixed ID or false on failure
	*/
	public function insert_id($table = null)
	{
	if (!$this->db_connected \|\| $this->db_mode == 'r' \|\| empty($table)) {
	return false;
	}

	$sequence = $this->quote_identifier($this->sequence_name($table));
	$result = $this->query("SELECT $sequence.currval FROM dual");
	$result = $this->fetch_array($result);

	return $result[0] ?: false;
	}

	/**
	* Get number of affected rows for the last query
	*
	* @param mixed $result Optional query handle
	*
	* @return int Number of (matching) rows
	*/
	public function affected_rows($result = null)
	{
	if ($result \|\| ($result === null && ($result = $this->last_result))) {
	return oci_num_rows($result);
	}

	return 0;
	}

	/**
	* Get number of rows for a SQL query
	* If no query handle is specified, the last query will be taken as reference
	*
	* @param mixed $result Optional query handle
	* @return mixed Number of rows or false on failure
	* @deprecated This method shows very poor performance and should be avoided.
	*/
	public function num_rows($result = null)
	{
	// not implemented
	return false;
	}

	/**
	* Get an associative array for one row
	* If no query handle is specified, the last query will be taken as reference
	*
	* @param mixed $result Optional query handle
	*
	* @return mixed Array with col values or false on failure
	*/
	public function fetch_assoc($result = null)
	{
	return $this->_fetch_row($result, OCI_ASSOC);
	}

	/**
	* Get an index array for one row
	* If no query handle is specified, the last query will be taken as reference
	*
	* @param mixed $result Optional query handle
	*
	* @return mixed Array with col values or false on failure
	*/
	public function fetch_array($result = null)
	{
	return $this->_fetch_row($result, OCI_NUM);
	}

	/**
	* Get col values for a result row
	*
	* @param mixed $result Optional query handle
	* @param int $mode Fetch mode identifier
	*
	* @return mixed Array with col values or false on failure
	*/
	protected function _fetch_row($result, $mode)
	{
	if ($result \|\| ($result === null && ($result = $this->last_result))) {
	return oci_fetch_array($result, $mode + OCI_RETURN_NULLS + OCI_RETURN_LOBS);
	}

	return false;
	}

	/**
	* Formats input so it can be safely used in a query
	* PDO_OCI does not implement quote() method
	*
	* @param mixed $input Value to quote
	* @param string $type Type of data (integer, bool, ident)
	*
	* @return string Quoted/converted string for use in query
	*/
	public function quote($input, $type = null)
	{
	// handle int directly for better performance
	if ($type == 'integer' \|\| $type == 'int') {
	return intval($input);
	}

	if (is_null($input)) {
	return 'NULL';
	}

	if ($input instanceof DateTime) {
	return $this->quote($input->format($this->options['datetime_format']));
	}

	if ($type == 'ident') {
	return $this->quote_identifier($input);
	}

	switch ($type) {
	case 'bool':
	case 'integer':
	return intval($input);
	default:
	return "'" . strtr($input, array(
	'?' => '??',
	"'" => "''",
	rcube_db::DEFAULT_QUOTE => rcube_db::DEFAULT_QUOTE . rcube_db::DEFAULT_QUOTE
	)) . "'";
	}
	}

	/**
	* Return correct name for a specific database sequence
	*
	* @param string $table Table name
	*
	* @return string Translated sequence name
	*/
	protected function sequence_name($table)
	{
	// Note: we support only one sequence per table
	// Note: The sequence name must be <table_name>_seq
	$sequence = $table . '_seq';

	// modify sequence name if prefix is configured
	if ($prefix = $this->options['table_prefix']) {
	return $prefix . $sequence;
	}

	return $sequence;
	}

	/**
	* Return SQL statement for case insensitive LIKE
	*
	* @param string $column Field name
	* @param string $value Search value
	*
	* @return string SQL statement to use in query
	*/
	public function ilike($column, $value)
	{
	return 'UPPER(' . $this->quote_identifier($column) . ') LIKE UPPER(' . $this->quote($value) . ')';
	}

	/**
	* Return SQL function for current time and date
	*
	* @param int $interval Optional interval (in seconds) to add/subtract
	*
	* @return string SQL function to use in query
	*/
	public function now($interval = 0)
	{
	if ($interval) {
	$interval = intval($interval);
	return "current_timestamp + INTERVAL '$interval' SECOND";
	}

	return "current_timestamp";
	}

	/**
	* Return SQL statement to convert a field value into a unix timestamp
	*
	* @param string $field Field name
	*
	* @return string SQL statement to use in query
	* @deprecated
	*/
	public function unixtimestamp($field)
	{
	return "(($field - to_date('1970-01-01','YYYY-MM-DD')) * 60 * 60 * 24)";
	}

	/**
	* Adds TOP (LIMIT,OFFSET) clause to the query
	*
	* @param string $query SQL query
	* @param int $limit Number of rows
	* @param int $offset Offset
	*
	* @return string SQL query
	*/
	protected function set_limit($query, $limit = 0, $offset = 0)
	{
	$limit = intval($limit);
	$offset = intval($offset);
	$end = $offset + $limit;

	// @TODO: Oracle 12g has better OFFSET support

	if (!$offset) {
	$query = "SELECT * FROM ($query) a WHERE rownum <= $end";
	}
	else {
	$query = "SELECT * FROM (SELECT a.*, rownum as rn FROM ($query) a WHERE rownum <= $end) b WHERE rn > $offset";
	}

	return $query;
	}

	/**
	* Parse SQL file and fix table names according to table prefix
	*/
	protected function fix_table_names($sql)
	{
	if (!$this->options['table_prefix']) {
	return $sql;
	}

	$sql = parent::fix_table_names($sql);

	// replace sequence names, and other Oracle-specific commands
	$sql = preg_replace_callback('/(SEQUENCE ["]?)([^" \r\n]+)/',
	array($this, 'fix_table_names_callback'),
	$sql
	);

	$sql = preg_replace_callback(
	'/([ \r\n]+["]?)([^"\' \r\n\.]+)(["]?\.nextval)/',
	array($this, 'fix_table_names_seq_callback'),
	$sql
	);

	return $sql;
	}

	/**
	* Preg_replace callback for fix_table_names()
	*/
	protected function fix_table_names_seq_callback($matches)
	{
	return $matches[1] . $this->options['table_prefix'] . $matches[2] . $matches[3];
	}

	/**
	* Returns connection options from DSN array
	*/
	protected function dsn_options($dsn)
	{
	$params = array();

	- if ($dsn['hostspec']) {
	+ if (isset($dsn['hostspec'])) {
	$host = $dsn['hostspec'];
	- if ($dsn['port']) {
	+ if (isset($dsn['port'])) {
	$host .= ':' . $dsn['port'];
	}

	$params['database'] = $host . '/' . $dsn['database'];
	}

	$params['charset'] = 'UTF8';

	return $params;
	}

	/**
	* Execute the given SQL script
	*
	* @param string $sql SQL queries to execute
	*
	* @return boolen True on success, False on error
	*/
	public function exec_script($sql)
	{
	$sql = $this->fix_table_names($sql);
	$buff = '';
	$body = false;

	foreach (explode("\n", $sql) as $line) {
	$tok = strtolower(trim($line));
	if (preg_match('/^--/', $line) \|\| $tok == '' \|\| $tok == '/') {
	continue;
	}

	$buff .= $line . "\n";

	// detect PL/SQL function bodies, don't break on semicolon
	if ($body && $tok == 'end;') {
	$body = false;
	}
	else if (!$body && $tok == 'begin') {
	$body = true;
	}

	if (!$body && substr($tok, -1) == ';') {
	$this->query($buff);
	$buff = '';
	if ($this->db_error) {
	break;
	}
	}
	}

	return !$this->db_error;
	}

	/**
	* Start transaction
	*
	* @return bool True on success, False on failure
	*/
	public function startTransaction()
	{
	$this->db_connect('w', true);

	// check connection before proceeding
	if (!$this->is_connected()) {
	return $this->last_result = false;
	}

	$this->debug('BEGIN TRANSACTION');

	return $this->last_result = $this->in_transaction = true;
	}

	/**
	* Commit transaction
	*
	* @return bool True on success, False on failure
	*/
	public function endTransaction()
	{
	$this->db_connect('w', true);

	// check connection before proceeding
	if (!$this->is_connected()) {
	return $this->last_result = false;
	}

	$this->debug('COMMIT TRANSACTION');

	if ($result = @oci_commit($this->dbh)) {
	$this->in_transaction = true;
	}
	else {
	$this->handle_error('COMMIT');
	}

	return $this->last_result = $result;
	}

	/**
	* Rollback transaction
	*
	* @return bool True on success, False on failure
	*/
	public function rollbackTransaction()
	{
	$this->db_connect('w', true);

	// check connection before proceeding
	if (!$this->is_connected()) {
	return $this->last_result = false;
	}

	$this->debug('ROLLBACK TRANSACTION');

	if (@oci_rollback($this->dbh)) {
	$this->in_transaction = false;
	}
	else {
	$this->handle_error('ROLLBACK');
	}

	return $this->last_result = $this->dbh->rollBack();
	}

	/**
	* Terminate database connection.
	*/
	public function closeConnection()
	{
	// release statement and close connection(s)
	$this->last_result = null;
	foreach ($this->dbhs as $dbh) {
	oci_close($dbh);
	}

	parent::closeConnection();
	}
	}
	diff --git a/program/lib/Roundcube/db/pgsql.php b/program/lib/Roundcube/db/pgsql.php
	index a6eb704e8..7fb9759ef 100644
	--- a/program/lib/Roundcube/db/pgsql.php
	+++ b/program/lib/Roundcube/db/pgsql.php
	@@ -1,334 +1,334 @@
	<?php

	/**
	+-----------------------------------------------------------------------+
	\| This file is part of the Roundcube Webmail client \|
	\| \|
	\| Copyright (C) The Roundcube Dev Team \|
	\| \|
	\| Licensed under the GNU General Public License version 3 or \|
	\| any later version with exceptions for skins & plugins. \|
	\| See the README file for a full license statement. \|
	\| \|
	\| PURPOSE: \|
	\| Database wrapper class that implements PHP PDO functions \|
	\| for PostgreSQL database \|
	+-----------------------------------------------------------------------+
	\| Author: Aleksander Machniak <alec@alec.pl> \|
	+-----------------------------------------------------------------------+
	*/

	/**
	* Database independent query interface
	* This is a wrapper for the PHP PDO
	*
	* @package Framework
	* @subpackage Database
	*/
	class rcube_db_pgsql extends rcube_db
	{
	public $db_provider = 'postgres';

	// See https://www.postgresql.org/docs/current/static/libpq-connect.html#LIBPQ-PARAMKEYWORDS
	private static $libpq_connect_params = array("application_name", "sslmode", "sslcert", "sslkey", "sslrootcert", "sslcrl", "sslcompression", "service");

	/**
	* Object constructor
	*
	* @param string $db_dsnw DSN for read/write operations
	* @param string $db_dsnr Optional DSN for read only operations
	* @param bool $pconn Enables persistent connections
	*/
	public function __construct($db_dsnw, $db_dsnr = '', $pconn = false)
	{
	parent::__construct($db_dsnw, $db_dsnr, $pconn);

	// use date/time input format with timezone spec.
	$this->options['datetime_format'] = 'c';
	}

	/**
	* Driver-specific configuration of database connection
	*
	* @param array $dsn DSN for DB connections
	* @param PDO $dbh Connection handler
	*/
	protected function conn_configure($dsn, $dbh)
	{
	$dbh->query("SET NAMES 'utf8'");
	$dbh->query("SET DATESTYLE TO ISO");

	// if ?schema= is set in dsn, set the search_path
	if ($dsn['schema']) {
	$dbh->query("SET search_path TO " . $this->quote($dsn['schema']));
	}
	}

	/**
	* Get last inserted record ID
	*
	* @param string $table Table name (to find the incremented sequence)
	*
	* @return mixed ID or false on failure
	*/
	public function insert_id($table = null)
	{
	if (!$this->db_connected \|\| $this->db_mode == 'r') {
	return false;
	}

	if ($table) {
	$table = $this->sequence_name($table);
	}

	$id = $this->dbh->lastInsertId($table);

	return $id;
	}

	/**
	* Return correct name for a specific database sequence
	*
	* @param string $table Table name
	*
	* @return string Translated sequence name
	*/
	protected function sequence_name($table)
	{
	// Note: we support only one sequence per table
	// Note: The sequence name must be <table_name>_seq
	$sequence = $table . '_seq';

	// modify sequence name if prefix is configured
	if ($prefix = $this->options['table_prefix']) {
	return $prefix . $sequence;
	}

	return $sequence;
	}

	/**
	* Return SQL statement to convert a field value into a unix timestamp
	*
	* @param string $field Field name
	*
	* @return string SQL statement to use in query
	* @deprecated
	*/
	public function unixtimestamp($field)
	{
	return "EXTRACT (EPOCH FROM $field)";
	}

	/**
	* Return SQL function for current time and date
	*
	* @param int $interval Optional interval (in seconds) to add/subtract
	*
	* @return string SQL function to use in query
	*/
	public function now($interval = 0)
	{
	$result = 'now()';

	if ($interval) {
	$result .= ' ' . ($interval > 0 ? '+' : '-') . " interval '"
	. ($interval > 0 ? intval($interval) : intval($interval) * -1)
	. " seconds'";
	}

	return $result;
	}

	/**
	* Return SQL statement for case insensitive LIKE
	*
	* @param string $column Field name
	* @param string $value Search value
	*
	* @return string SQL statement to use in query
	*/
	public function ilike($column, $value)
	{
	return $this->quote_identifier($column) . ' ILIKE ' . $this->quote($value);
	}

	/**
	* Get database runtime variables
	*
	* @param string $varname Variable name
	* @param mixed $default Default value if variable is not set
	*
	* @return mixed Variable value or default
	*/
	public function get_variable($varname, $default = null)
	{
	// There's a known case when max_allowed_packet is queried
	// PostgreSQL doesn't have such limit, return immediately
	if ($varname == 'max_allowed_packet') {
	return rcube::get_instance()->config->get('db_' . $varname, $default);
	}

	$this->variables[$varname] = rcube::get_instance()->config->get('db_' . $varname);

	if (!isset($this->variables)) {
	$this->variables = array();

	$result = $this->query('SHOW ALL');

	while ($row = $this->fetch_array($result)) {
	$this->variables[$row[0]] = $row[1];
	}
	}

	return isset($this->variables[$varname]) ? $this->variables[$varname] : $default;
	}

	/**
	* INSERT ... ON CONFLICT DO UPDATE.
	* When not supported by the engine we do UPDATE and INSERT.
	*
	* @param string $table Table name
	* @param array $keys Hash array (column => value) of the unique constraint
	* @param array $columns List of columns to update
	* @param array $values List of values to update (number of elements
	* should be the same as in $columns)
	*
	* @return PDOStatement\|bool Query handle or False on error
	* @todo Multi-insert support
	*/
	public function insert_or_update($table, $keys, $columns, $values)
	{
	// Check if version >= 9.5, otherwise use fallback
	if ($this->get_variable('server_version_num') < 90500) {
	return parent::insert_or_update($table, $keys, $columns, $values);
	}

	$table = $this->table_name($table, true);
	$columns = array_map(array($this, 'quote_identifier'), $columns);
	$target = implode(', ', array_map(array($this, 'quote_identifier'), array_keys($keys)));
	$cols = $target . ', ' . implode(', ', $columns);
	$vals = implode(', ', array_map(function($i) { return $this->quote($i); }, $keys));
	$vals .= ', ' . rtrim(str_repeat('?, ', count($columns)), ', ');
	$update = implode(', ', array_map(function($i) { return "$i = EXCLUDED.$i"; }, $columns));

	return $this->query("INSERT INTO $table ($cols) VALUES ($vals)"
	. " ON CONFLICT ($target) DO UPDATE SET $update", $values);
	}

	/**
	* Returns list of tables in a database
	*
	* @return array List of all tables of the current database
	*/
	public function list_tables()
	{
	// get tables if not cached
	if ($this->tables === null) {
	if (($schema = $this->options['table_prefix']) && $schema[strlen($schema)-1] === '.') {
	$add = " AND TABLE_SCHEMA = " . $this->quote(substr($schema, 0, -1));
	}
	else {
	$add = " AND TABLE_SCHEMA NOT IN ('pg_catalog', 'information_schema')";
	}

	$q = $this->query("SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES"
	. " WHERE TABLE_TYPE = 'BASE TABLE'" . $add
	. " ORDER BY TABLE_NAME");

	$this->tables = $q ? $q->fetchAll(PDO::FETCH_COLUMN, 0) : array();
	}

	return $this->tables;
	}

	/**
	* Returns list of columns in database table
	*
	* @param string $table Table name
	*
	* @return array List of table cols
	*/
	public function list_cols($table)
	{
	$args = array($table);

	if (($schema = $this->options['table_prefix']) && $schema[strlen($schema)-1] === '.') {
	$add = " AND TABLE_SCHEMA = ?";
	$args[] = substr($schema, 0, -1);
	}
	else {
	$add = " AND TABLE_SCHEMA NOT IN ('pg_catalog', 'information_schema')";
	}

	$q = $this->query("SELECT COLUMN_NAME FROM INFORMATION_SCHEMA.COLUMNS"
	. " WHERE TABLE_NAME = ?" . $add, $args);

	if ($q) {
	return $q->fetchAll(PDO::FETCH_COLUMN, 0);
	}

	return array();
	}

	/**
	* Returns PDO DSN string from DSN array
	*
	* @param array $dsn DSN parameters
	*
	* @return string DSN string
	*/
	protected function dsn_string($dsn)
	{
	$params = array();
	$result = 'pgsql:';

	- if ($dsn['hostspec']) {
	+ if (isset($dsn['hostspec'])) {
	$params[] = 'host=' . $dsn['hostspec'];
	}
	- else if ($dsn['socket']) {
	+ else if (isset($dsn['socket'])) {
	$params[] = 'host=' . $dsn['socket'];
	}

	- if ($dsn['port']) {
	+ if (isset($dsn['port'])) {
	$params[] = 'port=' . $dsn['port'];
	}

	- if ($dsn['database']) {
	+ if (isset($dsn['database'])) {
	$params[] = 'dbname=' . $dsn['database'];
	}

	foreach (self::$libpq_connect_params as $param) {
	- if ($dsn[$param]) {
	+ if (isset($dsn[$param])) {
	$params[] = $param . '=' . $dsn[$param];
	}
	}

	if (!empty($params)) {
	$result .= implode(';', $params);
	}

	return $result;
	}

	/**
	* Parse SQL file and fix table names according to table prefix
	*/
	protected function fix_table_names($sql)
	{
	if (!$this->options['table_prefix']) {
	return $sql;
	}

	$sql = parent::fix_table_names($sql);

	// replace sequence names, and other postgres-specific commands
	$sql = preg_replace_callback(
	'/((SEQUENCE \|RENAME TO \|nextval\()["\']*)([^"\' \r\n]+)/',
	array($this, 'fix_table_names_callback'),
	$sql
	);

	return $sql;
	}
	}
	diff --git a/program/lib/Roundcube/db/sqlsrv.php b/program/lib/Roundcube/db/sqlsrv.php
	index c49704ce7..eb5f16dd9 100644
	--- a/program/lib/Roundcube/db/sqlsrv.php
	+++ b/program/lib/Roundcube/db/sqlsrv.php
	@@ -1,101 +1,101 @@
	<?php

	/**
	+-----------------------------------------------------------------------+
	\| This file is part of the Roundcube Webmail client \|
	\| \|
	\| Copyright (C) The Roundcube Dev Team \|
	\| \|
	\| Licensed under the GNU General Public License version 3 or \|
	\| any later version with exceptions for skins & plugins. \|
	\| See the README file for a full license statement. \|
	\| \|
	\| PURPOSE: \|
	\| Database wrapper class that implements PHP PDO functions \|
	\| for MS SQL Server database \|
	+-----------------------------------------------------------------------+
	\| Author: Aleksander Machniak <alec@alec.pl> \|
	+-----------------------------------------------------------------------+
	*/

	/**
	* Database independent query interface
	* This is a wrapper for the PHP PDO
	*
	* @package Framework
	* @subpackage Database
	*/
	class rcube_db_sqlsrv extends rcube_db_mssql
	{

	/**
	* Get last inserted record ID
	*
	* @param string $table Table name (to find the incremented sequence)
	*
	* @return string\|false The ID or False on failure
	*/
	public function insert_id($table = '')
	{
	if (!$this->db_connected \|\| $this->db_mode == 'r') {
	return false;
	}

	if ($table) {
	// For some unknown reason the constant described in the driver docs
	// might not exist, we'll fallback to PDO::ATTR_CLIENT_VERSION (#7564)
	if (defined('PDO::ATTR_DRIVER_VERSION')) {
	$driver_version = $this->dbh->getAttribute(PDO::ATTR_DRIVER_VERSION);
	}
	else if (defined('PDO::ATTR_CLIENT_VERSION')) {
	$client_version = $this->dbh->getAttribute(PDO::ATTR_CLIENT_VERSION);
	$driver_version = $client_version['ExtensionVer'];
	}
	else {
	$driver_version = 5;
	}

	// Starting from version 5 of the driver lastInsertId() method expects
	// a sequence name instead of a table name. We'll unset the argument
	// to get the last insert sequence (#7564)
	if (version_compare($driver_version, '5', '>=')) {
	$table = null;
	}
	else {
	// resolve table name
	$table = $this->table_name($table);
	}
	}

	return $this->dbh->lastInsertId($table);
	}

	/**
	* Returns PDO DSN string from DSN array
	*/
	protected function dsn_string($dsn)
	{
	$params = array();
	$result = 'sqlsrv:';

	- if ($dsn['hostspec']) {
	+ if (isset($dsn['hostspec'])) {
	$host = $dsn['hostspec'];

	- if ($dsn['port']) {
	+ if (isset($dsn['port'])) {
	$host .= ',' . $dsn['port'];
	}

	$params[] = 'Server=' . $host;
	}

	- if ($dsn['database']) {
	+ if (isset($dsn['database'])) {
	$params[] = 'Database=' . $dsn['database'];
	}

	if (!empty($params)) {
	$result .= implode(';', $params);
	}

	return $result;
	}
	}
	diff --git a/program/lib/Roundcube/html.php b/program/lib/Roundcube/html.php
	index 5e0c1eb39..940350984 100644
	--- a/program/lib/Roundcube/html.php
	+++ b/program/lib/Roundcube/html.php
	@@ -1,1021 +1,1023 @@
	<?php

	/**
	+-----------------------------------------------------------------------+
	\| This file is part of the Roundcube Webmail client \|
	\| \|
	\| Copyright (C) The Roundcube Dev Team \|
	\| \|
	\| Licensed under the GNU General Public License version 3 or \|
	\| any later version with exceptions for skins & plugins. \|
	\| See the README file for a full license statement. \|
	\| \|
	\| PURPOSE: \|
	\| Helper class to create valid XHTML code \|
	+-----------------------------------------------------------------------+
	\| Author: Thomas Bruederli <roundcube@gmail.com> \|
	+-----------------------------------------------------------------------+
	*/

	/**
	* Class for HTML code creation
	*
	* @package Framework
	* @subpackage View
	*/
	class html
	{
	protected $tagname;
	protected $content;
	protected $attrib = array();
	protected $allowed = array();

	public static $doctype = 'xhtml';
	public static $lc_tags = true;
	public static $common_attrib = array('id','class','style','title','align','unselectable','tabindex','role');
	public static $containers = array('iframe','div','span','p','h1','h2','h3','ul','form','textarea','table','thead','tbody','tr','th','td','style','script','a');
	public static $bool_attrib = array('checked','multiple','disabled','selected','autofocus','readonly','required');


	/**
	* Constructor
	*
	* @param array $attrib Hash array with tag attributes
	*/
	public function __construct($attrib = array())
	{
	if (is_array($attrib)) {
	$this->attrib = $attrib;
	}
	}

	/**
	* Return the tag code
	*
	* @return string The finally composed HTML tag
	*/
	public function show()
	{
	return self::tag($this->tagname, $this->attrib, $this->content, array_merge(self::$common_attrib, $this->allowed));
	}

	/**** STATIC METHODS *****/

	/**
	* Generic method to create a HTML tag
	*
	* @param string $tagname Tag name
	* @param array $attrib Tag attributes as key/value pairs
	* @param string $content Optional Tag content (creates a container tag)
	* @param array $allowed List with allowed attributes, omit to allow all
	*
	* @return string The XHTML tag
	*/
	public static function tag($tagname, $attrib = array(), $content = null, $allowed = null)
	{
	if (is_string($attrib)) {
	$attrib = array('class' => $attrib);
	}

	$inline_tags = array('a','span','img');
	$suffix = (isset($attrib['nl']) && $content && $attrib['nl'] && !in_array($tagname, $inline_tags)) ? "\n" : '';

	$tagname = self::$lc_tags ? strtolower($tagname) : $tagname;
	if (isset($content) \|\| in_array($tagname, self::$containers)) {
	$suffix = !empty($attrib['noclose']) ? $suffix : '</' . $tagname . '>' . $suffix;
	unset($attrib['noclose'], $attrib['nl']);
	return '<' . $tagname . self::attrib_string($attrib, $allowed) . '>' . $content . $suffix;
	}
	else {
	return '<' . $tagname . self::attrib_string($attrib, $allowed) . '>' . $suffix;
	}
	}

	/**
	* Return DOCTYPE tag of specified type
	*
	* @param string $type Document type (html5, xhtml, 'xhtml-trans, xhtml-strict)
	*/
	public static function doctype($type)
	{
	$doctypes = array(
	'html5' => '<!DOCTYPE html>',
	'xhtml' => '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">',
	'xhtml-trans' => '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">',
	'xhtml-strict' => '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">',
	);

	if ($doctypes[$type]) {
	self::$doctype = preg_replace('/-\w+$/', '', $type);
	return $doctypes[$type];
	}

	return '';
	}

	/**
	* Derrived method for <div> containers
	*
	* @param mixed $attr Hash array with tag attributes or string with class name
	* @param string $cont Div content
	*
	* @return string HTML code
	* @see html::tag()
	*/
	public static function div($attr = null, $cont = null)
	{
	if (is_string($attr)) {
	$attr = array('class' => $attr);
	}

	return self::tag('div', $attr, $cont, array_merge(self::$common_attrib, array('onclick')));
	}

	/**
	* Derrived method for <p> blocks
	*
	* @param mixed $attr Hash array with tag attributes or string with class name
	* @param string $cont Paragraph content
	*
	* @return string HTML code
	* @see html::tag()
	*/
	public static function p($attr = null, $cont = null)
	{
	if (is_string($attr)) {
	$attr = array('class' => $attr);
	}

	return self::tag('p', $attr, $cont, self::$common_attrib);
	}

	/**
	* Derrived method to create <img />
	*
	* @param mixed $attr Hash array with tag attributes or string with image source (src)
	*
	* @return string HTML code
	* @see html::tag()
	*/
	public static function img($attr = null)
	{
	if (is_string($attr)) {
	$attr = array('src' => $attr);
	}

	return self::tag('img', $attr + array('alt' => ''), null, array_merge(self::$common_attrib,
	array('src','alt','width','height','border','usemap','onclick','onerror','onload')));
	}

	/**
	* Derrived method for link tags
	*
	* @param mixed $attr Hash array with tag attributes or string with link location (href)
	* @param string $cont Link content
	*
	* @return string HTML code
	* @see html::tag()
	*/
	public static function a($attr, $cont)
	{
	if (is_string($attr)) {
	$attr = array('href' => $attr);
	}

	return self::tag('a', $attr, $cont, array_merge(self::$common_attrib,
	array('href','target','name','rel','onclick','onmouseover','onmouseout','onmousedown','onmouseup')));
	}

	/**
	* Derrived method for inline span tags
	*
	* @param mixed $attr Hash array with tag attributes or string with class name
	* @param string $cont Tag content
	*
	* @return string HTML code
	* @see html::tag()
	*/
	public static function span($attr, $cont)
	{
	if (is_string($attr)) {
	$attr = array('class' => $attr);
	}

	return self::tag('span', $attr, $cont, self::$common_attrib);
	}

	/**
	* Derrived method for form element labels
	*
	* @param mixed $attr Hash array with tag attributes or string with 'for' attrib
	* @param string $cont Tag content
	*
	* @return string HTML code
	* @see html::tag()
	*/
	public static function label($attr, $cont)
	{
	if (is_string($attr)) {
	$attr = array('for' => $attr);
	}

	return self::tag('label', $attr, $cont, array_merge(self::$common_attrib,
	array('for','onkeypress')));
	}

	/**
	* Derrived method to create <iframe></iframe>
	*
	* @param mixed $attr Hash array with tag attributes or string with frame source (src)
	* @param string $cont Tag content
	*
	* @return string HTML code
	* @see html::tag()
	*/
	public static function iframe($attr = null, $cont = null)
	{
	if (is_string($attr)) {
	$attr = array('src' => $attr);
	}

	return self::tag('iframe', $attr, $cont, array_merge(self::$common_attrib,
	array('src','name','width','height','border','frameborder','onload','allowfullscreen')));
	}

	/**
	* Derrived method to create <script> tags
	*
	* @param mixed $attr Hash array with tag attributes or string with script source (src)
	* @param string $cont Javascript code to be placed as tag content
	*
	* @return string HTML code
	* @see html::tag()
	*/
	public static function script($attr, $cont = null)
	{
	if (is_string($attr)) {
	$attr = array('src' => $attr);
	}

	if ($cont) {
	if (self::$doctype == 'xhtml') {
	$cont = "/* <![CDATA[ /\n{$cont}\n/ ]]> */";
	}

	$cont = "\n{$cont}\n";
	}

	if (self::$doctype == 'xhtml') {
	$attr += array('type' => 'text/javascript');
	}

	return self::tag('script', $attr + array('nl' => true), $cont,
	array_merge(self::$common_attrib, array('src', 'type', 'charset')));
	}

	/**
	* Derrived method for line breaks
	*
	* @param array $attrib Associative arry with tag attributes
	*
	* @return string HTML code
	* @see html::tag()
	*/
	public static function br($attrib = array())
	{
	return self::tag('br', $attrib);
	}

	/**
	* Create string with attributes
	*
	* @param array $attrib Associative array with tag attributes
	* @param array $allowed List of allowed attributes
	*
	* @return string Valid attribute string
	*/
	public static function attrib_string($attrib = array(), $allowed = null)
	{
	if (empty($attrib)) {
	return '';
	}

	$allowed_f = array_flip((array)$allowed);
	$attrib_arr = array();

	foreach ($attrib as $key => $value) {
	// skip size if not numeric
	if ($key == 'size' && !is_numeric($value)) {
	continue;
	}

	// ignore "internal" or empty attributes
	if ($key == 'nl' \|\| $value === null) {
	continue;
	}

	// ignore not allowed attributes, except aria-* and data-*
	if (!empty($allowed)) {
	$is_data_attr = @substr_compare($key, 'data-', 0, 5) === 0;
	$is_aria_attr = @substr_compare($key, 'aria-', 0, 5) === 0;
	if (!$is_aria_attr && !$is_data_attr && !isset($allowed_f[$key])) {
	continue;
	}
	}

	// skip empty eventhandlers
	if (preg_match('/^on[a-z]+/', $key) && !$value) {
	continue;
	}

	// attributes with no value
	if (in_array($key, self::$bool_attrib)) {
	if ($value) {
	$value = $key;
	if (self::$doctype == 'xhtml') {
	$value .= '="' . $value . '"';
	}

	$attrib_arr[] = $value;
	}
	}
	else {
	$attrib_arr[] = $key . '="' . self::quote($value) . '"';
	}
	}

	return count($attrib_arr) ? ' '.implode(' ', $attrib_arr) : '';
	}

	/**
	* Convert a HTML attribute string attributes to an associative array (name => value)
	*
	* @param string $str Input string
	*
	* @return array Key-value pairs of parsed attributes
	*/
	public static function parse_attrib_string($str)
	{
	$attrib = array();
	$html = '<html>'
	. '<head><meta http-equiv="Content-Type" content="text/html; charset=' . RCUBE_CHARSET . '" /></head>'
	. '<body><div ' . rtrim($str, '/ ') . ' /></body>'
	. '</html>';

	$document = new DOMDocument('1.0', RCUBE_CHARSET);
	@$document->loadHTML($html);

	if ($node = $document->getElementsByTagName('div')->item(0)) {
	foreach ($node->attributes as $name => $attr) {
	$attrib[strtolower($name)] = $attr->nodeValue;
	}
	}

	return $attrib;
	}

	/**
	* Replacing specials characters in html attribute value
	*
	* @param string $str Input string
	*
	* @return string The quoted string
	*/
	public static function quote($str)
	{
	return @htmlspecialchars($str, ENT_COMPAT \| ENT_SUBSTITUTE, RCUBE_CHARSET);
	}
	}


	/**
	* Class to create an HTML input field
	*
	* @package Framework
	* @subpackage View
	*/
	class html_inputfield extends html
	{
	protected $tagname = 'input';
	protected $type = 'text';
	protected $allowed = array(
	'type','name','value','size','tabindex','autocapitalize','required',
	'autocomplete','checked','onchange','onclick','disabled','readonly',
	'spellcheck','results','maxlength','src','multiple','accept',
	'placeholder','autofocus','pattern','oninput'
	);

	/**
	* Object constructor
	*
	* @param array $attrib Associative array with tag attributes
	*/
	public function __construct($attrib = array())
	{
	if (is_array($attrib)) {
	$this->attrib = $attrib;
	}

	- if ($attrib['type']) {
	+ if (!empty($attrib['type'])) {
	$this->type = $attrib['type'];
	}
	}

	/**
	* Compose input tag
	*
	* @param string $value Field value
	* @param array $attrib Additional attributes to override
	*
	* @return string HTML output
	*/
	public function show($value = null, $attrib = null)
	{
	// overwrite object attributes
	if (is_array($attrib)) {
	$this->attrib = array_merge($this->attrib, $attrib);
	}

	// set value attribute
	if ($value !== null) {
	$this->attrib['value'] = $value;
	}
	// set type
	$this->attrib['type'] = $this->type;

	return parent::show();
	}
	}

	/**
	* Class to create an HTML password field
	*
	* @package Framework
	* @subpackage View
	*/
	class html_passwordfield extends html_inputfield
	{
	protected $type = 'password';
	}

	/**
	* Class to create an hidden HTML input field
	*
	* @package Framework
	* @subpackage View
	*/
	class html_hiddenfield extends html
	{
	protected $tagname = 'input';
	protected $type = 'hidden';
	protected $allowed = array('type','name','value','onchange','disabled','readonly');
	protected $fields = array();

	/**
	* Constructor
	*
	* @param array $attrib Named tag attributes
	*/
	public function __construct($attrib = null)
	{
	if (is_array($attrib)) {
	$this->add($attrib);
	}
	}

	/**
	* Add a hidden field to this instance
	*
	* @param array $attrib Named tag attributes
	*/
	public function add($attrib)
	{
	$this->fields[] = $attrib;
	}

	/**
	* Create HTML code for the hidden fields
	*
	* @return string Final HTML code
	*/
	public function show()
	{
	$out = '';
	foreach ($this->fields as $attrib) {
	$out .= self::tag($this->tagname, array('type' => $this->type) + $attrib);
	}

	return $out;
	}
	}

	/**
	* Class to create HTML radio buttons
	*
	* @package Framework
	* @subpackage View
	*/
	class html_radiobutton extends html_inputfield
	{
	protected $type = 'radio';

	/**
	* Get HTML code for this object
	*
	* @param string $value Value of the checked field
	* @param array $attrib Additional attributes to override
	*
	* @return string HTML output
	*/
	public function show($value = '', $attrib = null)
	{
	// overwrite object attributes
	if (is_array($attrib)) {
	$this->attrib = array_merge($this->attrib, $attrib);
	}

	// set value attribute
	$this->attrib['checked'] = ((string)$value == (string)$this->attrib['value']);

	return parent::show();
	}
	}

	/**
	* Class to create HTML checkboxes
	*
	* @package Framework
	* @subpackage View
	*/
	class html_checkbox extends html_inputfield
	{
	protected $type = 'checkbox';

	/**
	* Get HTML code for this object
	*
	* @param string $value Value of the checked field
	* @param array $attrib Additional attributes to override
	*
	* @return string HTML output
	*/
	public function show($value = '', $attrib = null)
	{
	// overwrite object attributes
	if (is_array($attrib)) {
	$this->attrib = array_merge($this->attrib, $attrib);
	}

	// set value attribute
	$this->attrib['checked'] = ((string)$value == (string)$this->attrib['value']);

	return parent::show();
	}
	}

	/**
	* Class to create HTML button
	*
	* @package Framework
	* @subpackage View
	*/
	class html_button extends html_inputfield
	{
	protected $tagname = 'button';
	protected $type = 'button';

	/**
	* Get HTML code for this object
	*
	* @param string $content Text Content of the button
	* @param array $attrib Additional attributes to override
	*
	* @return string HTML output
	*/
	public function show($content = '', $attrib = null)
	{
	// overwrite object attributes
	if (is_array($attrib)) {
	$this->attrib = array_merge($this->attrib, $attrib);
	}

	$this->content = $content;

	return parent::show();
	}
	}

	/**
	* Class to create an HTML textarea
	*
	* @package Framework
	* @subpackage View
	*/
	class html_textarea extends html
	{
	protected $tagname = 'textarea';
	protected $allowed = array('name','rows','cols','wrap','tabindex',
	'onchange','disabled','readonly','spellcheck');

	/**
	* Get HTML code for this object
	*
	* @param string $value Textbox value
	* @param array $attrib Additional attributes to override
	*
	* @return string HTML output
	*/
	public function show($value = '', $attrib = null)
	{
	// overwrite object attributes
	if (is_array($attrib)) {
	$this->attrib = array_merge($this->attrib, $attrib);
	}

	// take value attribute as content
	if (empty($value) && !empty($this->attrib['value'])) {
	$value = $this->attrib['value'];
	}

	// make shure we don't print the value attribute
	if (isset($this->attrib['value'])) {
	unset($this->attrib['value']);
	}

	if (!empty($value) && empty($this->attrib['is_escaped'])) {
	$value = self::quote($value);
	}

	return self::tag($this->tagname, $this->attrib, $value,
	array_merge(self::$common_attrib, $this->allowed));
	}
	}

	/**
	* Builder for HTML drop-down menus
	* Syntax:<pre>
	* // create instance. arguments are used to set attributes of select-tag
	* $select = new html_select(array('name' => 'fieldname'));
	*
	* // add one option
	* $select->add('Switzerland', 'CH');
	*
	* // add multiple options
	* $select->add(array('Switzerland','Germany'), array('CH','DE'));
	*
	* // generate pulldown with selection 'Switzerland' and return html-code
	* // as second argument the same attributes available to instantiate can be used
	* print $select->show('CH');
	* </pre>
	*
	* @package Framework
	* @subpackage View
	*/
	class html_select extends html
	{
	protected $tagname = 'select';
	protected $options = array();
	protected $allowed = array('name','size','tabindex','autocomplete',
	'multiple','onchange','disabled','rel');

	/**
	* Add a new option to this drop-down
	*
	* @param mixed $names Option name or array with option names
	* @param mixed $values Option value or array with option values
	* @param array $attrib Additional attributes for the option entry
	*/
	public function add($names, $values = null, $attrib = array())
	{
	if (is_array($names)) {
	foreach ($names as $i => $text) {
	$this->options[] = array('text' => $text, 'value' => $values[$i]) + $attrib;
	}
	}
	else {
	$this->options[] = array('text' => $names, 'value' => $values) + $attrib;
	}
	}

	/**
	* Get HTML code for this object
	*
	* @param string $select Value of the selection option
	* @param array $attrib Additional attributes to override
	*
	* @return string HTML output
	*/
	public function show($select = array(), $attrib = null)
	{
	// overwrite object attributes
	if (is_array($attrib)) {
	$this->attrib = array_merge($this->attrib, $attrib);
	}

	$this->content = "\n";
	$select = (array)$select;
	foreach ($this->options as $option) {
	$attr = array(
	'value' => $option['value'],
	'selected' => (in_array($option['value'], $select, true) \|\|
	in_array($option['text'], $select, true)) ? 1 : null);

	$option_content = $option['text'];
	if (empty($this->attrib['is_escaped'])) {
	$option_content = self::quote($option_content);
	}

	$this->content .= self::tag('option', $attr + $option, $option_content, array('value','label','class','style','title','disabled','selected'));
	}

	return parent::show();
	}
	}


	/**
	* Class to build an HTML table
	*
	* @package Framework
	* @subpackage View
	*/
	class html_table extends html
	{
	protected $tagname = 'table';
	protected $allowed = array('id','class','style','width','summary',
	'cellpadding','cellspacing','border');

	private $header = null;
	private $rows = array();
	private $rowindex = 0;
	private $colindex = 0;

	/**
	* Constructor
	*
	* @param array $attrib Named tag attributes
	*/
	public function __construct($attrib = array())
	{
	$default_attrib = self::$doctype == 'xhtml' ? array('summary' => '', 'border' => '0') : array();
	$this->attrib = array_merge($attrib, $default_attrib);

	if (!empty($attrib['tagname']) && $attrib['tagname'] != 'table') {
	$this->tagname = $attrib['tagname'];
	$this->allowed = self::$common_attrib;
	}
	}

	/**
	* Add a table cell
	*
	* @param array $attr Cell attributes
	* @param string $cont Cell content
	*/
	public function add($attr, $cont)
	{
	if (is_string($attr)) {
	$attr = array('class' => $attr);
	}

	$cell = new stdClass;
	$cell->attrib = $attr;
	$cell->content = $cont;

	if (!isset($this->rows[$this->rowindex])) {
	$this->rows[$this->rowindex] = new stdClass;
	+ $this->rows[$this->rowindex]->attrib = [];
	}

	$this->rows[$this->rowindex]->cells[$this->colindex] = $cell;
	- $this->colindex += max(1, intval($attr['colspan']));
	+ $this->colindex += max(1, isset($attr['colspan']) ? intval($attr['colspan']) : 0);

	- if ($this->attrib['cols'] && $this->colindex >= $this->attrib['cols']) {
	+ if (!empty($this->attrib['cols']) && $this->colindex >= $this->attrib['cols']) {
	$this->add_row();
	}
	}

	/**
	* Add a table header cell
	*
	* @param array $attr Cell attributes
	* @param string $cont Cell content
	*/
	public function add_header($attr, $cont)
	{
	if (is_string($attr)) {
	$attr = array('class' => $attr);
	}

	$cell = new stdClass;
	$cell->attrib = $attr;
	$cell->content = $cont;

	if (empty($this->header)) {
	$this->header = new stdClass;
	+ $this->header->attrib = [];
	}

	$this->header->cells[] = $cell;
	}

	/**
	* Remove a column from a table
	* Useful for plugins making alterations
	*
	* @param string $class Class name
	*/
	public function remove_column($class)
	{
	// Remove the header
	- foreach ($this->header->cells as $index => $header){
	- if ($header->attrib['class'] == $class){
	+ foreach ($this->header->cells as $index => $header) {
	+ if ($header->attrib['class'] == $class) {
	unset($this->header[$index]);
	break;
	}
	}

	// Remove cells from rows
	- foreach ($this->rows as $i => $row){
	- foreach ($row->cells as $j => $cell){
	- if ($cell->attrib['class'] == $class){
	+ foreach ($this->rows as $i => $row) {
	+ foreach ($row->cells as $j => $cell) {
	+ if ($cell->attrib['class'] == $class) {
	unset($this->rows[$i]->cells[$j]);
	break;
	}
	}
	}
	}

	/**
	* Jump to next row
	*
	* @param array $attr Row attributes
	*/
	public function add_row($attr = array())
	{
	$this->rowindex++;
	$this->colindex = 0;
	$this->rows[$this->rowindex] = new stdClass;
	$this->rows[$this->rowindex]->attrib = $attr;
	$this->rows[$this->rowindex]->cells = array();
	}

	/**
	* Set header attributes
	*
	* @param array $attr Row attributes
	*/
	public function set_header_attribs($attr = array())
	{
	if (is_string($attr)) {
	$attr = array('class' => $attr);
	}

	if (empty($this->header)) {
	$this->header = new stdClass;
	}

	$this->header->attrib = $attr;
	}

	/**
	* Set row attributes
	*
	* @param array $attr Row attributes
	* @param int $index Optional row index (default current row index)
	*/
	public function set_row_attribs($attr = array(), $index = null)
	{
	if (is_string($attr)) {
	$attr = array('class' => $attr);
	}

	if ($index === null) {
	$index = $this->rowindex;
	}

	// make sure row object exists (#1489094)
	- if (!$this->rows[$index]) {
	+ if (empty($this->rows[$index])) {
	$this->rows[$index] = new stdClass;
	}

	$this->rows[$index]->attrib = $attr;
	}

	/**
	* Get row attributes
	*
	* @param int $index Row index
	*
	* @return array Row attributes
	*/
	public function get_row_attribs($index = null)
	{
	if ($index === null) {
	$index = $this->rowindex;
	}

	- return $this->rows[$index] ? $this->rows[$index]->attrib : null;
	+ return !empty($this->rows[$index]) ? $this->rows[$index]->attrib : null;
	}

	/**
	* Build HTML output of the table data
	*
	* @param array $attrib Table attributes
	*
	* @return string The final table HTML code
	*/
	public function show($attrib = null)
	{
	if (is_array($attrib)) {
	$this->attrib = array_merge($this->attrib, $attrib);
	}

	$thead = '';
	$tbody = '';
	$col_tagname = $this->_col_tagname();
	$row_tagname = $this->_row_tagname();
	$head_tagname = $this->_head_tagname();

	// include <thead>
	if (!empty($this->header)) {
	$rowcontent = '';
	foreach ($this->header->cells as $c => $col) {
	$rowcontent .= self::tag($head_tagname, $col->attrib, $col->content);
	}
	$thead = $this->tagname == 'table' ? self::tag('thead', null, self::tag('tr', $this->header->attrib ?: null, $rowcontent, parent::$common_attrib)) :
	self::tag($row_tagname, array('class' => 'thead'), $rowcontent, parent::$common_attrib);
	}

	foreach ($this->rows as $r => $row) {
	$rowcontent = '';
	foreach ($row->cells as $c => $col) {
	if ($row_tagname == 'li' && empty($col->attrib) && count($row->cells) == 1) {
	$rowcontent .= $col->content;
	}
	else {
	$rowcontent .= self::tag($col_tagname, $col->attrib, $col->content);
	}
	}

	if ($r < $this->rowindex \|\| count($row->cells)) {
	$tbody .= self::tag($row_tagname, $row->attrib, $rowcontent, parent::$common_attrib);
	}
	}

	- if ($this->attrib['rowsonly']) {
	+ if (!empty($this->attrib['rowsonly'])) {
	return $tbody;
	}

	// add <tbody>
	$this->content = $thead . ($this->tagname == 'table' ? self::tag('tbody', null, $tbody) : $tbody);

	unset($this->attrib['cols'], $this->attrib['rowsonly']);

	return parent::show();
	}

	/**
	* Count number of rows
	*
	* @return int The number of rows
	*/
	public function size()
	{
	return count($this->rows);
	}

	/**
	* Remove table body (all rows)
	*/
	public function remove_body()
	{
	$this->rows = array();
	$this->rowindex = 0;
	}

	/**
	* Getter for the corresponding tag name for table row elements
	*/
	private function _row_tagname()
	{
	static $row_tagnames = array('table' => 'tr', 'ul' => 'li', '*' => 'div');
	return $row_tagnames[$this->tagname] ?: $row_tagnames['*'];
	}

	/**
	* Getter for the corresponding tag name for table row elements
	*/
	private function _head_tagname()
	{
	static $head_tagnames = array('table' => 'th', '*' => 'span');
	return $head_tagnames[$this->tagname] ?: $head_tagnames['*'];
	}

	/**
	* Getter for the corresponding tag name for table cell elements
	*/
	private function _col_tagname()
	{
	static $col_tagnames = array('table' => 'td', '*' => 'span');
	return $col_tagnames[$this->tagname] ?: $col_tagnames['*'];
	}
	}
	diff --git a/program/lib/Roundcube/rcube_db.php b/program/lib/Roundcube/rcube_db.php
	index ba6ca5bb5..dc6b43022 100644
	--- a/program/lib/Roundcube/rcube_db.php
	+++ b/program/lib/Roundcube/rcube_db.php
	@@ -1,1469 +1,1469 @@
	<?php

	/**
	+-----------------------------------------------------------------------+
	\| This file is part of the Roundcube Webmail client \|
	\| \|
	\| Copyright (C) The Roundcube Dev Team \|
	\| \|
	\| Licensed under the GNU General Public License version 3 or \|
	\| any later version with exceptions for skins & plugins. \|
	\| See the README file for a full license statement. \|
	\| \|
	\| PURPOSE: \|
	\| Database wrapper class that implements PHP PDO functions \|
	+-----------------------------------------------------------------------+
	\| Author: Aleksander Machniak <alec@alec.pl> \|
	+-----------------------------------------------------------------------+
	*/

	/**
	* Database independent query interface.
	* This is a wrapper for the PHP PDO.
	*
	* @package Framework
	* @subpackage Database
	*/
	class rcube_db
	{
	public $db_provider;

	protected $db_dsnw; // DSN for write operations
	protected $db_dsnr; // DSN for read operations
	protected $db_dsnw_array; // DSN for write operations
	protected $db_dsnr_array; // DSN for read operations
	protected $db_connected = false; // Already connected ?
	protected $db_mode; // Connection mode
	protected $db_pconn = false; // Persistent connections flag
	protected $dbh; // Connection handle
	protected $dbhs = array();
	protected $table_connections = array();

	protected $db_error = false;
	protected $db_error_msg = '';
	protected $conn_failure = false;
	protected $db_index = 0;
	protected $last_result;
	protected $tables;
	protected $variables;

	protected $options = array(
	// column/table quotes
	'identifier_start' => '"',
	'identifier_end' => '"',
	// date/time input format
	'datetime_format' => 'Y-m-d H:i:s',
	);

	const DEBUG_LINE_LENGTH = 4096;
	const DEFAULT_QUOTE = '`';

	const TYPE_SQL = 'sql';
	const TYPE_INT = 'integer';
	const TYPE_BOOL = 'bool';
	const TYPE_STRING = 'string';


	/**
	* Factory, returns driver-specific instance of the class
	*
	* @param string $db_dsnw DSN for read/write operations
	* @param string $db_dsnr Optional DSN for read only operations
	* @param bool $pconn Enables persistent connections
	*
	* @return rcube_db Object instance
	*/
	public static function factory($db_dsnw, $db_dsnr = '', $pconn = false)
	{
	$driver = strtolower(substr($db_dsnw, 0, strpos($db_dsnw, ':')));
	$driver_map = array(
	'sqlite2' => 'sqlite',
	'sybase' => 'mssql',
	'dblib' => 'mssql',
	'mysqli' => 'mysql',
	'oci' => 'oracle',
	'oci8' => 'oracle',
	);

	$driver = isset($driver_map[$driver]) ? $driver_map[$driver] : $driver;
	$class = "rcube_db_$driver";

	if (!$driver \|\| !class_exists($class)) {
	rcube::raise_error(array('code' => 600, 'type' => 'db',
	'line' => __LINE__, 'file' => __FILE__,
	'message' => "Configuration error. Unsupported database driver: $driver"),
	true, true);
	}

	return new $class($db_dsnw, $db_dsnr, $pconn);
	}

	/**
	* Object constructor
	*
	* @param string $db_dsnw DSN for read/write operations
	* @param string $db_dsnr Optional DSN for read only operations
	* @param bool $pconn Enables persistent connections
	*/
	public function __construct($db_dsnw, $db_dsnr = '', $pconn = false)
	{
	if (empty($db_dsnr)) {
	$db_dsnr = $db_dsnw;
	}

	$this->db_dsnw = $db_dsnw;
	$this->db_dsnr = $db_dsnr;
	$this->db_pconn = $pconn;

	$this->db_dsnw_array = self::parse_dsn($db_dsnw);
	$this->db_dsnr_array = self::parse_dsn($db_dsnr);

	$config = rcube::get_instance()->config;

	$this->options['table_prefix'] = $config->get('db_prefix');
	$this->options['dsnw_noread'] = $config->get('db_dsnw_noread', false);
	$this->options['table_dsn_map'] = array_map(array($this, 'table_name'), $config->get('db_table_dsn', array()));
	}

	/**
	* Connect to specific database
	*
	* @param array $dsn DSN for DB connections
	* @param string $mode Connection mode (r\|w)
	*/
	protected function dsn_connect($dsn, $mode)
	{
	$this->db_error = false;
	$this->db_error_msg = null;

	// return existing handle
	- if ($this->dbhs[$mode]) {
	+ if (!empty($this->dbhs[$mode])) {
	$this->dbh = $this->dbhs[$mode];
	$this->db_mode = $mode;
	return $this->dbh;
	}

	// connect to database
	if ($dbh = $this->conn_create($dsn)) {
	$this->dbhs[$mode] = $dbh;
	$this->db_mode = $mode;
	$this->db_connected = true;
	}
	}

	/**
	* Create PDO connection
	*/
	protected function conn_create($dsn)
	{
	// Get database specific connection options
	$dsn_string = $this->dsn_string($dsn);
	$dsn_options = $this->dsn_options($dsn);

	// Connect
	try {
	// with this check we skip fatal error on PDO object creation
	if (!class_exists('PDO', false)) {
	throw new Exception('PDO extension not loaded. See http://php.net/manual/en/intro.pdo.php');
	}

	$this->conn_prepare($dsn);

	$this->dbh = new PDO($dsn_string, $dsn['username'], $dsn['password'], $dsn_options);

	// don't throw exceptions or warnings
	$this->dbh->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_SILENT);

	$this->conn_configure($dsn, $this->dbh);
	}
	catch (Exception $e) {
	$this->db_error = true;
	$this->db_error_msg = $e->getMessage();

	rcube::raise_error(array('code' => 500, 'type' => 'db',
	'line' => __LINE__, 'file' => __FILE__,
	'message' => $this->db_error_msg), true, false);

	return null;
	}

	return $this->dbh;
	}

	/**
	* Driver-specific preparation of database connection
	*
	* @param array $dsn DSN for DB connections
	*/
	protected function conn_prepare($dsn)
	{
	}

	/**
	* Driver-specific configuration of database connection
	*
	* @param array $dsn DSN for DB connections
	* @param PDO $dbh Connection handler
	*/
	protected function conn_configure($dsn, $dbh)
	{
	}

	/**
	* Connect to appropriate database depending on the operation
	*
	* @param string $mode Connection mode (r\|w)
	* @param boolean $force Enforce using the given mode
	*/
	public function db_connect($mode, $force = false)
	{
	// previous connection failed, don't attempt to connect again
	if ($this->conn_failure) {
	return;
	}

	// no replication
	if ($this->db_dsnw == $this->db_dsnr) {
	$mode = 'w';
	}

	// Already connected
	if ($this->db_connected) {
	// connected to db with the same or "higher" mode (if allowed)
	if ($this->db_mode == $mode \|\| $this->db_mode == 'w' && !$force && !$this->options['dsnw_noread']) {
	return;
	}
	}

	$dsn = ($mode == 'r') ? $this->db_dsnr_array : $this->db_dsnw_array;
	$this->dsn_connect($dsn, $mode);

	// use write-master when read-only fails
	if (!$this->db_connected && $mode == 'r' && $this->is_replicated()) {
	$this->dsn_connect($this->db_dsnw_array, 'w');
	}

	$this->conn_failure = !$this->db_connected;
	}

	/**
	* Analyze the given SQL statement and select the appropriate connection to use
	*/
	protected function dsn_select($query)
	{
	// no replication
	if ($this->db_dsnw == $this->db_dsnr) {
	return 'w';
	}

	// Read or write ?
	$mode = preg_match('/^(select\|show\|set)/i', $query) ? 'r' : 'w';

	$start = '[' . $this->options['identifier_start'] . self::DEFAULT_QUOTE . ']';
	$end = '[' . $this->options['identifier_end'] . self::DEFAULT_QUOTE . ']';
	$regex = '/(?:^\|\s)(from\|update\|into\|join)\s+'.$start.'?([a-z0-9._]+)'.$end.'?\s+/i';

	// find tables involved in this query
	if (preg_match_all($regex, $query, $matches, PREG_SET_ORDER)) {
	foreach ($matches as $m) {
	$table = $m[2];

	// always use direct mapping
	if ($this->options['table_dsn_map'][$table]) {
	$mode = $this->options['table_dsn_map'][$table];
	break; // primary table rules
	}
	else if ($mode == 'r') {
	// connected to db with the same or "higher" mode for this table
	$db_mode = $this->table_connections[$table];
	if ($db_mode == 'w' && !$this->options['dsnw_noread']) {
	$mode = $db_mode;
	}
	}
	}

	// remember mode chosen (for primary table)
	$table = $matches[0][2];
	$this->table_connections[$table] = $mode;
	}

	return $mode;
	}

	/**
	* Activate/deactivate debug mode
	*
	* @param boolean $dbg True if SQL queries should be logged
	*/
	public function set_debug($dbg = true)
	{
	$this->options['debug_mode'] = $dbg;
	}

	/**
	* Writes debug information/query to 'sql' log file
	*
	* @param string $query SQL query
	*/
	protected function debug($query)
	{
	if ($this->options['debug_mode']) {
	if (($len = strlen($query)) > self::DEBUG_LINE_LENGTH) {
	$diff = $len - self::DEBUG_LINE_LENGTH;
	$query = substr($query, 0, self::DEBUG_LINE_LENGTH)
	. "... [truncated $diff bytes]";
	}
	rcube::write_log('sql', '[' . (++$this->db_index) . '] ' . $query . ';');
	}
	}

	/**
	* Getter for error state
	*
	* @param mixed $result Optional query result
	*
	* @return string Error message
	*/
	public function is_error($result = null)
	{
	if ($result !== null) {
	return $result === false ? $this->db_error_msg : null;
	}

	return $this->db_error ? $this->db_error_msg : null;
	}

	/**
	* Connection state checker
	*
	* @return boolean True if in connected state
	*/
	public function is_connected()
	{
	return !is_object($this->dbh) ? false : $this->db_connected;
	}

	/**
	* Is database replication configured?
	*
	* @return bool Returns true if dsnw != dsnr
	*/
	public function is_replicated()
	{
	return !empty($this->db_dsnr) && $this->db_dsnw != $this->db_dsnr;
	}

	/**
	* Get database runtime variables
	*
	* @param string $varname Variable name
	* @param mixed $default Default value if variable is not set
	*
	* @return mixed Variable value or default
	*/
	public function get_variable($varname, $default = null)
	{
	// to be implemented by driver class
	return rcube::get_instance()->config->get('db_' . $varname, $default);
	}

	/**
	* Execute a SQL query
	*
	* @param string SQL query to execute
	* @param mixed Values to be inserted in query
	*
	* @return PDOStatement\|bool Query handle or False on error
	*/
	public function query()
	{
	$params = func_get_args();
	$query = array_shift($params);

	// Support one argument of type array, instead of n arguments
	if (count($params) == 1 && is_array($params[0])) {
	$params = $params[0];
	}

	return $this->_query($query, 0, 0, $params);
	}

	/**
	* Execute a SQL query with limits
	*
	* @param string SQL query to execute
	* @param int Offset for LIMIT statement
	* @param int Number of rows for LIMIT statement
	* @param mixed Values to be inserted in query
	*
	* @return PDOStatement\|bool Query handle or False on error
	*/
	public function limitquery()
	{
	$params = func_get_args();
	$query = array_shift($params);
	$offset = array_shift($params);
	$numrows = array_shift($params);

	return $this->_query($query, $offset, $numrows, $params);
	}

	/**
	* Execute a SQL query with limits
	*
	* @param string $query SQL query to execute
	* @param int $offset Offset for LIMIT statement
	* @param int $numrows Number of rows for LIMIT statement
	* @param array $params Values to be inserted in query
	*
	* @return PDOStatement\|bool Query handle or False on error
	*/
	protected function _query($query, $offset, $numrows, $params)
	{
	$query = ltrim($query);

	$this->db_connect($this->dsn_select($query), true);

	// check connection before proceeding
	if (!$this->is_connected()) {
	return $this->last_result = false;
	}

	if ($numrows \|\| $offset) {
	$query = $this->set_limit($query, $numrows, $offset);
	}

	// replace self::DEFAULT_QUOTE with driver-specific quoting
	$query = $this->query_parse($query);

	// Because in Roundcube we mostly use queries that are
	// executed only once, we will not use prepared queries
	$pos = 0;
	$idx = 0;

	if (count($params)) {
	while ($pos = strpos($query, '?', $pos)) {
	if (isset($query[$pos+1]) && $query[$pos+1] == '?') { // skip escaped '?'
	$pos += 2;
	}
	else {
	$val = $this->quote($params[$idx++]);
	unset($params[$idx-1]);
	$query = substr_replace($query, $val, $pos, 1);
	$pos += strlen($val);
	}
	}
	}

	$query = rtrim($query, " \t\n\r\0\x0B;");

	// replace escaped '?' and quotes back to normal, see self::quote()
	$query = str_replace(
	array('??', self::DEFAULT_QUOTE.self::DEFAULT_QUOTE),
	array('?', self::DEFAULT_QUOTE),
	$query
	);

	// log query
	$this->debug($query);

	return $this->query_execute($query);
	}

	/**
	* Query execution
	*/
	protected function query_execute($query)
	{
	// destroy reference to previous result, required for SQLite driver (#1488874)
	$this->last_result = null;
	$this->db_error_msg = null;

	// send query
	$result = $this->dbh->query($query);

	if ($result === false) {
	$result = $this->handle_error($query);
	}

	return $this->last_result = $result;
	}

	/**
	* Parse SQL query and replace identifier quoting
	*
	* @param string $query SQL query
	*
	* @return string SQL query
	*/
	protected function query_parse($query)
	{
	$start = $this->options['identifier_start'];
	$end = $this->options['identifier_end'];
	$quote = self::DEFAULT_QUOTE;

	if ($start == $quote) {
	return $query;
	}

	$pos = 0;
	$in = false;

	while ($pos = strpos($query, $quote, $pos)) {
	if ($query[$pos+1] == $quote) { // skip escaped quote
	$pos += 2;
	}
	else {
	if ($in) {
	$q = $end;
	$in = false;
	}
	else {
	$q = $start;
	$in = true;
	}

	$query = substr_replace($query, $q, $pos, 1);
	$pos++;
	}
	}

	return $query;
	}

	/**
	* Helper method to handle DB errors.
	* This by default logs the error but could be overridden by a driver implementation
	*
	* @param string $query Query that triggered the error
	*
	* @return mixed Result to be stored and returned
	*/
	protected function handle_error($query)
	{
	$error = $this->dbh->errorInfo();

	if (empty($this->options['ignore_key_errors']) \|\| !in_array($error[0], array('23000', '23505'))) {
	$this->db_error = true;
	$this->db_error_msg = sprintf('[%s] %s', $error[1], $error[2]);

	if (empty($this->options['ignore_errors'])) {
	rcube::raise_error(array(
	'code' => 500, 'type' => 'db', 'line' => __LINE__, 'file' => __FILE__,
	'message' => $this->db_error_msg . " (SQL Query: $query)"
	), true, false);
	}
	}

	return false;
	}

	/**
	* INSERT ... ON DUPLICATE KEY UPDATE (or equivalent).
	* When not supported by the engine we do UPDATE and INSERT.
	*
	* @param string $table Table name
	* @param array $keys Hash array (column => value) of the unique constraint
	* @param array $columns List of columns to update
	* @param array $values List of values to update (number of elements
	* should be the same as in $columns)
	*
	* @return PDOStatement\|bool Query handle or False on error
	* @todo Multi-insert support
	*/
	public function insert_or_update($table, $keys, $columns, $values)
	{
	$table = $this->table_name($table, true);
	$columns = array_map(function($i) { return "`$i`"; }, $columns);
	$sets = array_map(function($i) { return "$i = ?"; }, $columns);
	$where = $keys;

	array_walk($where, function(&$val, $key) {
	$val = $this->quote_identifier($key) . " = " . $this->quote($val);
	});

	// First try UPDATE
	$result = $this->query("UPDATE $table SET " . implode(", ", $sets)
	. " WHERE " . implode(" AND ", $where), $values);

	// if UPDATE fails use INSERT
	if ($result && !$this->affected_rows($result)) {
	$cols = implode(', ', array_map(function($i) { return "`$i`"; }, array_keys($keys)));
	$cols .= ', ' . implode(', ', $columns);
	$vals = implode(', ', array_map(function($i) { return $this->quote($i); }, $keys));
	$vals .= ', ' . rtrim(str_repeat('?, ', count($columns)), ', ');

	$result = $this->query("INSERT INTO $table ($cols) VALUES ($vals)", $values);
	}

	return $result;
	}

	/**
	* Get number of affected rows for the last query
	*
	* @param mixed $result Optional query handle
	*
	* @return int Number of (matching) rows
	*/
	public function affected_rows($result = null)
	{
	if ($result \|\| ($result === null && ($result = $this->last_result))) {
	if ($result !== true) {
	return $result->rowCount();
	}
	}

	return 0;
	}

	/**
	* Get number of rows for a SQL query
	* If no query handle is specified, the last query will be taken as reference
	*
	* @param mixed $result Optional query handle
	*
	* @return mixed Number of rows or false on failure
	* @deprecated This method shows very poor performance and should be avoided.
	*/
	public function num_rows($result = null)
	{
	if (($result \|\| ($result === null && ($result = $this->last_result))) && $result !== true) {
	// repeat query with SELECT COUNT(*) ...
	if (preg_match('/^SELECT\s+(?:ALL\s+\|DISTINCT\s+)?(?:.?)\s+FROM\s+(.)$/ims', $result->queryString, $m)) {
	$query = $this->dbh->query('SELECT COUNT(*) FROM ' . $m[1], PDO::FETCH_NUM);
	return $query ? intval($query->fetchColumn(0)) : false;
	}
	else {
	$num = count($result->fetchAll());
	$result->execute(); // re-execute query because there's no seek(0)
	return $num;
	}
	}

	return false;
	}

	/**
	* Get last inserted record ID
	*
	* @param string $table Table name (to find the incremented sequence)
	*
	* @return mixed ID or false on failure
	*/
	public function insert_id($table = '')
	{
	if (!$this->db_connected \|\| $this->db_mode == 'r') {
	return false;
	}

	if ($table) {
	// resolve table name
	$table = $this->table_name($table);
	}

	$id = $this->dbh->lastInsertId($table);

	return $id;
	}

	/**
	* Get an associative array for one row
	* If no query handle is specified, the last query will be taken as reference
	*
	* @param mixed $result Optional query handle
	*
	* @return mixed Array with col values or false on failure
	*/
	public function fetch_assoc($result = null)
	{
	return $this->_fetch_row($result, PDO::FETCH_ASSOC);
	}

	/**
	* Get an index array for one row
	* If no query handle is specified, the last query will be taken as reference
	*
	* @param mixed $result Optional query handle
	*
	* @return mixed Array with col values or false on failure
	*/
	public function fetch_array($result = null)
	{
	return $this->_fetch_row($result, PDO::FETCH_NUM);
	}

	/**
	* Get col values for a result row
	*
	* @param mixed $result Optional query handle
	* @param int $mode Fetch mode identifier
	*
	* @return mixed Array with col values or false on failure
	*/
	protected function _fetch_row($result, $mode)
	{
	if ($result \|\| ($result === null && ($result = $this->last_result))) {
	if ($result !== true) {
	return $result->fetch($mode);
	}
	}

	return false;
	}

	/**
	* Adds LIMIT,OFFSET clauses to the query
	*
	* @param string $query SQL query
	* @param int $limit Number of rows
	* @param int $offset Offset
	*
	* @return string SQL query
	*/
	protected function set_limit($query, $limit = 0, $offset = 0)
	{
	if ($limit) {
	$query .= ' LIMIT ' . intval($limit);
	}

	if ($offset) {
	$query .= ' OFFSET ' . intval($offset);
	}

	return $query;
	}

	/**
	* Returns list of tables in a database
	*
	* @return array List of all tables of the current database
	*/
	public function list_tables()
	{
	// get tables if not cached
	if ($this->tables === null) {
	$q = $this->query("SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES"
	. " WHERE TABLE_TYPE = 'BASE TABLE'"
	. " ORDER BY TABLE_NAME");

	$this->tables = $q ? $q->fetchAll(PDO::FETCH_COLUMN, 0) : array();
	}

	return $this->tables;
	}

	/**
	* Returns list of columns in database table
	*
	* @param string $table Table name
	*
	* @return array List of table cols
	*/
	public function list_cols($table)
	{
	$q = $this->query('SELECT COLUMN_NAME FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME = ?',
	array($table));

	if ($q) {
	return $q->fetchAll(PDO::FETCH_COLUMN, 0);
	}

	return array();
	}

	/**
	* Start transaction
	*
	* @return bool True on success, False on failure
	*/
	public function startTransaction()
	{
	$this->db_connect('w', true);

	// check connection before proceeding
	if (!$this->is_connected()) {
	return $this->last_result = false;
	}

	$this->debug('BEGIN TRANSACTION');

	return $this->last_result = $this->dbh->beginTransaction();
	}

	/**
	* Commit transaction
	*
	* @return bool True on success, False on failure
	*/
	public function endTransaction()
	{
	$this->db_connect('w', true);

	// check connection before proceeding
	if (!$this->is_connected()) {
	return $this->last_result = false;
	}

	$this->debug('COMMIT TRANSACTION');

	return $this->last_result = $this->dbh->commit();
	}

	/**
	* Rollback transaction
	*
	* @return bool True on success, False on failure
	*/
	public function rollbackTransaction()
	{
	$this->db_connect('w', true);

	// check connection before proceeding
	if (!$this->is_connected()) {
	return $this->last_result = false;
	}

	$this->debug('ROLLBACK TRANSACTION');

	return $this->last_result = $this->dbh->rollBack();
	}

	/**
	* Release resources related to the last query result.
	* When we know we don't need to access the last query result we can destroy it
	* and release memory. Useful especially if the query returned big chunk of data.
	*/
	public function reset()
	{
	$this->last_result = null;
	}

	/**
	* Terminate database connection.
	*/
	public function closeConnection()
	{
	$this->db_connected = false;
	$this->db_index = 0;

	// release statement and connection resources
	$this->last_result = null;
	$this->dbh = null;
	$this->dbhs = array();
	}

	/**
	* Formats input so it can be safely used in a query
	*
	* @param mixed $input Value to quote
	* @param string $type Type of data (integer, bool, ident)
	*
	* @return string Quoted/converted string for use in query
	*/
	public function quote($input, $type = null)
	{
	if ($input instanceof rcube_db_param) {
	return (string) $input;
	}

	// handle int directly for better performance
	if ($type == 'integer' \|\| $type == 'int') {
	return intval($input);
	}

	if (is_null($input)) {
	return 'NULL';
	}

	if ($input instanceof DateTime) {
	return $this->quote($input->format($this->options['datetime_format']));
	}

	if ($type == 'ident') {
	return $this->quote_identifier($input);
	}

	// create DB handle if not available
	if (!$this->dbh) {
	$this->db_connect('r');
	}

	if ($this->dbh) {
	$map = array(
	'bool' => PDO::PARAM_BOOL,
	'integer' => PDO::PARAM_INT,
	);

	$type = isset($map[$type]) ? $map[$type] : PDO::PARAM_STR;

	return strtr($this->dbh->quote($input, $type),
	// escape ? and `
	array('?' => '??', self::DEFAULT_QUOTE => self::DEFAULT_QUOTE.self::DEFAULT_QUOTE)
	);
	}

	return 'NULL';
	}

	/**
	* Escapes a string so it can be safely used in a query
	*
	* @param string $str A string to escape
	*
	* @return string Escaped string for use in a query
	*/
	public function escape($str)
	{
	if (is_null($str)) {
	return 'NULL';
	}

	return substr($this->quote($str), 1, -1);
	}

	/**
	* Quotes a string so it can be safely used as a table or column name
	*
	* @param string $str Value to quote
	*
	* @return string Quoted string for use in query
	* @deprecated Replaced by rcube_db::quote_identifier
	* @see rcube_db::quote_identifier
	*/
	public function quoteIdentifier($str)
	{
	return $this->quote_identifier($str);
	}

	/**
	* Escapes a string so it can be safely used in a query
	*
	* @param string $str A string to escape
	*
	* @return string Escaped string for use in a query
	* @deprecated Replaced by rcube_db::escape
	* @see rcube_db::escape
	*/
	public function escapeSimple($str)
	{
	return $this->escape($str);
	}

	/**
	* Quotes a string so it can be safely used as a table or column name
	*
	* @param string $str Value to quote
	*
	* @return string Quoted string for use in query
	*/
	public function quote_identifier($str)
	{
	$start = $this->options['identifier_start'];
	$end = $this->options['identifier_end'];
	$name = array();

	foreach (explode('.', $str) as $elem) {
	$elem = str_replace(array($start, $end), '', $elem);
	$name[] = $start . $elem . $end;
	}

	return implode('.', $name);
	}

	/**
	* Create query parameter object
	*
	* @param mixed $value Parameter value
	* @param string $type Parameter type (one of rcube_db::TYPE_* constants)
	*/
	public function param($value, $type = null)
	{
	return new rcube_db_param($this, $value, $type);
	}

	/**
	* Return SQL function for current time and date
	*
	* @param int $interval Optional interval (in seconds) to add/subtract
	*
	* @return string SQL function to use in query
	*/
	public function now($interval = 0)
	{
	$result = 'now()';

	if ($interval) {
	$result .= ' ' . ($interval > 0 ? '+' : '-') . ' INTERVAL '
	. ($interval > 0 ? intval($interval) : intval($interval) * -1)
	. ' SECOND';
	}

	return $result;
	}

	/**
	* Return list of elements for use with SQL's IN clause
	*
	* @param array $arr Input array
	* @param string $type Type of data (integer, bool, ident)
	*
	* @return string Comma-separated list of quoted values for use in query
	*/
	public function array2list($arr, $type = null)
	{
	if (!is_array($arr)) {
	return $this->quote($arr, $type);
	}

	foreach ($arr as $idx => $item) {
	$arr[$idx] = $this->quote($item, $type);
	}

	return implode(',', $arr);
	}

	/**
	* Return SQL statement to convert a field value into a unix timestamp
	*
	* This method is deprecated and should not be used anymore due to limitations
	* of timestamp functions in Mysql (year 2038 problem)
	*
	* @param string $field Field name
	*
	* @return string SQL statement to use in query
	* @deprecated
	*/
	public function unixtimestamp($field)
	{
	return "UNIX_TIMESTAMP($field)";
	}

	/**
	* Return SQL statement to convert from a unix timestamp
	*
	* @param int $timestamp Unix timestamp
	*
	* @return string Date string in db-specific format
	* @deprecated
	*/
	public function fromunixtime($timestamp)
	{
	return $this->quote(date($this->options['datetime_format'], $timestamp));
	}

	/**
	* Return SQL statement for case insensitive LIKE
	*
	* @param string $column Field name
	* @param string $value Search value
	*
	* @return string SQL statement to use in query
	*/
	public function ilike($column, $value)
	{
	return $this->quote_identifier($column).' LIKE '.$this->quote($value);
	}

	/**
	* Abstract SQL statement for value concatenation
	*
	* @return string SQL statement to be used in query
	*/
	public function concat(/* col1, col2, ... */)
	{
	$args = func_get_args();
	if (is_array($args[0])) {
	$args = $args[0];
	}

	return '(' . implode(' \|\| ', $args) . ')';
	}

	/**
	* Encodes non-UTF-8 characters in string/array/object (recursive)
	*
	* @param mixed $input Data to fix
	* @param bool $serialized Enable serialization
	*
	* @return mixed Properly UTF-8 encoded data
	*/
	public static function encode($input, $serialized = false)
	{
	// use Base64 encoding to workaround issues with invalid
	// or null characters in serialized string (#1489142)
	if ($serialized) {
	return base64_encode(serialize($input));
	}

	if (is_object($input)) {
	foreach (get_object_vars($input) as $idx => $value) {
	$input->$idx = self::encode($value);
	}
	return $input;
	}
	else if (is_array($input)) {
	foreach ($input as $idx => $value) {
	$input[$idx] = self::encode($value);
	}

	return $input;
	}

	return utf8_encode($input);
	}

	/**
	* Decodes encoded UTF-8 string/object/array (recursive)
	*
	* @param mixed $input Input data
	* @param bool $serialized Enable serialization
	*
	* @return mixed Decoded data
	*/
	public static function decode($input, $serialized = false)
	{
	// use Base64 encoding to workaround issues with invalid
	// or null characters in serialized string (#1489142)
	if ($serialized) {
	// Keep backward compatybility where base64 wasn't used
	if (strpos(substr($input, 0, 16), ':') !== false) {
	return self::decode(@unserialize($input));
	}

	return @unserialize(base64_decode($input));
	}

	if (is_object($input)) {
	foreach (get_object_vars($input) as $idx => $value) {
	$input->$idx = self::decode($value);
	}
	return $input;
	}
	else if (is_array($input)) {
	foreach ($input as $idx => $value) {
	$input[$idx] = self::decode($value);
	}
	return $input;
	}

	return utf8_decode($input);
	}

	/**
	* Return correct name for a specific database table
	*
	* @param string $table Table name
	* @param bool $quoted Quote table identifier
	*
	* @return string Translated table name
	*/
	public function table_name($table, $quoted = false)
	{
	// let plugins alter the table name (#1489837)
	$plugin = rcube::get_instance()->plugins->exec_hook('db_table_name', array('table' => $table));
	$table = $plugin['table'];

	// add prefix to the table name if configured
	if (($prefix = $this->options['table_prefix']) && strpos($table, $prefix) !== 0) {
	$table = $prefix . $table;
	}

	if ($quoted) {
	$table = $this->quote_identifier($table);
	}

	return $table;
	}

	/**
	* Set class option value
	*
	* @param string $name Option name
	* @param mixed $value Option value
	*/
	public function set_option($name, $value)
	{
	$this->options[$name] = $value;
	}

	/**
	* Set DSN connection to be used for the given table
	*
	* @param string $table Table name
	* @param string $mode DSN connection ('r' or 'w') to be used
	*/
	public function set_table_dsn($table, $mode)
	{
	$this->options['table_dsn_map'][$this->table_name($table)] = $mode;
	}

	/**
	* MDB2 DSN string parser
	*
	* @param string $sequence Secuence name
	*
	* @return array DSN parameters
	*/
	public static function parse_dsn($dsn)
	{
	if (empty($dsn)) {
	return null;
	}

	// Find phptype and dbsyntax
	if (($pos = strpos($dsn, '://')) !== false) {
	$str = substr($dsn, 0, $pos);
	$dsn = substr($dsn, $pos + 3);
	}
	else {
	$str = $dsn;
	$dsn = null;
	}

	// Get phptype and dbsyntax
	// $str => phptype(dbsyntax)
	if (preg_match('\|^(.+?)$(.*?)$$\|', $str, $arr)) {
	$parsed['phptype'] = $arr[1];
	$parsed['dbsyntax'] = !$arr[2] ? $arr[1] : $arr[2];
	}
	else {
	$parsed['phptype'] = $str;
	$parsed['dbsyntax'] = $str;
	}

	if (empty($dsn)) {
	return $parsed;
	}

	// Get (if found): username and password
	// $dsn => username:password@protocol+hostspec/database
	if (($at = strrpos($dsn,'@')) !== false) {
	$str = substr($dsn, 0, $at);
	$dsn = substr($dsn, $at + 1);
	if (($pos = strpos($str, ':')) !== false) {
	$parsed['username'] = rawurldecode(substr($str, 0, $pos));
	$parsed['password'] = rawurldecode(substr($str, $pos + 1));
	}
	else {
	$parsed['username'] = rawurldecode($str);
	}
	}

	// Find protocol and hostspec
	// $dsn => proto(proto_opts)/database
	if (preg_match('\|^([^(]+)$(.?)$/?(.?)$\|', $dsn, $match)) {
	$proto = $match[1];
	$proto_opts = $match[2] ? $match[2] : false;
	$dsn = $match[3];
	}
	// $dsn => protocol+hostspec/database (old format)
	else {
	if (strpos($dsn, '+') !== false) {
	list($proto, $dsn) = explode('+', $dsn, 2);
	}
	if ( strpos($dsn, '//') === 0
	&& strpos($dsn, '/', 2) !== false
	&& $parsed['phptype'] == 'oci8'
	) {
	// Oracle's "Easy Connect" syntax:
	// "username/password@[//]host[:port][/service_name]"
	// e.g. "scott/tiger@//mymachine:1521/oracle"
	$proto_opts = $dsn;
	$pos = strrpos($proto_opts, '/');
	$dsn = substr($proto_opts, $pos + 1);
	$proto_opts = substr($proto_opts, 0, $pos);
	}
	else if (strpos($dsn, '/') !== false) {
	list($proto_opts, $dsn) = explode('/', $dsn, 2);
	}
	else {
	$proto_opts = $dsn;
	$dsn = null;
	}
	}

	// process the different protocol options
	$parsed['protocol'] = !empty($proto) ? $proto : 'tcp';
	$proto_opts = rawurldecode($proto_opts);
	if (strpos($proto_opts, ':') !== false) {
	list($proto_opts, $parsed['port']) = explode(':', $proto_opts);
	}
	if ($parsed['protocol'] == 'tcp') {
	$parsed['hostspec'] = $proto_opts;
	}
	else if ($parsed['protocol'] == 'unix') {
	$parsed['socket'] = $proto_opts;
	}

	// Get database if any
	// $dsn => database
	if ($dsn) {
	// /database
	if (($pos = strpos($dsn, '?')) === false) {
	$parsed['database'] = rawurldecode($dsn);
	}
	else {
	// /database?param1=value1&param2=value2
	$parsed['database'] = rawurldecode(substr($dsn, 0, $pos));
	$dsn = substr($dsn, $pos + 1);

	if (strpos($dsn, '&') !== false) {
	$opts = explode('&', $dsn);
	}
	else { // database?param1=value1
	$opts = array($dsn);
	}
	foreach ($opts as $opt) {
	list($key, $value) = explode('=', $opt);
	if (!array_key_exists($key, $parsed) \|\| false === $parsed[$key]) {
	// don't allow params overwrite
	$parsed[$key] = rawurldecode($value);
	}
	}
	}

	// remove problematic suffix (#7034)
	$parsed['database'] = preg_replace('/;.*$/', '', $parsed['database']);

	// Resolve relative path to the sqlite database file
	// so for example it works with Roundcube Installer
	if (!empty($parsed['phptype']) && !empty($parsed['database'])
	&& stripos($parsed['phptype'], 'sqlite') === 0
	&& $parsed['database'][0] != '/'
	&& strpos($parsed['database'], ':') === false
	) {
	$parsed['database'] = INSTALL_PATH . $parsed['database'];
	}
	}

	return $parsed;
	}

	/**
	* Returns PDO DSN string from DSN array
	*
	* @param array $dsn DSN parameters
	*
	* @return string DSN string
	*/
	protected function dsn_string($dsn)
	{
	$params = array();
	$result = $dsn['phptype'] . ':';

	if ($dsn['hostspec']) {
	$params[] = 'host=' . $dsn['hostspec'];
	}

	if ($dsn['port']) {
	$params[] = 'port=' . $dsn['port'];
	}

	if ($dsn['database']) {
	$params[] = 'dbname=' . $dsn['database'];
	}

	if (!empty($params)) {
	$result .= implode(';', $params);
	}

	return $result;
	}

	/**
	* Returns driver-specific connection options
	*
	* @param array $dsn DSN parameters
	*
	* @return array Connection options
	*/
	protected function dsn_options($dsn)
	{
	$result = array();

	if ($this->db_pconn) {
	$result[PDO::ATTR_PERSISTENT] = true;
	}

	if (!empty($dsn['prefetch'])) {
	$result[PDO::ATTR_PREFETCH] = (int) $dsn['prefetch'];
	}

	if (!empty($dsn['timeout'])) {
	$result[PDO::ATTR_TIMEOUT] = (int) $dsn['timeout'];
	}

	return $result;
	}

	/**
	* Execute the given SQL script
	*
	* @param string $sql SQL queries to execute
	*
	* @return boolen True on success, False on error
	*/
	public function exec_script($sql)
	{
	$sql = $this->fix_table_names($sql);
	$buff = '';
	$exec = '';

	foreach (explode("\n", $sql) as $line) {
	$trimmed = trim($line);
	if ($trimmed == '' \|\| preg_match('/^--/', $trimmed)) {
	continue;
	}

	if ($trimmed == 'GO') {
	$exec = $buff;
	}
	else if ($trimmed[strlen($trimmed)-1] == ';') {
	$exec = $buff . substr(rtrim($line), 0, -1);
	}

	if ($exec) {
	$this->query($exec);
	$buff = '';
	$exec = '';
	if ($this->db_error) {
	break;
	}
	}
	else {
	$buff .= $line . "\n";
	}
	}

	return !$this->db_error;
	}

	/**
	* Parse SQL file and fix table names according to table prefix
	*/
	protected function fix_table_names($sql)
	{
	if (!$this->options['table_prefix']) {
	return $sql;
	}

	$sql = preg_replace_callback(
	'/((TABLE\|TRUNCATE( TABLE)?\|(?<!ON )UPDATE\|INSERT INTO\|FROM'
	. '\| ON(?! (DELETE\|UPDATE))\|REFERENCES\|CONSTRAINT\|FOREIGN KEY\|INDEX\|UNIQUE( INDEX)?)'
	. '\s+(IF (NOT )?EXISTS )?[`"]*)([^`"\( \r\n]+)/',
	array($this, 'fix_table_names_callback'),
	$sql
	);

	return $sql;
	}

	/**
	* Preg_replace callback for fix_table_names()
	*/
	protected function fix_table_names_callback($matches)
	{
	return $matches[1] . $this->options['table_prefix'] . $matches[count($matches)-1];
	}
	}
	diff --git a/program/lib/Roundcube/rcube_imap.php b/program/lib/Roundcube/rcube_imap.php
	index c77257ef1..3d3aa01cb 100644
	--- a/program/lib/Roundcube/rcube_imap.php
	+++ b/program/lib/Roundcube/rcube_imap.php
	@@ -1,4594 +1,4594 @@
	<?php

	/**
	+-----------------------------------------------------------------------+
	\| This file is part of the Roundcube Webmail client \|
	\| \|
	\| Copyright (C) The Roundcube Dev Team \|
	\| Copyright (C) Kolab Systems AG \|
	\| \|
	\| Licensed under the GNU General Public License version 3 or \|
	\| any later version with exceptions for skins & plugins. \|
	\| See the README file for a full license statement. \|
	\| \|
	\| PURPOSE: \|
	\| IMAP Storage Engine \|
	+-----------------------------------------------------------------------+
	\| Author: Thomas Bruederli <roundcube@gmail.com> \|
	\| Author: Aleksander Machniak <alec@alec.pl> \|
	+-----------------------------------------------------------------------+
	*/

	/**
	* Interface class for accessing an IMAP server
	*
	* @package Framework
	* @subpackage Storage
	*/
	class rcube_imap extends rcube_storage
	{
	/**
	* Instance of rcube_imap_generic
	*
	* @var rcube_imap_generic
	*/
	public $conn;

	/**
	* Instance of rcube_imap_cache
	*
	* @var rcube_imap_cache
	*/
	protected $mcache;

	/**
	* Instance of rcube_cache
	*
	* @var rcube_cache
	*/
	protected $cache;

	protected $plugins;
	protected $delimiter;
	protected $namespace;
	protected $struct_charset;
	protected $search_set;
	protected $search_string = '';
	protected $search_charset = '';
	protected $search_sort_field = '';
	protected $search_threads = false;
	protected $search_sorted = false;
	protected $sort_field = '';
	protected $sort_order = 'DESC';
	protected $options = array('auth_type' => 'check');
	protected $caching = false;
	protected $messages_caching = false;
	protected $threading = false;
	protected $connect_done = false;
	protected $list_excludes = array();
	protected $list_root;
	protected $msg_uid;
	protected $sort_folder_collator;


	/**
	* Object constructor.
	*/
	public function __construct()
	{
	$this->conn = new rcube_imap_generic();
	$this->plugins = rcube::get_instance()->plugins;

	// Set namespace and delimiter from session,
	// so some methods would work before connection
	if (isset($_SESSION['imap_namespace'])) {
	$this->namespace = $_SESSION['imap_namespace'];
	}
	if (isset($_SESSION['imap_delimiter'])) {
	$this->delimiter = $_SESSION['imap_delimiter'];
	}
	if (!empty($_SESSION['imap_list_conf'])) {
	list($this->list_root, $this->list_excludes) = $_SESSION['imap_list_conf'];
	}
	}

	/**
	* Magic getter for backward compat.
	*
	* @deprecated.
	*/
	public function __get($name)
	{
	if (isset($this->{$name})) {
	return $this->{$name};
	}
	}

	/**
	* Connect to an IMAP server
	*
	* @param string $host Host to connect
	* @param string $user Username for IMAP account
	* @param string $pass Password for IMAP account
	* @param integer $port Port to connect to
	* @param string $use_ssl SSL schema (either ssl or tls) or null if plain connection
	*
	* @return boolean True on success, False on failure
	*/
	public function connect($host, $user, $pass, $port=143, $use_ssl=null)
	{
	// check for OpenSSL support in PHP build
	if ($use_ssl && extension_loaded('openssl')) {
	$this->options['ssl_mode'] = $use_ssl == 'imaps' ? 'ssl' : $use_ssl;
	}
	else if ($use_ssl) {
	rcube::raise_error(array('code' => 403, 'type' => 'imap',
	'file' => __FILE__, 'line' => __LINE__,
	'message' => "OpenSSL not available"), true, false);
	$port = 143;
	}

	$this->options['port'] = $port;

	if ($this->options['debug']) {
	$this->set_debug(true);

	$this->options['ident'] = array(
	'name' => 'Roundcube',
	'version' => RCUBE_VERSION,
	'php' => PHP_VERSION,
	'os' => PHP_OS,
	'command' => $_SERVER['REQUEST_URI'],
	);
	}

	$attempt = 0;
	do {
	$data = $this->plugins->exec_hook('storage_connect',
	array_merge($this->options, array('host' => $host, 'user' => $user,
	'attempt' => ++$attempt)));

	if (!empty($data['pass'])) {
	$pass = $data['pass'];
	}

	// Handle per-host socket options
	rcube_utils::parse_socket_options($data['socket_options'], $data['host']);

	$this->conn->connect($data['host'], $data['user'], $pass, $data);
	} while(!$this->conn->connected() && $data['retry']);

	$config = array(
	'host' => $data['host'],
	'user' => $data['user'],
	'password' => $pass,
	'port' => $port,
	'ssl' => $use_ssl,
	);

	$this->options = array_merge($this->options, $config);
	$this->connect_done = true;

	if ($this->conn->connected()) {
	// check for session identifier
	$session = null;
	if (preg_match('/\s+SESSIONID=([^=\s]+)/', $this->conn->result, $m)) {
	$session = $m[1];
	}

	// get namespace and delimiter
	$this->set_env();

	// trigger post-connect hook
	$this->plugins->exec_hook('storage_connected', array(
	'host' => $host, 'user' => $user, 'session' => $session
	));

	return true;
	}
	// write error log
	else if ($this->conn->error) {
	if ($pass && $user) {
	$message = sprintf("Login failed for %s against %s from %s. %s",
	$user, $host, rcube_utils::remote_ip(), $this->conn->error);

	rcube::raise_error(array('code' => 403, 'type' => 'imap',
	'file' => __FILE__, 'line' => __LINE__,
	'message' => $message), true, false);
	}
	}

	return false;
	}

	/**
	* Close IMAP connection.
	* Usually done on script shutdown
	*/
	public function close()
	{
	$this->connect_done = false;
	$this->conn->closeConnection();

	if ($this->mcache) {
	$this->mcache->close();
	}
	}

	/**
	* Check connection state, connect if not connected.
	*
	* @return bool Connection state.
	*/
	public function check_connection()
	{
	// Establish connection if it wasn't done yet
	if (!$this->connect_done && !empty($this->options['user'])) {
	return $this->connect(
	$this->options['host'],
	$this->options['user'],
	$this->options['password'],
	$this->options['port'],
	$this->options['ssl']
	);
	}

	return $this->is_connected();
	}

	/**
	* Checks IMAP connection.
	*
	* @return boolean TRUE on success, FALSE on failure
	*/
	public function is_connected()
	{
	return $this->conn->connected();
	}

	/**
	* Returns code of last error
	*
	* @return int Error code
	*/
	public function get_error_code()
	{
	return $this->conn->errornum;
	}

	/**
	* Returns text of last error
	*
	* @return string Error string
	*/
	public function get_error_str()
	{
	return $this->conn->error;
	}

	/**
	* Returns code of last command response
	*
	* @return int Response code
	*/
	public function get_response_code()
	{
	switch ($this->conn->resultcode) {
	case 'NOPERM':
	return self::NOPERM;
	case 'READ-ONLY':
	return self::READONLY;
	case 'TRYCREATE':
	return self::TRYCREATE;
	case 'INUSE':
	return self::INUSE;
	case 'OVERQUOTA':
	return self::OVERQUOTA;
	case 'ALREADYEXISTS':
	return self::ALREADYEXISTS;
	case 'NONEXISTENT':
	return self::NONEXISTENT;
	case 'CONTACTADMIN':
	return self::CONTACTADMIN;
	default:
	return self::UNKNOWN;
	}
	}

	/**
	* Activate/deactivate debug mode
	*
	* @param boolean $dbg True if IMAP conversation should be logged
	*/
	public function set_debug($dbg = true)
	{
	$this->options['debug'] = $dbg;
	$this->conn->setDebug($dbg, array($this, 'debug_handler'));
	}

	/**
	* Set internal folder reference.
	* All operations will be performed on this folder.
	*
	* @param string $folder Folder name
	*/
	public function set_folder($folder)
	{
	$this->folder = $folder;
	}

	/**
	* Save a search result for future message listing methods
	*
	* @param array $set Search set, result from rcube_imap::get_search_set():
	* 0 - searching criteria, string
	* 1 - search result, rcube_result_index\|rcube_result_thread
	* 2 - searching character set, string
	* 3 - sorting field, string
	* 4 - true if sorted, bool
	*/
	public function set_search_set($set)
	{
	$set = (array)$set;

	$this->search_string = $set[0];
	$this->search_set = $set[1];
	$this->search_charset = $set[2];
	$this->search_sort_field = $set[3];
	$this->search_sorted = $set[4];
	$this->search_threads = is_a($this->search_set, 'rcube_result_thread');

	if (is_a($this->search_set, 'rcube_result_multifolder')) {
	$this->set_threading(false);
	}
	}

	/**
	* Return the saved search set as hash array
	*
	* @return array Search set
	*/
	public function get_search_set()
	{
	if (empty($this->search_set)) {
	return null;
	}

	return array(
	$this->search_string,
	$this->search_set,
	$this->search_charset,
	$this->search_sort_field,
	$this->search_sorted,
	);
	}

	/**
	* Returns the IMAP server's capability.
	*
	* @param string $cap Capability name
	*
	* @return mixed Capability value or TRUE if supported, FALSE if not
	*/
	public function get_capability($cap)
	{
	$cap = strtoupper($cap);
	$sess_key = "STORAGE_$cap";

	if (!isset($_SESSION[$sess_key])) {
	if (!$this->check_connection()) {
	return false;
	}

	if ($cap == rcube_storage::DUAL_USE_FOLDERS) {
	$_SESSION[$sess_key] = $this->detect_dual_use_folders();
	}
	else {
	$_SESSION[$sess_key] = $this->conn->getCapability($cap);
	}
	}

	return $_SESSION[$sess_key];
	}

	/**
	* Checks the PERMANENTFLAGS capability of the current folder
	* and returns true if the given flag is supported by the IMAP server
	*
	* @param string $flag Permanentflag name
	*
	* @return boolean True if this flag is supported
	*/
	public function check_permflag($flag)
	{
	$flag = strtoupper($flag);
	$perm_flags = $this->get_permflags($this->folder);
	$imap_flag = $this->conn->flags[$flag];

	return $imap_flag && !empty($perm_flags) && in_array_nocase($imap_flag, $perm_flags);
	}

	/**
	* Returns PERMANENTFLAGS of the specified folder
	*
	* @param string $folder Folder name
	*
	* @return array Flags
	*/
	public function get_permflags($folder)
	{
	if (!strlen($folder)) {
	return array();
	}

	if (!$this->check_connection()) {
	return array();
	}

	if ($this->conn->select($folder)) {
	$permflags = $this->conn->data['PERMANENTFLAGS'];
	}
	else {
	return array();
	}

	if (!is_array($permflags)) {
	$permflags = array();
	}

	return $permflags;
	}

	/**
	* Returns the delimiter that is used by the IMAP server for folder separation
	*
	* @return string Delimiter string
	*/
	public function get_hierarchy_delimiter()
	{
	return $this->delimiter;
	}

	/**
	* Get namespace
	*
	* @param string $name Namespace array index: personal, other, shared, prefix
	*
	* @return array Namespace data
	*/
	public function get_namespace($name = null)
	{
	$ns = $this->namespace;

	if ($name) {
	// an alias for BC
	if ($name == 'prefix') {
	$name = 'prefix_in';
	}

	return isset($ns[$name]) ? $ns[$name] : null;
	}

	unset($ns['prefix_in'], $ns['prefix_out']);

	return $ns;
	}

	/**
	* Sets delimiter and namespaces
	*/
	protected function set_env()
	{
	if ($this->delimiter !== null && $this->namespace !== null) {
	return;
	}

	$config = rcube::get_instance()->config;
	$imap_personal = $config->get('imap_ns_personal');
	$imap_other = $config->get('imap_ns_other');
	$imap_shared = $config->get('imap_ns_shared');
	$imap_delimiter = $config->get('imap_delimiter');

	if (!$this->check_connection()) {
	return;
	}

	$ns = $this->conn->getNamespace();

	// Set namespaces (NAMESPACE supported)
	if (is_array($ns)) {
	$this->namespace = $ns;
	}
	else {
	$this->namespace = array(
	'personal' => null,
	'other' => null,
	'shared' => null,
	);
	}

	if ($imap_delimiter) {
	$this->delimiter = $imap_delimiter;
	}
	if (empty($this->delimiter)) {
	$this->delimiter = $this->namespace['personal'][0][1];
	}
	if (empty($this->delimiter)) {
	$this->delimiter = $this->conn->getHierarchyDelimiter();
	}
	if (empty($this->delimiter)) {
	$this->delimiter = '/';
	}

	$this->list_root = null;
	$this->list_excludes = array();

	// Overwrite namespaces
	if ($imap_personal !== null) {
	$this->namespace['personal'] = null;
	foreach ((array)$imap_personal as $dir) {
	$this->namespace['personal'][] = array($dir, $this->delimiter);
	}
	}

	if ($imap_other === false) {
	foreach ((array) $this->namespace['other'] as $dir) {
	if (is_array($dir) && $dir[0]) {
	$this->list_excludes[] = $dir[0];
	}
	}

	$this->namespace['other'] = null;
	}
	else if ($imap_other !== null) {
	$this->namespace['other'] = null;
	foreach ((array)$imap_other as $dir) {
	if ($dir) {
	$this->namespace['other'][] = array($dir, $this->delimiter);
	}
	}
	}

	if ($imap_shared === false) {
	foreach ((array) $this->namespace['shared'] as $dir) {
	if (is_array($dir) && $dir[0]) {
	$this->list_excludes[] = $dir[0];
	}
	}

	$this->namespace['shared'] = null;
	}
	else if ($imap_shared !== null) {
	$this->namespace['shared'] = null;
	foreach ((array)$imap_shared as $dir) {
	if ($dir) {
	$this->namespace['shared'][] = array($dir, $this->delimiter);
	}
	}
	}

	// Performance optimization for case where we have no shared/other namespace
	// and personal namespace has one prefix (#5073)
	// In such a case we can tell the server to return only content of the
	// specified folder in LIST/LSUB, no post-filtering
	if (empty($this->namespace['other']) && empty($this->namespace['shared'])
	&& !empty($this->namespace['personal']) && count($this->namespace['personal']) === 1
	&& strlen($this->namespace['personal'][0][0]) > 1
	) {
	$this->list_root = $this->namespace['personal'][0][0];
	$this->list_excludes = array();
	}

	// Find personal namespace prefix(es) for self::mod_folder()
	if (is_array($this->namespace['personal']) && !empty($this->namespace['personal'])) {
	// There can be more than one namespace root,
	// - for prefix_out get the first one but only
	// if there is only one root
	// - for prefix_in get the first one but only
	// if there is no non-prefixed namespace root (#5403)
	$roots = array();
	foreach ($this->namespace['personal'] as $ns) {
	$roots[] = $ns[0];
	}

	if (!in_array('', $roots)) {
	$this->namespace['prefix_in'] = $roots[0];
	}
	if (count($roots) == 1) {
	$this->namespace['prefix_out'] = $roots[0];
	}
	}

	$_SESSION['imap_namespace'] = $this->namespace;
	$_SESSION['imap_delimiter'] = $this->delimiter;
	$_SESSION['imap_list_conf'] = array($this->list_root, $this->list_excludes);
	}

	/**
	* Returns IMAP server vendor name
	*
	* @return string Vendor name
	* @since 1.2
	*/
	public function get_vendor()
	{
	if ($_SESSION['imap_vendor'] !== null) {
	return $_SESSION['imap_vendor'];
	}

	$config = rcube::get_instance()->config;
	$imap_vendor = $config->get('imap_vendor');

	if ($imap_vendor) {
	return $imap_vendor;
	}

	if (!$this->check_connection()) {
	return;
	}

	if (($ident = $this->conn->data['ID']) === null && $this->get_capability('ID')) {
	$ident = $this->conn->id(array(
	'name' => 'Roundcube',
	'version' => RCUBE_VERSION,
	'php' => PHP_VERSION,
	'os' => PHP_OS,
	));
	}

	$vendor = (string) (!empty($ident) ? $ident['name'] : '');
	$ident = strtolower($vendor . ' ' . $this->conn->data['GREETING']);
	$vendors = array('cyrus', 'dovecot', 'uw-imap', 'gimap', 'hmail', 'greenmail');

	foreach ($vendors as $v) {
	if (strpos($ident, $v) !== false) {
	$vendor = $v;
	break;
	}
	}

	return $_SESSION['imap_vendor'] = $vendor;
	}

	/**
	* Get message count for a specific folder
	*
	* @param string $folder Folder name
	* @param string $mode Mode for count [ALL\|THREADS\|UNSEEN\|RECENT\|EXISTS]
	* @param boolean $force Force reading from server and update cache
	* @param boolean $status Enables storing folder status info (max UID/count),
	* required for folder_status()
	*
	* @return int Number of messages
	*/
	public function count($folder='', $mode='ALL', $force=false, $status=true)
	{
	if (!strlen($folder)) {
	$folder = $this->folder;
	}

	return $this->countmessages($folder, $mode, $force, $status);
	}

	/**
	* Protected method for getting number of messages
	*
	* @param string $folder Folder name
	* @param string $mode Mode for count [ALL\|THREADS\|UNSEEN\|RECENT\|EXISTS]
	* @param boolean $force Force reading from server and update cache
	* @param boolean $status Enables storing folder status info (max UID/count),
	* required for folder_status()
	* @param boolean $no_search Ignore current search result
	*
	* @return int Number of messages
	* @see rcube_imap::count()
	*/
	protected function countmessages($folder, $mode = 'ALL', $force = false, $status = true, $no_search = false)
	{
	$mode = strtoupper($mode);

	// Count search set, assume search set is always up-to-date (don't check $force flag)
	// @TODO: this could be handled in more reliable way, e.g. a separate method
	// maybe in rcube_imap_search
	if (!$no_search && $this->search_string && $folder == $this->folder) {
	if ($mode == 'ALL') {
	return $this->search_set->count_messages();
	}
	else if ($mode == 'THREADS') {
	return $this->search_set->count();
	}
	}

	// EXISTS is a special alias for ALL, it allows to get the number
	// of all messages in a folder also when search is active and with
	// any skip_deleted setting

	$a_folder_cache = $this->get_cache('messagecount');

	// return cached value
	- if (!$force && is_array($a_folder_cache[$folder]) && isset($a_folder_cache[$folder][$mode])) {
	+ if (!$force && isset($a_folder_cache[$folder][$mode])) {
	return $a_folder_cache[$folder][$mode];
	}

	- if (!is_array($a_folder_cache[$folder])) {
	+ if (!isset($a_folder_cache[$folder]) \|\| !is_array($a_folder_cache[$folder])) {
	$a_folder_cache[$folder] = array();
	}

	if ($mode == 'THREADS') {
	$res = $this->threads($folder);
	$count = $res->count();

	if ($status) {
	$msg_count = $res->count_messages();
	$this->set_folder_stats($folder, 'cnt', $msg_count);
	$this->set_folder_stats($folder, 'maxuid', $msg_count ? $this->id2uid($msg_count, $folder) : 0);
	}
	}
	// Need connection here
	else if (!$this->check_connection()) {
	return 0;
	}
	// RECENT count is fetched a bit different
	else if ($mode == 'RECENT') {
	$count = $this->conn->countRecent($folder);
	}
	// use SEARCH for message counting
	else if ($mode != 'EXISTS' && !empty($this->options['skip_deleted'])) {
	$search_str = "ALL UNDELETED";
	$keys = array('COUNT');

	if ($mode == 'UNSEEN') {
	$search_str .= " UNSEEN";
	}
	else {
	if ($this->messages_caching) {
	$keys[] = 'ALL';
	}
	if ($status) {
	$keys[] = 'MAX';
	}
	}

	// @TODO: if $mode == 'ALL' we could try to use cache index here

	// get message count using (E)SEARCH
	// not very performant but more precise (using UNDELETED)
	$index = $this->conn->search($folder, $search_str, true, $keys);
	$count = $index->count();

	if ($mode == 'ALL') {
	// Cache index data, will be used in index_direct()
	$this->icache['undeleted_idx'] = $index;

	if ($status) {
	$this->set_folder_stats($folder, 'cnt', $count);
	$this->set_folder_stats($folder, 'maxuid', $index->max());
	}
	}
	}
	else {
	if ($mode == 'UNSEEN') {
	$count = $this->conn->countUnseen($folder);
	}
	else {
	$count = $this->conn->countMessages($folder);
	if ($status && $mode == 'ALL') {
	$this->set_folder_stats($folder, 'cnt', $count);
	$this->set_folder_stats($folder, 'maxuid', $count ? $this->id2uid($count, $folder) : 0);
	}
	}
	}

	$count = (int) $count;

	- if ($a_folder_cache[$folder][$mode] !== $count) {
	+ if (!isset($a_folder_cache[$folder][$mode]) \|\| $a_folder_cache[$folder][$mode] !== $count) {
	$a_folder_cache[$folder][$mode] = $count;

	// write back to cache
	$this->update_cache('messagecount', $a_folder_cache);
	}

	return $count;
	}

	/**
	* Public method for listing message flags
	*
	* @param string $folder Folder name
	* @param array $uids Message UIDs
	* @param int $mod_seq Optional MODSEQ value (of last flag update)
	*
	* @return array Indexed array with message flags
	*/
	public function list_flags($folder, $uids, $mod_seq = null)
	{
	if (!strlen($folder)) {
	$folder = $this->folder;
	}

	if (!$this->check_connection()) {
	return array();
	}

	// @TODO: when cache was synchronized in this request
	// we might already have asked for flag updates, use it.

	$flags = $this->conn->fetch($folder, $uids, true, array('FLAGS'), $mod_seq);
	$result = array();

	if (!empty($flags)) {
	foreach ($flags as $message) {
	$result[$message->uid] = $message->flags;
	}
	}

	return $result;
	}

	/**
	* Public method for listing headers
	*
	* @param string $folder Folder name
	* @param int $page Current page to list
	* @param string $sort_field Header field to sort by
	* @param string $sort_order Sort order [ASC\|DESC]
	* @param int $slice Number of slice items to extract from result array
	*
	* @return array Indexed array with message header objects
	*/
	public function list_messages($folder='', $page=NULL, $sort_field=NULL, $sort_order=NULL, $slice=0)
	{
	if (!strlen($folder)) {
	$folder = $this->folder;
	}

	return $this->_list_messages($folder, $page, $sort_field, $sort_order, $slice);
	}

	/**
	* protected method for listing message headers
	*
	* @param string $folder Folder name
	* @param int $page Current page to list
	* @param string $sort_field Header field to sort by
	* @param string $sort_order Sort order [ASC\|DESC]
	* @param int $slice Number of slice items to extract from result array
	*
	* @return array Indexed array with message header objects
	* @see rcube_imap::list_messages
	*/
	protected function _list_messages($folder='', $page=NULL, $sort_field=NULL, $sort_order=NULL, $slice=0)
	{
	if (!strlen($folder)) {
	return array();
	}

	$this->set_sort_order($sort_field, $sort_order);
	$page = $page ? $page : $this->list_page;

	// use saved message set
	if ($this->search_string) {
	return $this->list_search_messages($folder, $page, $slice);
	}

	if ($this->threading) {
	return $this->list_thread_messages($folder, $page, $slice);
	}

	// get UIDs of all messages in the folder, sorted
	$index = $this->index($folder, $this->sort_field, $this->sort_order);

	if ($index->is_empty()) {
	return array();
	}

	$from = ($page-1) * $this->page_size;
	$to = $from + $this->page_size;

	$index->slice($from, $to - $from);

	if ($slice) {
	$index->slice(-$slice, $slice);
	}

	// fetch reqested messages headers
	$a_index = $index->get();
	$a_msg_headers = $this->fetch_headers($folder, $a_index);

	return array_values($a_msg_headers);
	}

	/**
	* protected method for listing message headers using threads
	*
	* @param string $folder Folder name
	* @param int $page Current page to list
	* @param int $slice Number of slice items to extract from result array
	*
	* @return array Indexed array with message header objects
	* @see rcube_imap::list_messages
	*/
	protected function list_thread_messages($folder, $page, $slice=0)
	{
	// get all threads (not sorted)
	if ($mcache = $this->get_mcache_engine()) {
	$threads = $mcache->get_thread($folder);
	}
	else {
	$threads = $this->threads($folder);
	}

	return $this->fetch_thread_headers($folder, $threads, $page, $slice);
	}

	/**
	* Method for fetching threads data
	*
	* @param string $folder Folder name
	*
	* @return rcube_imap_thread Thread data object
	*/
	function threads($folder)
	{
	if ($mcache = $this->get_mcache_engine()) {
	// don't store in self's internal cache, cache has it's own internal cache
	return $mcache->get_thread($folder);
	}

	if (!empty($this->icache['threads'])) {
	if ($this->icache['threads']->get_parameters('MAILBOX') == $folder) {
	return $this->icache['threads'];
	}
	}

	// get all threads
	$result = $this->threads_direct($folder);

	// add to internal (fast) cache
	return $this->icache['threads'] = $result;
	}

	/**
	* Method for direct fetching of threads data
	*
	* @param string $folder Folder name
	*
	* @return rcube_imap_thread Thread data object
	*/
	function threads_direct($folder)
	{
	if (!$this->check_connection()) {
	return new rcube_result_thread();
	}

	// get all threads
	return $this->conn->thread($folder, $this->threading,
	$this->options['skip_deleted'] ? 'UNDELETED' : '', true);
	}

	/**
	* protected method for fetching threaded messages headers
	*
	* @param string $folder Folder name
	* @param rcube_result_thread $threads Threads data object
	* @param int $page List page number
	* @param int $slice Number of threads to slice
	*
	* @return array Messages headers
	*/
	protected function fetch_thread_headers($folder, $threads, $page, $slice=0)
	{
	// Sort thread structure
	$this->sort_threads($threads);

	$from = ($page-1) * $this->page_size;
	$to = $from + $this->page_size;

	$threads->slice($from, $to - $from);

	if ($slice) {
	$threads->slice(-$slice, $slice);
	}

	// Get UIDs of all messages in all threads
	$a_index = $threads->get();

	// fetch reqested headers from server
	$a_msg_headers = $this->fetch_headers($folder, $a_index);

	unset($a_index);

	// Set depth, has_children and unread_children fields in headers
	$this->set_thread_flags($a_msg_headers, $threads);

	return array_values($a_msg_headers);
	}

	/**
	* protected method for setting threaded messages flags:
	* depth, has_children, unread_children, flagged_children
	*
	* @param array $headers Reference to headers array indexed by message UID
	* @param rcube_result_thread $threads Threads data object
	*
	* @return array Message headers array indexed by message UID
	*/
	protected function set_thread_flags(&$headers, $threads)
	{
	$parents = array();

	list ($msg_depth, $msg_children) = $threads->get_thread_data();

	foreach ($headers as $uid => $header) {
	$depth = $msg_depth[$uid];
	$parents = array_slice($parents, 0, $depth);

	if (!empty($parents)) {
	$headers[$uid]->parent_uid = end($parents);
	if (empty($header->flags['SEEN'])) {
	$headers[$parents[0]]->unread_children++;
	}
	if (!empty($header->flags['FLAGGED'])) {
	$headers[$parents[0]]->flagged_children++;
	}
	}
	array_push($parents, $uid);

	$headers[$uid]->depth = $depth;
	$headers[$uid]->has_children = $msg_children[$uid];
	}
	}

	/**
	* A protected method for listing a set of message headers (search results)
	*
	* @param string $folder Folder name
	* @param int $page Current page to list
	* @param int $slice Number of slice items to extract from the result array
	*
	* @return array Indexed array with message header objects
	*/
	protected function list_search_messages($folder, $page, $slice = 0)
	{
	if (!strlen($folder) \|\| empty($this->search_set) \|\| $this->search_set->is_empty()) {
	return array();
	}

	$from = ($page-1) * $this->page_size;

	// gather messages from a multi-folder search
	if ($this->search_set->multi) {
	$page_size = $this->page_size;
	$sort_field = $this->sort_field;
	$search_set = $this->search_set;

	// fetch resultset headers, sort and slice them
	if (!empty($sort_field) && $search_set->get_parameters('SORT') != $sort_field) {
	$this->sort_field = null;
	$this->page_size = 1000; // fetch up to 1000 matching messages per folder
	$this->threading = false;

	$a_msg_headers = array();
	foreach ($search_set->sets as $resultset) {
	if (!$resultset->is_empty()) {
	$this->search_set = $resultset;
	$this->search_threads = $resultset instanceof rcube_result_thread;

	$a_headers = $this->list_search_messages($resultset->get_parameters('MAILBOX'), 1);
	$a_msg_headers = array_merge($a_msg_headers, $a_headers);
	unset($a_headers);
	}
	}

	// sort headers
	if (!empty($a_msg_headers)) {
	$a_msg_headers = rcube_imap_generic::sortHeaders($a_msg_headers, $sort_field, $this->sort_order);
	}

	// store (sorted) message index
	$search_set->set_message_index($a_msg_headers, $sort_field, $this->sort_order);

	// only return the requested part of the set
	$a_msg_headers = array_slice(array_values($a_msg_headers), $from, $page_size);
	}
	else {
	if ($this->sort_order != $search_set->get_parameters('ORDER')) {
	$search_set->revert();
	}

	// slice resultset first...
	$index = array_slice($search_set->get(), $from, $page_size);
	$fetch = array();

	foreach ($index as $msg_id) {
	list($uid, $folder) = explode('-', $msg_id, 2);
	$fetch[$folder][] = $uid;
	}

	// ... and fetch the requested set of headers
	$a_msg_headers = array();
	foreach ($fetch as $folder => $a_index) {
	$a_msg_headers = array_merge($a_msg_headers, array_values($this->fetch_headers($folder, $a_index)));
	}

	// Re-sort the result according to the original search set order
	usort($a_msg_headers, function($a, $b) use ($index) {
	return array_search($a->uid . '-' . $a->folder, $index) - array_search($b->uid . '-' . $b->folder, $index);
	});
	}

	if ($slice) {
	$a_msg_headers = array_slice($a_msg_headers, -$slice, $slice);
	}

	// restore members
	$this->sort_field = $sort_field;
	$this->page_size = $page_size;
	$this->search_set = $search_set;

	return $a_msg_headers;
	}

	// use saved messages from searching
	if ($this->threading) {
	return $this->list_search_thread_messages($folder, $page, $slice);
	}

	// search set is threaded, we need a new one
	if ($this->search_threads) {
	$this->search('', $this->search_string, $this->search_charset, $this->sort_field);
	}

	$index = clone $this->search_set;

	// return empty array if no messages found
	if ($index->is_empty()) {
	return array();
	}

	// quickest method (default sorting)
	if (!$this->search_sort_field && !$this->sort_field) {
	$got_index = true;
	}
	// sorted messages, so we can first slice array and then fetch only wanted headers
	else if ($this->search_sorted) { // SORT searching result
	$got_index = true;
	// reset search set if sorting field has been changed
	if ($this->sort_field && $this->search_sort_field != $this->sort_field) {
	$this->search('', $this->search_string, $this->search_charset, $this->sort_field);

	$index = clone $this->search_set;

	// return empty array if no messages found
	if ($index->is_empty()) {
	return array();
	}
	}
	}

	if (!empty($got_index)) {
	if ($this->sort_order != $index->get_parameters('ORDER')) {
	$index->revert();
	}

	// get messages uids for one page
	$index->slice($from, $this->page_size);

	if ($slice) {
	$index->slice(-$slice, $slice);
	}

	// fetch headers
	$a_index = $index->get();
	$a_msg_headers = $this->fetch_headers($folder, $a_index);

	return array_values($a_msg_headers);
	}

	// SEARCH result, need sorting
	$cnt = $index->count();

	// 300: experimantal value for best result
	if (($cnt > 300 && $cnt > $this->page_size) \|\| !$this->sort_field) {
	// use memory less expensive (and quick) method for big result set
	$index = clone $this->index('', $this->sort_field, $this->sort_order);
	// get messages uids for one page...
	$index->slice($from, $this->page_size);

	if ($slice) {
	$index->slice(-$slice, $slice);
	}

	// ...and fetch headers
	$a_index = $index->get();
	$a_msg_headers = $this->fetch_headers($folder, $a_index);

	return array_values($a_msg_headers);
	}
	else {
	// for small result set we can fetch all messages headers
	$a_index = $index->get();
	$a_msg_headers = $this->fetch_headers($folder, $a_index, false);

	// return empty array if no messages found
	if (!is_array($a_msg_headers) \|\| empty($a_msg_headers)) {
	return array();
	}

	// if not already sorted
	$a_msg_headers = rcube_imap_generic::sortHeaders(
	$a_msg_headers, $this->sort_field, $this->sort_order);

	$a_msg_headers = array_slice(array_values($a_msg_headers), $from, $this->page_size);

	if ($slice) {
	$a_msg_headers = array_slice($a_msg_headers, -$slice, $slice);
	}

	return $a_msg_headers;
	}
	}

	/**
	* protected method for listing a set of threaded message headers (search results)
	*
	* @param string $folder Folder name
	* @param int $page Current page to list
	* @param int $slice Number of slice items to extract from result array
	*
	* @return array Indexed array with message header objects
	* @see rcube_imap::list_search_messages()
	*/
	protected function list_search_thread_messages($folder, $page, $slice=0)
	{
	// update search_set if previous data was fetched with disabled threading
	if (!$this->search_threads) {
	if ($this->search_set->is_empty()) {
	return array();
	}
	$this->search('', $this->search_string, $this->search_charset, $this->sort_field);
	}

	return $this->fetch_thread_headers($folder, clone $this->search_set, $page, $slice);
	}

	/**
	* Fetches messages headers (by UID)
	*
	* @param string $folder Folder name
	* @param array $msgs Message UIDs
	* @param bool $sort Enables result sorting by $msgs
	* @param bool $force Disables cache use
	*
	* @return array Messages headers indexed by UID
	*/
	function fetch_headers($folder, $msgs, $sort = true, $force = false)
	{
	if (empty($msgs)) {
	return array();
	}

	if (!$force && ($mcache = $this->get_mcache_engine())) {
	$headers = $mcache->get_messages($folder, $msgs);
	}
	else if (!$this->check_connection()) {
	return array();
	}
	else {
	// fetch reqested headers from server
	$headers = $this->conn->fetchHeaders(
	$folder, $msgs, true, false, $this->get_fetch_headers());
	}

	if (empty($headers)) {
	return array();
	}

	$msg_headers = array();
	foreach ($headers as $h) {
	$h->folder = $folder;
	$msg_headers[$h->uid] = $h;
	}

	if ($sort) {
	// use this class for message sorting
	$sorter = new rcube_message_header_sorter();
	$sorter->set_index($msgs);
	$sorter->sort_headers($msg_headers);
	}

	return $msg_headers;
	}

	/**
	* Returns current status of a folder (compared to the last time use)
	*
	* We compare the maximum UID to determine the number of
	* new messages because the RECENT flag is not reliable.
	*
	* @param string $folder Folder name
	* @param array $diff Difference data
	*
	* @return int Folder status
	*/
	public function folder_status($folder = null, &$diff = array())
	{
	if (!strlen($folder)) {
	$folder = $this->folder;
	}
	$old = $this->get_folder_stats($folder);

	// refresh message count -> will update
	$this->countmessages($folder, 'ALL', true, true, true);

	$result = 0;

	if (empty($old)) {
	return $result;
	}

	$new = $this->get_folder_stats($folder);

	// got new messages
	if ($new['maxuid'] > $old['maxuid']) {
	$result += 1;
	// get new message UIDs range, that can be used for example
	// to get the data of these messages
	$diff['new'] = ($old['maxuid'] + 1 < $new['maxuid'] ? ($old['maxuid']+1).':' : '') . $new['maxuid'];
	}
	// some messages has been deleted
	if ($new['cnt'] < $old['cnt']) {
	$result += 2;
	}

	// @TODO: optional checking for messages flags changes (?)
	// @TODO: UIDVALIDITY checking

	return $result;
	}

	/**
	* Stores folder statistic data in session
	* @TODO: move to separate DB table (cache?)
	*
	* @param string $folder Folder name
	* @param string $name Data name
	* @param mixed $data Data value
	*/
	protected function set_folder_stats($folder, $name, $data)
	{
	$_SESSION['folders'][$folder][$name] = $data;
	}

	/**
	* Gets folder statistic data
	*
	* @param string $folder Folder name
	*
	* @return array Stats data
	*/
	protected function get_folder_stats($folder)
	{
	- if ($_SESSION['folders'][$folder]) {
	+ if (isset($_SESSION['folders'][$folder])) {
	return (array) $_SESSION['folders'][$folder];
	}

	return array();
	}

	/**
	* Return sorted list of message UIDs
	*
	* @param string $folder Folder to get index from
	* @param string $sort_field Sort column
	* @param string $sort_order Sort order [ASC, DESC]
	* @param bool $no_threads Get not threaded index
	* @param bool $no_search Get index not limited to search result (optionally)
	*
	* @return rcube_result_index\|rcube_result_thread List of messages (UIDs)
	*/
	public function index($folder = '', $sort_field = NULL, $sort_order = NULL,
	$no_threads = false, $no_search = false
	) {
	if (!$no_threads && $this->threading) {
	return $this->thread_index($folder, $sort_field, $sort_order);
	}

	$this->set_sort_order($sort_field, $sort_order);

	if (!strlen($folder)) {
	$folder = $this->folder;
	}

	// we have a saved search result, get index from there
	if ($this->search_string) {
	if ($this->search_set->is_empty()) {
	return new rcube_result_index($folder, '* SORT');
	}

	if ($this->search_set instanceof rcube_result_multifolder) {
	$index = $this->search_set;
	$index->folder = $folder;
	// TODO: handle changed sorting
	}
	// search result is an index with the same sorting?
	else if (($this->search_set instanceof rcube_result_index)
	&& ((!$this->sort_field && !$this->search_sorted) \|\|
	($this->search_sorted && $this->search_sort_field == $this->sort_field))
	) {
	$index = $this->search_set;
	}
	// $no_search is enabled when we are not interested in
	// fetching index for search result, e.g. to sort
	// threaded search result we can use full mailbox index.
	// This makes possible to use index from cache
	else if (!$no_search) {
	if (!$this->sort_field) {
	// No sorting needed, just build index from the search result
	// @TODO: do we need to sort by UID here?
	$search = $this->search_set->get_compressed();
	$index = new rcube_result_index($folder, '* ESEARCH ALL ' . $search);
	}
	else {
	$index = $this->index_direct($folder, $this->sort_field, $this->sort_order, $this->search_set);
	}
	}

	if (isset($index)) {
	if ($this->sort_order != $index->get_parameters('ORDER')) {
	$index->revert();
	}

	return $index;
	}
	}

	// check local cache
	if ($mcache = $this->get_mcache_engine()) {
	return $mcache->get_index($folder, $this->sort_field, $this->sort_order);
	}

	// fetch from IMAP server
	return $this->index_direct($folder, $this->sort_field, $this->sort_order);
	}

	/**
	* Return sorted list of message UIDs ignoring current search settings.
	* Doesn't uses cache by default.
	*
	* @param string $folder Folder to get index from
	* @param string $sort_field Sort column
	* @param string $sort_order Sort order [ASC, DESC]
	* @param rcube_result_* $search Optional messages set to limit the result
	*
	* @return rcube_result_index Sorted list of message UIDs
	*/
	public function index_direct($folder, $sort_field = null, $sort_order = null, $search = null)
	{
	if (!empty($search)) {
	$search = $search->get_compressed();
	}

	// use message index sort as default sorting
	if (!$sort_field) {
	// use search result from count() if possible
	if (empty($search) && $this->options['skip_deleted']
	&& !empty($this->icache['undeleted_idx'])
	&& $this->icache['undeleted_idx']->get_parameters('ALL') !== null
	&& $this->icache['undeleted_idx']->get_parameters('MAILBOX') == $folder
	) {
	$index = $this->icache['undeleted_idx'];
	}
	else if (!$this->check_connection()) {
	return new rcube_result_index();
	}
	else {
	$query = $this->options['skip_deleted'] ? 'UNDELETED' : '';
	if ($search) {
	$query = trim($query . ' UID ' . $search);
	}

	$index = $this->conn->search($folder, $query, true);
	}
	}
	else if (!$this->check_connection()) {
	return new rcube_result_index();
	}
	// fetch complete message index
	else {
	if ($this->get_capability('SORT')) {
	$query = $this->options['skip_deleted'] ? 'UNDELETED' : '';
	if ($search) {
	$query = trim($query . ' UID ' . $search);
	}

	$index = $this->conn->sort($folder, $sort_field, $query, true);
	}

	if (empty($index) \|\| $index->is_error()) {
	$index = $this->conn->index($folder, $search ? $search : "1:*",
	$sort_field, $this->options['skip_deleted'],
	$search ? true : false, true);
	}
	}

	if ($sort_order != $index->get_parameters('ORDER')) {
	$index->revert();
	}

	return $index;
	}

	/**
	* Return index of threaded message UIDs
	*
	* @param string $folder Folder to get index from
	* @param string $sort_field Sort column
	* @param string $sort_order Sort order [ASC, DESC]
	*
	* @return rcube_result_thread Message UIDs
	*/
	public function thread_index($folder='', $sort_field=NULL, $sort_order=NULL)
	{
	if (!strlen($folder)) {
	$folder = $this->folder;
	}

	// we have a saved search result, get index from there
	if ($this->search_string && $this->search_threads && $folder == $this->folder) {
	$threads = $this->search_set;
	}
	else {
	// get all threads (default sort order)
	$threads = $this->threads($folder);
	}

	$this->set_sort_order($sort_field, $sort_order);
	$this->sort_threads($threads);

	return $threads;
	}

	/**
	* Sort threaded result, using THREAD=REFS method if available.
	* If not, use any method and re-sort the result in THREAD=REFS way.
	*
	* @param rcube_result_thread $threads Threads result set
	*/
	protected function sort_threads($threads)
	{
	if ($threads->is_empty()) {
	return;
	}

	// THREAD=ORDEREDSUBJECT: sorting by sent date of root message
	// THREAD=REFERENCES: sorting by sent date of root message
	// THREAD=REFS: sorting by the most recent date in each thread

	if ($this->threading != 'REFS' \|\| ($this->sort_field && $this->sort_field != 'date')) {
	$sortby = $this->sort_field ? $this->sort_field : 'date';
	$index = $this->index($this->folder, $sortby, $this->sort_order, true, true);

	if (!$index->is_empty()) {
	$threads->sort($index);
	}
	}
	else if ($this->sort_order != $threads->get_parameters('ORDER')) {
	$threads->revert();
	}
	}

	/**
	* Invoke search request to IMAP server
	*
	* @param string $folder Folder name to search in
	* @param string $search Search criteria
	* @param string $charset Search charset
	* @param string $sort_field Header field to sort by
	*
	* @return rcube_result_index Search result object
	* @todo: Search criteria should be provided in non-IMAP format, eg. array
	*/
	public function search($folder = '', $search = 'ALL', $charset = null, $sort_field = null)
	{
	if (!$search) {
	$search = 'ALL';
	}

	if ((is_array($folder) && empty($folder)) \|\| (!is_array($folder) && !strlen($folder))) {
	$folder = $this->folder;
	}

	$plugin = $this->plugins->exec_hook('imap_search_before', array(
	'folder' => $folder,
	'search' => $search,
	'charset' => $charset,
	'sort_field' => $sort_field,
	'threading' => $this->threading,
	));

	$folder = $plugin['folder'];
	$search = $plugin['search'];
	$charset = $plugin['charset'];
	$sort_field = $plugin['sort_field'];
	$results = $plugin['result'];

	// multi-folder search
	if (!$results && is_array($folder) && count($folder) > 1 && $search != 'ALL') {
	// connect IMAP to have all the required classes and settings loaded
	$this->check_connection();

	// disable threading
	$this->threading = false;

	$searcher = new rcube_imap_search($this->options, $this->conn);

	// set limit to not exceed the client's request timeout
	$searcher->set_timelimit(60);

	// continue existing incomplete search
	if (!empty($this->search_set) && $this->search_set->incomplete && $search == $this->search_string) {
	$searcher->set_results($this->search_set);
	}

	// execute the search
	$results = $searcher->exec(
	$folder,
	$search,
	$charset ? $charset : $this->default_charset,
	$sort_field && $this->get_capability('SORT') ? $sort_field : null,
	$this->threading
	);
	}
	else if (!$results) {
	$folder = is_array($folder) ? $folder[0] : $folder;
	$search = is_array($search) ? $search[$folder] : $search;
	$results = $this->search_index($folder, $search, $charset, $sort_field);
	}

	$sorted = $this->threading \|\| $this->search_sorted \|\| $plugin['search_sorted'] ? true : false;

	$this->set_search_set(array($search, $results, $charset, $sort_field, $sorted));

	return $results;
	}

	/**
	* Direct (real and simple) SEARCH request (without result sorting and caching).
	*
	* @param string $mailbox Mailbox name to search in
	* @param string $str Search string
	*
	* @return rcube_result_index Search result (UIDs)
	*/
	public function search_once($folder = null, $str = 'ALL')
	{
	if (!$this->check_connection()) {
	return new rcube_result_index();
	}

	if (!$str) {
	$str = 'ALL';
	}

	// multi-folder search
	if (is_array($folder) && count($folder) > 1) {
	$searcher = new rcube_imap_search($this->options, $this->conn);
	$index = $searcher->exec($folder, $str, $this->default_charset);
	}
	else {
	$folder = is_array($folder) ? $folder[0] : $folder;
	if (!strlen($folder)) {
	$folder = $this->folder;
	}
	$index = $this->conn->search($folder, $str, true);
	}

	return $index;
	}

	/**
	* protected search method
	*
	* @param string $folder Folder name
	* @param string $criteria Search criteria
	* @param string $charset Charset
	* @param string $sort_field Sorting field
	*
	* @return rcube_result_index\|rcube_result_thread Search results (UIDs)
	* @see rcube_imap::search()
	*/
	protected function search_index($folder, $criteria='ALL', $charset=NULL, $sort_field=NULL)
	{
	if (!$this->check_connection()) {
	if ($this->threading) {
	return new rcube_result_thread();
	}
	else {
	return new rcube_result_index();
	}
	}

	if ($this->options['skip_deleted'] && !preg_match('/UNDELETED/', $criteria)) {
	$criteria = 'UNDELETED '.$criteria;
	}

	// unset CHARSET if criteria string is ASCII, this way
	// SEARCH won't be re-sent after "unsupported charset" response
	if ($charset && $charset != 'US-ASCII' && is_ascii($criteria)) {
	$charset = 'US-ASCII';
	}

	if ($this->threading) {
	$threads = $this->conn->thread($folder, $this->threading, $criteria, true, $charset);

	// Error, try with US-ASCII (RFC5256: SORT/THREAD must support US-ASCII and UTF-8,
	// but I've seen that Courier doesn't support UTF-8)
	if ($threads->is_error() && $charset && $charset != 'US-ASCII') {
	$threads = $this->conn->thread($folder, $this->threading,
	self::convert_criteria($criteria, $charset), true, 'US-ASCII');
	}

	return $threads;
	}

	if ($sort_field && $this->get_capability('SORT')) {
	$charset = $charset ? $charset : $this->default_charset;
	$messages = $this->conn->sort($folder, $sort_field, $criteria, true, $charset);

	// Error, try with US-ASCII (RFC5256: SORT/THREAD must support US-ASCII and UTF-8,
	// but I've seen Courier with disabled UTF-8 support)
	if ($messages->is_error() && $charset && $charset != 'US-ASCII') {
	$messages = $this->conn->sort($folder, $sort_field,
	self::convert_criteria($criteria, $charset), true, 'US-ASCII');
	}

	if (!$messages->is_error()) {
	$this->search_sorted = true;
	return $messages;
	}
	}

	$messages = $this->conn->search($folder,
	($charset && $charset != 'US-ASCII' ? "CHARSET $charset " : '') . $criteria, true);

	// Error, try with US-ASCII (some servers may support only US-ASCII)
	if ($messages->is_error() && $charset && $charset != 'US-ASCII') {
	$messages = $this->conn->search($folder,
	self::convert_criteria($criteria, $charset), true);
	}

	$this->search_sorted = false;

	return $messages;
	}

	/**
	* Converts charset of search criteria string
	*
	* @param string $str Search string
	* @param string $charset Original charset
	* @param string $dest_charset Destination charset (default US-ASCII)
	*
	* @return string Search string
	*/
	public static function convert_criteria($str, $charset, $dest_charset='US-ASCII')
	{
	// convert strings to US_ASCII
	if (preg_match_all('/\{([0-9]+)\}\r\n/', $str, $matches, PREG_OFFSET_CAPTURE)) {
	$last = 0; $res = '';
	foreach ($matches[1] as $m) {
	$string_offset = $m[1] + strlen($m[0]) + 4; // {}\r\n
	$string = substr($str, $string_offset - 1, $m[0]);
	$string = rcube_charset::convert($string, $charset, $dest_charset);

	if ($string === false \|\| !strlen($string)) {
	continue;
	}

	$res .= substr($str, $last, $m[1] - $last - 1) . rcube_imap_generic::escape($string);
	$last = $m[0] + $string_offset - 1;
	}

	if ($last < strlen($str)) {
	$res .= substr($str, $last, strlen($str)-$last);
	}
	}
	// strings for conversion not found
	else {
	$res = $str;
	}

	return $res;
	}

	/**
	* Refresh saved search set
	*
	* @return array Current search set
	*/
	public function refresh_search()
	{
	if (!empty($this->search_string)) {
	$this->search(
	is_object($this->search_set) ? $this->search_set->get_parameters('MAILBOX') : '',
	$this->search_string,
	$this->search_charset,
	$this->search_sort_field
	);
	}

	return $this->get_search_set();
	}

	/**
	* Flag certain result subsets as 'incomplete'.
	* For subsequent refresh_search() calls to only refresh the updated parts.
	*/
	protected function set_search_dirty($folder)
	{
	if ($this->search_set && is_a($this->search_set, 'rcube_result_multifolder')) {
	if ($subset = $this->search_set->get_set($folder)) {
	$subset->incomplete = $this->search_set->incomplete = true;
	}
	}
	}

	/**
	* Return message headers object of a specific message
	*
	* @param int $id Message UID
	* @param string $folder Folder to read from
	* @param bool $force True to skip cache
	*
	* @return rcube_message_header Message headers
	*/
	public function get_message_headers($uid, $folder = null, $force = false)
	{
	// decode combined UID-folder identifier
	if (preg_match('/^\d+-.+/', $uid)) {
	list($uid, $folder) = explode('-', $uid, 2);
	}

	if (!strlen($folder)) {
	$folder = $this->folder;
	}

	// get cached headers
	if (!$force && $uid && ($mcache = $this->get_mcache_engine())) {
	$headers = $mcache->get_message($folder, $uid);
	}
	else if (!$this->check_connection()) {
	$headers = false;
	}
	else {
	$headers = $this->conn->fetchHeader(
	$folder, $uid, true, true, $this->get_fetch_headers());

	if (is_object($headers))
	$headers->folder = $folder;
	}

	return $headers;
	}

	/**
	* Fetch message headers and body structure from the IMAP server and build
	* an object structure.
	*
	* @param int $uid Message UID to fetch
	* @param string $folder Folder to read from
	*
	* @return object rcube_message_header Message data
	*/
	public function get_message($uid, $folder = null)
	{
	if (!strlen($folder)) {
	$folder = $this->folder;
	}

	// decode combined UID-folder identifier
	if (preg_match('/^\d+-.+/', $uid)) {
	list($uid, $folder) = explode('-', $uid, 2);
	}

	// Check internal cache
	if (!empty($this->icache['message']) && ($headers = $this->icache['message'])) {
	// Make sure the folder and UID is what we expect.
	// In case when the same process works with folders that are personal
	// and shared two folders can contain the same UIDs.
	if ($headers->uid == $uid && $headers->folder == $folder) {
	return $headers;
	}
	}

	$headers = $this->get_message_headers($uid, $folder);

	// message doesn't exist?
	if (empty($headers)) {
	return null;
	}

	// structure might be cached
	if (!empty($headers->structure)) {
	return $headers;
	}

	$this->msg_uid = $uid;

	if (!$this->check_connection()) {
	return $headers;
	}

	if (empty($headers->bodystructure)) {
	$headers->bodystructure = $this->conn->getStructure($folder, $uid, true);
	}

	$structure = $headers->bodystructure;

	if (empty($structure)) {
	return $headers;
	}

	// set message charset from message headers
	if ($headers->charset) {
	$this->struct_charset = $headers->charset;
	}
	else {
	$this->struct_charset = $this->structure_charset($structure);
	}

	$headers->ctype = @strtolower($headers->ctype);

	// Here we can recognize malformed BODYSTRUCTURE and
	// 1. [@TODO] parse the message in other way to create our own message structure
	// 2. or just show the raw message body.
	// Example of structure for malformed MIME message:
	// ("text" "plain" NIL NIL NIL "7bit" 2154 70 NIL NIL NIL)
	if ($headers->ctype && !is_array($structure[0]) && $headers->ctype != 'text/plain'
	&& strtolower($structure[0].'/'.$structure[1]) == 'text/plain'
	) {
	// A special known case "Content-type: text" (#1488968)
	if ($headers->ctype == 'text') {
	$structure[1] = 'plain';
	$headers->ctype = 'text/plain';
	}
	// we can handle single-part messages, by simple fix in structure (#1486898)
	else if (preg_match('/^(text\|application)\/(.*)/', $headers->ctype, $m)) {
	$structure[0] = $m[1];
	$structure[1] = $m[2];
	}
	else {
	// Try to parse the message using rcube_mime_decode.
	// We need a better solution, it parses message
	// in memory, which wouldn't work for very big messages,
	// (it uses up to 10x more memory than the message size)
	// it's also buggy and not actively developed
	if ($headers->size && rcube_utils::mem_check($headers->size * 10)) {
	$raw_msg = $this->get_raw_body($uid);
	$struct = rcube_mime::parse_message($raw_msg);
	}
	else {
	return $headers;
	}
	}
	}

	if (empty($struct)) {
	$struct = $this->structure_part($structure, 0, '', $headers);
	}

	// some workarounds on simple messages...
	if (empty($struct->parts)) {
	// ...don't trust given content-type
	if (!empty($headers->ctype)) {
	$struct->mime_id = '1';
	$struct->mimetype = strtolower($headers->ctype);
	list($struct->ctype_primary, $struct->ctype_secondary) = explode('/', $struct->mimetype);
	}

	// ...and charset (there's a case described in #1488968 where invalid content-type
	// results in invalid charset in BODYSTRUCTURE)
	if (!empty($headers->charset) && $headers->charset != $struct->ctype_parameters['charset']) {
	$struct->charset = $headers->charset;
	$struct->ctype_parameters['charset'] = $headers->charset;
	}
	}

	$headers->structure = $struct;

	return $this->icache['message'] = $headers;
	}

	/**
	* Build message part object
	*
	* @param array $part
	* @param int $count
	* @param string $parent
	*/
	protected function structure_part($part, $count = 0, $parent = '', $mime_headers = null)
	{
	$struct = new rcube_message_part;
	$struct->mime_id = empty($parent) ? (string)$count : "$parent.$count";

	// multipart
	if (is_array($part[0])) {
	$struct->ctype_primary = 'multipart';

	/* RFC3501: BODYSTRUCTURE fields of multipart part
	part1 array
	part2 array
	part3 array
	....
	1. subtype
	2. parameters (optional)
	3. description (optional)
	4. language (optional)
	5. location (optional)
	*/

	// find first non-array entry
	for ($i=1; $i<count($part); $i++) {
	if (!is_array($part[$i])) {
	$struct->ctype_secondary = strtolower($part[$i]);

	// read content type parameters
	if (is_array($part[$i+1])) {
	$struct->ctype_parameters = array();
	for ($j=0; $j<count($part[$i+1]); $j+=2) {
	$param = strtolower($part[$i+1][$j]);
	$struct->ctype_parameters[$param] = $part[$i+1][$j+1];
	}
	}

	break;
	}
	}

	$struct->mimetype = 'multipart/'.$struct->ctype_secondary;

	// build parts list for headers pre-fetching
	for ($i=0; $i<count($part); $i++) {
	// fetch message headers if message/rfc822 or named part
	if (is_array($part[$i]) && !is_array($part[$i][0])) {
	$tmp_part_id = $struct->mime_id ? $struct->mime_id.'.'.($i+1) : $i+1;
	if (strtolower($part[$i][0]) == 'message' && strtolower($part[$i][1]) == 'rfc822') {
	$mime_part_headers[] = $tmp_part_id;
	}
	else if (!empty($part[$i][2]) && empty($part[$i][3])) {
	$params = array_map('strtolower', (array) $part[$i][2]);
	$find = array('name', 'filename', 'name', 'filename', 'name0', 'filename0', 'name0', 'filename0');

	// In case of malformed header check disposition. E.g. some servers for
	// "Content-Type: PDF; name=test.pdf" may return text/plain and ignore name argument
	if (count(array_intersect($params, $find)) > 0
	\|\| (is_array($part[$i][9]) && stripos($part[$i][9][0], 'attachment') === 0)
	) {
	$mime_part_headers[] = $tmp_part_id;
	}
	}
	}
	}

	// pre-fetch headers of all parts (in one command for better performance)
	// @TODO: we could do this before _structure_part() call, to fetch
	// headers for parts on all levels
	if (!empty($mime_part_headers)) {
	$mime_part_headers = $this->conn->fetchMIMEHeaders($this->folder,
	$this->msg_uid, $mime_part_headers);
	}

	$struct->parts = array();
	for ($i=0, $count=0; $i<count($part); $i++) {
	if (!is_array($part[$i])) {
	break;
	}
	$tmp_part_id = $struct->mime_id ? $struct->mime_id.'.'.($i+1) : $i+1;
	$struct->parts[] = $this->structure_part($part[$i], ++$count, $struct->mime_id,
	!empty($mime_part_headers[$tmp_part_id]) ? $mime_part_headers[$tmp_part_id] : null);
	}

	return $struct;
	}

	/* RFC3501: BODYSTRUCTURE fields of non-multipart part
	0. type
	1. subtype
	2. parameters
	3. id
	4. description
	5. encoding
	6. size
	-- text
	7. lines
	-- message/rfc822
	7. envelope structure
	8. body structure
	9. lines
	--
	x. md5 (optional)
	x. disposition (optional)
	x. language (optional)
	x. location (optional)
	*/

	// regular part
	$struct->ctype_primary = strtolower($part[0]);
	$struct->ctype_secondary = strtolower($part[1]);
	$struct->mimetype = $struct->ctype_primary.'/'.$struct->ctype_secondary;

	// read content type parameters
	if (is_array($part[2])) {
	$struct->ctype_parameters = array();
	for ($i=0; $i<count($part[2]); $i+=2) {
	$struct->ctype_parameters[strtolower($part[2][$i])] = $part[2][$i+1];
	}

	if (isset($struct->ctype_parameters['charset'])) {
	$struct->charset = $struct->ctype_parameters['charset'];
	}
	}

	// #1487700: workaround for lack of charset in malformed structure
	if (empty($struct->charset) && !empty($mime_headers) && $mime_headers->charset) {
	$struct->charset = $mime_headers->charset;
	}

	// read content encoding
	if (!empty($part[5])) {
	$struct->encoding = strtolower($part[5]);
	$struct->headers['content-transfer-encoding'] = $struct->encoding;
	}

	// get part size
	if (!empty($part[6])) {
	$struct->size = intval($part[6]);
	}

	// read part disposition
	$di = 8;
	if ($struct->ctype_primary == 'text') {
	$di += 1;
	}
	else if ($struct->mimetype == 'message/rfc822') {
	$di += 3;
	}

	if (is_array($part[$di]) && count($part[$di]) == 2) {
	$struct->disposition = strtolower($part[$di][0]);
	if ($struct->disposition && $struct->disposition !== 'inline' && $struct->disposition !== 'attachment') {
	// RFC2183, Section 2.8 - unrecognized type should be treated as "attachment"
	$struct->disposition = 'attachment';
	}
	if (is_array($part[$di][1])) {
	for ($n=0; $n<count($part[$di][1]); $n+=2) {
	$struct->d_parameters[strtolower($part[$di][1][$n])] = $part[$di][1][$n+1];
	}
	}
	}

	// get message/rfc822's child-parts
	if (is_array($part[8]) && $di != 8) {
	$struct->parts = array();
	for ($i=0, $count=0; $i<count($part[8]); $i++) {
	if (!is_array($part[8][$i])) {
	break;
	}
	$struct->parts[] = $this->structure_part($part[8][$i], ++$count, $struct->mime_id);
	}
	}

	// get part ID
	if (!empty($part[3])) {
	$struct->content_id = $struct->headers['content-id'] = trim($part[3]);

	if (empty($struct->disposition)) {
	$struct->disposition = 'inline';
	}
	}

	// fetch message headers if message/rfc822 or named part (could contain Content-Location header)
	if ($struct->ctype_primary == 'message' \|\| ($struct->ctype_parameters['name'] && !$struct->content_id)) {
	if (empty($mime_headers)) {
	$mime_headers = $this->conn->fetchPartHeader(
	$this->folder, $this->msg_uid, true, $struct->mime_id);
	}

	if (is_string($mime_headers)) {
	$struct->headers = rcube_mime::parse_headers($mime_headers) + $struct->headers;
	}
	else if (is_object($mime_headers)) {
	$struct->headers = get_object_vars($mime_headers) + $struct->headers;
	}

	// get real content-type of message/rfc822
	if ($struct->mimetype == 'message/rfc822') {
	// single-part
	if (!is_array($part[8][0])) {
	$struct->real_mimetype = strtolower($part[8][0] . '/' . $part[8][1]);
	}
	// multi-part
	else {
	for ($n=0; $n<count($part[8]); $n++) {
	if (!is_array($part[8][$n])) {
	break;
	}
	}
	$struct->real_mimetype = 'multipart/' . strtolower($part[8][$n]);
	}
	}

	if ($struct->ctype_primary == 'message' && empty($struct->parts)) {
	if (is_array($part[8]) && $di != 8) {
	$struct->parts[] = $this->structure_part($part[8], ++$count, $struct->mime_id);
	}
	}
	}

	// normalize filename property
	$this->set_part_filename($struct, $mime_headers);

	return $struct;
	}

	/**
	* Set attachment filename from message part structure
	*
	* @param rcube_message_part $part Part object
	* @param string $headers Part's raw headers
	*/
	protected function set_part_filename(&$part, $headers = null)
	{
	// Some IMAP servers do not support RFC2231, if we have
	// part headers we'll get attachment name from them, not the BODYSTRUCTURE
	$rfc2231_params = array();
	if (!empty($headers) \|\| !empty($part->headers)) {
	if (is_object($headers)) {
	$headers = get_object_vars($headers);
	}
	else {
	$headers = !empty($headers) ? rcube_mime::parse_headers($headers) : $part->headers;
	}

	$tokens = preg_split('/;[\s\r\n\t]*/', $headers['content-type'] . ';' . $headers['content-disposition']);

	foreach ($tokens as $token) {
	// TODO: Use order defined by the parameter name not order of occurrence in the header
	if (preg_match('/^(name\|filename)\([0-9])\?="([^"]+)"*/i', $token, $matches)) {
	$rfc2231_params[strtolower($matches[1])] .= $matches[3];
	}
	}
	}

	if (isset($rfc2231_params['name'])) {
	$filename_encoded = $rfc2231_params['name'];
	}
	else if (isset($rfc2231_params['filename'])) {
	$filename_encoded = $rfc2231_params['filename'];
	}
	else if (!empty($part->d_parameters['filename'])) {
	$filename_mime = $part->d_parameters['filename'];
	}
	// read 'name' after rfc2231 parameters as it may contain truncated filename (from Thunderbird)
	else if (!empty($part->ctype_parameters['name'])) {
	$filename_mime = $part->ctype_parameters['name'];
	}
	// Content-Disposition
	else if (!empty($part->headers['content-description'])) {
	$filename_mime = $part->headers['content-description'];
	}
	else {
	return;
	}

	// decode filename
	if (isset($filename_mime)) {
	if (!empty($part->charset)) {
	$charset = $part->charset;
	}
	else if (!empty($this->struct_charset)) {
	$charset = $this->struct_charset;
	}
	else {
	$charset = rcube_charset::detect($filename_mime, $this->default_charset);
	}

	$part->filename = rcube_mime::decode_mime_string($filename_mime, $charset);
	}
	else if (isset($filename_encoded)) {
	// decode filename according to RFC 2231, Section 4
	if (preg_match("/^([^'])'[^']'(.*)$/", $filename_encoded, $fmatches)) {
	$filename_charset = $fmatches[1];
	$filename_encoded = $fmatches[2];
	}

	$part->filename = urldecode($filename_encoded);

	if (!empty($filename_charset)) {
	$part->filename = rcube_charset::convert($part->filename, $filename_charset);
	}
	}

	// Workaround for invalid Content-Type (#6816)
	// Some servers for "Content-Type: PDF; name=test.pdf" may return text/plain and ignore name argument
	if ($part->mimetype == 'text/plain' && !empty($headers['content-type'])) {
	$tokens = preg_split('/;[\s\r\n\t]*/', $headers['content-type']);
	$type = rcube_mime::fix_mimetype($tokens[0]);

	if ($type != $part->mimetype) {
	$part->mimetype = $type;
	list($part->ctype_primary, $part->ctype_secondary) = explode('/', $part->mimetype);
	}
	}
	}

	/**
	* Get charset name from message structure (first part)
	*
	* @param array $structure Message structure
	*
	* @return string Charset name
	*/
	protected function structure_charset($structure)
	{
	while (is_array($structure)) {
	if (is_array($structure[2]) && $structure[2][0] == 'charset') {
	return $structure[2][1];
	}
	$structure = $structure[0];
	}
	}


	/**
	* Fetch message body of a specific message from the server
	*
	* @param int Message UID
	* @param string Part number
	* @param rcube_message_part Part object created by get_structure()
	* @param mixed True to print part, resource to write part contents in
	* @param resource File pointer to save the message part
	* @param boolean Disables charset conversion
	* @param int Only read this number of bytes
	* @param boolean Enables formatting of text/* parts bodies
	*
	* @return string Message/part body if not printed
	*/
	public function get_message_part($uid, $part = 1, $o_part = null, $print = null, $fp = null,
	$skip_charset_conv = false, $max_bytes = 0, $formatted = true)
	{
	if (!$this->check_connection()) {
	return null;
	}

	// get part data if not provided
	if (!is_object($o_part)) {
	$structure = $this->conn->getStructure($this->folder, $uid, true);
	$part_data = rcube_imap_generic::getStructurePartData($structure, $part);

	$o_part = new rcube_message_part;
	$o_part->ctype_primary = $part_data['type'];
	$o_part->ctype_secondary = $part_data['subtype'];
	$o_part->encoding = $part_data['encoding'];
	$o_part->charset = $part_data['charset'];
	$o_part->size = $part_data['size'];
	}

	$body = '';

	// Note: multipart/* parts will have size=0, we don't want to ignore them
	if ($o_part && ($o_part->size \|\| $o_part->ctype_primary == 'multipart')) {
	$formatted = $formatted && $o_part->ctype_primary == 'text';
	$body = $this->conn->handlePartBody($this->folder, $uid, true,
	$part ? $part : 'TEXT', $o_part->encoding, $print, $fp, $formatted, $max_bytes);
	}

	if ($fp \|\| $print) {
	return true;
	}

	// convert charset (if text or message part)
	if ($body && preg_match('/^(text\|message)$/', $o_part->ctype_primary)) {
	// Remove NULL characters if any (#1486189)
	if ($formatted && strpos($body, "\x00") !== false) {
	$body = str_replace("\x00", '', $body);
	}

	if (!$skip_charset_conv) {
	if (!$o_part->charset \|\| strtoupper($o_part->charset) == 'US-ASCII') {
	// try to extract charset information from HTML meta tag (#1488125)
	if ($o_part->ctype_secondary == 'html' && preg_match('/<meta[^>]+charset=([a-z0-9-_]+)/i', $body, $m)) {
	$o_part->charset = strtoupper($m[1]);
	}
	else {
	$o_part->charset = $this->default_charset;
	}
	}
	$body = rcube_charset::convert($body, $o_part->charset);
	}
	}

	return $body;
	}

	/**
	* Returns the whole message source as string (or saves to a file)
	*
	* @param int $uid Message UID
	* @param resource $fp File pointer to save the message
	* @param string $part Optional message part ID
	*
	* @return string Message source string
	*/
	public function get_raw_body($uid, $fp=null, $part = null)
	{
	if (!$this->check_connection()) {
	return null;
	}

	return $this->conn->handlePartBody($this->folder, $uid,
	true, $part, null, false, $fp);
	}

	/**
	* Returns the message headers as string
	*
	* @param int $uid Message UID
	* @param string $part Optional message part ID
	*
	* @return string Message headers string
	*/
	public function get_raw_headers($uid, $part = null)
	{
	if (!$this->check_connection()) {
	return null;
	}

	return $this->conn->fetchPartHeader($this->folder, $uid, true, $part);
	}

	/**
	* Sends the whole message source to stdout
	*
	* @param int $uid Message UID
	* @param bool $formatted Enables line-ending formatting
	*/
	public function print_raw_body($uid, $formatted = true)
	{
	if (!$this->check_connection()) {
	return;
	}

	$this->conn->handlePartBody($this->folder, $uid, true, null, null, true, null, $formatted);
	}

	/**
	* Set message flag to one or several messages
	*
	* @param mixed $uids Message UIDs as array or comma-separated string, or '*'
	* @param string $flag Flag to set: SEEN, UNDELETED, DELETED, RECENT, ANSWERED, DRAFT, MDNSENT
	* @param string $folder Folder name
	* @param boolean $skip_cache True to skip message cache clean up
	*
	* @return boolean Operation status
	*/
	public function set_flag($uids, $flag, $folder=null, $skip_cache=false)
	{
	if (!strlen($folder)) {
	$folder = $this->folder;
	}

	if (!$this->check_connection()) {
	return false;
	}

	$flag = strtoupper($flag);
	list($uids, $all_mode) = $this->parse_uids($uids);

	if (strpos($flag, 'UN') === 0) {
	$result = $this->conn->unflag($folder, $uids, substr($flag, 2));
	}
	else {
	$result = $this->conn->flag($folder, $uids, $flag);
	}

	if ($result && !$skip_cache) {
	// reload message headers if cached
	// update flags instead removing from cache
	if ($mcache = $this->get_mcache_engine()) {
	$status = strpos($flag, 'UN') !== 0;
	$mflag = preg_replace('/^UN/', '', $flag);
	$mcache->change_flag($folder, $all_mode ? null : explode(',', $uids),
	$mflag, $status);
	}

	// clear cached counters
	if ($flag == 'SEEN' \|\| $flag == 'UNSEEN') {
	$this->clear_messagecount($folder, array('SEEN', 'UNSEEN'));
	}
	else if ($flag == 'DELETED' \|\| $flag == 'UNDELETED') {
	$this->clear_messagecount($folder, array('ALL', 'THREADS'));
	if ($this->options['skip_deleted']) {
	// remove cached messages
	$this->clear_message_cache($folder, $all_mode ? null : explode(',', $uids));
	}
	}

	$this->set_search_dirty($folder);
	}

	return $result;
	}

	/**
	* Append a mail message (source) to a specific folder
	*
	* @param string $folder Target folder
	* @param string\|array $message The message source string or filename
	* or array (of strings and file pointers)
	* @param string $headers Headers string if $message contains only the body
	* @param boolean $is_file True if $message is a filename
	* @param array $flags Message flags
	* @param mixed $date Message internal date
	* @param bool $binary Enables BINARY append
	*
	* @return int\|bool Appended message UID or True on success, False on error
	*/
	public function save_message($folder, &$message, $headers='', $is_file=false, $flags = array(), $date = null, $binary = false)
	{
	if (!strlen($folder)) {
	$folder = $this->folder;
	}

	if (!$this->check_connection()) {
	return false;
	}

	// make sure folder exists
	if (!$this->folder_exists($folder)) {
	return false;
	}

	$date = $this->date_format($date);

	if ($is_file) {
	$saved = $this->conn->appendFromFile($folder, $message, $headers, $flags, $date, $binary);
	}
	else {
	$saved = $this->conn->append($folder, $message, $flags, $date, $binary);
	}

	if ($saved) {
	// increase messagecount of the target folder
	$this->set_messagecount($folder, 'ALL', 1);

	$this->plugins->exec_hook('message_saved', array(
	'folder' => $folder,
	'message' => $message,
	'headers' => $headers,
	'is_file' => $is_file,
	'flags' => $flags,
	'date' => $date,
	'binary' => $binary,
	'result' => $saved,
	));
	}

	return $saved;
	}

	/**
	* Move a message from one folder to another
	*
	* @param mixed $uids Message UIDs as array or comma-separated string, or '*'
	* @param string $to_mbox Target folder
	* @param string $from_mbox Source folder
	*
	* @return boolean True on success, False on error
	*/
	public function move_message($uids, $to_mbox, $from_mbox = '')
	{
	if (!strlen($from_mbox)) {
	$from_mbox = $this->folder;
	}

	if ($to_mbox === $from_mbox) {
	return false;
	}

	list($uids, $all_mode) = $this->parse_uids($uids);

	// exit if no message uids are specified
	if (empty($uids)) {
	return false;
	}

	if (!$this->check_connection()) {
	return false;
	}

	$config = rcube::get_instance()->config;
	$to_trash = $to_mbox == $config->get('trash_mbox');

	// flag messages as read before moving them
	if ($to_trash && $config->get('read_when_deleted')) {
	// don't flush cache (4th argument)
	$this->set_flag($uids, 'SEEN', $from_mbox, true);
	}

	// move messages
	$moved = $this->conn->move($uids, $from_mbox, $to_mbox);

	// when moving to Trash we make sure the folder exists
	// as it's uncommon scenario we do this when MOVE fails, not before
	if (!$moved && $to_trash && $this->get_response_code() == rcube_storage::TRYCREATE) {
	if ($this->create_folder($to_mbox, true, 'trash')) {
	$moved = $this->conn->move($uids, $from_mbox, $to_mbox);
	}
	}

	if ($moved) {
	$this->clear_messagecount($from_mbox);
	$this->clear_messagecount($to_mbox);
	$this->set_search_dirty($from_mbox);
	$this->set_search_dirty($to_mbox);

	// unset threads internal cache
	unset($this->icache['threads']);

	// remove message ids from search set
	if ($this->search_set && $from_mbox == $this->folder) {
	// threads are too complicated to just remove messages from set
	if ($this->search_threads \|\| $all_mode) {
	$this->refresh_search();
	}
	else if (!$this->search_set->incomplete) {
	$this->search_set->filter(explode(',', $uids), $this->folder);
	}
	}

	// remove cached messages
	// @TODO: do cache update instead of clearing it
	$this->clear_message_cache($from_mbox, $all_mode ? null : explode(',', $uids));
	}

	return $moved;
	}

	/**
	* Copy a message from one folder to another
	*
	* @param mixed $uids Message UIDs as array or comma-separated string, or '*'
	* @param string $to_mbox Target folder
	* @param string $from_mbox Source folder
	*
	* @return boolean True on success, False on error
	*/
	public function copy_message($uids, $to_mbox, $from_mbox = '')
	{
	if (!strlen($from_mbox)) {
	$from_mbox = $this->folder;
	}

	list($uids, ) = $this->parse_uids($uids);

	// exit if no message uids are specified
	if (empty($uids)) {
	return false;
	}

	if (!$this->check_connection()) {
	return false;
	}

	// copy messages
	$copied = $this->conn->copy($uids, $from_mbox, $to_mbox);

	if ($copied) {
	$this->clear_messagecount($to_mbox);
	}

	return $copied;
	}

	/**
	* Mark messages as deleted and expunge them
	*
	* @param mixed $uids Message UIDs as array or comma-separated string, or '*'
	* @param string $folder Source folder
	*
	* @return boolean True on success, False on error
	*/
	public function delete_message($uids, $folder = '')
	{
	if (!strlen($folder)) {
	$folder = $this->folder;
	}

	list($uids, $all_mode) = $this->parse_uids($uids);

	// exit if no message uids are specified
	if (empty($uids)) {
	return false;
	}

	if (!$this->check_connection()) {
	return false;
	}

	$deleted = $this->conn->flag($folder, $uids, 'DELETED');

	if ($deleted) {
	// send expunge command in order to have the deleted message
	// really deleted from the folder
	$this->expunge_message($uids, $folder, false);
	$this->clear_messagecount($folder);

	// unset threads internal cache
	unset($this->icache['threads']);

	$this->set_search_dirty($folder);

	// remove message ids from search set
	if ($this->search_set && $folder == $this->folder) {
	// threads are too complicated to just remove messages from set
	if ($this->search_threads \|\| $all_mode) {
	$this->refresh_search();
	}
	else if (!$this->search_set->incomplete) {
	$this->search_set->filter(explode(',', $uids));
	}
	}

	// remove cached messages
	$this->clear_message_cache($folder, $all_mode ? null : explode(',', $uids));
	}

	return $deleted;
	}

	/**
	* Send IMAP expunge command and clear cache
	*
	* @param mixed $uids Message UIDs as array or comma-separated string, or '*'
	* @param string $folder Folder name
	* @param boolean $clear_cache False if cache should not be cleared
	*
	* @return boolean True on success, False on failure
	*/
	public function expunge_message($uids, $folder = null, $clear_cache = true)
	{
	if ($uids && $this->get_capability('UIDPLUS')) {
	list($uids, $all_mode) = $this->parse_uids($uids);
	}
	else {
	$uids = null;
	}

	if (!strlen($folder)) {
	$folder = $this->folder;
	}

	if (!$this->check_connection()) {
	return false;
	}

	// force folder selection and check if folder is writeable
	// to prevent a situation when CLOSE is executed on closed
	// or EXPUNGE on read-only folder
	$result = $this->conn->select($folder);
	if (!$result) {
	return false;
	}

	if (!$this->conn->data['READ-WRITE']) {
	$this->conn->setError(rcube_imap_generic::ERROR_READONLY, "Folder is read-only");
	return false;
	}

	// CLOSE(+SELECT) should be faster than EXPUNGE
	if (empty($uids) \|\| !empty($all_mode)) {
	$result = $this->conn->close();
	}
	else {
	$result = $this->conn->expunge($folder, $uids);
	}

	if ($result && $clear_cache) {
	$this->clear_message_cache($folder, !empty($all_mode) ? null : explode(',', $uids));
	$this->clear_messagecount($folder);
	}

	return $result;
	}


	/* --------------------------------
	* folder management
	* --------------------------------*/

	/**
	* Public method for listing subscribed folders.
	*
	* @param string $root Optional root folder
	* @param string $name Optional name pattern
	* @param string $filter Optional filter
	* @param string $rights Optional ACL requirements
	* @param bool $skip_sort Enable to return unsorted list (for better performance)
	*
	* @return array List of folders
	*/
	public function list_folders_subscribed($root = '', $name = '*', $filter = null, $rights = null, $skip_sort = false)
	{
	$cache_key = rcube_cache::key_name('mailboxes', array($root, $name, $filter, $rights));

	// get cached folder list
	$a_mboxes = $this->get_cache($cache_key);
	if (is_array($a_mboxes)) {
	return $a_mboxes;
	}

	// Give plugins a chance to provide a list of folders
	$data = $this->plugins->exec_hook('storage_folders',
	array('root' => $root, 'name' => $name, 'filter' => $filter, 'mode' => 'LSUB'));

	if (isset($data['folders'])) {
	$a_mboxes = $data['folders'];
	}
	else {
	$a_mboxes = $this->list_folders_subscribed_direct($root, $name);
	}

	if (!is_array($a_mboxes)) {
	return array();
	}

	// filter folders list according to rights requirements
	if ($rights && $this->get_capability('ACL')) {
	$a_mboxes = $this->filter_rights($a_mboxes, $rights);
	}

	// INBOX should always be available
	if (in_array_nocase($root . $name, array('', '%', 'INBOX', 'INBOX'))
	&& (!$filter \|\| $filter == 'mail') && !in_array('INBOX', $a_mboxes)
	) {
	array_unshift($a_mboxes, 'INBOX');
	}

	// sort folders (always sort for cache)
	if (!$skip_sort \|\| $this->cache) {
	$a_mboxes = $this->sort_folder_list($a_mboxes);
	}

	// write folders list to cache
	$this->update_cache($cache_key, $a_mboxes);

	return $a_mboxes;
	}

	/**
	* Method for direct folders listing (LSUB)
	*
	* @param string $root Optional root folder
	* @param string $name Optional name pattern
	*
	* @return array List of subscribed folders
	* @see rcube_imap::list_folders_subscribed()
	*/
	public function list_folders_subscribed_direct($root = '', $name = '*')
	{
	if (!$this->check_connection()) {
	return null;
	}

	$config = rcube::get_instance()->config;
	$list_root = $root === '' && $this->list_root ? $this->list_root : $root;

	// Server supports LIST-EXTENDED, we can use selection options
	// #1486225: Some dovecot versions return wrong result using LIST-EXTENDED
	$list_extended = !$config->get('imap_force_lsub') && $this->get_capability('LIST-EXTENDED');

	if ($list_extended) {
	// This will also set folder options, LSUB doesn't do that
	$result = $this->conn->listMailboxes($list_root, $name,
	NULL, array('SUBSCRIBED'));
	}
	else {
	// retrieve list of folders from IMAP server using LSUB
	$result = $this->conn->listSubscribed($list_root, $name);
	}

	if (!is_array($result)) {
	return array();
	}

	// Add/Remove folders according to some configuration options
	$this->list_folders_filter($result, $root . $name, ($list_extended ? 'ext-' : '') . 'subscribed');

	// Save the last command state, so we can ignore errors on any following UNSEBSCRIBE calls
	$state = $this->save_conn_state();

	if ($list_extended) {
	// unsubscribe non-existent folders, remove from the list
	if ($name == '*' && !empty($this->conn->data['LIST'])) {
	foreach ($result as $idx => $folder) {
	if (($opts = $this->conn->data['LIST'][$folder])
	&& in_array_nocase('\\NonExistent', $opts)
	) {
	$this->conn->unsubscribe($folder);
	unset($result[$idx]);
	}
	}
	}
	}
	else {
	// unsubscribe non-existent folders, remove them from the list
	if (!empty($result) && $name == '*') {
	$existing = $this->list_folders($root, $name);

	// Try to make sure the list of existing folders is not malformed,
	// we don't want to unsubscribe existing folders on error
	if (is_array($existing) && (!empty($root) \|\| count($existing) > 1)) {
	$nonexisting = array_diff($result, $existing);
	$result = array_diff($result, $nonexisting);

	foreach ($nonexisting as $folder) {
	$this->conn->unsubscribe($folder);
	}
	}
	}
	}

	$this->restore_conn_state($state);

	return $result;
	}

	/**
	* Get a list of all folders available on the server
	*
	* @param string $root IMAP root dir
	* @param string $name Optional name pattern
	* @param mixed $filter Optional filter
	* @param string $rights Optional ACL requirements
	* @param bool $skip_sort Enable to return unsorted list (for better performance)
	*
	* @return array Indexed array with folder names
	*/
	public function list_folders($root = '', $name = '*', $filter = null, $rights = null, $skip_sort = false)
	{
	$cache_key = rcube_cache::key_name('mailboxes.list', array($root, $name, $filter, $rights));

	// get cached folder list
	$a_mboxes = $this->get_cache($cache_key);
	if (is_array($a_mboxes)) {
	return $a_mboxes;
	}

	// Give plugins a chance to provide a list of folders
	$data = $this->plugins->exec_hook('storage_folders',
	array('root' => $root, 'name' => $name, 'filter' => $filter, 'mode' => 'LIST'));

	if (isset($data['folders'])) {
	$a_mboxes = $data['folders'];
	}
	else {
	// retrieve list of folders from IMAP server
	$a_mboxes = $this->list_folders_direct($root, $name);
	}

	if (!is_array($a_mboxes)) {
	$a_mboxes = array();
	}

	// INBOX should always be available
	if (in_array_nocase($root . $name, array('', '%', 'INBOX', 'INBOX'))
	&& (!$filter \|\| $filter == 'mail') && !in_array('INBOX', $a_mboxes)
	) {
	array_unshift($a_mboxes, 'INBOX');
	}

	// cache folder attributes
	if ($root == '' && $name == '*' && empty($filter) && !empty($this->conn->data)) {
	$this->update_cache('mailboxes.attributes', $this->conn->data['LIST']);
	}

	// filter folders list according to rights requirements
	if ($rights && $this->get_capability('ACL')) {
	$a_mboxes = $this->filter_rights($a_mboxes, $rights);
	}

	// filter folders and sort them
	if (!$skip_sort) {
	$a_mboxes = $this->sort_folder_list($a_mboxes);
	}

	// write folders list to cache
	$this->update_cache($cache_key, $a_mboxes);

	return $a_mboxes;
	}

	/**
	* Method for direct folders listing (LIST)
	*
	* @param string $root Optional root folder
	* @param string $name Optional name pattern
	*
	* @return array List of folders
	* @see rcube_imap::list_folders()
	*/
	public function list_folders_direct($root = '', $name = '*')
	{
	if (!$this->check_connection()) {
	return null;
	}

	$list_root = $root === '' && $this->list_root ? $this->list_root : $root;

	$result = $this->conn->listMailboxes($list_root, $name);

	if (!is_array($result)) {
	return array();
	}

	// Add/Remove folders according to some configuration options
	$this->list_folders_filter($result, $root . $name);

	return $result;
	}

	/**
	* Apply configured filters on folders list
	*/
	protected function list_folders_filter(&$result, $root, $update_type = null)
	{
	$config = rcube::get_instance()->config;

	// #1486796: some server configurations doesn't return folders in all namespaces
	if ($root === '*' && $config->get('imap_force_ns')) {
	$this->list_folders_update($result, $update_type);
	}

	// Remove hidden folders
	if ($config->get('imap_skip_hidden_folders')) {
	$result = array_filter($result, function($v) { return $v[0] != '.'; });
	}

	// Remove folders in shared namespaces (if configured, see self::set_env())
	if ($root === '*' && !empty($this->list_excludes)) {
	$result = array_filter($result, function($v) {
	foreach ($this->list_excludes as $prefix) {
	if (strpos($v, $prefix) === 0) {
	return false;
	}
	}

	return true;
	});
	}
	}

	/**
	* Fix folders list by adding folders from other namespaces.
	* Needed on some servers eg. Courier IMAP
	*
	* @param array $result Reference to folders list
	* @param string $type Listing type (ext-subscribed, subscribed or all)
	*/
	protected function list_folders_update(&$result, $type = null)
	{
	$namespace = $this->get_namespace();
	$search = array();

	// build list of namespace prefixes
	foreach ((array)$namespace as $ns) {
	if (is_array($ns)) {
	foreach ($ns as $ns_data) {
	if (strlen($ns_data[0])) {
	$search[] = $ns_data[0];
	}
	}
	}
	}

	if (!empty($search)) {
	// go through all folders detecting namespace usage
	foreach ($result as $folder) {
	foreach ($search as $idx => $prefix) {
	if (strpos($folder, $prefix) === 0) {
	unset($search[$idx]);
	}
	}
	if (empty($search)) {
	break;
	}
	}

	// get folders in hidden namespaces and add to the result
	foreach ($search as $prefix) {
	if ($type == 'ext-subscribed') {
	$list = $this->conn->listMailboxes('', $prefix . '*', null, array('SUBSCRIBED'));
	}
	else if ($type == 'subscribed') {
	$list = $this->conn->listSubscribed('', $prefix . '*');
	}
	else {
	$list = $this->conn->listMailboxes('', $prefix . '*');
	}

	if (!empty($list)) {
	$result = array_merge($result, $list);
	}
	}
	}
	}

	/**
	* Filter the given list of folders according to access rights
	*
	* For performance reasons we assume user has full rights
	* on all personal folders.
	*/
	protected function filter_rights($a_folders, $rights)
	{
	$regex = '/('.$rights.')/';

	foreach ($a_folders as $idx => $folder) {
	if ($this->folder_namespace($folder) == 'personal') {
	continue;
	}

	$myrights = implode('', (array)$this->my_rights($folder));

	if ($myrights !== null && !preg_match($regex, $myrights)) {
	unset($a_folders[$idx]);
	}
	}

	return $a_folders;
	}

	/**
	* Get mailbox quota information
	*
	* @param string $folder Folder name
	*
	* @return mixed Quota info or False if not supported
	*/
	public function get_quota($folder = null)
	{
	if ($this->get_capability('QUOTA') && $this->check_connection()) {
	return $this->conn->getQuota($folder);
	}

	return false;
	}

	/**
	* Get folder size (size of all messages in a folder)
	*
	* @param string $folder Folder name
	*
	* @return int Folder size in bytes, False on error
	*/
	public function folder_size($folder)
	{
	if (!strlen($folder)) {
	return false;
	}

	if (!$this->check_connection()) {
	return 0;
	}

	if ($this->get_capability('STATUS=SIZE')) {
	$status = $this->conn->status($folder, array('SIZE'));
	if (is_array($status) && array_key_exists('SIZE', $status)) {
	return (int) $status['SIZE'];
	}
	}

	// On Cyrus we can use special folder annotation, which should be much faster
	if ($this->get_vendor() == 'cyrus') {
	$idx = '/shared/vendor/cmu/cyrus-imapd/size';
	$result = $this->get_metadata($folder, $idx, array(), true);

	if (!empty($result) && is_numeric($result[$folder][$idx])) {
	return $result[$folder][$idx];
	}
	}

	// @TODO: could we try to use QUOTA here?
	$result = $this->conn->fetchHeaderIndex($folder, '1:*', 'SIZE', false);

	if (is_array($result)) {
	$result = array_sum($result);
	}

	return $result;
	}

	/**
	* Subscribe to a specific folder(s)
	*
	* @param array $folders Folder name(s)
	*
	* @return boolean True on success
	*/
	public function subscribe($folders)
	{
	// let this common function do the main work
	return $this->change_subscription($folders, 'subscribe');
	}

	/**
	* Unsubscribe folder(s)
	*
	* @param array $a_mboxes Folder name(s)
	*
	* @return boolean True on success
	*/
	public function unsubscribe($folders)
	{
	// let this common function do the main work
	return $this->change_subscription($folders, 'unsubscribe');
	}

	/**
	* Create a new folder on the server and register it in local cache
	*
	* @param string $folder New folder name
	* @param boolean $subscribe True if the new folder should be subscribed
	* @param string $type Optional folder type (junk, trash, drafts, sent, archive)
	* @param boolean $noselect Make the folder a \NoSelect folder by adding hierarchy
	* separator at the end (useful for server that do not support
	* both folders and messages as folder children)
	*
	* @return boolean True on success
	*/
	public function create_folder($folder, $subscribe = false, $type = null, $noselect = false)
	{
	if (!$this->check_connection()) {
	return false;
	}

	if ($noselect) {
	$folder .= $this->delimiter;
	}

	$result = $this->conn->createFolder($folder, $type ? array("\\" . ucfirst($type)) : null);

	// Folder creation may fail when specific special-use flag is not supported.
	// Try to create it anyway with no flag specified (#7147)
	if (!$result && $type) {
	$result = $this->conn->createFolder($folder);
	}

	// try to subscribe it
	if ($result) {
	// clear cache
	$this->clear_cache('mailboxes', true);

	if ($subscribe && !$noselect) {
	$this->subscribe($folder);
	}
	}

	return $result;
	}

	/**
	* Set a new name to an existing folder
	*
	* @param string $folder Folder to rename
	* @param string $new_name New folder name
	*
	* @return boolean True on success
	*/
	public function rename_folder($folder, $new_name)
	{
	if (!strlen($new_name)) {
	return false;
	}

	if (!$this->check_connection()) {
	return false;
	}

	$delm = $this->get_hierarchy_delimiter();

	// get list of subscribed folders
	if ((strpos($folder, '%') === false) && (strpos($folder, '*') === false)) {
	$a_subscribed = $this->list_folders_subscribed('', $folder . $delm . '*');
	$subscribed = $this->folder_exists($folder, true);
	}
	else {
	$a_subscribed = $this->list_folders_subscribed();
	$subscribed = in_array($folder, $a_subscribed);
	}

	$result = $this->conn->renameFolder($folder, $new_name);

	if ($result) {
	// unsubscribe the old folder, subscribe the new one
	if ($subscribed) {
	$this->conn->unsubscribe($folder);
	$this->conn->subscribe($new_name);
	}

	// check if folder children are subscribed
	foreach ($a_subscribed as $c_subscribed) {
	if (strpos($c_subscribed, $folder.$delm) === 0) {
	$this->conn->unsubscribe($c_subscribed);
	$this->conn->subscribe(preg_replace('/^'.preg_quote($folder, '/').'/',
	$new_name, $c_subscribed));

	// clear cache
	$this->clear_message_cache($c_subscribed);
	}
	}

	// clear cache
	$this->clear_message_cache($folder);
	$this->clear_cache('mailboxes', true);
	}

	return $result;
	}

	/**
	* Remove folder (with subfolders) from the server
	*
	* @param string $folder Folder name
	*
	* @return boolean True on success, False on failure
	*/
	public function delete_folder($folder)
	{
	if (!$this->check_connection()) {
	return false;
	}

	$delm = $this->get_hierarchy_delimiter();

	// get list of sub-folders or all folders
	// if folder name contains special characters
	$path = strspn($folder, '%*') > 0 ? ($folder . $delm) : '';
	$sub_mboxes = $this->list_folders('', $path . '*');

	// According to RFC3501 deleting a \Noselect folder
	// with subfolders may fail. To workaround this we delete
	// subfolders first (in reverse order) (#5466)
	if (!empty($sub_mboxes)) {
	foreach (array_reverse($sub_mboxes) as $mbox) {
	if (strpos($mbox, $folder . $delm) === 0) {
	if ($this->conn->deleteFolder($mbox)) {
	$this->conn->unsubscribe($mbox);
	$this->clear_message_cache($mbox);
	}
	}
	}
	}

	// delete the folder
	if ($result = $this->conn->deleteFolder($folder)) {
	// and unsubscribe it
	$this->conn->unsubscribe($folder);
	$this->clear_message_cache($folder);
	}

	$this->clear_cache('mailboxes', true);

	return $result;
	}

	/**
	* Detect special folder associations stored in storage backend
	*/
	public function get_special_folders($forced = false)
	{
	$result = parent::get_special_folders();
	$rcube = rcube::get_instance();

	// Lock SPECIAL-USE after user preferences change (#4782)
	if ($rcube->config->get('lock_special_folders')) {
	return $result;
	}

	if (isset($this->icache['special-use'])) {
	return array_merge($result, $this->icache['special-use']);
	}

	if (!$forced \|\| !$this->get_capability('SPECIAL-USE')) {
	return $result;
	}

	if (!$this->check_connection()) {
	return $result;
	}

	$types = array_map(function($value) { return "\\" . ucfirst($value); }, rcube_storage::$folder_types);
	$special = array();

	// request \Subscribed flag in LIST response as performance improvement for folder_exists()
	$folders = $this->conn->listMailboxes('', '*', array('SUBSCRIBED'), array('SPECIAL-USE'));

	if (!empty($folders)) {
	foreach ($folders as $idx => $folder) {
	if (is_array($folder)) {
	$folder = $idx;
	}
	if ($flags = $this->conn->data['LIST'][$folder]) {
	foreach ($types as $type) {
	if (in_array($type, $flags)) {
	$type = strtolower(substr($type, 1));
	$special[$type] = $folder;
	}
	}
	}
	}
	}

	$this->icache['special-use'] = $special;
	unset($this->icache['special-folders']);

	return array_merge($result, $special);
	}

	/**
	* Set special folder associations stored in storage backend
	*/
	public function set_special_folders($specials)
	{
	if (!$this->get_capability('SPECIAL-USE') \|\| !$this->get_capability('METADATA')) {
	return false;
	}

	if (!$this->check_connection()) {
	return false;
	}

	$folders = $this->get_special_folders(true);
	$old = (array) $this->icache['special-use'];

	foreach ($specials as $type => $folder) {
	if (in_array($type, rcube_storage::$folder_types)) {
	$old_folder = $old[$type];
	if ($old_folder !== $folder) {
	// unset old-folder metadata
	if ($old_folder !== null) {
	$this->delete_metadata($old_folder, array('/private/specialuse'));
	}
	// set new folder metadata
	if ($folder) {
	$this->set_metadata($folder, array('/private/specialuse' => "\\" . ucfirst($type)));
	}
	}
	}
	}

	$this->icache['special-use'] = $specials;
	unset($this->icache['special-folders']);

	return true;
	}

	/**
	* Checks if folder exists and is subscribed
	*
	* @param string $folder Folder name
	* @param boolean $subscription Enable subscription checking
	*
	* @return boolean TRUE or FALSE
	*/
	public function folder_exists($folder, $subscription = false)
	{
	if ($folder == 'INBOX') {
	return true;
	}

	$key = $subscription ? 'subscribed' : 'existing';

	- if (is_array($this->icache[$key]) && in_array($folder, $this->icache[$key])) {
	+ if (!empty($this->icache[$key]) && in_array($folder, (array) $this->icache[$key])) {
	return true;
	}

	if (!$this->check_connection()) {
	return false;
	}

	if ($subscription) {
	// It's possible we already called LIST command, check LIST data
	if (!empty($this->conn->data['LIST']) && !empty($this->conn->data['LIST'][$folder])
	&& in_array_nocase('\\Subscribed', $this->conn->data['LIST'][$folder])
	) {
	$a_folders = array($folder);
	}
	else {
	$a_folders = $this->conn->listSubscribed('', $folder);
	}
	}
	else {
	// It's possible we already called LIST command, check LIST data
	if (!empty($this->conn->data['LIST']) && isset($this->conn->data['LIST'][$folder])) {
	$a_folders = array($folder);
	}
	else {
	$a_folders = $this->conn->listMailboxes('', $folder);
	}
	}

	if (is_array($a_folders) && in_array($folder, $a_folders)) {
	$this->icache[$key][] = $folder;
	return true;
	}

	return false;
	}

	/**
	* Returns the namespace where the folder is in
	*
	* @param string $folder Folder name
	*
	* @return string One of 'personal', 'other' or 'shared'
	*/
	public function folder_namespace($folder)
	{
	if ($folder == 'INBOX') {
	return 'personal';
	}

	foreach ($this->namespace as $type => $namespace) {
	if (is_array($namespace)) {
	foreach ($namespace as $ns) {
	if ($len = strlen($ns[0])) {
	if (($len > 1 && $folder == substr($ns[0], 0, -1))
	\|\| strpos($folder, $ns[0]) === 0
	) {
	return $type;
	}
	}
	}
	}
	}

	return 'personal';
	}

	/**
	* Modify folder name according to personal namespace prefix.
	* For output it removes prefix of the personal namespace if it's possible.
	* For input it adds the prefix. Use it before creating a folder in root
	* of the folders tree.
	*
	* @param string $folder Folder name
	* @param string $mode Mode name (out/in)
	*
	* @return string Folder name
	*/
	public function mod_folder($folder, $mode = 'out')
	{
	$prefix = $this->namespace['prefix_' . $mode]; // see set_env()

	if ($prefix === null \|\| $prefix === ''
	\|\| !($prefix_len = strlen($prefix)) \|\| !strlen($folder)
	) {
	return $folder;
	}

	// remove prefix for output
	if ($mode == 'out') {
	if (substr($folder, 0, $prefix_len) === $prefix) {
	return substr($folder, $prefix_len);
	}

	return $folder;
	}

	// add prefix for input (e.g. folder creation)
	return $prefix . $folder;
	}

	/**
	* Gets folder attributes from LIST response, e.g. \Noselect, \Noinferiors
	*
	* @param string $folder Folder name
	* @param bool $force Set to True if attributes should be refreshed
	*
	* @return array Options list
	*/
	public function folder_attributes($folder, $force=false)
	{
	// get attributes directly from LIST command
	if (!empty($this->conn->data['LIST']) && is_array($this->conn->data['LIST'][$folder])) {
	$opts = $this->conn->data['LIST'][$folder];
	}
	// get cached folder attributes
	else if (!$force) {
	$opts = $this->get_cache('mailboxes.attributes');
	$opts = $opts[$folder];
	}

	if (!isset($opts) \|\| !is_array($opts)) {
	if (!$this->check_connection()) {
	return array();
	}

	$this->conn->listMailboxes('', $folder);
	$opts = $this->conn->data['LIST'][$folder];
	}

	return isset($opts) && is_array($opts) ? $opts : array();
	}

	/**
	* Gets connection (and current folder) data: UIDVALIDITY, EXISTS, RECENT,
	* PERMANENTFLAGS, UIDNEXT, UNSEEN
	*
	* @param string $folder Folder name
	*
	* @return array Data
	*/
	public function folder_data($folder)
	{
	if (!strlen($folder)) {
	$folder = $this->folder !== null ? $this->folder : 'INBOX';
	}

	if ($this->conn->selected != $folder) {
	if (!$this->check_connection()) {
	return array();
	}

	if ($this->conn->select($folder)) {
	$this->folder = $folder;
	}
	else {
	return null;
	}
	}

	$data = $this->conn->data;

	// add (E)SEARCH result for ALL UNDELETED query
	if (!empty($this->icache['undeleted_idx'])
	&& $this->icache['undeleted_idx']->get_parameters('MAILBOX') == $folder
	) {
	$data['UNDELETED'] = $this->icache['undeleted_idx'];
	}

	// dovecot does not return HIGHESTMODSEQ until requested, we use it though in our caching system
	// calling STATUS is needed only once, after first use mod-seq db will be maintained
	if (!isset($data['HIGHESTMODSEQ']) && empty($data['NOMODSEQ'])
	&& ($this->get_capability('QRESYNC') \|\| $this->get_capability('CONDSTORE'))
	) {
	if ($add_data = $this->conn->status($folder, array('HIGHESTMODSEQ'))) {
	$data = array_merge($data, $add_data);
	}
	}

	return $data;
	}

	/**
	* Returns extended information about the folder
	*
	* @param string $folder Folder name
	*
	* @return array Data
	*/
	public function folder_info($folder)
	{
	if ($this->icache['options'] && $this->icache['options']['name'] == $folder) {
	return $this->icache['options'];
	}

	// get cached metadata
	$cache_key = rcube_cache::key_name('mailboxes.folder-info', array($folder));
	$cached = $this->get_cache($cache_key);

	if (is_array($cached)) {
	return $cached;
	}

	$acl = $this->get_capability('ACL');
	$namespace = $this->get_namespace();
	$options = array();

	// check if the folder is a namespace prefix
	if (!empty($namespace)) {
	$mbox = $folder . $this->delimiter;
	foreach ($namespace as $ns) {
	if (!empty($ns)) {
	foreach ($ns as $item) {
	if ($item[0] === $mbox) {
	$options['is_root'] = true;
	break 2;
	}
	}
	}
	}
	}
	// check if the folder is other user virtual-root
	if (!$options['is_root'] && !empty($namespace) && !empty($namespace['other'])) {
	$parts = explode($this->delimiter, $folder);
	if (count($parts) == 2) {
	$mbox = $parts[0] . $this->delimiter;
	foreach ($namespace['other'] as $item) {
	if ($item[0] === $mbox) {
	$options['is_root'] = true;
	break;
	}
	}
	}
	}

	$options['name'] = $folder;
	$options['attributes'] = $this->folder_attributes($folder, true);
	$options['namespace'] = $this->folder_namespace($folder);
	$options['special'] = $this->is_special_folder($folder);

	// Set 'noselect' flag
	if (is_array($options['attributes'])) {
	foreach ($options['attributes'] as $attrib) {
	$attrib = strtolower($attrib);
	if ($attrib == '\noselect' \|\| $attrib == '\nonexistent') {
	$options['noselect'] = true;
	}
	}
	}
	else {
	$options['noselect'] = true;
	}

	// Get folder rights (MYRIGHTS)
	if ($acl && ($rights = $this->my_rights($folder))) {
	$options['rights'] = $rights;
	}

	// Set 'norename' flag
	if (!empty($options['rights'])) {
	$rfc_4314 = is_array($this->get_capability('RIGHTS'));
	$options['norename'] = ($rfc_4314 && !in_array('x', $options['rights']))
	\|\| (!$rfc_4314 && !in_array('d', $options['rights']));

	if (!$options['noselect']) {
	$options['noselect'] = !in_array('r', $options['rights']);
	}
	}
	else {
	$options['norename'] = $options['is_root'] \|\| $options['namespace'] != 'personal';
	}

	// update caches
	$this->icache['options'] = $options;
	$this->update_cache($cache_key, $options);

	return $options;
	}

	/**
	* Synchronizes messages cache.
	*
	* @param string $folder Folder name
	*/
	public function folder_sync($folder)
	{
	if ($mcache = $this->get_mcache_engine()) {
	$mcache->synchronize($folder);
	}
	}

	/**
	* Check if the folder name is valid
	*
	* @param string $folder Folder name (UTF-8)
	* @param string &$char First forbidden character found
	*
	* @return bool True if the name is valid, False otherwise
	*/
	public function folder_validate($folder, &$char = null)
	{
	if (parent::folder_validate($folder, $char)) {
	$vendor = $this->get_vendor();
	$regexp = '\\x00-\\x1F\\x7F%*';

	if ($vendor == 'cyrus') {
	// List based on testing Kolab's Cyrus-IMAP 2.5
	$regexp .= '!`@(){}\|\\?<;"';
	}

	if (!preg_match("/[$regexp]/", $folder, $m)) {
	return true;
	}

	$char = $m[0];
	}

	return false;
	}

	/**
	* Get message header names for rcube_imap_generic::fetchHeader(s)
	*
	* @return string Space-separated list of header names
	*/
	protected function get_fetch_headers()
	{
	if (!empty($this->options['fetch_headers'])) {
	$headers = explode(' ', $this->options['fetch_headers']);
	}
	else {
	$headers = array();
	}

	- if ($this->messages_caching \|\| $this->options['all_headers']) {
	+ if ($this->messages_caching \|\| !empty($this->options['all_headers'])) {
	$headers = array_merge($headers, $this->all_headers);
	}

	return $headers;
	}


	/* -----------------------------------------
	* ACL and METADATA/ANNOTATEMORE methods
	* ----------------------------------------*/

	/**
	* Changes the ACL on the specified folder (SETACL)
	*
	* @param string $folder Folder name
	* @param string $user User name
	* @param string $acl ACL string
	*
	* @return boolean True on success, False on failure
	* @since 0.5-beta
	*/
	public function set_acl($folder, $user, $acl)
	{
	if (!$this->get_capability('ACL')) {
	return false;
	}

	if (!$this->check_connection()) {
	return false;
	}

	$this->clear_cache(rcube_cache::key_name('mailboxes.folder-info', array($folder)));

	return $this->conn->setACL($folder, $user, $acl);
	}

	/**
	* Removes any <identifier,rights> pair for the
	* specified user from the ACL for the specified
	* folder (DELETEACL)
	*
	* @param string $folder Folder name
	* @param string $user User name
	*
	* @return boolean True on success, False on failure
	* @since 0.5-beta
	*/
	public function delete_acl($folder, $user)
	{
	if (!$this->get_capability('ACL')) {
	return false;
	}

	if (!$this->check_connection()) {
	return false;
	}

	return $this->conn->deleteACL($folder, $user);
	}

	/**
	* Returns the access control list for folder (GETACL)
	*
	* @param string $folder Folder name
	*
	* @return array User-rights array on success, NULL on error
	* @since 0.5-beta
	*/
	public function get_acl($folder)
	{
	if (!$this->get_capability('ACL')) {
	return null;
	}

	if (!$this->check_connection()) {
	return null;
	}

	return $this->conn->getACL($folder);
	}

	/**
	* Returns information about what rights can be granted to the
	* user (identifier) in the ACL for the folder (LISTRIGHTS)
	*
	* @param string $folder Folder name
	* @param string $user User name
	*
	* @return array List of user rights
	* @since 0.5-beta
	*/
	public function list_rights($folder, $user)
	{
	if (!$this->get_capability('ACL')) {
	return null;
	}

	if (!$this->check_connection()) {
	return null;
	}

	return $this->conn->listRights($folder, $user);
	}

	/**
	* Returns the set of rights that the current user has to
	* folder (MYRIGHTS)
	*
	* @param string $folder Folder name
	*
	* @return array MYRIGHTS response on success, NULL on error
	* @since 0.5-beta
	*/
	public function my_rights($folder)
	{
	if (!$this->get_capability('ACL')) {
	return null;
	}

	if (!$this->check_connection()) {
	return null;
	}

	return $this->conn->myRights($folder);
	}

	/**
	* Sets IMAP metadata/annotations (SETMETADATA/SETANNOTATION)
	*
	* @param string $folder Folder name (empty for server metadata)
	* @param array $entries Entry-value array (use NULL value as NIL)
	*
	* @return boolean True on success, False on failure
	* @since 0.5-beta
	*/
	public function set_metadata($folder, $entries)
	{
	if (!$this->check_connection()) {
	return false;
	}

	$this->clear_cache('mailboxes.metadata.', true);

	if ($this->get_capability('METADATA') \|\|
	(!strlen($folder) && $this->get_capability('METADATA-SERVER'))
	) {
	return $this->conn->setMetadata($folder, $entries);
	}
	else if ($this->get_capability('ANNOTATEMORE') \|\| $this->get_capability('ANNOTATEMORE2')) {
	foreach ((array)$entries as $entry => $value) {
	list($ent, $attr) = $this->md2annotate($entry);
	$entries[$entry] = array($ent, $attr, $value);
	}
	return $this->conn->setAnnotation($folder, $entries);
	}

	return false;
	}

	/**
	* Unsets IMAP metadata/annotations (SETMETADATA/SETANNOTATION)
	*
	* @param string $folder Folder name (empty for server metadata)
	* @param array $entries Entry names array
	*
	* @return boolean True on success, False on failure
	* @since 0.5-beta
	*/
	public function delete_metadata($folder, $entries)
	{
	if (!$this->check_connection()) {
	return false;
	}

	$this->clear_cache('mailboxes.metadata.', true);

	if ($this->get_capability('METADATA') \|\|
	(!strlen($folder) && $this->get_capability('METADATA-SERVER'))
	) {
	return $this->conn->deleteMetadata($folder, $entries);
	}
	else if ($this->get_capability('ANNOTATEMORE') \|\| $this->get_capability('ANNOTATEMORE2')) {
	foreach ((array)$entries as $idx => $entry) {
	list($ent, $attr) = $this->md2annotate($entry);
	$entries[$idx] = array($ent, $attr, NULL);
	}
	return $this->conn->setAnnotation($folder, $entries);
	}

	return false;
	}

	/**
	* Returns IMAP metadata/annotations (GETMETADATA/GETANNOTATION)
	*
	* @param string $folder Folder name (empty for server metadata)
	* @param array $entries Entries
	* @param array $options Command options (with MAXSIZE and DEPTH keys)
	* @param bool $force Disables cache use
	*
	* @return array Metadata entry-value hash array on success, NULL on error
	* @since 0.5-beta
	*/
	public function get_metadata($folder, $entries, $options = array(), $force = false)
	{
	$entries = (array) $entries;

	if (!$force) {
	$cache_key = rcube_cache::key_name('mailboxes.metadata', array($folder, $options, $entries));

	// get cached data
	$cached_data = $this->get_cache($cache_key);

	if (is_array($cached_data)) {
	return $cached_data;
	}
	}

	if (!$this->check_connection()) {
	return null;
	}

	if ($this->get_capability('METADATA') \|\|
	(!strlen($folder) && $this->get_capability('METADATA-SERVER'))
	) {
	$res = $this->conn->getMetadata($folder, $entries, $options);
	}
	else if ($this->get_capability('ANNOTATEMORE') \|\| $this->get_capability('ANNOTATEMORE2')) {
	$queries = array();
	$res = array();

	// Convert entry names
	foreach ($entries as $entry) {
	list($ent, $attr) = $this->md2annotate($entry);
	$queries[$attr][] = $ent;
	}

	// @TODO: Honor MAXSIZE and DEPTH options
	foreach ($queries as $attrib => $entry) {
	$result = $this->conn->getAnnotation($folder, $entry, $attrib);

	// an error, invalidate any previous getAnnotation() results
	if (!is_array($result)) {
	return null;
	}
	else {
	foreach ($result as $fldr => $data) {
	$res[$fldr] = array_merge((array) $res[$fldr], $data);
	}
	}
	}
	}

	if (isset($res)) {
	if (!$force) {
	$this->update_cache($cache_key, $res);
	}

	return $res;
	}
	}

	/**
	* Converts the METADATA extension entry name into the correct
	* entry-attrib names for older ANNOTATEMORE version.
	*
	* @param string $entry Entry name
	*
	* @return array Entry-attribute list, NULL if not supported (?)
	*/
	protected function md2annotate($entry)
	{
	if (substr($entry, 0, 7) == '/shared') {
	return array(substr($entry, 7), 'value.shared');
	}
	else if (substr($entry, 0, 8) == '/private') {
	return array(substr($entry, 8), 'value.priv');
	}

	// @TODO: log error
	}


	/* --------------------------------
	* internal caching methods
	* --------------------------------*/

	/**
	* Enable or disable indexes caching
	*
	* @param string $type Cache type (@see rcube::get_cache)
	*/
	public function set_caching($type)
	{
	if ($type) {
	$this->caching = $type;
	}
	else {
	if ($this->cache) {
	$this->cache->close();
	}
	$this->cache = null;
	$this->caching = false;
	}
	}

	/**
	* Getter for IMAP cache object
	*/
	protected function get_cache_engine()
	{
	if ($this->caching && !$this->cache) {
	$rcube = rcube::get_instance();
	$ttl = $rcube->config->get('imap_cache_ttl', '10d');
	$this->cache = $rcube->get_cache('IMAP', $this->caching, $ttl);
	}

	return $this->cache;
	}

	/**
	* Returns cached value
	*
	* @param string $key Cache key
	*
	* @return mixed
	*/
	public function get_cache($key)
	{
	if ($cache = $this->get_cache_engine()) {
	return $cache->get($key);
	}
	}

	/**
	* Update cache
	*
	* @param string $key Cache key
	* @param mixed $data Data
	*/
	public function update_cache($key, $data)
	{
	if ($cache = $this->get_cache_engine()) {
	$cache->set($key, $data);
	}
	}

	/**
	* Clears the cache.
	*
	* @param string $key Cache key name or pattern
	* @param boolean $prefix_mode Enable it to clear all keys starting
	* with prefix specified in $key
	*/
	public function clear_cache($key = null, $prefix_mode = false)
	{
	if ($cache = $this->get_cache_engine()) {
	$cache->remove($key, $prefix_mode);
	}
	}


	/* --------------------------------
	* message caching methods
	* --------------------------------*/

	/**
	* Enable or disable messages caching
	*
	* @param boolean $set Flag
	* @param int $mode Cache mode
	*/
	public function set_messages_caching($set, $mode = null)
	{
	if ($set) {
	$this->messages_caching = true;

	if ($mode && ($cache = $this->get_mcache_engine())) {
	$cache->set_mode($mode);
	}
	}
	else {
	if ($this->mcache) {
	$this->mcache->close();
	}
	$this->mcache = null;
	$this->messages_caching = false;
	}
	}

	/**
	* Getter for messages cache object
	*/
	protected function get_mcache_engine()
	{
	if ($this->messages_caching && !$this->mcache) {
	$rcube = rcube::get_instance();
	if (($dbh = $rcube->get_dbh()) && ($userid = $rcube->get_user_id())) {
	$ttl = $rcube->config->get('messages_cache_ttl', '10d');
	$threshold = $rcube->config->get('messages_cache_threshold', 50);
	$this->mcache = new rcube_imap_cache(
	$dbh, $this, $userid, $this->options['skip_deleted'], $ttl, $threshold);
	}
	}

	return $this->mcache;
	}

	/**
	* Clears the messages cache.
	*
	* @param string $folder Folder name
	* @param array $uids Optional message UIDs to remove from cache
	*/
	protected function clear_message_cache($folder = null, $uids = null)
	{
	if ($mcache = $this->get_mcache_engine()) {
	$mcache->clear($folder, $uids);
	}
	}

	/**
	* Delete outdated cache entries
	*/
	function cache_gc()
	{
	rcube_imap_cache::gc();
	}


	/* --------------------------------
	* protected methods
	* --------------------------------*/

	/**
	* Determines if server supports dual use folders (those can
	* contain both sub-folders and messages).
	*
	* @return bool
	*/
	protected function detect_dual_use_folders()
	{
	$val = rcube::get_instance()->config->get('imap_dual_use_folders');
	if ($val !== null) {
	return (bool) $val;
	}

	if (!$this->check_connection()) {
	return false;
	}

	$folder = str_replace('.', '', 'foldertest' . microtime(true));
	$folder = $this->mod_folder($folder, 'in');
	$subfolder = $folder . $this->delimiter . 'foldertest';

	if ($this->conn->createFolder($folder)) {
	if ($created = $this->conn->createFolder($subfolder)) {
	$this->conn->deleteFolder($subfolder);
	}

	$this->conn->deleteFolder($folder);

	return $created;
	}
	}

	/**
	* Validate the given input and save to local properties
	*
	* @param string $sort_field Sort column
	* @param string $sort_order Sort order
	*/
	protected function set_sort_order($sort_field, $sort_order)
	{
	if ($sort_field != null) {
	$this->sort_field = asciiwords($sort_field);
	}
	if ($sort_order != null) {
	$this->sort_order = strtoupper($sort_order) == 'DESC' ? 'DESC' : 'ASC';
	}
	}

	/**
	* Sort folders in alphabethical order. Optionally put special folders
	* first and other-users/shared namespaces last.
	*
	* @param array $a_folders Folders list
	* @param bool $skip_special Skip special folders handling
	*
	* @return array Sorted list
	*/
	public function sort_folder_list($a_folders, $skip_special = false)
	{
	$folders = array();

	// convert names to UTF-8
	foreach ($a_folders as $folder) {
	// for better performance skip encoding conversion
	// if the string does not look like UTF7-IMAP
	$folders[$folder] = strpos($folder, '&') === false ? $folder : rcube_charset::convert($folder, 'UTF7-IMAP');
	}

	// sort folders
	// asort($folders, SORT_LOCALE_STRING) is not properly sorting case sensitive names
	uasort($folders, array($this, 'sort_folder_comparator'));

	$folders = array_keys($folders);

	if ($skip_special \|\| empty($folders)) {
	return $folders;
	}

	// Collect special folders and non-personal namespace roots
	$specials = array_merge(array('INBOX'), array_values($this->get_special_folders()));
	$ns_roots = array();

	foreach (array('other', 'shared') as $ns_name) {
	if ($ns = $this->get_namespace($ns_name)) {
	foreach ($ns as $root) {
	$ns_roots[rtrim($root[0], $root[1])] = $root[0];
	}
	}
	}

	// Force the type of folder name variable (#1485527)
	$folders = array_map('strval', $folders);
	$out = array();

	// Put special folders on top...
	$specials = array_unique(array_intersect($specials, $folders));
	$folders = array_merge($specials, array_diff($folders, $specials));

	// ... and rebuild the list to move their subfolders where they belong
	$this->sort_folder_specials(null, $folders, $specials, $out);

	// Put other-user/shared namespaces at the end
	if (!empty($ns_roots)) {
	$folders = array();
	foreach ($out as $folder) {
	foreach ($ns_roots as $root => $prefix) {
	if ($folder === $root \|\| strpos($folder, $prefix) === 0) {
	$folders[] = $folder;
	}
	}
	}

	if (!empty($folders)) {
	$out = array_merge(array_diff($out, $folders), $folders);
	}
	}

	return $out;
	}

	/**
	* Recursive function to put subfolders of special folders in place
	*/
	protected function sort_folder_specials($folder, &$list, &$specials, &$out)
	{
	$count = count($list);

	for ($i = 0; $i < $count; $i++) {
	$name = $list[$i];
	if ($name === null) {
	continue;
	}

	if ($folder === null \|\| strpos($name, $folder.$this->delimiter) === 0) {
	$out[] = $name;
	$list[$i] = null;

	if (!empty($specials) && ($found = array_search($name, $specials)) !== false) {
	unset($specials[$found]);
	$this->sort_folder_specials($name, $list, $specials, $out);
	}
	}
	}
	}

	/**
	* Callback for uasort() that implements correct
	* locale-aware case-sensitive sorting
	*/
	protected function sort_folder_comparator($str1, $str2)
	{
	if ($this->sort_folder_collator === null) {
	$this->sort_folder_collator = false;

	// strcoll() does not work with UTF8 locale on Windows,
	// use Collator from the intl extension
	if (stripos(PHP_OS, 'win') === 0 && function_exists('collator_compare')) {
	$locale = $this->options['language'] ?: 'en_US';
	$this->sort_folder_collator = collator_create($locale) ?: false;
	}
	}

	$path1 = explode($this->delimiter, $str1);
	$path2 = explode($this->delimiter, $str2);

	foreach ($path1 as $idx => $folder1) {
	$folder2 = isset($path2[$idx]) ? $path2[$idx] : '';

	if ($folder1 === $folder2) {
	continue;
	}

	if ($this->sort_folder_collator) {
	return collator_compare($this->sort_folder_collator, $folder1, $folder2);
	}

	return strcoll($folder1, $folder2);
	}
	}

	/**
	* Find UID of the specified message sequence ID
	*
	* @param int $id Message (sequence) ID
	* @param string $folder Folder name
	*
	* @return int Message UID
	*/
	public function id2uid($id, $folder = null)
	{
	if (!strlen($folder)) {
	$folder = $this->folder;
	}

	if (!$this->check_connection()) {
	return null;
	}

	return $this->conn->ID2UID($folder, $id);
	}

	/**
	* Subscribe/unsubscribe a list of folders and update local cache
	*/
	protected function change_subscription($folders, $mode)
	{
	$updated = 0;
	$folders = (array) $folders;

	if (!empty($folders)) {
	if (!$this->check_connection()) {
	return false;
	}

	foreach ($folders as $folder) {
	$updated += (int) $this->conn->{$mode}($folder);
	}
	}

	// clear cached folders list(s)
	if ($updated) {
	$this->clear_cache('mailboxes', true);
	}

	return $updated == count($folders);
	}

	/**
	* Increde/decrese messagecount for a specific folder
	*/
	protected function set_messagecount($folder, $mode, $increment)
	{
	if (!is_numeric($increment)) {
	return false;
	}

	$mode = strtoupper($mode);
	$a_folder_cache = $this->get_cache('messagecount');

	if (!is_array($a_folder_cache[$folder]) \|\| !isset($a_folder_cache[$folder][$mode])) {
	return false;
	}

	// add incremental value to messagecount
	$a_folder_cache[$folder][$mode] += $increment;

	// there's something wrong, delete from cache
	if ($a_folder_cache[$folder][$mode] < 0) {
	unset($a_folder_cache[$folder][$mode]);
	}

	// write back to cache
	$this->update_cache('messagecount', $a_folder_cache);

	return true;
	}

	/**
	* Remove messagecount of a specific folder from cache
	*/
	protected function clear_messagecount($folder, $mode = array())
	{
	$a_folder_cache = $this->get_cache('messagecount');

	if (is_array($a_folder_cache[$folder])) {
	if (!empty($mode)) {
	foreach ((array) $mode as $key) {
	unset($a_folder_cache[$folder][$key]);
	}
	}
	else {
	unset($a_folder_cache[$folder]);
	}
	$this->update_cache('messagecount', $a_folder_cache);
	}
	}

	/**
	* Converts date string/object into IMAP date/time format
	*/
	protected function date_format($date)
	{
	if (empty($date)) {
	return null;
	}

	if (!is_object($date) \|\| !is_a($date, 'DateTime')) {
	try {
	$timestamp = rcube_utils::strtotime($date);
	$date = new DateTime("@".$timestamp);
	}
	catch (Exception $e) {
	return null;
	}
	}

	return $date->format('d-M-Y H:i:s O');
	}

	/**
	* Remember state of the IMAP connection (last IMAP command).
	* Use e.g. if you want to execute more commands and ignore results of these.
	*
	* @return array Connection state
	*/
	protected function save_conn_state()
	{
	return array(
	$this->conn->error,
	$this->conn->errornum,
	$this->conn->resultcode,
	);
	}

	/**
	* Restore saved connection state.
	*
	* @param array $state Connection result
	*/
	protected function restore_conn_state($state)
	{
	list($this->conn->error, $this->conn->errornum, $this->conn->resultcode) = $state;
	}

	/**
	* This is our own debug handler for the IMAP connection
	*/
	public function debug_handler($imap, $message)
	{
	rcube::write_log('imap', $message);
	}
	}
	diff --git a/program/lib/Roundcube/rcube_imap_generic.php b/program/lib/Roundcube/rcube_imap_generic.php
	index 65cb1e157..8a7ca5861 100644
	--- a/program/lib/Roundcube/rcube_imap_generic.php
	+++ b/program/lib/Roundcube/rcube_imap_generic.php
	@@ -1,4150 +1,4156 @@
	<?php

	/**
	+-----------------------------------------------------------------------+
	\| This file is part of the Roundcube Webmail client \|
	\| \|
	\| Copyright (C) The Roundcube Dev Team \|
	\| Copyright (C) Kolab Systems AG \|
	\| \|
	\| Licensed under the GNU General Public License version 3 or \|
	\| any later version with exceptions for skins & plugins. \|
	\| See the README file for a full license statement. \|
	\| \|
	\| PURPOSE: \|
	\| Provide alternative IMAP library that doesn't rely on the standard \|
	\| C-Client based version. This allows to function regardless \|
	\| of whether or not the PHP build it's running on has IMAP \|
	\| functionality built-in. \|
	\| \|
	\| Based on Iloha IMAP Library. See http://ilohamail.org/ for details \|
	+-----------------------------------------------------------------------+
	\| Author: Aleksander Machniak <alec@alec.pl> \|
	\| Author: Ryo Chijiiwa <Ryo@IlohaMail.org> \|
	+-----------------------------------------------------------------------+
	*/

	/**
	* PHP based wrapper class to connect to an IMAP server
	*
	* @package Framework
	* @subpackage Storage
	*/
	class rcube_imap_generic
	{
	public $error;
	public $errornum;
	public $result;
	public $resultcode;
	public $selected;
	public $data = array();
	public $flags = array(
	'SEEN' => '\\Seen',
	'DELETED' => '\\Deleted',
	'ANSWERED' => '\\Answered',
	'DRAFT' => '\\Draft',
	'FLAGGED' => '\\Flagged',
	'FORWARDED' => '$Forwarded',
	'MDNSENT' => '$MDNSent',
	'' => '\\',
	);

	protected $fp;
	protected $host;
	protected $user;
	protected $cmd_tag;
	protected $cmd_num = 0;
	protected $resourceid;
	protected $extensions_enabled;
	protected $prefs = array();
	protected $logged = false;
	protected $capability = array();
	protected $capability_readed = false;
	protected $debug = false;
	protected $debug_handler = false;

	const ERROR_OK = 0;
	const ERROR_NO = -1;
	const ERROR_BAD = -2;
	const ERROR_BYE = -3;
	const ERROR_UNKNOWN = -4;
	const ERROR_COMMAND = -5;
	const ERROR_READONLY = -6;

	const COMMAND_NORESPONSE = 1;
	const COMMAND_CAPABILITY = 2;
	const COMMAND_LASTLINE = 4;
	const COMMAND_ANONYMIZED = 8;

	const DEBUG_LINE_LENGTH = 4098; // 4KB + 2B for \r\n


	/**
	* Send simple (one line) command to the connection stream
	*
	* @param string $string Command string
	* @param bool $endln True if CRLF need to be added at the end of command
	* @param bool $anonymized Don't write the given data to log but a placeholder
	*
	* @param int Number of bytes sent, False on error
	*/
	protected function putLine($string, $endln = true, $anonymized = false)
	{
	if (!$this->fp) {
	return false;
	}

	if ($this->debug) {
	// anonymize the sent command for logging
	$cut = $endln ? 2 : 0;
	if ($anonymized && preg_match('/^(A\d+ (?:[A-Z]+ )+)(.+)/', $string, $m)) {
	$log = $m[1] . sprintf('****** [%d]', strlen($m[2]) - $cut);
	}
	else if ($anonymized) {
	$log = sprintf('****** [%d]', strlen($string) - $cut);
	}
	else {
	$log = rtrim($string);
	}

	$this->debug('C: ' . $log);
	}

	if ($endln) {
	$string .= "\r\n";
	}

	$res = fwrite($this->fp, $string);

	if ($res === false) {
	$this->closeSocket();
	}

	return $res;
	}

	/**
	* Send command to the connection stream with Command Continuation
	* Requests (RFC3501 7.5) and LITERAL+ (RFC2088) support
	*
	* @param string $string Command string
	* @param bool $endln True if CRLF need to be added at the end of command
	* @param bool $anonymized Don't write the given data to log but a placeholder
	*
	* @return int\|bool Number of bytes sent, False on error
	*/
	protected function putLineC($string, $endln=true, $anonymized=false)
	{
	if (!$this->fp) {
	return false;
	}

	if ($endln) {
	$string .= "\r\n";
	}

	$res = 0;
	if ($parts = preg_split('/(\{[0-9]+\}\r\n)/m', $string, -1, PREG_SPLIT_DELIM_CAPTURE)) {
	for ($i=0, $cnt=count($parts); $i<$cnt; $i++) {
	if ($i+1 < $cnt && preg_match('/^\{([0-9]+)\}\r\n$/', $parts[$i+1], $matches)) {
	// LITERAL+ support
	if ($this->prefs['literal+']) {
	$parts[$i+1] = sprintf("{%d+}\r\n", $matches[1]);
	}

	$bytes = $this->putLine($parts[$i].$parts[$i+1], false, $anonymized);
	if ($bytes === false) {
	return false;
	}

	$res += $bytes;

	// don't wait if server supports LITERAL+ capability
	if (!$this->prefs['literal+']) {
	$line = $this->readLine(1000);
	// handle error in command
	if ($line[0] != '+') {
	return false;
	}
	}

	$i++;
	}
	else {
	$bytes = $this->putLine($parts[$i], false, $anonymized);
	if ($bytes === false) {
	return false;
	}

	$res += $bytes;
	}
	}
	}

	return $res;
	}

	/**
	* Reads line from the connection stream
	*
	* @param int $size Buffer size
	*
	* @return string Line of text response
	*/
	protected function readLine($size = 1024)
	{
	$line = '';

	if (!$size) {
	$size = 1024;
	}

	do {
	if ($this->eof()) {
	return $line ?: null;
	}

	$buffer = fgets($this->fp, $size);

	if ($buffer === false) {
	$this->closeSocket();
	break;
	}

	if ($this->debug) {
	$this->debug('S: '. rtrim($buffer));
	}

	$line .= $buffer;
	}
	while (substr($buffer, -1) != "\n");

	return $line;
	}

	/**
	* Reads a line of data from the connection stream inluding all
	* string continuation literals.
	*
	* @param int $size Buffer size
	*
	* @return string Line of text response
	*/
	protected function readFullLine($size = 1024)
	{
	$line = $this->readLine($size);

	// include all string literels untile the real end of "line"
	while (preg_match('/\{([0-9]+)\}\r\n$/', $line, $m)) {
	$bytes = $m[1];
	$out = '';

	while (strlen($out) < $bytes) {
	$out = $this->readBytes($bytes);
	if ($out === null) {
	break;
	}

	$line .= $out;
	}

	$line .= $this->readLine($size);
	}

	return $line;
	}

	/**
	* Reads more data from the connection stream when provided
	* data contain string literal
	*
	* @param string $line Response text
	* @param bool $escape Enables escaping
	*
	* @return string Line of text response
	*/
	protected function multLine($line, $escape = false)
	{
	$line = rtrim($line);
	if (preg_match('/\{([0-9]+)\}$/', $line, $m)) {
	$out = '';
	$str = substr($line, 0, -strlen($m[0]));
	$bytes = $m[1];

	while (strlen($out) < $bytes) {
	$line = $this->readBytes($bytes);
	if ($line === null) {
	break;
	}

	$out .= $line;
	}

	$line = $str . ($escape ? $this->escape($out) : $out);
	}

	return $line;
	}

	/**
	* Reads specified number of bytes from the connection stream
	*
	* @param int $bytes Number of bytes to get
	*
	* @return string Response text
	*/
	protected function readBytes($bytes)
	{
	$data = '';
	$len = 0;

	while ($len < $bytes && !$this->eof()) {
	$d = fread($this->fp, $bytes-$len);
	if ($this->debug) {
	$this->debug('S: '. $d);
	}
	$data .= $d;
	$data_len = strlen($data);
	if ($len == $data_len) {
	break; // nothing was read -> exit to avoid apache lockups
	}
	$len = $data_len;
	}

	return $data;
	}

	/**
	* Reads complete response to the IMAP command
	*
	* @param array $untagged Will be filled with untagged response lines
	*
	* @return string Response text
	*/
	protected function readReply(&$untagged = null)
	{
	do {
	$line = trim($this->readLine(1024));
	// store untagged response lines
	if ($line[0] == '*') {
	$untagged[] = $line;
	}
	}
	while ($line[0] == '*');

	if ($untagged) {
	$untagged = implode("\n", $untagged);
	}

	return $line;
	}

	/**
	* Response parser.
	*
	* @param string $string Response text
	* @param string $err_prefix Error message prefix
	*
	* @return int Response status
	*/
	protected function parseResult($string, $err_prefix = '')
	{
	if (preg_match('/^[a-z0-9]+ (OK\|NO\|BAD\|BYE)(.)$/i', trim($string), $matches)) {
	$res = strtoupper($matches[1]);
	$str = trim($matches[2]);

	if ($res == 'OK') {
	$this->errornum = self::ERROR_OK;
	}
	else if ($res == 'NO') {
	$this->errornum = self::ERROR_NO;
	}
	else if ($res == 'BAD') {
	$this->errornum = self::ERROR_BAD;
	}
	else if ($res == 'BYE') {
	$this->closeSocket();
	$this->errornum = self::ERROR_BYE;
	}

	if ($str) {
	$str = trim($str);
	// get response string and code (RFC5530)
	if (preg_match("/^\[([a-z-]+)\]/i", $str, $m)) {
	$this->resultcode = strtoupper($m[1]);
	$str = trim(substr($str, strlen($m[1]) + 2));
	}
	else {
	$this->resultcode = null;
	// parse response for [APPENDUID 1204196876 3456]
	if (preg_match("/^\[APPENDUID [0-9]+ ([0-9]+)\]/i", $str, $m)) {
	$this->data['APPENDUID'] = $m[1];
	}
	// parse response for [COPYUID 1204196876 3456:3457 123:124]
	else if (preg_match("/^\[COPYUID [0-9]+ ([0-9,:]+) ([0-9,:]+)\]/i", $str, $m)) {
	$this->data['COPYUID'] = array($m[1], $m[2]);
	}
	}

	$this->result = $str;

	if ($this->errornum != self::ERROR_OK) {
	$this->error = $err_prefix ? $err_prefix.$str : $str;
	}
	}

	return $this->errornum;
	}

	return self::ERROR_UNKNOWN;
	}

	/**
	* Checks connection stream state.
	*
	* @return bool True if connection is closed
	*/
	protected function eof()
	{
	if (!is_resource($this->fp)) {
	return true;
	}

	// If a connection opened by fsockopen() wasn't closed
	// by the server, feof() will hang.
	$start = microtime(true);

	if (feof($this->fp) \|\|
	($this->prefs['timeout'] && (microtime(true) - $start > $this->prefs['timeout']))
	) {
	$this->closeSocket();
	return true;
	}

	return false;
	}

	/**
	* Closes connection stream.
	*/
	protected function closeSocket()
	{
	if ($this->fp) {
	fclose($this->fp);
	$this->fp = null;
	}
	}

	/**
	* Error code/message setter.
	*/
	protected function setError($code, $msg = '')
	{
	$this->errornum = $code;
	$this->error = $msg;

	return $code;
	}

	/**
	* Checks response status.
	* Checks if command response line starts with specified prefix (or * BYE/BAD)
	*
	* @param string $string Response text
	* @param string $match Prefix to match with (case-sensitive)
	* @param bool $error Enables BYE/BAD checking
	* @param bool $nonempty Enables empty response checking
	*
	* @return bool True any check is true or connection is closed.
	*/
	protected function startsWith($string, $match, $error = false, $nonempty = false)
	{
	if (!$this->fp) {
	return true;
	}

	if (strncmp($string, $match, strlen($match)) == 0) {
	return true;
	}

	if ($error && preg_match('/^\* (BYE\|BAD) /i', $string, $m)) {
	if (strtoupper($m[1]) == 'BYE') {
	$this->closeSocket();
	}
	return true;
	}

	if ($nonempty && !strlen($string)) {
	return true;
	}

	return false;
	}

	/**
	* Capabilities checker
	*/
	protected function hasCapability($name)
	{
	if (empty($this->capability) \|\| $name == '') {
	return false;
	}

	if (in_array($name, $this->capability)) {
	return true;
	}
	else if (strpos($name, '=')) {
	return false;
	}

	$result = array();
	foreach ($this->capability as $cap) {
	$entry = explode('=', $cap);
	if ($entry[0] == $name) {
	$result[] = $entry[1];
	}
	}

	return $result ?: false;
	}

	/**
	* Capabilities checker
	*
	* @param string $name Capability name
	*
	* @return mixed Capability values array for key=value pairs, true/false for others
	*/
	public function getCapability($name)
	{
	$result = $this->hasCapability($name);

	if (!empty($result)) {
	return $result;
	}
	else if ($this->capability_readed) {
	return false;
	}

	// get capabilities (only once) because initial
	// optional CAPABILITY response may differ
	$result = $this->execute('CAPABILITY');

	if ($result[0] == self::ERROR_OK) {
	$this->parseCapability($result[1]);
	}

	$this->capability_readed = true;

	return $this->hasCapability($name);
	}

	/**
	* Clears detected server capabilities
	*/
	public function clearCapability()
	{
	$this->capability = array();
	$this->capability_readed = false;
	}

	/**
	* DIGEST-MD5/CRAM-MD5/PLAIN Authentication
	*
	* @param string $user Username
	* @param string $pass Password
	* @param string $type Authentication type (PLAIN/CRAM-MD5/DIGEST-MD5)
	*
	* @return resource Connection resourse on success, error code on error
	*/
	protected function authenticate($user, $pass, $type = 'PLAIN')
	{
	if ($type == 'CRAM-MD5' \|\| $type == 'DIGEST-MD5') {
	if ($type == 'DIGEST-MD5' && !class_exists('Auth_SASL')) {
	return $this->setError(self::ERROR_BYE,
	"The Auth_SASL package is required for DIGEST-MD5 authentication");
	}

	$this->putLine($this->nextTag() . " AUTHENTICATE $type");
	$line = trim($this->readReply());

	if ($line[0] == '+') {
	$challenge = substr($line, 2);
	}
	else {
	return $this->parseResult($line);
	}

	if ($type == 'CRAM-MD5') {
	// RFC2195: CRAM-MD5
	$ipad = '';
	$opad = '';
	$xor = function($str1, $str2) {
	$result = '';
	$size = strlen($str1);
	for ($i=0; $i<$size; $i++) {
	$result .= chr(ord($str1[$i]) ^ ord($str2[$i]));
	}
	return $result;
	};

	// initialize ipad, opad
	for ($i=0; $i<64; $i++) {
	$ipad .= chr(0x36);
	$opad .= chr(0x5C);
	}

	// pad $pass so it's 64 bytes
	$pass = str_pad($pass, 64, chr(0));

	// generate hash
	$hash = md5($xor($pass, $opad) . pack("H*",
	md5($xor($pass, $ipad) . base64_decode($challenge))));
	$reply = base64_encode($user . ' ' . $hash);

	// send result
	$this->putLine($reply, true, true);
	}
	else {
	// RFC2831: DIGEST-MD5
	// proxy authorization
	if (!empty($this->prefs['auth_cid'])) {
	$authc = $this->prefs['auth_cid'];
	$pass = $this->prefs['auth_pw'];
	}
	else {
	$authc = $user;
	$user = '';
	}

	$auth_sasl = new Auth_SASL;
	$auth_sasl = $auth_sasl->factory('digestmd5');
	$reply = base64_encode($auth_sasl->getResponse($authc, $pass,
	base64_decode($challenge), $this->host, 'imap', $user));

	// send result
	$this->putLine($reply, true, true);
	$line = trim($this->readReply());

	if ($line[0] != '+') {
	return $this->parseResult($line);
	}

	// check response
	$challenge = substr($line, 2);
	$challenge = base64_decode($challenge);
	if (strpos($challenge, 'rspauth=') === false) {
	return $this->setError(self::ERROR_BAD,
	"Unexpected response from server to DIGEST-MD5 response");
	}

	$this->putLine('');
	}

	$line = $this->readReply();
	$result = $this->parseResult($line);
	}
	else if ($type == 'GSSAPI') {
	if (!extension_loaded('krb5')) {
	return $this->setError(self::ERROR_BYE,
	"The krb5 extension is required for GSSAPI authentication");
	}

	if (empty($this->prefs['gssapi_cn'])) {
	return $this->setError(self::ERROR_BYE,
	"The gssapi_cn parameter is required for GSSAPI authentication");
	}

	if (empty($this->prefs['gssapi_context'])) {
	return $this->setError(self::ERROR_BYE,
	"The gssapi_context parameter is required for GSSAPI authentication");
	}

	putenv('KRB5CCNAME=' . $this->prefs['gssapi_cn']);

	try {
	$ccache = new KRB5CCache();
	$ccache->open($this->prefs['gssapi_cn']);
	$gssapicontext = new GSSAPIContext();
	$gssapicontext->acquireCredentials($ccache);

	$token = '';
	$success = $gssapicontext->initSecContext($this->prefs['gssapi_context'], null, null, null, $token);
	$token = base64_encode($token);
	}
	catch (Exception $e) {
	trigger_error($e->getMessage(), E_USER_WARNING);
	return $this->setError(self::ERROR_BYE, "GSSAPI authentication failed");
	}

	$this->putLine($this->nextTag() . " AUTHENTICATE GSSAPI " . $token);
	$line = trim($this->readReply());

	if ($line[0] != '+') {
	return $this->parseResult($line);
	}

	try {
	$itoken = base64_decode(substr($line, 2));

	if (!$gssapicontext->unwrap($itoken, $itoken)) {
	throw new Exception("GSSAPI SASL input token unwrap failed");
	}

	if (strlen($itoken) < 4) {
	throw new Exception("GSSAPI SASL input token invalid");
	}

	// Integrity/encryption layers are not supported. The first bit
	// indicates that the server supports "no security layers".
	// 0x00 should not occur, but support broken implementations.
	$server_layers = ord($itoken[0]);
	if ($server_layers && ($server_layers & 0x1) != 0x1) {
	throw new Exception("Server requires GSSAPI SASL integrity/encryption");
	}

	// Construct output token. 0x01 in the first octet = SASL layer "none",
	// zero in the following three octets = no data follows.
	// See https://github.com/cyrusimap/cyrus-sasl/blob/e41cfb986c1b1935770de554872247453fdbb079/plugins/gssapi.c#L1284
	if (!$gssapicontext->wrap(pack("CCCC", 0x1, 0, 0, 0), $otoken, true)) {
	throw new Exception("GSSAPI SASL output token wrap failed");
	}
	}
	catch (Exception $e) {
	trigger_error($e->getMessage(), E_USER_WARNING);
	return $this->setError(self::ERROR_BYE, "GSSAPI authentication failed");
	}

	$this->putLine(base64_encode($otoken));

	$line = $this->readReply();
	$result = $this->parseResult($line);
	}
	else if ($type == 'PLAIN') {
	// proxy authorization
	if (!empty($this->prefs['auth_cid'])) {
	$authc = $this->prefs['auth_cid'];
	$pass = $this->prefs['auth_pw'];
	}
	else {
	$authc = $user;
	$user = '';
	}

	$reply = base64_encode($user . chr(0) . $authc . chr(0) . $pass);

	// RFC 4959 (SASL-IR): save one round trip
	if ($this->getCapability('SASL-IR')) {
	list($result, $line) = $this->execute("AUTHENTICATE PLAIN", array($reply),
	self::COMMAND_LASTLINE \| self::COMMAND_CAPABILITY \| self::COMMAND_ANONYMIZED);
	}
	else {
	$this->putLine($this->nextTag() . " AUTHENTICATE PLAIN");
	$line = trim($this->readReply());

	if ($line[0] != '+') {
	return $this->parseResult($line);
	}

	// send result, get reply and process it
	$this->putLine($reply, true, true);
	$line = $this->readReply();
	$result = $this->parseResult($line);
	}
	}
	else if ($type == 'LOGIN') {
	$this->putLine($this->nextTag() . " AUTHENTICATE LOGIN");

	$line = trim($this->readReply());
	if ($line[0] != '+') {
	return $this->parseResult($line);
	}

	$this->putLine(base64_encode($user), true, true);

	$line = trim($this->readReply());
	if ($line[0] != '+') {
	return $this->parseResult($line);
	}

	// send result, get reply and process it
	$this->putLine(base64_encode($pass), true, true);

	$line = $this->readReply();
	$result = $this->parseResult($line);
	}
	else if ($type == 'XOAUTH2') {
	$auth = base64_encode("user=$user\1auth=$pass\1\1");
	$this->putLine($this->nextTag() . " AUTHENTICATE XOAUTH2 $auth", true, true);

	$line = trim($this->readReply());

	if ($line[0] == '+') {
	// send empty line
	$this->putLine('', true, true);
	$line = $this->readReply();
	}

	$result = $this->parseResult($line);
	}
	else {
	$line = 'not supported';
	$result = self::ERROR_UNKNOWN;
	}

	if ($result === self::ERROR_OK) {
	// optional CAPABILITY response
	if ($line && preg_match('/\[CAPABILITY ([^]]+)\]/i', $line, $matches)) {
	$this->parseCapability($matches[1], true);
	}

	return $this->fp;
	}

	return $this->setError($result, "AUTHENTICATE $type: $line");
	}

	/**
	* LOGIN Authentication
	*
	* @param string $user Username
	* @param string $pass Password
	*
	* @return resource Connection resourse on success, error code on error
	*/
	protected function login($user, $password)
	{
	// Prevent from sending credentials in plain text when connection is not secure
	if ($this->getCapability('LOGINDISABLED')) {
	return $this->setError(self::ERROR_BAD, "Login disabled by IMAP server");
	}

	list($code, $response) = $this->execute('LOGIN', array(
	$this->escape($user), $this->escape($password)), self::COMMAND_CAPABILITY \| self::COMMAND_ANONYMIZED);

	// re-set capabilities list if untagged CAPABILITY response provided
	if (preg_match('/\* CAPABILITY (.+)/i', $response, $matches)) {
	$this->parseCapability($matches[1], true);
	}

	if ($code == self::ERROR_OK) {
	return $this->fp;
	}

	return $code;
	}

	/**
	* Detects hierarchy delimiter
	*
	* @return string The delimiter
	*/
	public function getHierarchyDelimiter()
	{
	if ($this->prefs['delimiter']) {
	return $this->prefs['delimiter'];
	}

	// try (LIST "" ""), should return delimiter (RFC2060 Sec 6.3.8)
	list($code, $response) = $this->execute('LIST',
	array($this->escape(''), $this->escape('')));

	if ($code == self::ERROR_OK) {
	$args = $this->tokenizeResponse($response, 4);
	$delimiter = $args[3];

	if (strlen($delimiter) > 0) {
	return ($this->prefs['delimiter'] = $delimiter);
	}
	}
	}

	/**
	* NAMESPACE handler (RFC 2342)
	*
	* @return array Namespace data hash (personal, other, shared)
	*/
	public function getNamespace()
	{
	if (array_key_exists('namespace', $this->prefs)) {
	return $this->prefs['namespace'];
	}

	if (!$this->getCapability('NAMESPACE')) {
	return self::ERROR_BAD;
	}

	list($code, $response) = $this->execute('NAMESPACE');

	if ($code == self::ERROR_OK && preg_match('/^\* NAMESPACE /', $response)) {
	$response = substr($response, 11);
	$data = $this->tokenizeResponse($response);
	}

	if (!isset($data) \|\| !is_array($data)) {
	return $code;
	}

	$this->prefs['namespace'] = array(
	'personal' => $data[0],
	'other' => $data[1],
	'shared' => $data[2],
	);

	return $this->prefs['namespace'];
	}

	/**
	* Connects to IMAP server and authenticates.
	*
	* @param string $host Server hostname or IP
	* @param string $user User name
	* @param string $password Password
	* @param array $options Connection and class options
	*
	* @return bool True on success, False on failure
	*/
	public function connect($host, $user, $password, $options = array())
	{
	// configure
	$this->set_prefs($options);

	$this->host = $host;
	$this->user = $user;
	$this->logged = false;
	$this->selected = null;

	// check input
	if (empty($host)) {
	$this->setError(self::ERROR_BAD, "Empty host");
	return false;
	}

	if (empty($user)) {
	$this->setError(self::ERROR_NO, "Empty user");
	return false;
	}

	if (empty($password) && empty($options['gssapi_cn'])) {
	$this->setError(self::ERROR_NO, "Empty password");
	return false;
	}

	// Connect
	if (!$this->_connect($host)) {
	return false;
	}

	// Send ID info
	if (!empty($this->prefs['ident']) && $this->getCapability('ID')) {
	$this->data['ID'] = $this->id($this->prefs['ident']);
	}

	$auth_method = $this->prefs['auth_type'];
	$auth_methods = array();
	$result = null;

	// check for supported auth methods
	if (!$auth_method \|\| $auth_method == 'CHECK') {
	if ($auth_caps = $this->getCapability('AUTH')) {
	$auth_methods = $auth_caps;
	}

	// Use best (for security) supported authentication method
	$all_methods = array('DIGEST-MD5', 'CRAM-MD5', 'CRAM_MD5', 'PLAIN', 'LOGIN');

	if (!empty($this->prefs['gssapi_cn'])) {
	array_unshift($all_methods, 'GSSAPI');
	}

	foreach ($all_methods as $auth_method) {
	if (in_array($auth_method, $auth_methods)) {
	break;
	}
	}

	// Prefer LOGIN over AUTHENTICATE LOGIN for performance reasons
	if ($auth_method == 'LOGIN' && !$this->getCapability('LOGINDISABLED')) {
	$auth_method = 'IMAP';
	}
	}

	// pre-login capabilities can be not complete
	$this->capability_readed = false;

	// Authenticate
	switch ($auth_method) {
	case 'CRAM_MD5':
	$auth_method = 'CRAM-MD5';
	case 'CRAM-MD5':
	case 'DIGEST-MD5':
	case 'GSSAPI':
	case 'PLAIN':
	case 'LOGIN':
	case 'XOAUTH2':
	$result = $this->authenticate($user, $password, $auth_method);
	break;

	case 'IMAP':
	$result = $this->login($user, $password);
	break;

	default:
	$this->setError(self::ERROR_BAD, "Configuration error. Unknown auth method: $auth_method");
	}

	// Connected and authenticated
	if (is_resource($result)) {
	if (!empty($this->prefs['force_caps'])) {
	$this->clearCapability();
	}
	$this->logged = true;

	return true;
	}

	$this->closeConnection();

	return false;
	}

	/**
	* Connects to IMAP server.
	*
	* @param string $host Server hostname or IP
	*
	* @return bool True on success, False on failure
	*/
	protected function _connect($host)
	{
	// initialize connection
	$this->error = '';
	$this->errornum = self::ERROR_OK;

	if (!$this->prefs['port']) {
	$this->prefs['port'] = 143;
	}

	// check for SSL
	if (!empty($this->prefs['ssl_mode']) && $this->prefs['ssl_mode'] != 'tls') {
	$host = $this->prefs['ssl_mode'] . '://' . $host;
	}

	if (empty($this->prefs['timeout']) \|\| $this->prefs['timeout'] < 0) {
	$this->prefs['timeout'] = max(0, intval(ini_get('default_socket_timeout')));
	}

	if ($this->debug) {
	// set connection identifier for debug output
	$this->resourceid = strtoupper(substr(md5(microtime() . $host . $this->user), 0, 4));

	$_host = ($this->prefs['ssl_mode'] == 'tls' ? 'tls://' : '') . $host . ':' . $this->prefs['port'];
	$this->debug("Connecting to $_host...");
	}

	if (!empty($this->prefs['socket_options'])) {
	$context = stream_context_create($this->prefs['socket_options']);
	$this->fp = stream_socket_client($host . ':' . $this->prefs['port'], $errno, $errstr,
	$this->prefs['timeout'], STREAM_CLIENT_CONNECT, $context);
	}
	else {
	$this->fp = @fsockopen($host, $this->prefs['port'], $errno, $errstr, $this->prefs['timeout']);
	}

	if (!$this->fp) {
	$this->setError(self::ERROR_BAD, sprintf("Could not connect to %s:%d: %s",
	$host, $this->prefs['port'], $errstr ?: "Unknown reason"));

	return false;
	}

	if ($this->prefs['timeout'] > 0) {
	stream_set_timeout($this->fp, $this->prefs['timeout']);
	}

	$line = trim(fgets($this->fp, 8192));

	if ($this->debug && $line) {
	$this->debug('S: '. $line);
	}

	// Connected to wrong port or connection error?
	if (!preg_match('/^\* (OK\|PREAUTH)/i', $line)) {
	if ($line)
	$error = sprintf("Wrong startup greeting (%s:%d): %s", $host, $this->prefs['port'], $line);
	else
	$error = sprintf("Empty startup greeting (%s:%d)", $host, $this->prefs['port']);

	$this->setError(self::ERROR_BAD, $error);
	$this->closeConnection();
	return false;
	}

	$this->data['GREETING'] = trim(preg_replace('/\[[^\]]+\]\s*/', '', $line));

	// RFC3501 [7.1] optional CAPABILITY response
	if (preg_match('/\[CAPABILITY ([^]]+)\]/i', $line, $matches)) {
	$this->parseCapability($matches[1], true);
	}

	// TLS connection
	if ($this->prefs['ssl_mode'] == 'tls' && $this->getCapability('STARTTLS')) {
	$res = $this->execute('STARTTLS');

	if ($res[0] != self::ERROR_OK) {
	$this->closeConnection();
	return false;
	}

	if (isset($this->prefs['socket_options']['ssl']['crypto_method'])) {
	$crypto_method = $this->prefs['socket_options']['ssl']['crypto_method'];
	}
	else {
	// There is no flag to enable all TLS methods. Net_SMTP
	// handles enabling TLS similarly.
	$crypto_method = STREAM_CRYPTO_METHOD_TLS_CLIENT
	\| @STREAM_CRYPTO_METHOD_TLSv1_1_CLIENT
	\| @STREAM_CRYPTO_METHOD_TLSv1_2_CLIENT;
	}

	if (!stream_socket_enable_crypto($this->fp, true, $crypto_method)) {
	$this->setError(self::ERROR_BAD, "Unable to negotiate TLS");
	$this->closeConnection();
	return false;
	}

	// Now we're secure, capabilities need to be reread
	$this->clearCapability();
	}

	return true;
	}

	/**
	* Initializes environment
	*/
	protected function set_prefs($prefs)
	{
	// set preferences
	if (is_array($prefs)) {
	$this->prefs = $prefs;
	}

	// set auth method
	if (!empty($this->prefs['auth_type'])) {
	$this->prefs['auth_type'] = strtoupper($this->prefs['auth_type']);
	}
	else {
	$this->prefs['auth_type'] = 'CHECK';
	}

	// disabled capabilities
	if (!empty($this->prefs['disabled_caps'])) {
	$this->prefs['disabled_caps'] = array_map('strtoupper', (array)$this->prefs['disabled_caps']);
	}

	// additional message flags
	if (!empty($this->prefs['message_flags'])) {
	$this->flags = array_merge($this->flags, $this->prefs['message_flags']);
	unset($this->prefs['message_flags']);
	}
	}

	/**
	* Checks connection status
	*
	* @return bool True if connection is active and user is logged in, False otherwise.
	*/
	public function connected()
	{
	return $this->fp && $this->logged;
	}

	/**
	* Closes connection with logout.
	*/
	public function closeConnection()
	{
	if ($this->logged && $this->putLine($this->nextTag() . ' LOGOUT')) {
	$this->readReply();
	}

	$this->closeSocket();
	}

	/**
	* Executes SELECT command (if mailbox is already not in selected state)
	*
	* @param string $mailbox Mailbox name
	* @param array $qresync_data QRESYNC data (RFC5162)
	*
	* @return boolean True on success, false on error
	*/
	public function select($mailbox, $qresync_data = null)
	{
	if (!strlen($mailbox)) {
	return false;
	}

	if ($this->selected === $mailbox) {
	return true;
	}

	$params = array($this->escape($mailbox));

	// QRESYNC data items
	// 0. the last known UIDVALIDITY,
	// 1. the last known modification sequence,
	// 2. the optional set of known UIDs, and
	// 3. an optional parenthesized list of known sequence ranges and their
	// corresponding UIDs.
	if (!empty($qresync_data)) {
	if (!empty($qresync_data[2])) {
	$qresync_data[2] = self::compressMessageSet($qresync_data[2]);
	}

	$params[] = array('QRESYNC', $qresync_data);
	}

	list($code, $response) = $this->execute('SELECT', $params);

	if ($code == self::ERROR_OK) {
	$this->clear_mailbox_cache();

	$response = explode("\r\n", $response);
	foreach ($response as $line) {
	if (preg_match('/^\* OK \[/i', $line)) {
	$pos = strcspn($line, ' ]', 6);
	$token = strtoupper(substr($line, 6, $pos));
	$pos += 7;

	switch ($token) {
	case 'UIDNEXT':
	case 'UIDVALIDITY':
	case 'UNSEEN':
	if ($len = strspn($line, '0123456789', $pos)) {
	$this->data[$token] = (int) substr($line, $pos, $len);
	}
	break;

	case 'HIGHESTMODSEQ':
	if ($len = strspn($line, '0123456789', $pos)) {
	$this->data[$token] = (string) substr($line, $pos, $len);
	}
	break;

	case 'NOMODSEQ':
	$this->data[$token] = true;
	break;

	case 'PERMANENTFLAGS':
	$start = strpos($line, '(', $pos);
	$end = strrpos($line, ')');
	if ($start && $end) {
	$flags = substr($line, $start + 1, $end - $start - 1);
	$this->data[$token] = explode(' ', $flags);
	}
	break;
	}
	}
	else if (preg_match('/^\* ([0-9]+) (EXISTS\|RECENT\|FETCH)/i', $line, $match)) {
	$token = strtoupper($match[2]);
	switch ($token) {
	case 'EXISTS':
	case 'RECENT':
	$this->data[$token] = (int) $match[1];
	break;

	case 'FETCH':
	// QRESYNC FETCH response (RFC5162)
	$line = substr($line, strlen($match[0]));
	$fetch_data = $this->tokenizeResponse($line, 1);
	$data = array('id' => $match[1]);

	for ($i=0, $size=count($fetch_data); $i<$size; $i+=2) {
	$data[strtolower($fetch_data[$i])] = $fetch_data[$i+1];
	}

	$this->data['QRESYNC'][$data['uid']] = $data;
	break;
	}
	}
	// QRESYNC VANISHED response (RFC5162)
	else if (preg_match('/^\* VANISHED [()EARLIER]*/i', $line, $match)) {
	$line = substr($line, strlen($match[0]));
	$v_data = $this->tokenizeResponse($line, 1);

	$this->data['VANISHED'] = $v_data;
	}
	}

	$this->data['READ-WRITE'] = $this->resultcode != 'READ-ONLY';
	$this->selected = $mailbox;

	return true;
	}

	return false;
	}

	/**
	* Executes STATUS command
	*
	* @param string $mailbox Mailbox name
	* @param array $items Additional requested item names. By default
	* MESSAGES and UNSEEN are requested. Other defined
	* in RFC3501: UIDNEXT, UIDVALIDITY, RECENT
	*
	* @return array Status item-value hash
	* @since 0.5-beta
	*/
	public function status($mailbox, $items = array())
	{
	if (!strlen($mailbox)) {
	return false;
	}

	if (!in_array('MESSAGES', $items)) {
	$items[] = 'MESSAGES';
	}
	if (!in_array('UNSEEN', $items)) {
	$items[] = 'UNSEEN';
	}

	list($code, $response) = $this->execute('STATUS',
	array($this->escape($mailbox), '(' . implode(' ', $items) . ')'), 0, '/^\* STATUS /i');

	if ($code == self::ERROR_OK && $response) {
	$result = array();
	$response = substr($response, 9); // remove prefix "* STATUS "

	list($mbox, $items) = $this->tokenizeResponse($response, 2);

	// Fix for #1487859. Some buggy server returns not quoted
	// folder name with spaces. Let's try to handle this situation
	if (!is_array($items) && ($pos = strpos($response, '(')) !== false) {
	$response = substr($response, $pos);
	$items = $this->tokenizeResponse($response, 1);
	}

	if (!is_array($items)) {
	return $result;
	}

	for ($i=0, $len=count($items); $i<$len; $i += 2) {
	$result[$items[$i]] = $items[$i+1];
	}

	$this->data['STATUS:'.$mailbox] = $result;

	return $result;
	}

	return false;
	}

	/**
	* Executes EXPUNGE command
	*
	* @param string $mailbox Mailbox name
	* @param string\|array $messages Message UIDs to expunge
	*
	* @return boolean True on success, False on error
	*/
	public function expunge($mailbox, $messages = null)
	{
	if (!$this->select($mailbox)) {
	return false;
	}

	if (!$this->data['READ-WRITE']) {
	$this->setError(self::ERROR_READONLY, "Mailbox is read-only");
	return false;
	}

	// Clear internal status cache
	$this->clear_status_cache($mailbox);

	if (!empty($messages) && $messages != '*' && $this->hasCapability('UIDPLUS')) {
	$messages = self::compressMessageSet($messages);
	$result = $this->execute('UID EXPUNGE', array($messages), self::COMMAND_NORESPONSE);
	}
	else {
	$result = $this->execute('EXPUNGE', null, self::COMMAND_NORESPONSE);
	}

	if ($result == self::ERROR_OK) {
	$this->selected = null; // state has changed, need to reselect
	return true;
	}

	return false;
	}

	/**
	* Executes CLOSE command
	*
	* @return boolean True on success, False on error
	* @since 0.5
	*/
	public function close()
	{
	$result = $this->execute('CLOSE', null, self::COMMAND_NORESPONSE);

	if ($result == self::ERROR_OK) {
	$this->selected = null;
	return true;
	}

	return false;
	}

	/**
	* Folder subscription (SUBSCRIBE)
	*
	* @param string $mailbox Mailbox name
	*
	* @return boolean True on success, False on error
	*/
	public function subscribe($mailbox)
	{
	$result = $this->execute('SUBSCRIBE', array($this->escape($mailbox)),
	self::COMMAND_NORESPONSE);

	return $result == self::ERROR_OK;
	}

	/**
	* Folder unsubscription (UNSUBSCRIBE)
	*
	* @param string $mailbox Mailbox name
	*
	* @return boolean True on success, False on error
	*/
	public function unsubscribe($mailbox)
	{
	$result = $this->execute('UNSUBSCRIBE', array($this->escape($mailbox)),
	self::COMMAND_NORESPONSE);

	return $result == self::ERROR_OK;
	}

	/**
	* Folder creation (CREATE)
	*
	* @param string $mailbox Mailbox name
	* @param array $types Optional folder types (RFC 6154)
	*
	* @return bool True on success, False on error
	*/
	public function createFolder($mailbox, $types = null)
	{
	$args = array($this->escape($mailbox));

	// RFC 6154: CREATE-SPECIAL-USE
	if (!empty($types) && $this->getCapability('CREATE-SPECIAL-USE')) {
	$args[] = '(USE (' . implode(' ', $types) . '))';
	}

	$result = $this->execute('CREATE', $args, self::COMMAND_NORESPONSE);

	return $result == self::ERROR_OK;
	}

	/**
	* Folder renaming (RENAME)
	*
	* @param string $mailbox Mailbox name
	*
	* @return bool True on success, False on error
	*/
	public function renameFolder($from, $to)
	{
	$result = $this->execute('RENAME', array($this->escape($from), $this->escape($to)),
	self::COMMAND_NORESPONSE);

	return $result == self::ERROR_OK;
	}

	/**
	* Executes DELETE command
	*
	* @param string $mailbox Mailbox name
	*
	* @return boolean True on success, False on error
	*/
	public function deleteFolder($mailbox)
	{
	$result = $this->execute('DELETE', array($this->escape($mailbox)),
	self::COMMAND_NORESPONSE);

	return $result == self::ERROR_OK;
	}

	/**
	* Removes all messages in a folder
	*
	* @param string $mailbox Mailbox name
	*
	* @return boolean True on success, False on error
	*/
	public function clearFolder($mailbox)
	{
	if ($this->countMessages($mailbox) > 0) {
	$res = $this->flag($mailbox, '1:*', 'DELETED');
	}

	if (!empty($res)) {
	if ($this->selected === $mailbox) {
	$res = $this->close();
	}
	else {
	$res = $this->expunge($mailbox);
	}
	}

	return $res;
	}

	/**
	* Returns list of mailboxes
	*
	* @param string $ref Reference name
	* @param string $mailbox Mailbox name
	* @param array $return_opts (see self::_listMailboxes)
	* @param array $select_opts (see self::_listMailboxes)
	*
	* @return array\|bool List of mailboxes or hash of options if STATUS/MYRIGHTS response
	* is requested, False on error.
	*/
	public function listMailboxes($ref, $mailbox, $return_opts = array(), $select_opts = array())
	{
	return $this->_listMailboxes($ref, $mailbox, false, $return_opts, $select_opts);
	}

	/**
	* Returns list of subscribed mailboxes
	*
	* @param string $ref Reference name
	* @param string $mailbox Mailbox name
	* @param array $return_opts (see self::_listMailboxes)
	*
	* @return array\|bool List of mailboxes or hash of options if STATUS/MYRIGHTS response
	* is requested, False on error.
	*/
	public function listSubscribed($ref, $mailbox, $return_opts = array())
	{
	return $this->_listMailboxes($ref, $mailbox, true, $return_opts, null);
	}

	/**
	* IMAP LIST/LSUB command
	*
	* @param string $ref Reference name
	* @param string $mailbox Mailbox name
	* @param bool $subscribed Enables returning subscribed mailboxes only
	* @param array $return_opts List of RETURN options (RFC5819: LIST-STATUS, RFC5258: LIST-EXTENDED)
	* Possible: MESSAGES, RECENT, UIDNEXT, UIDVALIDITY, UNSEEN,
	* MYRIGHTS, SUBSCRIBED, CHILDREN
	* @param array $select_opts List of selection options (RFC5258: LIST-EXTENDED)
	* Possible: SUBSCRIBED, RECURSIVEMATCH, REMOTE,
	* SPECIAL-USE (RFC6154)
	*
	* @return array\|bool List of mailboxes or hash of options if STATUS/MYRIGHTS response
	* is requested, False on error.
	*/
	protected function _listMailboxes($ref, $mailbox, $subscribed = false,
	$return_opts = array(), $select_opts = array())
	{
	if (!strlen($mailbox)) {
	$mailbox = '*';
	}

	$lstatus = false;
	$args = array();
	$rets = array();

	if (!empty($select_opts) && $this->getCapability('LIST-EXTENDED')) {
	$select_opts = (array) $select_opts;

	$args[] = '(' . implode(' ', $select_opts) . ')';
	}

	$args[] = $this->escape($ref);
	$args[] = $this->escape($mailbox);

	if (!empty($return_opts) && $this->getCapability('LIST-EXTENDED')) {
	$ext_opts = array('SUBSCRIBED', 'CHILDREN');
	$rets = array_intersect($return_opts, $ext_opts);
	$return_opts = array_diff($return_opts, $rets);
	}

	if (!empty($return_opts) && $this->getCapability('LIST-STATUS')) {
	$lstatus = true;
	$status_opts = array('MESSAGES', 'RECENT', 'UIDNEXT', 'UIDVALIDITY', 'UNSEEN', 'SIZE');
	$opts = array_diff($return_opts, $status_opts);
	$status_opts = array_diff($return_opts, $opts);

	if (!empty($status_opts)) {
	$rets[] = 'STATUS (' . implode(' ', $status_opts) . ')';
	}

	if (!empty($opts)) {
	$rets = array_merge($rets, $opts);
	}
	}

	if (!empty($rets)) {
	$args[] = 'RETURN (' . implode(' ', $rets) . ')';
	}

	list($code, $response) = $this->execute($subscribed ? 'LSUB' : 'LIST', $args);

	if ($code == self::ERROR_OK) {
	$folders = array();
	$last = 0;
	$pos = 0;
	$response .= "\r\n";

	while ($pos = strpos($response, "\r\n", $pos+1)) {
	// literal string, not real end-of-command-line
	if ($response[$pos-1] == '}') {
	continue;
	}

	$line = substr($response, $last, $pos - $last);
	$last = $pos + 2;

	if (!preg_match('/^\* (LIST\|LSUB\|STATUS\|MYRIGHTS) /i', $line, $m)) {
	continue;
	}

	$cmd = strtoupper($m[1]);
	$line = substr($line, strlen($m[0]));

	// * LIST (<options>) <delimiter> <mailbox>
	if ($cmd == 'LIST' \|\| $cmd == 'LSUB') {
	list($opts, $delim, $mailbox) = $this->tokenizeResponse($line, 3);

	// Remove redundant separator at the end of folder name, UW-IMAP bug? (#1488879)
	if ($delim) {
	$mailbox = rtrim($mailbox, $delim);
	}

	// Add to result array
	if (!$lstatus) {
	$folders[] = $mailbox;
	}
	else {
	$folders[$mailbox] = array();
	}

	// store folder options
	if ($cmd == 'LIST') {
	// Add to options array
	if (empty($this->data['LIST'][$mailbox])) {
	$this->data['LIST'][$mailbox] = $opts;
	}
	else if (!empty($opts)) {
	$this->data['LIST'][$mailbox] = array_unique(array_merge(
	$this->data['LIST'][$mailbox], $opts));
	}
	}
	}
	else if ($lstatus) {
	// * STATUS <mailbox> (<result>)
	if ($cmd == 'STATUS') {
	list($mailbox, $status) = $this->tokenizeResponse($line, 2);

	for ($i=0, $len=count($status); $i<$len; $i += 2) {
	list($name, $value) = $this->tokenizeResponse($status, 2);
	$folders[$mailbox][$name] = $value;
	}
	}
	// * MYRIGHTS <mailbox> <acl>
	else if ($cmd == 'MYRIGHTS') {
	list($mailbox, $acl) = $this->tokenizeResponse($line, 2);
	$folders[$mailbox]['MYRIGHTS'] = $acl;
	}
	}
	}

	return $folders;
	}

	return false;
	}

	/**
	* Returns count of all messages in a folder
	*
	* @param string $mailbox Mailbox name
	*
	* @return int Number of messages, False on error
	*/
	public function countMessages($mailbox)
	{
	if ($this->selected === $mailbox && isset($this->data['EXISTS'])) {
	return $this->data['EXISTS'];
	}

	// Check internal cache
	- $cache = $this->data['STATUS:'.$mailbox];
	- if (!empty($cache) && isset($cache['MESSAGES'])) {
	- return (int) $cache['MESSAGES'];
	+ if (!empty($this->data['STATUS:'.$mailbox])) {
	+ $cache = $this->data['STATUS:'.$mailbox];
	+ if (isset($cache['MESSAGES'])) {
	+ return (int) $cache['MESSAGES'];
	+ }
	}

	// Try STATUS (should be faster than SELECT)
	$counts = $this->status($mailbox);
	if (is_array($counts)) {
	return (int) $counts['MESSAGES'];
	}

	return false;
	}

	/**
	* Returns count of messages with \Recent flag in a folder
	*
	* @param string $mailbox Mailbox name
	*
	* @return int Number of messages, False on error
	*/
	public function countRecent($mailbox)
	{
	if ($this->selected === $mailbox && isset($this->data['RECENT'])) {
	return $this->data['RECENT'];
	}

	// Check internal cache
	$cache = $this->data['STATUS:'.$mailbox];
	if (!empty($cache) && isset($cache['RECENT'])) {
	return (int) $cache['RECENT'];
	}

	// Try STATUS (should be faster than SELECT)
	$counts = $this->status($mailbox, array('RECENT'));
	if (is_array($counts)) {
	return (int) $counts['RECENT'];
	}

	return false;
	}

	/**
	* Returns count of messages without \Seen flag in a specified folder
	*
	* @param string $mailbox Mailbox name
	*
	* @return int Number of messages, False on error
	*/
	public function countUnseen($mailbox)
	{
	// Check internal cache
	- $cache = $this->data['STATUS:'.$mailbox];
	- if (!empty($cache) && isset($cache['UNSEEN'])) {
	- return (int) $cache['UNSEEN'];
	+ if (!empty($this->data['STATUS:'.$mailbox])) {
	+ $cache = $this->data['STATUS:'.$mailbox];
	+ if (isset($cache['UNSEEN'])) {
	+ return (int) $cache['UNSEEN'];
	+ }
	}

	// Try STATUS (should be faster than SELECT+SEARCH)
	$counts = $this->status($mailbox);
	if (is_array($counts)) {
	return (int) $counts['UNSEEN'];
	}

	// Invoke SEARCH as a fallback
	$index = $this->search($mailbox, 'ALL UNSEEN', false, array('COUNT'));
	if (!$index->is_error()) {
	return $index->count();
	}

	return false;
	}

	/**
	* Executes ID command (RFC2971)
	*
	* @param array $items Client identification information key/value hash
	*
	* @return array\|false Server identification information key/value hash, False on error
	* @since 0.6
	*/
	public function id($items = array())
	{
	if (is_array($items) && !empty($items)) {
	foreach ($items as $key => $value) {
	$args[] = $this->escape($key, true);
	$args[] = $this->escape($value, true);
	}
	}

	list($code, $response) = $this->execute('ID',
	array(!empty($args) ? '(' . implode(' ', (array) $args) . ')' : $this->escape(null)),
	0, '/^\* ID /i');

	if ($code == self::ERROR_OK && $response) {
	$response = substr($response, 5); // remove prefix "* ID "
	$items = $this->tokenizeResponse($response, 1);
	$result = array();

	if (is_array($items)) {
	for ($i=0, $len=count($items); $i<$len; $i += 2) {
	$result[$items[$i]] = $items[$i+1];
	}
	}

	return $result;
	}

	return false;
	}

	/**
	* Executes ENABLE command (RFC5161)
	*
	* @param mixed $extension Extension name to enable (or array of names)
	*
	* @return array\|bool List of enabled extensions, False on error
	* @since 0.6
	*/
	public function enable($extension)
	{
	if (empty($extension)) {
	return false;
	}

	if (!$this->hasCapability('ENABLE')) {
	return false;
	}

	if (!is_array($extension)) {
	$extension = array($extension);
	}

	if (!empty($this->extensions_enabled)) {
	// check if all extensions are already enabled
	$diff = array_diff($extension, $this->extensions_enabled);

	if (empty($diff)) {
	return $extension;
	}

	// Make sure the mailbox isn't selected, before enabling extension(s)
	if ($this->selected !== null) {
	$this->close();
	}
	}

	list($code, $response) = $this->execute('ENABLE', $extension, 0, '/^\* ENABLED /i');

	if ($code == self::ERROR_OK && $response) {
	$response = substr($response, 10); // remove prefix "* ENABLED "
	$result = (array) $this->tokenizeResponse($response);

	$this->extensions_enabled = array_unique(array_merge((array)$this->extensions_enabled, $result));

	return $this->extensions_enabled;
	}

	return false;
	}

	/**
	* Executes SORT command
	*
	* @param string $mailbox Mailbox name
	* @param string $field Field to sort by (ARRIVAL, CC, DATE, FROM, SIZE, SUBJECT, TO)
	* @param string $criteria Searching criteria
	* @param bool $return_uid Enables UID SORT usage
	* @param string $encoding Character set
	*
	* @return rcube_result_index Response data
	*/
	public function sort($mailbox, $field = 'ARRIVAL', $criteria = '', $return_uid = false, $encoding = 'US-ASCII')
	{
	$old_sel = $this->selected;
	$supported = array('ARRIVAL', 'CC', 'DATE', 'FROM', 'SIZE', 'SUBJECT', 'TO');
	$field = strtoupper($field);

	if ($field == 'INTERNALDATE') {
	$field = 'ARRIVAL';
	}

	if (!in_array($field, $supported)) {
	return new rcube_result_index($mailbox);
	}

	if (!$this->select($mailbox)) {
	return new rcube_result_index($mailbox);
	}

	// return empty result when folder is empty and we're just after SELECT
	if ($old_sel != $mailbox && !$this->data['EXISTS']) {
	return new rcube_result_index($mailbox, '* SORT');
	}

	// RFC 5957: SORT=DISPLAY
	if (($field == 'FROM' \|\| $field == 'TO') && $this->getCapability('SORT=DISPLAY')) {
	$field = 'DISPLAY' . $field;
	}

	$encoding = $encoding ? trim($encoding) : 'US-ASCII';
	$criteria = $criteria ? 'ALL ' . trim($criteria) : 'ALL';

	list($code, $response) = $this->execute($return_uid ? 'UID SORT' : 'SORT',
	array("($field)", $encoding, $criteria));

	if ($code != self::ERROR_OK) {
	$response = null;
	}

	return new rcube_result_index($mailbox, $response);
	}

	/**
	* Executes THREAD command
	*
	* @param string $mailbox Mailbox name
	* @param string $algorithm Threading algorithm (ORDEREDSUBJECT, REFERENCES, REFS)
	* @param string $criteria Searching criteria
	* @param bool $return_uid Enables UIDs in result instead of sequence numbers
	* @param string $encoding Character set
	*
	* @return rcube_result_thread Thread data
	*/
	public function thread($mailbox, $algorithm = 'REFERENCES', $criteria = '', $return_uid = false, $encoding = 'US-ASCII')
	{
	$old_sel = $this->selected;

	if (!$this->select($mailbox)) {
	return new rcube_result_thread($mailbox);
	}

	// return empty result when folder is empty and we're just after SELECT
	if ($old_sel != $mailbox && !$this->data['EXISTS']) {
	return new rcube_result_thread($mailbox, '* THREAD');
	}

	$encoding = $encoding ? trim($encoding) : 'US-ASCII';
	$algorithm = $algorithm ? trim($algorithm) : 'REFERENCES';
	$criteria = $criteria ? 'ALL '.trim($criteria) : 'ALL';

	list($code, $response) = $this->execute($return_uid ? 'UID THREAD' : 'THREAD',
	array($algorithm, $encoding, $criteria));

	if ($code != self::ERROR_OK) {
	$response = null;
	}

	return new rcube_result_thread($mailbox, $response);
	}

	/**
	* Executes SEARCH command
	*
	* @param string $mailbox Mailbox name
	* @param string $criteria Searching criteria
	* @param bool $return_uid Enable UID in result instead of sequence ID
	* @param array $items Return items (MIN, MAX, COUNT, ALL)
	*
	* @return rcube_result_index Result data
	*/
	public function search($mailbox, $criteria, $return_uid = false, $items = array())
	{
	$old_sel = $this->selected;

	if (!$this->select($mailbox)) {
	return new rcube_result_index($mailbox);
	}

	// return empty result when folder is empty and we're just after SELECT
	if ($old_sel != $mailbox && !$this->data['EXISTS']) {
	return new rcube_result_index($mailbox, '* SEARCH');
	}

	// If ESEARCH is supported always use ALL
	// but not when items are specified or using simple id2uid search
	if (empty($items) && preg_match('/[^0-9]/', $criteria)) {
	$items = array('ALL');
	}

	$esearch = empty($items) ? false : $this->getCapability('ESEARCH');
	$criteria = trim($criteria);
	$params = '';

	// RFC4731: ESEARCH
	if (!empty($items) && $esearch) {
	$params .= 'RETURN (' . implode(' ', $items) . ')';
	}

	if (!empty($criteria)) {
	$params .= ($params ? ' ' : '') . $criteria;
	}
	else {
	$params .= 'ALL';
	}

	list($code, $response) = $this->execute($return_uid ? 'UID SEARCH' : 'SEARCH',
	array($params));

	if ($code != self::ERROR_OK) {
	$response = null;
	}

	return new rcube_result_index($mailbox, $response);
	}

	/**
	* Simulates SORT command by using FETCH and sorting.
	*
	* @param string $mailbox Mailbox name
	* @param string\|array $message_set Searching criteria (list of messages to return)
	* @param string $index_field Field to sort by (ARRIVAL, CC, DATE, FROM, SIZE, SUBJECT, TO)
	* @param bool $skip_deleted Makes that DELETED messages will be skipped
	* @param bool $uidfetch Enables UID FETCH usage
	* @param bool $return_uid Enables returning UIDs instead of IDs
	*
	* @return rcube_result_index Response data
	*/
	public function index($mailbox, $message_set, $index_field='', $skip_deleted=true,
	$uidfetch=false, $return_uid=false)
	{
	$msg_index = $this->fetchHeaderIndex($mailbox, $message_set,
	$index_field, $skip_deleted, $uidfetch, $return_uid);

	if (!empty($msg_index)) {
	asort($msg_index); // ASC
	$msg_index = array_keys($msg_index);
	$msg_index = '* SEARCH ' . implode(' ', $msg_index);
	}
	else {
	$msg_index = is_array($msg_index) ? '* SEARCH' : null;
	}

	return new rcube_result_index($mailbox, $msg_index);
	}

	/**
	* Fetches specified header/data value for a set of messages.
	*
	* @param string $mailbox Mailbox name
	* @param string\|array $message_set Searching criteria (list of messages to return)
	* @param string $index_field Field to sort by (ARRIVAL, CC, DATE, FROM, SIZE, SUBJECT, TO)
	* @param bool $skip_deleted Makes that DELETED messages will be skipped
	* @param bool $uidfetch Enables UID FETCH usage
	* @param bool $return_uid Enables returning UIDs instead of IDs
	*
	* @return array\|bool List of header values or False on failure
	*/
	public function fetchHeaderIndex($mailbox, $message_set, $index_field = '', $skip_deleted = true,
	$uidfetch = false, $return_uid = false)
	{
	// Validate input
	if (is_array($message_set)) {
	if (!($message_set = $this->compressMessageSet($message_set))) {
	return false;
	}
	}
	else if (empty($message_set)) {
	return false;
	}
	else if (strpos($message_set, ':')) {
	list($from_idx, $to_idx) = explode(':', $message_set);
	if ($to_idx != '*' && (int) $from_idx > (int) $to_idx) {
	return false;
	}
	}

	$index_field = empty($index_field) ? 'DATE' : strtoupper($index_field);

	$fields_a['DATE'] = 1;
	$fields_a['INTERNALDATE'] = 4;
	$fields_a['ARRIVAL'] = 4;
	$fields_a['FROM'] = 1;
	$fields_a['REPLY-TO'] = 1;
	$fields_a['SENDER'] = 1;
	$fields_a['TO'] = 1;
	$fields_a['CC'] = 1;
	$fields_a['SUBJECT'] = 1;
	$fields_a['UID'] = 2;
	$fields_a['SIZE'] = 2;
	$fields_a['SEEN'] = 3;
	$fields_a['RECENT'] = 3;
	$fields_a['DELETED'] = 3;

	if (!($mode = $fields_a[$index_field])) {
	return false;
	}

	// Select the mailbox
	if (!$this->select($mailbox)) {
	return false;
	}

	// build FETCH command string
	$key = $this->nextTag();
	$cmd = $uidfetch ? 'UID FETCH' : 'FETCH';
	$fields = array();

	if ($return_uid) {
	$fields[] = 'UID';
	}
	if ($skip_deleted) {
	$fields[] = 'FLAGS';
	}

	if ($mode == 1) {
	if ($index_field == 'DATE') {
	$fields[] = 'INTERNALDATE';
	}
	$fields[] = "BODY.PEEK[HEADER.FIELDS ($index_field)]";
	}
	else if ($mode == 2) {
	if ($index_field == 'SIZE') {
	$fields[] = 'RFC822.SIZE';
	}
	else if (!$return_uid \|\| $index_field != 'UID') {
	$fields[] = $index_field;
	}
	}
	else if ($mode == 3 && !$skip_deleted) {
	$fields[] = 'FLAGS';
	}
	else if ($mode == 4) {
	$fields[] = 'INTERNALDATE';
	}

	$request = "$key $cmd $message_set (" . implode(' ', $fields) . ")";

	if (!$this->putLine($request)) {
	$this->setError(self::ERROR_COMMAND, "Failed to send $cmd command");
	return false;
	}

	$result = array();

	do {
	$line = rtrim($this->readLine(200));
	$line = $this->multLine($line);

	if (preg_match('/^\* ([0-9]+) FETCH/', $line, $m)) {
	$id = $m[1];
	$flags = null;

	if ($return_uid) {
	if (preg_match('/UID ([0-9]+)/', $line, $matches)) {
	$id = (int) $matches[1];
	}
	else {
	continue;
	}
	}
	if ($skip_deleted && preg_match('/FLAGS $([^)]+)$/', $line, $matches)) {
	$flags = explode(' ', strtoupper($matches[1]));
	if (in_array('\\DELETED', $flags)) {
	continue;
	}
	}

	if ($mode == 1 && $index_field == 'DATE') {
	if (preg_match('/BODY\[HEADER\.FIELDS $"DATE"$\] (.*)/', $line, $matches)) {
	$value = preg_replace(array('/^"*[a-z]+:/i'), '', $matches[1]);
	$value = trim($value);
	$result[$id] = rcube_utils::strtotime($value);
	}
	// non-existent/empty Date: header, use INTERNALDATE
	if (empty($result[$id])) {
	if (preg_match('/INTERNALDATE "([^"]+)"/', $line, $matches)) {
	$result[$id] = rcube_utils::strtotime($matches[1]);
	}
	else {
	$result[$id] = 0;
	}
	}
	}
	else if ($mode == 1) {
	if (preg_match('/BODY\[HEADER\.FIELDS $"?(FROM\|REPLY-TO\|SENDER\|TO\|SUBJECT)"?$\] (.*)/', $line, $matches)) {
	$value = preg_replace(array('/^"*[a-z]+:/i', '/\s+$/sm'), array('', ''), $matches[2]);
	$result[$id] = trim($value);
	}
	else {
	$result[$id] = '';
	}
	}
	else if ($mode == 2) {
	if (preg_match('/' . $index_field . ' ([0-9]+)/', $line, $matches)) {
	$result[$id] = trim($matches[1]);
	}
	else {
	$result[$id] = 0;
	}
	}
	else if ($mode == 3) {
	if (!$flags && preg_match('/FLAGS $([^)]+)$/', $line, $matches)) {
	$flags = explode(' ', $matches[1]);
	}
	$result[$id] = in_array("\\".$index_field, (array) $flags) ? 1 : 0;
	}
	else if ($mode == 4) {
	if (preg_match('/INTERNALDATE "([^"]+)"/', $line, $matches)) {
	$result[$id] = rcube_utils::strtotime($matches[1]);
	}
	else {
	$result[$id] = 0;
	}
	}
	}
	}
	while (!$this->startsWith($line, $key, true, true));

	return $result;
	}

	/**
	* Returns message sequence identifier
	*
	* @param string $mailbox Mailbox name
	* @param int $uid Message unique identifier (UID)
	*
	* @return int Message sequence identifier
	*/
	public function UID2ID($mailbox, $uid)
	{
	if ($uid > 0) {
	$index = $this->search($mailbox, "UID $uid");

	if ($index->count() == 1) {
	$arr = $index->get();
	return (int) $arr[0];
	}
	}
	}

	/**
	* Returns message unique identifier (UID)
	*
	* @param string $mailbox Mailbox name
	* @param int $uid Message sequence identifier
	*
	* @return int Message unique identifier
	*/
	public function ID2UID($mailbox, $id)
	{
	if (empty($id) \|\| $id < 0) {
	return null;
	}

	if (!$this->select($mailbox)) {
	return null;
	}

	- if ($uid = $this->data['UID-MAP'][$id]) {
	- return $uid;
	+ if (!empty($this->data['UID-MAP'][$id])) {
	+ return $this->data['UID-MAP'][$id];
	}

	if (isset($this->data['EXISTS']) && $id > $this->data['EXISTS']) {
	return null;
	}

	$index = $this->search($mailbox, $id, true);

	if ($index->count() == 1) {
	$arr = $index->get();
	return $this->data['UID-MAP'][$id] = (int) $arr[0];
	}
	}

	/**
	* Sets flag of the message(s)
	*
	* @param string $mailbox Mailbox name
	* @param string\|array $messages Message UID(s)
	* @param string $flag Flag name
	*
	* @return bool True on success, False on failure
	*/
	public function flag($mailbox, $messages, $flag)
	{
	return $this->modFlag($mailbox, $messages, $flag, '+');
	}

	/**
	* Unsets flag of the message(s)
	*
	* @param string $mailbox Mailbox name
	* @param string\|array $messages Message UID(s)
	* @param string $flag Flag name
	*
	* @return bool True on success, False on failure
	*/
	public function unflag($mailbox, $messages, $flag)
	{
	return $this->modFlag($mailbox, $messages, $flag, '-');
	}

	/**
	* Changes flag of the message(s)
	*
	* @param string $mailbox Mailbox name
	* @param string\|array $messages Message UID(s)
	* @param string $flag Flag name
	* @param string $mod Modifier [+\|-]. Default: "+".
	*
	* @return bool True on success, False on failure
	*/
	protected function modFlag($mailbox, $messages, $flag, $mod = '+')
	{
	if (!$flag) {
	return false;
	}

	if (!$this->select($mailbox)) {
	return false;
	}

	if (!$this->data['READ-WRITE']) {
	$this->setError(self::ERROR_READONLY, "Mailbox is read-only");
	return false;
	}

	if ($this->flags[strtoupper($flag)]) {
	$flag = $this->flags[strtoupper($flag)];
	}

	// if PERMANENTFLAGS is not specified all flags are allowed
	if (!empty($this->data['PERMANENTFLAGS'])
	&& !in_array($flag, (array) $this->data['PERMANENTFLAGS'])
	&& !in_array('\\*', (array) $this->data['PERMANENTFLAGS'])
	) {
	return false;
	}

	// Clear internal status cache
	if ($flag == 'SEEN') {
	unset($this->data['STATUS:'.$mailbox]['UNSEEN']);
	}

	if ($mod != '+' && $mod != '-') {
	$mod = '+';
	}

	$result = $this->execute('UID STORE', array(
	$this->compressMessageSet($messages), $mod . 'FLAGS.SILENT', "($flag)"),
	self::COMMAND_NORESPONSE);

	return $result == self::ERROR_OK;
	}

	/**
	* Copies message(s) from one folder to another
	*
	* @param string\|array $messages Message UID(s)
	* @param string $from Mailbox name
	* @param string $to Destination mailbox name
	*
	* @return bool True on success, False on failure
	*/
	public function copy($messages, $from, $to)
	{
	// Clear last COPYUID data
	unset($this->data['COPYUID']);

	if (!$this->select($from)) {
	return false;
	}

	// Clear internal status cache
	unset($this->data['STATUS:'.$to]);

	$result = $this->execute('UID COPY', array(
	$this->compressMessageSet($messages), $this->escape($to)),
	self::COMMAND_NORESPONSE);

	return $result == self::ERROR_OK;
	}

	/**
	* Moves message(s) from one folder to another.
	*
	* @param string\|array $messages Message UID(s)
	* @param string $from Mailbox name
	* @param string $to Destination mailbox name
	*
	* @return bool True on success, False on failure
	*/
	public function move($messages, $from, $to)
	{
	if (!$this->select($from)) {
	return false;
	}

	if (!$this->data['READ-WRITE']) {
	$this->setError(self::ERROR_READONLY, "Mailbox is read-only");
	return false;
	}

	// use MOVE command (RFC 6851)
	if ($this->hasCapability('MOVE')) {
	// Clear last COPYUID data
	unset($this->data['COPYUID']);

	// Clear internal status cache
	unset($this->data['STATUS:'.$to]);
	$this->clear_status_cache($from);

	$result = $this->execute('UID MOVE', array(
	$this->compressMessageSet($messages), $this->escape($to)),
	self::COMMAND_NORESPONSE);

	return $result == self::ERROR_OK;
	}

	// use COPY + STORE +FLAGS.SILENT \Deleted + EXPUNGE
	$result = $this->copy($messages, $from, $to);

	if ($result) {
	// Clear internal status cache
	unset($this->data['STATUS:'.$from]);

	$result = $this->flag($from, $messages, 'DELETED');

	if ($messages == '*') {
	// CLOSE+SELECT should be faster than EXPUNGE
	$this->close();
	}
	else {
	$this->expunge($from, $messages);
	}
	}

	return $result;
	}

	/**
	* FETCH command (RFC3501)
	*
	* @param string $mailbox Mailbox name
	* @param mixed $message_set Message(s) sequence identifier(s) or UID(s)
	* @param bool $is_uid True if $message_set contains UIDs
	* @param array $query_items FETCH command data items
	* @param string $mod_seq Modification sequence for CHANGEDSINCE (RFC4551) query
	* @param bool $vanished Enables VANISHED parameter (RFC5162) for CHANGEDSINCE query
	*
	* @return array List of rcube_message_header elements, False on error
	* @since 0.6
	*/
	public function fetch($mailbox, $message_set, $is_uid = false, $query_items = array(),
	$mod_seq = null, $vanished = false)
	{
	if (!$this->select($mailbox)) {
	return false;
	}

	$message_set = $this->compressMessageSet($message_set);
	$result = array();

	$key = $this->nextTag();
	$cmd = ($is_uid ? 'UID ' : '') . 'FETCH';
	$request = "$key $cmd $message_set (" . implode(' ', $query_items) . ")";

	if ($mod_seq !== null && $this->hasCapability('CONDSTORE')) {
	$request .= " (CHANGEDSINCE $mod_seq" . ($vanished ? " VANISHED" : '') .")";
	}

	if (!$this->putLine($request)) {
	$this->setError(self::ERROR_COMMAND, "Failed to send $cmd command");
	return false;
	}

	do {
	$line = $this->readFullLine(4096);

	if (!$line) {
	break;
	}

	// Sample reply line:
	// * 321 FETCH (UID 2417 RFC822.SIZE 2730 FLAGS (\Seen)
	// INTERNALDATE "16-Nov-2008 21:08:46 +0100" BODYSTRUCTURE (...)
	// BODY[HEADER.FIELDS ...

	if (preg_match('/^\* ([0-9]+) FETCH/', $line, $m)) {
	$id = intval($m[1]);

	$result[$id] = new rcube_message_header;
	$result[$id]->id = $id;
	$result[$id]->subject = '';
	$result[$id]->messageID = 'mid:' . $id;

	$headers = null;
	$lines = array();
	$line = substr($line, strlen($m[0]) + 2);
	$ln = 0;

	// Tokenize response and assign to object properties
	- while (list($name, $value) = $this->tokenizeResponse($line, 2)) {
	+ while (($tokens = $this->tokenizeResponse($line, 2)) && count($tokens) == 2) {
	+ list($name, $value) = $tokens;
	if ($name == 'UID') {
	$result[$id]->uid = intval($value);
	}
	else if ($name == 'RFC822.SIZE') {
	$result[$id]->size = intval($value);
	}
	else if ($name == 'RFC822.TEXT') {
	$result[$id]->body = $value;
	}
	else if ($name == 'INTERNALDATE') {
	$result[$id]->internaldate = $value;
	$result[$id]->date = $value;
	$result[$id]->timestamp = rcube_utils::strtotime($value);
	}
	else if ($name == 'FLAGS') {
	if (!empty($value)) {
	foreach ((array)$value as $flag) {
	$flag = str_replace(array('$', "\\"), '', $flag);
	$flag = strtoupper($flag);

	$result[$id]->flags[$flag] = true;
	}
	}
	}
	else if ($name == 'MODSEQ') {
	$result[$id]->modseq = $value[0];
	}
	else if ($name == 'ENVELOPE') {
	$result[$id]->envelope = $value;
	}
	else if ($name == 'BODYSTRUCTURE' \|\| ($name == 'BODY' && count($value) > 2)) {
	if (!is_array($value[0]) && (strtolower($value[0]) == 'message' && strtolower($value[1]) == 'rfc822')) {
	$value = array($value);
	}
	$result[$id]->bodystructure = $value;
	}
	else if ($name == 'RFC822') {
	$result[$id]->body = $value;
	}
	else if (stripos($name, 'BODY[') === 0) {
	$name = str_replace(']', '', substr($name, 5));

	if ($name == 'HEADER.FIELDS') {
	// skip ']' after headers list
	$this->tokenizeResponse($line, 1);
	$headers = $this->tokenizeResponse($line, 1);
	}
	else if (strlen($name)) {
	$result[$id]->bodypart[$name] = $value;
	}
	else {
	$result[$id]->body = $value;
	}
	}
	}

	// create array with header field:data
	if (!empty($headers)) {
	$headers = explode("\n", trim($headers));
	foreach ($headers as $resln) {
	if (ord($resln[0]) <= 32) {
	$lines[$ln] .= (empty($lines[$ln]) ? '' : "\n") . trim($resln);
	}
	else {
	$lines[++$ln] = trim($resln);
	}
	}

	foreach ($lines as $str) {
	list($field, $string) = explode(':', $str, 2);

	$field = strtolower($field);
	$string = preg_replace('/\n[\t\s]*/', ' ', trim($string));

	switch ($field) {
	case 'date';
	$string = substr($string, 0, 128);
	$result[$id]->date = $string;
	$result[$id]->timestamp = rcube_utils::strtotime($string);
	break;
	case 'to':
	$result[$id]->to = preg_replace('/undisclosed-recipients:[;,]*/', '', $string);
	break;
	case 'from':
	case 'subject':
	$string = substr($string, 0, 2048);
	case 'cc':
	case 'bcc':
	case 'references':
	$result[$id]->{$field} = $string;
	break;
	case 'reply-to':
	$result[$id]->replyto = $string;
	break;
	case 'content-transfer-encoding':
	$result[$id]->encoding = substr($string, 0, 32);
	break;
	case 'content-type':
	$ctype_parts = preg_split('/[; ]+/', $string);
	$result[$id]->ctype = strtolower(array_shift($ctype_parts));
	if (preg_match('/charset\s=\s"?([a-z0-9\-\.\_]+)"?/i', $string, $regs)) {
	$result[$id]->charset = $regs[1];
	}
	break;
	case 'in-reply-to':
	$result[$id]->in_reply_to = str_replace(array("\n", '<', '>'), '', $string);
	break;
	case 'return-receipt-to':
	case 'disposition-notification-to':
	case 'x-confirm-reading-to':
	$result[$id]->mdn_to = substr($string, 0, 2048);
	break;
	case 'message-id':
	$result[$id]->messageID = substr($string, 0, 2048);
	break;
	case 'x-priority':
	if (preg_match('/^(\d+)/', $string, $matches)) {
	$result[$id]->priority = intval($matches[1]);
	}
	break;
	default:
	if (strlen($field) < 3) {
	break;
	}
	if ($result[$id]->others[$field]) {
	$string = array_merge((array)$result[$id]->others[$field], (array)$string);
	}
	$result[$id]->others[$field] = $string;
	}
	}
	}
	}
	// VANISHED response (QRESYNC RFC5162)
	// Sample: * VANISHED (EARLIER) 300:310,405,411
	else if (preg_match('/^\* VANISHED [()EARLIER]*/i', $line, $match)) {
	$line = substr($line, strlen($match[0]));
	$v_data = $this->tokenizeResponse($line, 1);

	$this->data['VANISHED'] = $v_data;
	}
	}
	while (!$this->startsWith($line, $key, true));

	return $result;
	}

	/**
	* Returns message(s) data (flags, headers, etc.)
	*
	* @param string $mailbox Mailbox name
	* @param mixed $message_set Message(s) sequence identifier(s) or UID(s)
	* @param bool $is_uid True if $message_set contains UIDs
	* @param bool $bodystr Enable to add BODYSTRUCTURE data to the result
	* @param array $add_headers List of additional headers
	*
	* @return bool\|array List of rcube_message_header elements, False on error
	*/
	public function fetchHeaders($mailbox, $message_set, $is_uid = false, $bodystr = false, $add_headers = array())
	{
	$query_items = array('UID', 'RFC822.SIZE', 'FLAGS', 'INTERNALDATE');
	$headers = array('DATE', 'FROM', 'TO', 'SUBJECT', 'CONTENT-TYPE', 'CC', 'REPLY-TO',
	'LIST-POST', 'DISPOSITION-NOTIFICATION-TO', 'X-PRIORITY');

	if (!empty($add_headers)) {
	$add_headers = array_map('strtoupper', $add_headers);
	$headers = array_unique(array_merge($headers, $add_headers));
	}

	if ($bodystr) {
	$query_items[] = 'BODYSTRUCTURE';
	}

	$query_items[] = 'BODY.PEEK[HEADER.FIELDS (' . implode(' ', $headers) . ')]';

	return $this->fetch($mailbox, $message_set, $is_uid, $query_items);
	}

	/**
	* Returns message data (flags, headers, etc.)
	*
	* @param string $mailbox Mailbox name
	* @param int $id Message sequence identifier or UID
	* @param bool $is_uid True if $id is an UID
	* @param bool $bodystr Enable to add BODYSTRUCTURE data to the result
	* @param array $add_headers List of additional headers
	*
	* @return bool\|rcube_message_header Message data, False on error
	*/
	public function fetchHeader($mailbox, $id, $is_uid = false, $bodystr = false, $add_headers = array())
	{
	$a = $this->fetchHeaders($mailbox, $id, $is_uid, $bodystr, $add_headers);
	if (is_array($a)) {
	return array_shift($a);
	}

	return false;
	}

	/**
	* Sort messages by specified header field
	*
	* @param array $messages Array of rcube_message_header objects
	* @param string $field Name of the property to sort by
	* @param string $flag Sorting order (ASC\|DESC)
	*
	* @return array Sorted input array
	*/
	public static function sortHeaders($messages, $field, $flag)
	{
	$field = empty($field) ? 'uid' : strtolower($field);
	$order = empty($flag) ? 'ASC' : strtoupper($flag);
	$index = array();

	reset($messages);

	// Create an index
	foreach ($messages as $key => $headers) {
	switch ($field) {
	case 'arrival':
	$field = 'internaldate';
	// no-break
	case 'date':
	case 'internaldate':
	case 'timestamp':
	$value = rcube_utils::strtotime($headers->$field);
	if (!$value && $field != 'timestamp') {
	$value = $headers->timestamp;
	}

	break;

	default:
	// @TODO: decode header value, convert to UTF-8
	$value = $headers->$field;
	if (is_string($value)) {
	$value = str_replace('"', '', $value);

	if ($field == 'subject') {
	$value = preg_replace('/^(Re:\s\|Fwd:\s\|Fw:\s*)+/i', '', $value);
	}
	}
	}

	$index[$key] = $value;
	}

	$sort_order = $flag == 'ASC' ? SORT_ASC : SORT_DESC;
	$sort_flags = SORT_STRING \| SORT_FLAG_CASE;

	if (in_array($field, array('arrival', 'date', 'internaldate', 'timestamp'))) {
	$sort_flags = SORT_NUMERIC;
	}

	array_multisort($index, $sort_order, $sort_flags, $messages);

	return $messages;
	}

	/**
	* Fetch MIME headers of specified message parts
	*
	* @param string $mailbox Mailbox name
	* @param int $uid Message UID
	* @param array $parts Message part identifiers
	* @param bool $mime Use MIME instad of HEADER
	*
	* @return array\|bool Array containing headers string for each specified body
	* False on failure.
	*/
	public function fetchMIMEHeaders($mailbox, $uid, $parts, $mime = true)
	{
	if (!$this->select($mailbox)) {
	return false;
	}

	$result = false;
	$parts = (array) $parts;
	$key = $this->nextTag();
	$peeks = array();
	$type = $mime ? 'MIME' : 'HEADER';

	// format request
	foreach ($parts as $part) {
	$peeks[] = "BODY.PEEK[$part.$type]";
	}

	$request = "$key UID FETCH $uid (" . implode(' ', $peeks) . ')';

	// send request
	if (!$this->putLine($request)) {
	$this->setError(self::ERROR_COMMAND, "Failed to send UID FETCH command");
	return false;
	}

	do {
	$line = $this->readLine(1024);

	if (preg_match('/^\* [0-9]+ FETCH [0-9UID( ]+/', $line, $m)) {
	$line = ltrim(substr($line, strlen($m[0])));
	while (preg_match('/^BODY\[([0-9\.]+)\.'.$type.'\]/', $line, $matches)) {
	$line = substr($line, strlen($matches[0]));
	$result[$matches[1]] = trim($this->multLine($line));
	$line = $this->readLine(1024);
	}
	}
	}
	while (!$this->startsWith($line, $key, true));

	return $result;
	}

	/**
	* Fetches message part header
	*/
	public function fetchPartHeader($mailbox, $id, $is_uid = false, $part = null)
	{
	$part = empty($part) ? 'HEADER' : $part.'.MIME';

	return $this->handlePartBody($mailbox, $id, $is_uid, $part);
	}

	/**
	* Fetches body of the specified message part
	*/
	public function handlePartBody($mailbox, $id, $is_uid=false, $part='', $encoding=null, $print=null, $file=null, $formatted=false, $max_bytes=0)
	{
	if (!$this->select($mailbox)) {
	return false;
	}

	$binary = true;
	$initiated = false;

	do {
	if (!$initiated) {
	switch ($encoding) {
	case 'base64':
	$mode = 1;
	break;
	case 'quoted-printable':
	$mode = 2;
	break;
	case 'x-uuencode':
	case 'x-uue':
	case 'uue':
	case 'uuencode':
	$mode = 3;
	break;
	default:
	$mode = 0;
	}

	// Use BINARY extension when possible (and safe)
	$binary = $binary && $mode && preg_match('/^[0-9.]+$/', $part) && $this->hasCapability('BINARY');
	$fetch_mode = $binary ? 'BINARY' : 'BODY';
	$partial = $max_bytes ? sprintf('<0.%d>', $max_bytes) : '';

	// format request
	$key = $this->nextTag();
	$cmd = ($is_uid ? 'UID ' : '') . 'FETCH';
	$request = "$key $cmd $id ($fetch_mode.PEEK[$part]$partial)";
	$result = false;
	$found = false;
	$initiated = true;

	// send request
	if (!$this->putLine($request)) {
	$this->setError(self::ERROR_COMMAND, "Failed to send $cmd command");
	return false;
	}

	if ($binary) {
	// WARNING: Use $formatted argument with care, this may break binary data stream
	$mode = -1;
	}
	}

	$line = trim($this->readLine(1024));

	if (!$line) {
	break;
	}

	// handle UNKNOWN-CTE response - RFC 3516, try again with standard BODY request
	if ($binary && !$found && preg_match('/^' . $key . ' NO \[(UNKNOWN-CTE\|PARSE)\]/i', $line)) {
	$binary = $initiated = false;
	continue;
	}

	// skip irrelevant untagged responses (we have a result already)
	if ($found \|\| !preg_match('/^\* ([0-9]+) FETCH (.*)$/', $line, $m)) {
	continue;
	}

	$line = $m[2];

	// handle one line response
	if ($line[0] == '(' && substr($line, -1) == ')') {
	// tokenize content inside brackets
	// the content can be e.g.: (UID 9844 BODY[2.4] NIL)
	$tokens = $this->tokenizeResponse(preg_replace('/(^$\|$$)/', '', $line));

	for ($i=0; $i<count($tokens); $i+=2) {
	if (preg_match('/^(BODY\|BINARY)/i', $tokens[$i])) {
	$result = $tokens[$i+1];
	$found = true;
	break;
	}
	}

	if ($result !== false) {
	if ($mode == 1) {
	$result = base64_decode($result);
	}
	else if ($mode == 2) {
	$result = quoted_printable_decode($result);
	}
	else if ($mode == 3) {
	$result = convert_uudecode($result);
	}
	}
	}
	// response with string literal
	else if (preg_match('/\{([0-9]+)\}$/', $line, $m)) {
	$bytes = (int) $m[1];
	$prev = '';
	$found = true;

	// empty body
	if (!$bytes) {
	$result = '';
	}
	else while ($bytes > 0) {
	$line = $this->readLine(8192);

	if ($line === null) {
	break;
	}

	$len = strlen($line);

	if ($len > $bytes) {
	$line = substr($line, 0, $bytes);
	$len = strlen($line);
	}
	$bytes -= $len;

	// BASE64
	if ($mode == 1) {
	$line = preg_replace('\|[^a-zA-Z0-9+=/]\|', '', $line);
	// create chunks with proper length for base64 decoding
	$line = $prev.$line;
	$length = strlen($line);
	if ($length % 4) {
	$length = floor($length / 4) * 4;
	$prev = substr($line, $length);
	$line = substr($line, 0, $length);
	}
	else {
	$prev = '';
	}
	$line = base64_decode($line);
	}
	// QUOTED-PRINTABLE
	else if ($mode == 2) {
	$line = rtrim($line, "\t\r\0\x0B");
	$line = quoted_printable_decode($line);
	}
	// UUENCODE
	else if ($mode == 3) {
	$line = rtrim($line, "\t\r\n\0\x0B");
	if ($line == 'end' \|\| preg_match('/^begin\s+[0-7]+\s+.+$/', $line)) {
	continue;
	}
	$line = convert_uudecode($line);
	}
	// default
	else if ($formatted) {
	$line = rtrim($line, "\t\r\n\0\x0B") . "\n";
	}

	if ($file) {
	if (fwrite($file, $line) === false) {
	break;
	}
	}
	else if ($print) {
	echo $line;
	}
	else {
	$result .= $line;
	}
	}
	}
	}
	while (!$this->startsWith($line, $key, true) \|\| !$initiated);

	if ($result !== false) {
	if ($file) {
	return fwrite($file, $result);
	}
	else if ($print) {
	echo $result;
	return true;
	}

	return $result;
	}

	return false;
	}

	/**
	* Handler for IMAP APPEND command
	*
	* @param string $mailbox Mailbox name
	* @param string\|array $message The message source string or array (of strings and file pointers)
	* @param array $flags Message flags
	* @param string $date Message internal date
	* @param bool $binary Enable BINARY append (RFC3516)
	*
	* @return string\|bool On success APPENDUID response (if available) or True, False on failure
	*/
	public function append($mailbox, &$message, $flags = array(), $date = null, $binary = false)
	{
	unset($this->data['APPENDUID']);

	if ($mailbox === null \|\| $mailbox === '') {
	return false;
	}

	$binary = $binary && $this->getCapability('BINARY');
	$literal_plus = !$binary && $this->prefs['literal+'];
	$len = 0;
	$msg = is_array($message) ? $message : array(&$message);
	$chunk_size = 512000;

	for ($i=0, $cnt=count($msg); $i<$cnt; $i++) {
	if (is_resource($msg[$i])) {
	$stat = fstat($msg[$i]);
	if ($stat === false) {
	return false;
	}
	$len += $stat['size'];
	}
	else {
	if (!$binary) {
	$msg[$i] = str_replace("\r", '', $msg[$i]);
	$msg[$i] = str_replace("\n", "\r\n", $msg[$i]);
	}

	$len += strlen($msg[$i]);
	}
	}

	if (!$len) {
	return false;
	}

	// build APPEND command
	$key = $this->nextTag();
	$request = "$key APPEND " . $this->escape($mailbox) . ' (' . $this->flagsToStr($flags) . ')';
	if (!empty($date)) {
	$request .= ' ' . $this->escape($date);
	}
	$request .= ' ' . ($binary ? '~' : '') . '{' . $len . ($literal_plus ? '+' : '') . '}';

	// send APPEND command
	if (!$this->putLine($request)) {
	$this->setError(self::ERROR_COMMAND, "Failed to send APPEND command");
	return false;
	}

	// Do not wait when LITERAL+ is supported
	if (!$literal_plus) {
	$line = $this->readReply();

	if ($line[0] != '+') {
	$this->parseResult($line, 'APPEND: ');
	return false;
	}
	}

	foreach ($msg as $msg_part) {
	// file pointer
	if (is_resource($msg_part)) {
	rewind($msg_part);
	while (!feof($msg_part) && $this->fp) {
	$buffer = fread($msg_part, $chunk_size);
	$this->putLine($buffer, false);
	}
	fclose($msg_part);
	}
	// string
	else {
	$size = strlen($msg_part);

	// Break up the data by sending one chunk (up to 512k) at a time.
	// This approach reduces our peak memory usage
	for ($offset = 0; $offset < $size; $offset += $chunk_size) {
	$chunk = substr($msg_part, $offset, $chunk_size);
	if (!$this->putLine($chunk, false)) {
	return false;
	}
	}
	}
	}

	if (!$this->putLine('')) { // \r\n
	return false;
	}

	do {
	$line = $this->readLine();
	} while (!$this->startsWith($line, $key, true, true));

	// Clear internal status cache
	unset($this->data['STATUS:'.$mailbox]);

	if ($this->parseResult($line, 'APPEND: ') != self::ERROR_OK) {
	return false;
	}

	if (!empty($this->data['APPENDUID'])) {
	return $this->data['APPENDUID'];
	}

	return true;
	}

	/**
	* Handler for IMAP APPEND command.
	*
	* @param string $mailbox Mailbox name
	* @param string $path Path to the file with message body
	* @param string $headers Message headers
	* @param array $flags Message flags
	* @param string $date Message internal date
	* @param bool $binary Enable BINARY append (RFC3516)
	*
	* @return string\|bool On success APPENDUID response (if available) or True, False on failure
	*/
	public function appendFromFile($mailbox, $path, $headers=null, $flags = array(), $date = null, $binary = false)
	{
	// open message file
	if (file_exists(realpath($path))) {
	$fp = fopen($path, 'r');
	}

	if (empty($fp)) {
	$this->setError(self::ERROR_UNKNOWN, "Couldn't open $path for reading");
	return false;
	}

	$message = array();
	if ($headers) {
	$message[] = trim($headers, "\r\n") . "\r\n\r\n";
	}
	$message[] = $fp;

	return $this->append($mailbox, $message, $flags, $date, $binary);
	}

	/**
	* Returns QUOTA information
	*
	* @param string $mailbox Mailbox name
	*
	* @return array Quota information
	*/
	public function getQuota($mailbox = null)
	{
	if ($mailbox === null \|\| $mailbox === '') {
	$mailbox = 'INBOX';
	}

	// a0001 GETQUOTAROOT INBOX
	// * QUOTAROOT INBOX user/sample
	// * QUOTA user/sample (STORAGE 654 9765)
	// a0001 OK Completed

	list($code, $response) = $this->execute('GETQUOTAROOT', array($this->escape($mailbox)), 0, '/^\* QUOTA /i');

	$result = false;
	$min_free = PHP_INT_MAX;
	$all = array();

	if ($code == self::ERROR_OK) {
	foreach (explode("\n", $response) as $line) {
	list(, , $quota_root) = $this->tokenizeResponse($line, 3);

	$quotas = $this->tokenizeResponse($line, 1);

	if (empty($quotas)) {
	continue;
	}

	foreach (array_chunk($quotas, 3) as $quota) {
	list($type, $used, $total) = $quota;
	$type = strtolower($type);

	if ($type && $total) {
	$all[$quota_root][$type]['used'] = intval($used);
	$all[$quota_root][$type]['total'] = intval($total);
	}
	}

	if (empty($all[$quota_root]['storage'])) {
	continue;
	}

	$used = $all[$quota_root]['storage']['used'];
	$total = $all[$quota_root]['storage']['total'];
	$free = $total - $used;

	// calculate lowest available space from all storage quotas
	if ($free < $min_free) {
	$min_free = $free;
	$result['used'] = $used;
	$result['total'] = $total;
	$result['percent'] = min(100, round(($used/max(1,$total))*100));
	$result['free'] = 100 - $result['percent'];
	}
	}
	}

	if (!empty($result)) {
	$result['all'] = $all;
	}

	return $result;
	}

	/**
	* Send the SETACL command (RFC4314)
	*
	* @param string $mailbox Mailbox name
	* @param string $user User name
	* @param mixed $acl ACL string or array
	*
	* @return boolean True on success, False on failure
	*
	* @since 0.5-beta
	*/
	public function setACL($mailbox, $user, $acl)
	{
	if (is_array($acl)) {
	$acl = implode('', $acl);
	}

	$result = $this->execute('SETACL', array(
	$this->escape($mailbox), $this->escape($user), strtolower($acl)),
	self::COMMAND_NORESPONSE);

	return ($result == self::ERROR_OK);
	}

	/**
	* Send the DELETEACL command (RFC4314)
	*
	* @param string $mailbox Mailbox name
	* @param string $user User name
	*
	* @return boolean True on success, False on failure
	*
	* @since 0.5-beta
	*/
	public function deleteACL($mailbox, $user)
	{
	$result = $this->execute('DELETEACL', array(
	$this->escape($mailbox), $this->escape($user)),
	self::COMMAND_NORESPONSE);

	return ($result == self::ERROR_OK);
	}

	/**
	* Send the GETACL command (RFC4314)
	*
	* @param string $mailbox Mailbox name
	*
	* @return array User-rights array on success, NULL on error
	* @since 0.5-beta
	*/
	public function getACL($mailbox)
	{
	list($code, $response) = $this->execute('GETACL', array($this->escape($mailbox)), 0, '/^\* ACL /i');

	if ($code == self::ERROR_OK && $response) {
	// Parse server response (remove "* ACL ")
	$response = substr($response, 6);
	$ret = $this->tokenizeResponse($response);
	$mbox = array_shift($ret);
	$size = count($ret);

	// Create user-rights hash array
	// @TODO: consider implementing fixACL() method according to RFC4314.2.1.1
	// so we could return only standard rights defined in RFC4314,
	// excluding 'c' and 'd' defined in RFC2086.
	if ($size % 2 == 0) {
	for ($i=0; $i<$size; $i++) {
	$ret[$ret[$i]] = str_split($ret[++$i]);
	unset($ret[$i-1]);
	unset($ret[$i]);
	}
	return $ret;
	}

	$this->setError(self::ERROR_COMMAND, "Incomplete ACL response");
	}
	}

	/**
	* Send the LISTRIGHTS command (RFC4314)
	*
	* @param string $mailbox Mailbox name
	* @param string $user User name
	*
	* @return array List of user rights
	* @since 0.5-beta
	*/
	public function listRights($mailbox, $user)
	{
	list($code, $response) = $this->execute('LISTRIGHTS',
	array($this->escape($mailbox), $this->escape($user)), 0, '/^\* LISTRIGHTS /i');

	if ($code == self::ERROR_OK && $response) {
	// Parse server response (remove "* LISTRIGHTS ")
	$response = substr($response, 13);

	$ret_mbox = $this->tokenizeResponse($response, 1);
	$ret_user = $this->tokenizeResponse($response, 1);
	$granted = $this->tokenizeResponse($response, 1);
	$optional = trim($response);

	return array(
	'granted' => str_split($granted),
	'optional' => explode(' ', $optional),
	);
	}
	}

	/**
	* Send the MYRIGHTS command (RFC4314)
	*
	* @param string $mailbox Mailbox name
	*
	* @return array MYRIGHTS response on success, NULL on error
	* @since 0.5-beta
	*/
	public function myRights($mailbox)
	{
	list($code, $response) = $this->execute('MYRIGHTS', array($this->escape($mailbox)), 0, '/^\* MYRIGHTS /i');

	if ($code == self::ERROR_OK && $response) {
	// Parse server response (remove "* MYRIGHTS ")
	$response = substr($response, 11);

	$ret_mbox = $this->tokenizeResponse($response, 1);
	$rights = $this->tokenizeResponse($response, 1);

	return str_split($rights);
	}
	}

	/**
	* Send the SETMETADATA command (RFC5464)
	*
	* @param string $mailbox Mailbox name
	* @param array $entries Entry-value array (use NULL value as NIL)
	*
	* @return boolean True on success, False on failure
	* @since 0.5-beta
	*/
	public function setMetadata($mailbox, $entries)
	{
	if (!is_array($entries) \|\| empty($entries)) {
	$this->setError(self::ERROR_COMMAND, "Wrong argument for SETMETADATA command");
	return false;
	}

	foreach ($entries as $name => $value) {
	$entries[$name] = $this->escape($name) . ' ' . $this->escape($value, true);
	}

	$entries = implode(' ', $entries);
	$result = $this->execute('SETMETADATA', array(
	$this->escape($mailbox), '(' . $entries . ')'),
	self::COMMAND_NORESPONSE);

	return ($result == self::ERROR_OK);
	}

	/**
	* Send the SETMETADATA command with NIL values (RFC5464)
	*
	* @param string $mailbox Mailbox name
	* @param array $entries Entry names array
	*
	* @return boolean True on success, False on failure
	*
	* @since 0.5-beta
	*/
	public function deleteMetadata($mailbox, $entries)
	{
	if (!is_array($entries) && !empty($entries)) {
	$entries = explode(' ', $entries);
	}

	if (empty($entries)) {
	$this->setError(self::ERROR_COMMAND, "Wrong argument for SETMETADATA command");
	return false;
	}

	foreach ($entries as $entry) {
	$data[$entry] = null;
	}

	return $this->setMetadata($mailbox, $data);
	}

	/**
	* Send the GETMETADATA command (RFC5464)
	*
	* @param string $mailbox Mailbox name
	* @param array $entries Entries
	* @param array $options Command options (with MAXSIZE and DEPTH keys)
	*
	* @return array GETMETADATA result on success, NULL on error
	*
	* @since 0.5-beta
	*/
	public function getMetadata($mailbox, $entries, $options=array())
	{
	if (!is_array($entries)) {
	$entries = array($entries);
	}

	// create entries string
	foreach ($entries as $idx => $name) {
	$entries[$idx] = $this->escape($name);
	}

	$optlist = '';
	$entlist = '(' . implode(' ', $entries) . ')';

	// create options string
	if (is_array($options)) {
	$options = array_change_key_case($options, CASE_UPPER);
	$opts = array();

	if (!empty($options['MAXSIZE'])) {
	$opts[] = 'MAXSIZE '.intval($options['MAXSIZE']);
	}
	if (!empty($options['DEPTH'])) {
	$opts[] = 'DEPTH '.intval($options['DEPTH']);
	}

	if ($opts) {
	$optlist = '(' . implode(' ', $opts) . ')';
	}
	}

	$optlist .= ($optlist ? ' ' : '') . $entlist;

	list($code, $response) = $this->execute('GETMETADATA', array(
	$this->escape($mailbox), $optlist));

	if ($code == self::ERROR_OK) {
	$result = array();
	$data = $this->tokenizeResponse($response);

	// The METADATA response can contain multiple entries in a single
	// response or multiple responses for each entry or group of entries
	for ($i = 0, $size = count($data); $i < $size; $i++) {
	if ($data[$i] === '*'
	&& $data[++$i] === 'METADATA'
	&& is_string($mbox = $data[++$i])
	&& is_array($data[++$i])
	) {
	for ($x = 0, $size2 = count($data[$i]); $x < $size2; $x += 2) {
	if ($data[$i][$x+1] !== null) {
	$result[$mbox][$data[$i][$x]] = $data[$i][$x+1];
	}
	}
	}
	}

	return $result;
	}
	}

	/**
	* Send the SETANNOTATION command (draft-daboo-imap-annotatemore)
	*
	* @param string $mailbox Mailbox name
	* @param array $data Data array where each item is an array with
	* three elements: entry name, attribute name, value
	*
	* @return boolean True on success, False on failure
	* @since 0.5-beta
	*/
	public function setAnnotation($mailbox, $data)
	{
	if (!is_array($data) \|\| empty($data)) {
	$this->setError(self::ERROR_COMMAND, "Wrong argument for SETANNOTATION command");
	return false;
	}

	foreach ($data as $entry) {
	// ANNOTATEMORE drafts before version 08 require quoted parameters
	$entries[] = sprintf('%s (%s %s)', $this->escape($entry[0], true),
	$this->escape($entry[1], true), $this->escape($entry[2], true));
	}

	$entries = implode(' ', $entries);
	$result = $this->execute('SETANNOTATION', array(
	$this->escape($mailbox), $entries), self::COMMAND_NORESPONSE);

	return ($result == self::ERROR_OK);
	}

	/**
	* Send the SETANNOTATION command with NIL values (draft-daboo-imap-annotatemore)
	*
	* @param string $mailbox Mailbox name
	* @param array $data Data array where each item is an array with
	* two elements: entry name and attribute name
	*
	* @return boolean True on success, False on failure
	*
	* @since 0.5-beta
	*/
	public function deleteAnnotation($mailbox, $data)
	{
	if (!is_array($data) \|\| empty($data)) {
	$this->setError(self::ERROR_COMMAND, "Wrong argument for SETANNOTATION command");
	return false;
	}

	return $this->setAnnotation($mailbox, $data);
	}

	/**
	* Send the GETANNOTATION command (draft-daboo-imap-annotatemore)
	*
	* @param string $mailbox Mailbox name
	* @param array $entries Entries names
	* @param array $attribs Attribs names
	*
	* @return array Annotations result on success, NULL on error
	*
	* @since 0.5-beta
	*/
	public function getAnnotation($mailbox, $entries, $attribs)
	{
	if (!is_array($entries)) {
	$entries = array($entries);
	}

	// create entries string
	// ANNOTATEMORE drafts before version 08 require quoted parameters
	foreach ($entries as $idx => $name) {
	$entries[$idx] = $this->escape($name, true);
	}
	$entries = '(' . implode(' ', $entries) . ')';

	if (!is_array($attribs)) {
	$attribs = array($attribs);
	}

	// create attributes string
	foreach ($attribs as $idx => $name) {
	$attribs[$idx] = $this->escape($name, true);
	}
	$attribs = '(' . implode(' ', $attribs) . ')';

	list($code, $response) = $this->execute('GETANNOTATION', array(
	$this->escape($mailbox), $entries, $attribs));

	if ($code == self::ERROR_OK) {
	$result = array();
	$data = $this->tokenizeResponse($response);
	$last_entry = null;

	// Here we returns only data compatible with METADATA result format
	if (!empty($data) && ($size = count($data))) {
	for ($i=0; $i<$size; $i++) {
	$entry = $data[$i];
	if (isset($mbox) && is_array($entry)) {
	$attribs = $entry;
	$entry = $last_entry;
	}
	else if ($entry == '*') {
	if ($data[$i+1] == 'ANNOTATION') {
	$mbox = $data[$i+2];
	unset($data[$i]); // "*"
	unset($data[++$i]); // "ANNOTATION"
	unset($data[++$i]); // Mailbox
	}
	// get rid of other untagged responses
	else {
	unset($mbox);
	unset($data[$i]);
	}
	continue;
	}
	else if (isset($mbox)) {
	$attribs = $data[++$i];
	}
	else {
	unset($data[$i]);
	continue;
	}

	if (!empty($attribs)) {
	for ($x=0, $len=count($attribs); $x<$len;) {
	$attr = $attribs[$x++];
	$value = $attribs[$x++];
	if ($attr == 'value.priv' && $value !== null) {
	$result[$mbox]['/private' . $entry] = $value;
	}
	else if ($attr == 'value.shared' && $value !== null) {
	$result[$mbox]['/shared' . $entry] = $value;
	}
	}
	}

	$last_entry = $entry;
	unset($data[$i]);
	}
	}

	return $result;
	}
	}

	/**
	* Returns BODYSTRUCTURE for the specified message.
	*
	* @param string $mailbox Folder name
	* @param int $id Message sequence number or UID
	* @param bool $is_uid True if $id is an UID
	*
	* @return array/bool Body structure array or False on error.
	* @since 0.6
	*/
	public function getStructure($mailbox, $id, $is_uid = false)
	{
	$result = $this->fetch($mailbox, $id, $is_uid, array('BODYSTRUCTURE'));

	if (is_array($result)) {
	$result = array_shift($result);
	return $result->bodystructure;
	}

	return false;
	}

	/**
	* Returns data of a message part according to specified structure.
	*
	* @param array $structure Message structure (getStructure() result)
	* @param string $part Message part identifier
	*
	* @return array Part data as hash array (type, encoding, charset, size)
	*/
	public static function getStructurePartData($structure, $part)
	{
	$part_a = self::getStructurePartArray($structure, $part);
	$data = array();

	if (empty($part_a)) {
	return $data;
	}

	// content-type
	if (is_array($part_a[0])) {
	$data['type'] = 'multipart';
	}
	else {
	$data['type'] = strtolower($part_a[0]);
	$data['subtype'] = strtolower($part_a[1]);
	$data['encoding'] = strtolower($part_a[5]);

	// charset
	if (is_array($part_a[2])) {
	foreach ($part_a[2] as $key => $val) {
	if (strcasecmp($val, 'charset') == 0) {
	$data['charset'] = $part_a[2][$key+1];
	break;
	}
	}
	}
	}

	// size
	$data['size'] = intval($part_a[6]);

	return $data;
	}

	public static function getStructurePartArray($a, $part)
	{
	if (!is_array($a)) {
	return false;
	}

	if (empty($part)) {
	return $a;
	}

	$ctype = is_string($a[0]) && is_string($a[1]) ? $a[0] . '/' . $a[1] : '';

	if (strcasecmp($ctype, 'message/rfc822') == 0) {
	$a = $a[8];
	}

	if (strpos($part, '.') > 0) {
	$orig_part = $part;
	$pos = strpos($part, '.');
	$rest = substr($orig_part, $pos+1);
	$part = substr($orig_part, 0, $pos);

	return self::getStructurePartArray($a[$part-1], $rest);
	}
	else if ($part > 0) {
	return (is_array($a[$part-1])) ? $a[$part-1] : $a;
	}
	}

	/**
	* Creates next command identifier (tag)
	*
	* @return string Command identifier
	* @since 0.5-beta
	*/
	public function nextTag()
	{
	$this->cmd_num++;
	$this->cmd_tag = sprintf('A%04d', $this->cmd_num);

	return $this->cmd_tag;
	}

	/**
	* Sends IMAP command and parses result
	*
	* @param string $command IMAP command
	* @param array $arguments Command arguments
	* @param int $options Execution options
	* @param string $filter Line filter (regexp)
	*
	* @return mixed Response code or list of response code and data
	* @since 0.5-beta
	*/
	public function execute($command, $arguments = array(), $options = 0, $filter = null)
	{
	$tag = $this->nextTag();
	$query = $tag . ' ' . $command;
	$noresp = ($options & self::COMMAND_NORESPONSE);
	$response = $noresp ? null : '';

	if (!empty($arguments)) {
	foreach ($arguments as $arg) {
	$query .= ' ' . self::r_implode($arg);
	}
	}

	// Send command
	if (!$this->putLineC($query, true, ($options & self::COMMAND_ANONYMIZED))) {
	preg_match('/^[A-Z0-9]+ ((UID )?[A-Z]+)/', $query, $matches);
	$cmd = $matches[1] ?: 'UNKNOWN';
	$this->setError(self::ERROR_COMMAND, "Failed to send $cmd command");

	return $noresp ? self::ERROR_COMMAND : array(self::ERROR_COMMAND, '');
	}

	// Parse response
	do {
	$line = $this->readFullLine(4096);

	if ($response !== null) {
	if (!$filter \|\| preg_match($filter, $line)) {
	$response .= $line;
	}
	}

	// parse untagged response for [COPYUID 1204196876 3456:3457 123:124] (RFC6851)
	if ($line && $command == 'UID MOVE') {
	if (preg_match("/^\* OK \[COPYUID [0-9]+ ([0-9,:]+) ([0-9,:]+)\]/i", $line, $m)) {
	$this->data['COPYUID'] = array($m[1], $m[2]);
	}
	}
	}
	while (!$this->startsWith($line, $tag . ' ', true, true));

	$code = $this->parseResult($line, $command . ': ');

	// Remove last line from response
	if ($response) {
	if (!$filter) {
	$line_len = min(strlen($response), strlen($line));
	$response = substr($response, 0, -$line_len);
	}

	$response = rtrim($response, "\r\n");
	}

	// optional CAPABILITY response
	if (($options & self::COMMAND_CAPABILITY) && $code == self::ERROR_OK
	&& preg_match('/\[CAPABILITY ([^]]+)\]/i', $line, $matches)
	) {
	$this->parseCapability($matches[1], true);
	}

	// return last line only (without command tag, result and response code)
	if ($line && ($options & self::COMMAND_LASTLINE)) {
	$response = preg_replace("/^$tag (OK\|NO\|BAD\|BYE\|PREAUTH)?\s(\[[a-z-]+\])?\s/i", '', trim($line));
	}

	return $noresp ? $code : array($code, $response);
	}

	/**
	* Splits IMAP response into string tokens
	*
	* @param string &$str The IMAP's server response
	* @param int $num Number of tokens to return
	*
	* @return mixed Tokens array or string if $num=1
	* @since 0.5-beta
	*/
	public static function tokenizeResponse(&$str, $num=0)
	{
	$result = array();

	while (!$num \|\| count($result) < $num) {
	// remove spaces from the beginning of the string
	$str = ltrim($str);

	+ // empty string
	+ if ($str === '' \|\| $str === null) {
	+ break;
	+ }
	+
	switch ($str[0]) {

	// String literal
	case '{':
	if (($epos = strpos($str, "}\r\n", 1)) == false) {
	// error
	}
	if (!is_numeric(($bytes = substr($str, 1, $epos - 1)))) {
	// error
	}

	$result[] = $bytes ? substr($str, $epos + 3, $bytes) : '';
	$str = substr($str, $epos + 3 + $bytes);
	break;

	// Quoted string
	case '"':
	$len = strlen($str);

	for ($pos=1; $pos<$len; $pos++) {
	if ($str[$pos] == '"') {
	break;
	}
	if ($str[$pos] == "\\") {
	if ($str[$pos + 1] == '"' \|\| $str[$pos + 1] == "\\") {
	$pos++;
	}
	}
	}

	// we need to strip slashes for a quoted string
	$result[] = stripslashes(substr($str, 1, $pos - 1));
	$str = substr($str, $pos + 1);
	break;

	// Parenthesized list
	case '(':
	$str = substr($str, 1);
	$result[] = self::tokenizeResponse($str);
	break;

	case ')':
	$str = substr($str, 1);
	return $result;

	// String atom, number, astring, NIL, *, %
	default:
	- // empty string
	- if ($str === '' \|\| $str === null) {
	- break 2;
	- }
	-
	// excluded chars: SP, CTL, ), DEL
	// we do not exclude [ and ] (#1489223)
	if (preg_match('/^([^\x00-\x20\x29\x7F]+)/', $str, $m)) {
	$result[] = $m[1] == 'NIL' ? null : $m[1];
	$str = substr($str, strlen($m[1]));
	}
	+
	break;
	}
	}

	- return $num == 1 ? $result[0] : $result;
	+ return $num == 1 ? (isset($result[0]) ? $result[0] : '') : $result;
	}

	/**
	* Joins IMAP command line elements (recursively)
	*/
	protected static function r_implode($element)
	{
	$string = '';

	if (is_array($element)) {
	reset($element);
	foreach ($element as $value) {
	$string .= ' ' . self::r_implode($value);
	}
	}
	else {
	return $element;
	}

	return '(' . trim($string) . ')';
	}

	/**
	* Converts message identifiers array into sequence-set syntax
	*
	* @param array $messages Message identifiers
	* @param bool $force Forces compression of any size
	*
	* @return string Compressed sequence-set
	*/
	public static function compressMessageSet($messages, $force=false)
	{
	// given a comma delimited list of independent mid's,
	// compresses by grouping sequences together
	if (!is_array($messages)) {
	// if less than 255 bytes long, let's not bother
	if (!$force && strlen($messages) < 255) {
	return preg_match('/[^0-9:,*]/', $messages) ? 'INVALID' : $messages;
	}

	// see if it's already been compressed
	if (strpos($messages, ':') !== false) {
	return preg_match('/[^0-9:,*]/', $messages) ? 'INVALID' : $messages;
	}

	// separate, then sort
	$messages = explode(',', $messages);
	}

	sort($messages);

	$result = array();
	$start = $prev = $messages[0];

	foreach ($messages as $id) {
	$incr = $id - $prev;
	if ($incr > 1) { // found a gap
	if ($start == $prev) {
	$result[] = $prev; // push single id
	}
	else {
	$result[] = $start . ':' . $prev; // push sequence as start_id:end_id
	}
	$start = $id; // start of new sequence
	}
	$prev = $id;
	}

	// handle the last sequence/id
	if ($start == $prev) {
	$result[] = $prev;
	}
	else {
	$result[] = $start.':'.$prev;
	}

	// return as comma separated string
	$result = implode(',', $result);

	return preg_match('/[^0-9:,*]/', $result) ? 'INVALID' : $result;
	}

	/**
	* Converts message sequence-set into array
	*
	* @param string $messages Message identifiers
	*
	* @return array List of message identifiers
	*/
	public static function uncompressMessageSet($messages)
	{
	if (empty($messages)) {
	return array();
	}

	$result = array();
	$messages = explode(',', $messages);

	foreach ($messages as $idx => $part) {
	$items = explode(':', $part);

	if (!empty($items[1]) && $items[1] > $items[0]) {
	$max = $items[1];
	}
	else {
	$max = $items[0];
	}

	for ($x = $items[0]; $x <= $max; $x++) {
	$result[] = (int) $x;
	}

	unset($messages[$idx]);
	}

	return $result;
	}

	/**
	* Clear internal status cache
	*/
	protected function clear_status_cache($mailbox)
	{
	unset($this->data['STATUS:' . $mailbox]);

	$keys = array('EXISTS', 'RECENT', 'UNSEEN', 'UID-MAP');

	foreach ($keys as $key) {
	unset($this->data[$key]);
	}
	}

	/**
	* Clear internal cache of the current mailbox
	*/
	protected function clear_mailbox_cache()
	{
	$this->clear_status_cache($this->selected);

	$keys = array('UIDNEXT', 'UIDVALIDITY', 'HIGHESTMODSEQ', 'NOMODSEQ',
	'PERMANENTFLAGS', 'QRESYNC', 'VANISHED', 'READ-WRITE');

	foreach ($keys as $key) {
	unset($this->data[$key]);
	}
	}

	/**
	* Converts flags array into string for inclusion in IMAP command
	*
	* @param array $flags Flags (see self::flags)
	*
	* @return string Space-separated list of flags
	*/
	protected function flagsToStr($flags)
	{
	foreach ((array)$flags as $idx => $flag) {
	if ($flag = $this->flags[strtoupper($flag)]) {
	$flags[$idx] = $flag;
	}
	}

	return implode(' ', (array)$flags);
	}

	/**
	* CAPABILITY response parser
	*/
	protected function parseCapability($str, $trusted=false)
	{
	$str = preg_replace('/^\* CAPABILITY /i', '', $str);

	$this->capability = explode(' ', strtoupper($str));

	if (!empty($this->prefs['disabled_caps'])) {
	$this->capability = array_diff($this->capability, $this->prefs['disabled_caps']);
	}

	if (!isset($this->prefs['literal+']) && in_array('LITERAL+', $this->capability)) {
	$this->prefs['literal+'] = true;
	}

	if ($trusted) {
	$this->capability_readed = true;
	}
	}

	/**
	* Escapes a string when it contains special characters (RFC3501)
	*
	* @param string $string IMAP string
	* @param boolean $force_quotes Forces string quoting (for atoms)
	*
	* @return string String atom, quoted-string or string literal
	* @todo lists
	*/
	public static function escape($string, $force_quotes=false)
	{
	if ($string === null) {
	return 'NIL';
	}

	if ($string === '') {
	return '""';
	}

	// atom-string (only safe characters)
	if (!$force_quotes && !preg_match('/[\x00-\x20\x22\x25\x28-\x2A\x5B-\x5D\x7B\x7D\x80-\xFF]/', $string)) {
	return $string;
	}

	// quoted-string
	if (!preg_match('/[\r\n\x00\x80-\xFF]/', $string)) {
	return '"' . addcslashes($string, '\\"') . '"';
	}

	// literal-string
	return sprintf("{%d}\r\n%s", strlen($string), $string);
	}

	/**
	* Set the value of the debugging flag.
	*
	* @param boolean $debug New value for the debugging flag.
	* @param callback $handler Logging handler function
	*
	* @since 0.5-stable
	*/
	public function setDebug($debug, $handler = null)
	{
	$this->debug = $debug;
	$this->debug_handler = $handler;
	}

	/**
	* Write the given debug text to the current debug output handler.
	*
	* @param string $message Debug message text.
	*
	* @since 0.5-stable
	*/
	protected function debug($message)
	{
	if (($len = strlen($message)) > self::DEBUG_LINE_LENGTH) {
	$diff = $len - self::DEBUG_LINE_LENGTH;
	$message = substr($message, 0, self::DEBUG_LINE_LENGTH)
	. "... [truncated $diff bytes]";
	}

	if ($this->resourceid) {
	$message = sprintf('[%s] %s', $this->resourceid, $message);
	}

	if ($this->debug_handler) {
	call_user_func_array($this->debug_handler, array($this, $message));
	}
	else {
	echo "DEBUG: $message\n";
	}
	}
	}
	diff --git a/program/lib/Roundcube/rcube_output.php b/program/lib/Roundcube/rcube_output.php
	index f1f2d173e..4de7f70ac 100644
	--- a/program/lib/Roundcube/rcube_output.php
	+++ b/program/lib/Roundcube/rcube_output.php
	@@ -1,370 +1,370 @@
	<?php

	/**
	+-----------------------------------------------------------------------+
	\| This file is part of the Roundcube webmail client \|
	\| \|
	\| Copyright (C) The Roundcube Dev Team \|
	\| \|
	\| Licensed under the GNU General Public License version 3 or \|
	\| any later version with exceptions for skins & plugins. \|
	\| See the README file for a full license statement. \|
	\| \|
	\| CONTENTS: \|
	\| Abstract class for output generation \|
	+-----------------------------------------------------------------------+
	\| Author: Thomas Bruederli <roundcube@gmail.com> \|
	\| Author: Aleksander Machniak <alec@alec.pl> \|
	+-----------------------------------------------------------------------+
	*/

	/**
	* Class for output generation
	*
	* @package Framework
	* @subpackage View
	*/
	abstract class rcube_output
	{
	public $browser;

	protected $app;
	protected $config;
	protected $charset = RCUBE_CHARSET;
	protected $env = array();
	protected $skins = array();


	/**
	* Object constructor
	*/
	public function __construct()
	{
	$this->app = rcube::get_instance();
	$this->config = $this->app->config;
	$this->browser = new rcube_browser();
	}

	/**
	* Magic getter
	*/
	public function __get($var)
	{
	// allow read-only access to some members
	switch ($var) {
	case 'env': return $this->env;
	case 'skins': return $this->skins;
	case 'charset': return $this->charset;
	}
	}

	/**
	* Setter for output charset.
	* To be specified in a meta tag and sent as http-header
	*
	* @param string $charset Charset name
	*/
	public function set_charset($charset)
	{
	$this->charset = $charset;
	}

	/**
	* Getter for output charset
	*
	* @return string Output charset name
	*/
	public function get_charset()
	{
	return $this->charset;
	}

	/**
	* Set environment variable
	*
	* @param string $name Property name
	* @param mixed $value Property value
	*/
	public function set_env($name, $value)
	{
	$this->env[$name] = $value;
	}

	/**
	* Environment variable getter.
	*
	* @param string $name Property name
	*
	* @return mixed Property value
	*/
	public function get_env($name)
	{
	- return $this->env[$name];
	+ return isset($this->env[$name]) ? $this->env[$name] : null;
	}

	/**
	* Delete all stored env variables and commands
	*/
	public function reset()
	{
	$this->env = array();
	}

	/**
	* Invoke display_message command
	*
	* @param string $message Message to display
	* @param string $type Message type [notice\|confirm\|error]
	* @param array $vars Key-value pairs to be replaced in localized text
	* @param boolean $override Override last set message
	* @param int $timeout Message displaying time in seconds
	*/
	abstract function show_message($message, $type = 'notice', $vars = null, $override = true, $timeout = 0);

	/**
	* Redirect to a certain url.
	*
	* @param mixed $p Either a string with the action or url parameters as key-value pairs
	* @param int $delay Delay in seconds
	*/
	abstract function redirect($p = array(), $delay = 1);

	/**
	* Send output to the client.
	*/
	abstract function send();

	/**
	* Send HTTP headers to prevent caching a page
	*/
	public function nocacheing_headers()
	{
	if (headers_sent()) {
	return;
	}

	header("Expires: ".gmdate("D, d M Y H:i:s")." GMT");
	header("Last-Modified: ".gmdate("D, d M Y H:i:s")." GMT");

	// We need to set the following headers to make downloads work using IE in HTTPS mode.
	if ($this->browser->ie && rcube_utils::https_check()) {
	header('Pragma: private');
	header("Cache-Control: private, must-revalidate");
	}
	else {
	header("Cache-Control: private, no-cache, no-store, must-revalidate, post-check=0, pre-check=0");
	header("Pragma: no-cache");
	}
	}

	/**
	* Send header with expire date 30 days in future
	*
	* @param int Expiration time in seconds
	*/
	public function future_expire_header($offset = 2600000)
	{
	if (headers_sent()) {
	return;
	}

	header("Expires: " . gmdate("D, d M Y H:i:s", time()+$offset) . " GMT");
	header("Cache-Control: max-age=$offset");
	header("Pragma: ");
	}

	/**
	* Send browser compatibility/security/privacy headers
	*
	* @param bool $privacy Enable privacy headers
	*/
	public function common_headers($privacy = true)
	{
	if (headers_sent()) {
	return;
	}

	$headers = array();

	// Unlock IE compatibility mode
	if ($this->browser->ie) {
	$headers['X-UA-Compatible'] = 'IE=edge';
	}

	if ($privacy) {
	// Request browser to disable DNS prefetching (CVE-2010-0464)
	$headers['X-DNS-Prefetch-Control'] = 'off';

	// Request browser disable Referer (sic) header
	$headers['Referrer-Policy'] = 'same-origin';
	}

	// send CSRF and clickjacking protection headers
	if ($xframe = $this->app->config->get('x_frame_options', 'sameorigin')) {
	$headers['X-Frame-Options'] = $xframe;
	}

	$plugin = $this->app->plugins->exec_hook('common_headers', array('headers' => $headers, 'privacy' => $privacy));

	foreach ($plugin['headers'] as $header => $value) {
	header("$header: $value");
	}
	}

	/**
	* Send headers related to file downloads
	*
	* @param string $filename File name
	* @param array $params Optional parameters:
	* type - File content type (default: 'application/octet-stream')
	* disposition - Download type: 'inline' or 'attachment' (default)
	* length - Content length
	* charset - File name character set
	* type_charset - Content character set
	* time_limit - Script execution limit (default: 3600)
	*/
	public function download_headers($filename, $params = array())
	{
	if (empty($params['disposition'])) {
	$params['disposition'] = 'attachment';
	}

	if ($params['disposition'] == 'inline' && stripos($params['type'], 'text') === 0) {
	$params['type'] .= '; charset=' . ($params['type_charset'] ?: $this->charset);
	}

	header("Content-Type: " . ($params['type'] ?: "application/octet-stream"));

	if ($params['disposition'] == 'attachment' && $this->browser->ie) {
	header("Content-Type: application/force-download");
	}

	$disposition = "Content-Disposition: " . $params['disposition'];

	// For non-ascii characters we'll use RFC2231 syntax
	if (!preg_match('/[^a-zA-Z0-9_.:,?;@+ -]/', $filename)) {
	$disposition .= sprintf("; filename=\"%s\"", $filename);
	}
	else {
	$disposition .= sprintf("; filename*=%s''%s", $params['charset'] ?: $this->charset, rawurlencode($filename));
	}

	header($disposition);

	if (isset($params['length'])) {
	header("Content-Length: " . $params['length']);
	}

	// don't kill the connection if download takes more than 30 sec.
	if (!array_key_exists('time_limit', $params)) {
	$params['time_limit'] = 3600;
	}

	if (is_numeric($params['time_limit'])) {
	@set_time_limit($params['time_limit']);
	}
	}

	/**
	* Show error page and terminate script execution
	*
	* @param int $code Error code
	* @param string $message Error message
	*/
	public function raise_error($code, $message)
	{
	// STUB: to be overloaded by specific output classes
	fwrite(STDERR, "Error $code: $message\n");
	exit(-1);
	}

	/**
	* Create an edit field for inclusion on a form
	*
	* @param string $col Field name
	* @param string $value Field value
	* @param array $attrib HTML element attributes for the field
	* @param string $type HTML element type (default 'text')
	*
	* @return string HTML field definition
	*/
	public static function get_edit_field($col, $value, $attrib, $type = 'text')
	{
	static $colcounts = array();

	$fname = '_'.$col;
	$attrib['name'] = $fname . ($attrib['array'] ? '[]' : '');
	$attrib['class'] = trim($attrib['class'] . ' ff_' . $col);

	if ($type == 'checkbox') {
	$attrib['value'] = '1';
	$input = new html_checkbox($attrib);
	}
	else if ($type == 'textarea') {
	$attrib['cols'] = $attrib['size'];
	$input = new html_textarea($attrib);
	}
	else if ($type == 'select') {
	$input = new html_select($attrib);
	if (empty($attrib['skip-empty'])) {
	$input->add('---', '');
	}
	$input->add(array_values($attrib['options']), array_keys($attrib['options']));
	}
	else if ($type == 'password' \|\| $attrib['type'] == 'password') {
	$input = new html_passwordfield($attrib);
	}
	else {
	if ($attrib['type'] != 'text' && $attrib['type'] != 'hidden') {
	$attrib['type'] = 'text';
	}
	$input = new html_inputfield($attrib);
	}

	// use value from post
	if (isset($_POST[$fname])) {
	$postvalue = rcube_utils::get_input_value($fname, rcube_utils::INPUT_POST, true);
	$value = $attrib['array'] ? $postvalue[intval($colcounts[$col]++)] : $postvalue;
	}

	$out = $input->show($value);

	return $out;
	}

	/**
	* Convert a variable into a javascript object notation
	*
	* @param mixed $input Input value
	* @param boolean $pretty Enable JSON formatting
	* @param boolean $inline Enable inline mode (generates output safe for use inside HTML)
	*
	* @return string Serialized JSON string
	*/
	public static function json_serialize($input, $pretty = false, $inline = true)
	{
	// The input need to be valid UTF-8 to use with json_encode()
	$input = rcube_charset::clean($input);
	$options = JSON_UNESCAPED_SLASHES;

	// JSON_HEX_TAG is needed for inlining JSON inside of the <script> tag
	// if input contains a html tag it will cause issues (#6207)
	if ($inline) {
	$options \|= JSON_HEX_TAG;
	}

	// JSON_UNESCAPED_UNICODE in PHP < 7.1.0 does not escape U+2028 and U+2029
	// which causes issues (#6187)
	if (PHP_VERSION_ID >= 70100) {
	$options \|= JSON_UNESCAPED_UNICODE;
	}

	if ($pretty) {
	$options \|= JSON_PRETTY_PRINT;
	}

	// sometimes even using rcube_charset::clean() the input contains invalid UTF-8 sequences
	// that's why we have @ here
	return @json_encode($input, $options);
	}
	}
	diff --git a/program/lib/Roundcube/rcube_plugin.php b/program/lib/Roundcube/rcube_plugin.php
	index cafa0a41f..1931caaa5 100644
	--- a/program/lib/Roundcube/rcube_plugin.php
	+++ b/program/lib/Roundcube/rcube_plugin.php
	@@ -1,420 +1,420 @@
	<?php

	/**
	+-----------------------------------------------------------------------+
	\| This file is part of the Roundcube Webmail client \|
	\| \|
	\| Copyright (C) The Roundcube Dev Team \|
	\| \|
	\| Licensed under the GNU General Public License version 3 or \|
	\| any later version with exceptions for skins & plugins. \|
	\| See the README file for a full license statement. \|
	\| \|
	\| PURPOSE: \|
	\| Abstract plugins interface/class \|
	\| All plugins need to extend this class \|
	+-----------------------------------------------------------------------+
	\| Author: Thomas Bruederli <roundcube@gmail.com> \|
	+-----------------------------------------------------------------------+
	*/

	/**
	* Plugin interface class
	*
	* @package Framework
	* @subpackage PluginAPI
	*/
	abstract class rcube_plugin
	{
	/**
	* Class name of the plugin instance
	*
	* @var string
	*/
	public $ID;

	/**
	* Instance of Plugin API
	*
	* @var rcube_plugin_api
	*/
	public $api;

	/**
	* Regular expression defining task(s) to bind with
	*
	* @var string
	*/
	public $task;

	/**
	* Disables plugin in AJAX requests
	*
	* @var boolean
	*/
	public $noajax = false;

	/**
	* Disables plugin in framed mode
	*
	* @var boolean
	*/
	public $noframe = false;

	/**
	* A list of config option names that can be modified
	* by the user via user interface (with save-prefs command)
	*
	* @var array
	*/
	public $allowed_prefs;

	/** @var string Plugin directory location */
	protected $home;

	/** @var string Base URL to the plugin directory */
	protected $urlbase;

	/** @var string Plugin task name (if registered) */
	private $mytask;

	/** @var array List of plugin configuration files already loaded */
	private $loaded_config = array();


	/**
	* Default constructor.
	*
	* @param rcube_plugin_api $api Plugin API
	*/
	public function __construct($api)
	{
	$this->ID = get_class($this);
	$this->api = $api;
	$this->home = $api->dir . $this->ID;
	$this->urlbase = $api->url . $this->ID . '/';
	}

	/**
	* Initialization method, needs to be implemented by the plugin itself
	*/
	abstract function init();

	/**
	* Provide information about this
	*
	* @return array Meta information about a plugin or false if not implemented.
	* As hash array with the following keys:
	* name: The plugin name
	* vendor: Name of the plugin developer
	* version: Plugin version name
	* license: License name (short form according to http://spdx.org/licenses/)
	* uri: The URL to the plugin homepage or source repository
	* src_uri: Direct download URL to the source code of this plugin
	* require: List of plugins required for this one (as array of plugin names)
	*/
	public static function info()
	{
	return false;
	}

	/**
	* Attempt to load the given plugin which is required for the current plugin
	*
	* @param string Plugin name
	* @return boolean True on success, false on failure
	*/
	public function require_plugin($plugin_name)
	{
	return $this->api->load_plugin($plugin_name, true);
	}

	/**
	* Attempt to load the given plugin which is optional for the current plugin
	*
	* @param string Plugin name
	* @return boolean True on success, false on failure
	*/
	public function include_plugin($plugin_name)
	{
	return $this->api->load_plugin($plugin_name, true, false);
	}

	/**
	* Load local config file from plugins directory.
	* The loaded values are patched over the global configuration.
	*
	* @param string $fname Config file name relative to the plugin's folder
	*
	* @return boolean True on success, false on failure
	*/
	public function load_config($fname = 'config.inc.php')
	{
	if (in_array($fname, $this->loaded_config)) {
	return true;
	}

	$this->loaded_config[] = $fname;

	$fpath = $this->home.'/'.$fname;
	$rcube = rcube::get_instance();

	if (($is_local = is_file($fpath)) && !$rcube->config->load_from_file($fpath)) {
	rcube::raise_error(array(
	'code' => 527, 'type' => 'php',
	'file' => __FILE__, 'line' => __LINE__,
	'message' => "Failed to load config from $fpath"), true, false);
	return false;
	}
	else if (!$is_local) {
	// Search plugin_name.inc.php file in any configured path
	return $rcube->config->load_from_file($this->ID . '.inc.php');
	}

	return true;
	}

	/**
	* Register a callback function for a specific (server-side) hook
	*
	* @param string $hook Hook name
	* @param mixed $callback Callback function as string or array
	* with object reference and method name
	*/
	public function add_hook($hook, $callback)
	{
	$this->api->register_hook($hook, $callback);
	}

	/**
	* Unregister a callback function for a specific (server-side) hook.
	*
	* @param string $hook Hook name
	* @param mixed $callback Callback function as string or array
	* with object reference and method name
	*/
	public function remove_hook($hook, $callback)
	{
	$this->api->unregister_hook($hook, $callback);
	}

	/**
	* Load localized texts from the plugins dir
	*
	* @param string $dir Directory to search in
	* @param mixed $add2client Make texts also available on the client
	* (array with list or true for all)
	*/
	public function add_texts($dir, $add2client = false)
	{
	$rcube = rcube::get_instance();
	$texts = $rcube->read_localization(realpath(slashify($this->home) . $dir));

	// prepend domain to text keys and add to the application texts repository
	if (!empty($texts)) {
	$domain = $this->ID;
	$add = array();

	foreach ($texts as $key => $value) {
	$add[$domain.'.'.$key] = $value;
	}

	$rcube->load_language($_SESSION['language'], $add);

	// add labels to client
	if ($add2client && method_exists($rcube->output, 'add_label')) {
	if (is_array($add2client)) {
	$js_labels = array_map(array($this, 'label_map_callback'), $add2client);
	}
	else {
	$js_labels = array_keys($add);
	}

	$rcube->output->add_label($js_labels);
	}
	}
	}

	/**
	* Wrapper for add_label() adding the plugin ID as domain
	*/
	public function add_label()
	{
	$rcube = rcube::get_instance();

	if (method_exists($rcube->output, 'add_label')) {
	$args = func_get_args();
	if (count($args) == 1 && is_array($args[0])) {
	$args = $args[0];
	}

	$args = array_map(array($this, 'label_map_callback'), $args);
	$rcube->output->add_label($args);
	}
	}

	/**
	* Wrapper for rcube::gettext() adding the plugin ID as domain
	*
	* @param mixed $p Named parameters array or label name
	*
	* @return string Localized text
	* @see rcube::gettext()
	*/
	public function gettext($p)
	{
	return rcube::get_instance()->gettext($p, $this->ID);
	}

	/**
	* Register this plugin to be responsible for a specific task
	*
	* @param string $task Task name (only characters [a-z0-9_-] are allowed)
	*/
	public function register_task($task)
	{
	if ($this->api->register_task($task, $this->ID)) {
	$this->mytask = $task;
	}
	}

	/**
	* Register a handler for a specific client-request action
	*
	* The callback will be executed upon a request like /?_task=mail&_action=plugin.myaction
	*
	* @param string $action Action name (should be unique)
	* @param mixed $callback Callback function as string
	* or array with object reference and method name
	*/
	public function register_action($action, $callback)
	{
	$this->api->register_action($action, $this->ID, $callback, $this->mytask);
	}

	/**
	* Register a handler function for a template object
	*
	* When parsing a template for display, tags like <roundcube:object name="plugin.myobject" />
	* will be replaced by the return value if the registered callback function.
	*
	* @param string $name Object name (should be unique and start with 'plugin.')
	* @param mixed $callback Callback function as string or array with object reference
	* and method name
	*/
	public function register_handler($name, $callback)
	{
	$this->api->register_handler($name, $this->ID, $callback);
	}

	/**
	* Make this javascipt file available on the client
	*
	* @param string $fn File path; absolute or relative to the plugin directory
	*/
	public function include_script($fn)
	{
	$this->api->include_script($this->resource_url($fn));
	}

	/**
	* Make this stylesheet available on the client
	*
	* @param string $fn File path; absolute or relative to the plugin directory
	*/
	public function include_stylesheet($fn)
	{
	$this->api->include_stylesheet($this->resource_url($fn));
	}

	/**
	* Append a button to a certain container
	*
	* @param array $p Hash array with named parameters (as used in skin templates)
	* @param string $container Container name where the buttons should be added to
	*
	* @see rcube_remplate::button()
	*/
	public function add_button($p, $container)
	{
	if ($this->api->output->type == 'html') {
	// fix relative paths
	foreach (array('imagepas', 'imageact', 'imagesel') as $key) {
	- if ($p[$key]) {
	+ if (!empty($p[$key])) {
	$p[$key] = $this->api->url . $this->resource_url($p[$key]);
	}
	}

	$this->api->add_content($this->api->output->button($p), $container);
	}
	}

	/**
	* Generate an absolute URL to the given resource within the current
	* plugin directory
	*
	* @param string $fn The file name
	*
	* @return string Absolute URL to the given resource
	*/
	public function url($fn)
	{
	return $this->api->url . $this->resource_url($fn);
	}

	/**
	* Make the given file name link into the plugin directory
	*
	* @param string $fn Filename
	*/
	private function resource_url($fn)
	{
	if ($fn[0] != '/' && !preg_match('\|^https?://\|i', $fn)) {
	return $this->ID . '/' . $fn;
	}
	else {
	return $fn;
	}
	}

	/**
	* Provide path to the currently selected skin folder within the plugin directory
	* with a fallback to the default skin folder.
	*
	* @return string Skin path relative to plugins directory
	*/
	public function local_skin_path()
	{
	$rcube = rcube::get_instance();
	$skins = array_keys((array)$rcube->output->skins);
	$skin_path = '';

	if (empty($skins)) {
	$skins = (array) $rcube->config->get('skin');
	}

	foreach ($skins as $skin) {
	$skin_path = 'skins/' . $skin;
	if (is_dir(realpath(slashify($this->home) . $skin_path))) {
	break;
	}
	}

	return $skin_path;
	}

	/**
	* Callback function for array_map
	*
	* @param string $key Array key.
	* @return string
	*/
	private function label_map_callback($key)
	{
	if (strpos($key, $this->ID.'.') === 0) {
	return $key;
	}

	return $this->ID.'.'.$key;
	}
	}
	diff --git a/program/lib/Roundcube/rcube_plugin_api.php b/program/lib/Roundcube/rcube_plugin_api.php
	index 0186489c1..f71afb8e4 100644
	--- a/program/lib/Roundcube/rcube_plugin_api.php
	+++ b/program/lib/Roundcube/rcube_plugin_api.php
	@@ -1,729 +1,739 @@
	<?php

	/**
	+-----------------------------------------------------------------------+
	\| This file is part of the Roundcube Webmail client \|
	\| \|
	\| Copyright (C) The Roundcube Dev Team \|
	\| \|
	\| Licensed under the GNU General Public License version 3 or \|
	\| any later version with exceptions for skins & plugins. \|
	\| See the README file for a full license statement. \|
	\| \|
	\| PURPOSE: \|
	\| Plugins repository \|
	+-----------------------------------------------------------------------+
	\| Author: Thomas Bruederli <roundcube@gmail.com> \|
	+-----------------------------------------------------------------------+
	*/

	// location where plugins are loaded from
	if (!defined('RCUBE_PLUGINS_DIR')) {
	define('RCUBE_PLUGINS_DIR', RCUBE_INSTALL_PATH . 'plugins/');
	}

	/**
	* The plugin loader and global API
	*
	* @package Framework
	* @subpackage PluginAPI
	*/
	class rcube_plugin_api
	{
	static protected $instance;

	public $dir;
	public $url = 'plugins/';
	public $task = '';
	public $initialized = false;

	public $output;
	public $handlers = array();
	public $allowed_prefs = array();
	public $allowed_session_prefs = array();
	public $active_plugins = array();

	protected $plugins = array();
	protected $plugins_initialized = array();
	protected $tasks = array();
	protected $actions = array();
	protected $actionmap = array();
	protected $objectsmap = array();
	protected $template_contents = array();
	protected $exec_stack = array();
	protected $deprecated_hooks = array();


	/**
	* This implements the 'singleton' design pattern
	*
	* @return rcube_plugin_api The one and only instance if this class
	*/
	static function get_instance()
	{
	if (!self::$instance) {
	self::$instance = new rcube_plugin_api();
	}

	return self::$instance;
	}

	/**
	* Private constructor
	*/
	protected function __construct()
	{
	$this->dir = slashify(RCUBE_PLUGINS_DIR);
	}

	/**
	* Initialize plugin engine
	*
	* This has to be done after rcmail::load_gui() or rcmail::json_init()
	* was called because plugins need to have access to rcmail->output
	*
	* @param object rcube Instance of the rcube base class
	* @param string Current application task (used for conditional plugin loading)
	*/
	public function init($app, $task = '')
	{
	$this->task = $task;
	$this->output = $app->output;
	// register an internal hook
	$this->register_hook('template_container', array($this, 'template_container_hook'));
	// maybe also register a shudown function which triggers
	// shutdown functions of all plugin objects

	foreach ($this->plugins as $plugin) {
	// ... task, request type and framed mode
	if (empty($this->plugins_initialized[$plugin->ID]) && !$this->filter($plugin)) {
	$plugin->init();
	$this->plugins_initialized[$plugin->ID] = $plugin;
	}
	}

	// we have finished initializing all plugins
	$this->initialized = true;
	}

	/**
	* Load and init all enabled plugins
	*
	* This has to be done after rcmail::load_gui() or rcmail::json_init()
	* was called because plugins need to have access to rcmail->output
	*
	* @param array List of configured plugins to load
	* @param array List of plugins required by the application
	*/
	public function load_plugins($plugins_enabled, $required_plugins = array())
	{
	foreach ($plugins_enabled as $plugin_name) {
	$this->load_plugin($plugin_name);
	}

	// check existance of all required core plugins
	foreach ($required_plugins as $plugin_name) {
	$loaded = false;
	foreach ($this->plugins as $plugin) {
	if ($plugin instanceof $plugin_name) {
	$loaded = true;
	break;
	}
	}

	// load required core plugin if no derivate was found
	if (!$loaded) {
	$loaded = $this->load_plugin($plugin_name);
	}

	// trigger fatal error if still not loaded
	if (!$loaded) {
	rcube::raise_error(array(
	'code' => 520, 'type' => 'php',
	'file' => __FILE__, 'line' => __LINE__,
	'message' => "Requried plugin $plugin_name was not loaded"), true, true);
	}
	}
	}

	/**
	* Load the specified plugin
	*
	* @param string Plugin name
	* @param boolean Force loading of the plugin even if it doesn't match the filter
	* @param boolean Require loading of the plugin, error if it doesn't exist
	*
	* @return boolean True on success, false if not loaded or failure
	*/
	public function load_plugin($plugin_name, $force = false, $require = true)
	{
	static $plugins_dir;

	if (!$plugins_dir) {
	$dir = dir($this->dir);
	$plugins_dir = unslashify($dir->path);
	}

	// Validate the plugin name to prevent from path traversal
	if (preg_match('/[^a-zA-Z0-9_-]/', $plugin_name)) {
	rcube::raise_error(array('code' => 520,
	'file' => __FILE__, 'line' => __LINE__,
	'message' => "Invalid plugin name: $plugin_name"), true, false);
	return false;
	}

	// plugin already loaded?
	if (!isset($this->plugins[$plugin_name])) {
	$fn = "$plugins_dir/$plugin_name/$plugin_name.php";

	if (!is_readable($fn)) {
	if ($require) {
	rcube::raise_error(array('code' => 520, 'type' => 'php',
	'file' => __FILE__, 'line' => __LINE__,
	'message' => "Failed to load plugin file $fn"), true, false);
	}

	return false;
	}

	if (!class_exists($plugin_name, false)) {
	include $fn;
	}

	// instantiate class if exists
	if (!class_exists($plugin_name, false)) {
	rcube::raise_error(array('code' => 520, 'type' => 'php',
	'file' => __FILE__, 'line' => __LINE__,
	'message' => "No plugin class $plugin_name found in $fn"),
	true, false);

	return false;
	}

	$plugin = new $plugin_name($this);
	$this->active_plugins[] = $plugin_name;

	// check inheritance...
	if (is_subclass_of($plugin, 'rcube_plugin')) {
	// call onload method on plugin if it exists.
	// this is useful if you want to be called early in the boot process
	if (method_exists($plugin, 'onload')) {
	$plugin->onload();
	}

	if (!empty($plugin->allowed_prefs)) {
	$this->allowed_prefs = array_merge($this->allowed_prefs, $plugin->allowed_prefs);
	}

	$this->plugins[$plugin_name] = $plugin;
	}
	}

	if ($plugin = $this->plugins[$plugin_name]) {
	// init a plugin only if $force is set or if we're called after initialization
	if (($force \|\| $this->initialized) && !$this->plugins_initialized[$plugin_name] && ($force \|\| !$this->filter($plugin))) {
	$plugin->init();
	$this->plugins_initialized[$plugin_name] = $plugin;
	}
	}

	return true;
	}

	/**
	* check if we should prevent this plugin from initialising
	*
	* @param $plugin
	* @return bool
	*/
	private function filter($plugin)
	{
	return ($plugin->noajax && !(is_object($this->output) && $this->output->type == 'html'))
	\|\| ($plugin->task && !preg_match('/^('.$plugin->task.')$/i', $this->task))
	\|\| ($plugin->noframe && !empty($_REQUEST['_framed']));
	}

	/**
	* Get information about a specific plugin.
	* This is either provided by a plugin's info() method or extracted from a package.xml or a composer.json file
	*
	* @param string Plugin name
	* @return array Meta information about a plugin or False if plugin was not found
	*/
	public function get_info($plugin_name)
	{
	static $composer_lock, $license_uris = array(
	'Apache' => 'http://www.apache.org/licenses/LICENSE-2.0.html',
	'Apache-2' => 'http://www.apache.org/licenses/LICENSE-2.0.html',
	'Apache-1' => 'http://www.apache.org/licenses/LICENSE-1.0',
	'Apache-1.1' => 'http://www.apache.org/licenses/LICENSE-1.1',
	'GPL' => 'http://www.gnu.org/licenses/gpl.html',
	'GPLv2' => 'http://www.gnu.org/licenses/gpl-2.0.html',
	'GPL-2.0' => 'http://www.gnu.org/licenses/gpl-2.0.html',
	'GPLv3' => 'http://www.gnu.org/licenses/gpl-3.0.html',
	'GPLv3+' => 'http://www.gnu.org/licenses/gpl-3.0.html',
	'GPL-3.0' => 'http://www.gnu.org/licenses/gpl-3.0.html',
	'GPL-3.0+' => 'http://www.gnu.org/licenses/gpl.html',
	'GPL-2.0+' => 'http://www.gnu.org/licenses/gpl.html',
	'AGPLv3' => 'http://www.gnu.org/licenses/agpl.html',
	'AGPLv3+' => 'http://www.gnu.org/licenses/agpl.html',
	'AGPL-3.0' => 'http://www.gnu.org/licenses/agpl.html',
	'LGPL' => 'http://www.gnu.org/licenses/lgpl.html',
	'LGPLv2' => 'http://www.gnu.org/licenses/lgpl-2.0.html',
	'LGPLv2.1' => 'http://www.gnu.org/licenses/lgpl-2.1.html',
	'LGPLv3' => 'http://www.gnu.org/licenses/lgpl.html',
	'LGPL-2.0' => 'http://www.gnu.org/licenses/lgpl-2.0.html',
	'LGPL-2.1' => 'http://www.gnu.org/licenses/lgpl-2.1.html',
	'LGPL-3.0' => 'http://www.gnu.org/licenses/lgpl.html',
	'LGPL-3.0+' => 'http://www.gnu.org/licenses/lgpl.html',
	'BSD' => 'http://opensource.org/licenses/bsd-license.html',
	'BSD-2-Clause' => 'http://opensource.org/licenses/BSD-2-Clause',
	'BSD-3-Clause' => 'http://opensource.org/licenses/BSD-3-Clause',
	'FreeBSD' => 'http://opensource.org/licenses/BSD-2-Clause',
	'MIT' => 'http://www.opensource.org/licenses/mit-license.php',
	'PHP' => 'http://opensource.org/licenses/PHP-3.0',
	'PHP-3' => 'http://www.php.net/license/3_01.txt',
	'PHP-3.0' => 'http://www.php.net/license/3_0.txt',
	'PHP-3.01' => 'http://www.php.net/license/3_01.txt',
	);

	$dir = dir($this->dir);
	$fn = unslashify($dir->path) . "/$plugin_name/$plugin_name.php";
	$info = false;

	// Validate the plugin name to prevent from path traversal
	if (preg_match('/[^a-zA-Z0-9_-]/', $plugin_name)) {
	rcube::raise_error(array('code' => 520,
	'file' => __FILE__, 'line' => __LINE__,
	'message' => "Invalid plugin name: $plugin_name"), true, false);
	return false;
	}

	if (!class_exists($plugin_name, false)) {
	if (is_readable($fn)) {
	include($fn);
	}
	else {
	return false;
	}
	}

	if (class_exists($plugin_name)) {
	$info = $plugin_name::info();
	}

	// fall back to composer.json file
	if (!$info) {
	$composer = INSTALL_PATH . "/plugins/$plugin_name/composer.json";
	if (is_readable($composer) && ($json = @json_decode(file_get_contents($composer), true))) {
	// Build list of plugins required
	$require = array();
	foreach (array_keys((array) $json['require']) as $dname) {
	if (!preg_match('\|^([^/]+)/([a-zA-Z0-9_-]+)$\|', $dname, $m)) {
	continue;
	}

	$vendor = $m[1];
	$name = $m[2];

	if ($name != 'plugin-installer' && $vendor != 'pear' && $vendor != 'pear-pear') {
	$dpath = unslashify($dir->path) . "/$name/$name.php";
	if (is_readable($dpath)) {
	$require[] = $name;
	}
	}
	}

	list($info['vendor'], $info['name']) = explode('/', $json['name']);
	$info['version'] = $json['version'];
	$info['license'] = $json['license'];
	$info['uri'] = $json['homepage'];
	$info['require'] = $require;
	}

	// read local composer.lock file (once)
	if (!isset($composer_lock)) {
	$composer_lock = @json_decode(@file_get_contents(INSTALL_PATH . "/composer.lock"), true);
	if ($composer_lock['packages']) {
	foreach ($composer_lock['packages'] as $i => $package) {
	$composer_lock['installed'][$package['name']] = $package;
	}
	}
	}

	// load additional information from local composer.lock file
	if (!empty($json['name']) && !empty($composer_lock['installed'])
	&& !empty($composer_lock['installed'][$json['name']])
	) {
	$lock = $composer_lock['installed'][$json['name']];
	$info['version'] = $lock['version'];
	$info['uri'] = $lock['homepage'] ?: $lock['source']['uri'];
	$info['src_uri'] = $lock['dist']['uri'] ?: $lock['source']['uri'];
	}
	}

	// fall back to package.xml file
	if (!$info) {
	$package = INSTALL_PATH . "/plugins/$plugin_name/package.xml";
	if (is_readable($package) && ($file = file_get_contents($package))) {
	$doc = new DOMDocument();
	$doc->loadXML($file);
	$xpath = new DOMXPath($doc);
	$xpath->registerNamespace('rc', "http://pear.php.net/dtd/package-2.0");

	// XPaths of plugin metadata elements
	$metadata = array(
	'name' => 'string(//rc:package/rc:name)',
	'version' => 'string(//rc:package/rc:version/rc:release)',
	'license' => 'string(//rc:package/rc:license)',
	'license_uri' => 'string(//rc:package/rc:license/@uri)',
	'src_uri' => 'string(//rc:package/rc:srcuri)',
	'uri' => 'string(//rc:package/rc:uri)',
	);

	foreach ($metadata as $key => $path) {
	$info[$key] = $xpath->evaluate($path);
	}

	// dependent required plugins (can be used, but not included in config)
	$deps = $xpath->evaluate('//rc:package/rc:dependencies/rc:required/rc:package/rc:name');
	for ($i = 0; $i < $deps->length; $i++) {
	$dn = $deps->item($i)->nodeValue;
	$info['require'][] = $dn;
	}
	}
	}

	// At least provide the name
	if (!$info && class_exists($plugin_name)) {
	$info = array('name' => $plugin_name, 'version' => '--');
	}
	else if ($info['license'] && empty($info['license_uri']) && ($license_uri = $license_uris[$info['license']])) {
	$info['license_uri'] = $license_uri;
	}

	return $info;
	}

	/**
	* Allows a plugin object to register a callback for a certain hook
	*
	* @param string $hook Hook name
	* @param mixed $callback String with global function name or array($obj, 'methodname')
	*/
	public function register_hook($hook, $callback)
	{
	if (is_callable($callback)) {
	if (isset($this->deprecated_hooks[$hook])) {
	rcube::raise_error(array('code' => 522, 'type' => 'php',
	'file' => __FILE__, 'line' => __LINE__,
	'message' => "Deprecated hook name. "
	. $hook . ' -> ' . $this->deprecated_hooks[$hook]), true, false);
	$hook = $this->deprecated_hooks[$hook];
	}
	$this->handlers[$hook][] = $callback;
	}
	else {
	rcube::raise_error(array('code' => 521, 'type' => 'php',
	'file' => __FILE__, 'line' => __LINE__,
	'message' => "Invalid callback function for $hook"), true, false);
	}
	}

	/**
	* Allow a plugin object to unregister a callback.
	*
	* @param string $hook Hook name
	* @param mixed $callback String with global function name or array($obj, 'methodname')
	*/
	public function unregister_hook($hook, $callback)
	{
	$callback_id = array_search($callback, (array) $this->handlers[$hook]);
	if ($callback_id !== false) {
	// array_splice() removes the element and re-indexes keys
	// that is required by the 'for' loop in exec_hook() below
	array_splice($this->handlers[$hook], $callback_id, 1);
	}
	}

	/**
	* Triggers a plugin hook.
	* This is called from the application and executes all registered handlers
	*
	* @param string $hook Hook name
	* @param array $args Named arguments (key->value pairs)
	*
	* @return array The (probably) altered hook arguments
	*/
	public function exec_hook($hook, $args = array())
	{
	if (!is_array($args)) {
	$args = array('arg' => $args);
	}

	// TODO: avoid recursion by checking in_array($hook, $this->exec_stack) ?

	$args += array('abort' => false);
	array_push($this->exec_stack, $hook);

	// Use for loop here, so handlers added in the hook will be executed too
	if (!empty($this->handlers[$hook])) {
	for ($i = 0; $i < count($this->handlers[$hook]); $i++) {
	$ret = call_user_func($this->handlers[$hook][$i], $args);
	if ($ret && is_array($ret)) {
	$args = $ret + $args;
	}

	- if ($args['break']) {
	+ if (!empty($args['break'])) {
	break;
	}
	}
	}

	array_pop($this->exec_stack);
	return $args;
	}

	/**
	* Let a plugin register a handler for a specific request
	*
	* @param string $action Action name (_task=mail&_action=plugin.foo)
	* @param string $owner Plugin name that registers this action
	* @param mixed $callback Callback: string with global function name or array($obj, 'methodname')
	* @param string $task Task name registered by this plugin
	*/
	public function register_action($action, $owner, $callback, $task = null)
	{
	// check action name
	if ($task)
	$action = $task.'.'.$action;
	else if (strpos($action, 'plugin.') !== 0)
	$action = 'plugin.'.$action;

	// can register action only if it's not taken or registered by myself
	if (!isset($this->actionmap[$action]) \|\| $this->actionmap[$action] == $owner) {
	$this->actions[$action] = $callback;
	$this->actionmap[$action] = $owner;
	}
	else {
	rcube::raise_error(array('code' => 523, 'type' => 'php',
	'file' => __FILE__, 'line' => __LINE__,
	'message' => "Cannot register action $action;"
	." already taken by another plugin"), true, false);
	}
	}

	/**
	* This method handles requests like _task=mail&_action=plugin.foo
	* It executes the callback function that was registered with the given action.
	*
	* @param string $action Action name
	*/
	public function exec_action($action)
	{
	if (isset($this->actions[$action])) {
	call_user_func($this->actions[$action]);
	}
	else if (rcube::get_instance()->action != 'refresh') {
	rcube::raise_error(array('code' => 524, 'type' => 'php',
	'file' => __FILE__, 'line' => __LINE__,
	'message' => "No handler found for action $action"), true, true);
	}
	}

	/**
	* Register a handler function for template objects
	*
	* @param string $name Object name
	* @param string $owner Plugin name that registers this action
	* @param mixed $callback Callback: string with global function name or array($obj, 'methodname')
	*/
	public function register_handler($name, $owner, $callback)
	{
	// check name
	if (strpos($name, 'plugin.') !== 0) {
	$name = 'plugin.' . $name;
	}

	// can register handler only if it's not taken or registered by myself
	if (is_object($this->output)
	&& (!isset($this->objectsmap[$name]) \|\| $this->objectsmap[$name] == $owner)
	) {
	$this->output->add_handler($name, $callback);
	$this->objectsmap[$name] = $owner;
	}
	else {
	rcube::raise_error(array('code' => 525, 'type' => 'php',
	'file' => __FILE__, 'line' => __LINE__,
	'message' => "Cannot register template handler $name;"
	." already taken by another plugin or no output object available"), true, false);
	}
	}

	/**
	* Register this plugin to be responsible for a specific task
	*
	* @param string $task Task name (only characters [a-z0-9_-] are allowed)
	* @param string $owner Plugin name that registers this action
	*/
	public function register_task($task, $owner)
	{
	// tasks are irrelevant in framework mode
	if (!class_exists('rcmail', false)) {
	return true;
	}

	if ($task != asciiwords($task, true)) {
	rcube::raise_error(array('code' => 526, 'type' => 'php',
	'file' => __FILE__, 'line' => __LINE__,
	'message' => "Invalid task name: $task."
	." Only characters [a-z0-9_.-] are allowed"), true, false);
	}
	else if (in_array($task, rcmail::$main_tasks)) {
	rcube::raise_error(array('code' => 526, 'type' => 'php',
	'file' => __FILE__, 'line' => __LINE__,
	'message' => "Cannot register taks $task;"
	." already taken by another plugin or the application itself"), true, false);
	}
	else {
	$this->tasks[$task] = $owner;
	rcmail::$main_tasks[] = $task;
	return true;
	}

	return false;
	}

	/**
	* Checks whether the given task is registered by a plugin
	*
	* @param string $task Task name
	*
	* @return boolean True if registered, otherwise false
	*/
	public function is_plugin_task($task)
	{
	- return $this->tasks[$task] ? true : false;
	+ return !empty($this->tasks[$task]) ? true : false;
	}

	/**
	* Check if a plugin hook is currently processing.
	* Mainly used to prevent loops and recursion.
	*
	* @param string $hook Hook to check (optional)
	*
	* @return boolean True if any/the given hook is currently processed, otherwise false
	*/
	public function is_processing($hook = null)
	{
	return count($this->exec_stack) > 0 && (!$hook \|\| in_array($hook, $this->exec_stack));
	}

	/**
	* Include a plugin script file in the current HTML page
	*
	* @param string $fn Path to script
	*/
	public function include_script($fn)
	{
	if (is_object($this->output) && $this->output->type == 'html') {
	$src = $this->resource_url($fn);
	$this->output->include_script($src, 'head_bottom', false);
	}
	}

	/**
	* Include a plugin stylesheet in the current HTML page
	*
	* @param string $fn Path to stylesheet
	*/
	public function include_stylesheet($fn)
	{
	if (is_object($this->output) && $this->output->type == 'html') {
	if ($fn[0] != '/' && !preg_match('\|^https?://\|i', $fn)) {
	$rcube = rcube::get_instance();
	$devel_mode = $rcube->config->get('devel_mode');
	$assets_dir = $rcube->config->get('assets_dir');
	$path = unslashify($assets_dir ?: RCUBE_INSTALL_PATH);

	// Prefer .less files in devel_mode (assume less.js is loaded)
	if ($devel_mode) {
	$less = preg_replace('/\.css$/i', '.less', $fn);
	if ($less != $fn && is_file("$path/plugins/$less")) {
	$fn = $less;
	}
	}
	else if (!preg_match('/\.min\.css$/', $fn)) {
	$min = preg_replace('/\.css$/i', '.min.css', $fn);
	if (is_file("$path/plugins/$min")) {
	$fn = $min;
	}
	}

	if (!is_file("$path/plugins/$fn")) {
	return;
	}
	}

	$src = $this->resource_url($fn);
	$this->output->include_css($src);
	}
	}

	/**
	* Save the given HTML content to be added to a template container
	*
	* @param string $html HTML content
	* @param string $container Template container identifier
	*/
	public function add_content($html, $container)
	{
	+ if (!isset($this->template_contents[$container])) {
	+ $this->template_contents[$container] = '';
	+ }
	+
	$this->template_contents[$container] .= $html . "\n";
	}

	/**
	* Returns list of loaded plugins names
	*
	* @return array List of plugin names
	*/
	public function loaded_plugins()
	{
	return array_keys($this->plugins);
	}

	/**
	* Returns loaded plugin
	*
	- * @return rcube_plugin Plugin instance
	+ * @return rcube_plugin\|null Plugin instance
	*/
	public function get_plugin($name)
	{
	- return $this->plugins[$name];
	+ return !empty($this->plugins[$name]) ? $this->plugins[$name] : null;
	}

	/**
	* Callback for template_container hooks
	*
	* @param array $attrib
	* @return array
	*/
	protected function template_container_hook($attrib)
	{
	- $container = $attrib['name'];
	- return array('content' => $attrib['content'] . $this->template_contents[$container]);
	+ $container = $attrib['name'];
	+ $content = isset($attrib['content']) ? $attrib['content'] : '';
	+
	+ if (isset($this->template_contents[$container])) {
	+ $content .= $this->template_contents[$container];
	+ }
	+
	+ return ['content' => $content];
	}

	/**
	* Make the given file name link into the plugins directory
	*
	* @param string $fn Filename
	* @return string
	*/
	protected function resource_url($fn)
	{
	if ($fn[0] != '/' && !preg_match('\|^https?://\|i', $fn))
	return $this->url . $fn;
	else
	return $fn;
	}
	}
	diff --git a/program/lib/Roundcube/rcube_utils.php b/program/lib/Roundcube/rcube_utils.php
	index b72c28263..33cf34e61 100644
	--- a/program/lib/Roundcube/rcube_utils.php
	+++ b/program/lib/Roundcube/rcube_utils.php
	@@ -1,1490 +1,1490 @@
	<?php

	/**
	+-----------------------------------------------------------------------+
	\| This file is part of the Roundcube Webmail client \|
	\| \|
	\| Copyright (C) The Roundcube Dev Team \|
	\| Copyright (C) Kolab Systems AG \|
	\| \|
	\| Licensed under the GNU General Public License version 3 or \|
	\| any later version with exceptions for skins & plugins. \|
	\| See the README file for a full license statement. \|
	\| \|
	\| PURPOSE: \|
	\| Utility class providing common functions \|
	+-----------------------------------------------------------------------+
	\| Author: Thomas Bruederli <roundcube@gmail.com> \|
	\| Author: Aleksander Machniak <alec@alec.pl> \|
	+-----------------------------------------------------------------------+
	*/

	/**
	* Utility class providing common functions
	*
	* @package Framework
	* @subpackage Utils
	*/
	class rcube_utils
	{
	// define constants for input reading
	const INPUT_GET = 1;
	const INPUT_POST = 2;
	const INPUT_COOKIE = 4;
	const INPUT_GP = 3; // GET + POST
	const INPUT_GPC = 7; // GET + POST + COOKIE


	/**
	* Helper method to set a cookie with the current path and host settings
	*
	* @param string $name Cookie name
	* @param string $value Cookie value
	* @param int $exp Expiration time
	* @param bool $http_only HTTP Only
	*/
	public static function setcookie($name, $value, $exp = 0, $http_only = true)
	{
	if (headers_sent()) {
	return;
	}

	$attrib = session_get_cookie_params();
	$attrib['expires'] = $exp;
	$attrib['secure'] = $attrib['secure'] \|\| self::https_check();
	$attrib['httponly'] = $http_only;

	// session_get_cookie_params() return includes 'lifetime' but setcookie() does not use it, instead it uses 'expires'
	unset($attrib['lifetime']);

	if (version_compare(PHP_VERSION, '7.3.0', '>=')) {
	// An alternative signature for setcookie supporting an options array added in PHP 7.3.0
	setcookie($name, $value, $attrib);
	}
	else {
	setcookie($name, $value, $attrib['expires'], $attrib['path'], $attrib['domain'], $attrib['secure'], $attrib['httponly']);
	}
	}

	/**
	* E-mail address validation.
	*
	* @param string $email Email address
	* @param bool $dns_check True to check dns
	*
	* @return bool True on success, False if address is invalid
	*/
	public static function check_email($email, $dns_check = true)
	{
	// Check for invalid (control) characters
	if (preg_match('/\p{Cc}/u', $email)) {
	return false;
	}

	// Check for length limit specified by RFC 5321 (#1486453)
	if (strlen($email) > 254) {
	return false;
	}

	$pos = strrpos($email, '@');
	if (!$pos) {
	return false;
	}

	$domain_part = substr($email, $pos + 1);
	$local_part = substr($email, 0, $pos);

	// quoted-string, make sure all backslashes and quotes are
	// escaped
	if (substr($local_part, 0, 1) == '"') {
	$local_quoted = preg_replace('/\\\\(\\\\\|\")/','', substr($local_part, 1, -1));
	if (preg_match('/\\\\\|"/', $local_quoted)) {
	return false;
	}
	}
	// dot-atom portion, make sure there's no prohibited characters
	else if (preg_match('/(^\.\|\.\.\|\.$)/', $local_part)
	\|\| preg_match('/[\\ ",:;<>@]/', $local_part)
	) {
	return false;
	}

	// Validate domain part
	if (preg_match('/^\[((IPv6:[0-9a-f:.]+)\|([0-9.]+))\]$/i', $domain_part, $matches)) {
	return self::check_ip(preg_replace('/^IPv6:/i', '', $matches[1])); // valid IPv4 or IPv6 address
	}
	else {
	// If not an IP address
	$domain_array = explode('.', $domain_part);
	// Not enough parts to be a valid domain
	if (count($domain_array) < 2) {
	return false;
	}

	foreach ($domain_array as $part) {
	if (!preg_match('/^((xn--)?([A-Za-z0-9][A-Za-z0-9-]{0,61}[A-Za-z0-9])\|([A-Za-z0-9]))$/', $part)) {
	return false;
	}
	}

	// last domain part (allow extended TLD)
	$last_part = array_pop($domain_array);
	if (strpos($last_part, 'xn--') !== 0
	&& (preg_match('/[^a-zA-Z0-9]/', $last_part) \|\| preg_match('/^[0-9]+$/', $last_part))
	) {
	return false;
	}

	$rcube = rcube::get_instance();

	if (!$dns_check \|\| !function_exists('checkdnsrr') \|\| !$rcube->config->get('email_dns_check')) {
	return true;
	}

	// Check DNS record(s)
	// Note: We can't use ANY (#6581)
	foreach (array('A', 'MX', 'CNAME', 'AAAA') as $type) {
	if (checkdnsrr($domain_part, $type)) {
	return true;
	}
	}
	}

	return false;
	}

	/**
	* Validates IPv4 or IPv6 address
	*
	* @param string $ip IP address in v4 or v6 format
	*
	* @return bool True if the address is valid
	*/
	public static function check_ip($ip)
	{
	return filter_var($ip, FILTER_VALIDATE_IP) !== false;
	}

	/**
	* Replacing specials characters to a specific encoding type
	*
	* @param string $str Input string
	* @param string $enctype Encoding type: text\|html\|xml\|js\|url
	* @param string $mode Replace mode for tags: show\|remove\|strict
	* @param bool $newlines Convert newlines
	*
	* @return string The quoted string
	*/
	public static function rep_specialchars_output($str, $enctype = '', $mode = '', $newlines = true)
	{
	static $html_encode_arr = false;
	static $js_rep_table = false;
	static $xml_rep_table = false;

	if (!is_string($str)) {
	$str = strval($str);
	}

	// encode for HTML output
	if ($enctype == 'html') {
	if (!$html_encode_arr) {
	$html_encode_arr = get_html_translation_table(HTML_SPECIALCHARS);
	unset($html_encode_arr['?']);
	}

	$encode_arr = $html_encode_arr;

	if ($mode == 'remove') {
	$str = strip_tags($str);
	}
	else if ($mode != 'strict') {
	// don't replace quotes and html tags
	$ltpos = strpos($str, '<');
	if ($ltpos !== false && strpos($str, '>', $ltpos) !== false) {
	unset($encode_arr['"']);
	unset($encode_arr['<']);
	unset($encode_arr['>']);
	unset($encode_arr['&']);
	}
	}

	$out = strtr($str, $encode_arr);

	return $newlines ? nl2br($out) : $out;
	}

	// if the replace tables for XML and JS are not yet defined
	if ($js_rep_table === false) {
	$js_rep_table = $xml_rep_table = array();
	$xml_rep_table['&'] = '&';

	// can be increased to support more charsets
	for ($c=160; $c<256; $c++) {
	$xml_rep_table[chr($c)] = "&#$c;";
	}

	$xml_rep_table['"'] = '"';
	$js_rep_table['"'] = '\\"';
	$js_rep_table["'"] = "\\'";
	$js_rep_table["\\"] = "\\\\";
	// Unicode line and paragraph separators (#1486310)
	$js_rep_table[chr(hexdec('E2')).chr(hexdec('80')).chr(hexdec('A8'))] = ' ';
	$js_rep_table[chr(hexdec('E2')).chr(hexdec('80')).chr(hexdec('A9'))] = ' ';
	}

	// encode for javascript use
	if ($enctype == 'js') {
	return preg_replace(array("/\r?\n/", "/\r/", '/<\\//'), array('\n', '\n', '<\\/'), strtr($str, $js_rep_table));
	}

	// encode for plaintext
	if ($enctype == 'text') {
	return str_replace("\r\n", "\n", $mode == 'remove' ? strip_tags($str) : $str);
	}

	if ($enctype == 'url') {
	return rawurlencode($str);
	}

	// encode for XML
	if ($enctype == 'xml') {
	return strtr($str, $xml_rep_table);
	}

	// no encoding given -> return original string
	return $str;
	}

	/**
	* Read input value and convert it for internal use
	* Performs stripslashes() and charset conversion if necessary
	*
	* @param string $fname Field name to read
	* @param int $source Source to get value from (see self::INPUT_*)
	* @param bool $allow_html Allow HTML tags in field value
	* @param string $charset Charset to convert into
	*
	* @return string Field value or NULL if not available
	*/
	public static function get_input_value($fname, $source, $allow_html = false, $charset = null)
	{
	$value = null;

	if (($source & self::INPUT_GET) && isset($_GET[$fname])) {
	$value = $_GET[$fname];
	}

	if (($source & self::INPUT_POST) && isset($_POST[$fname])) {
	$value = $_POST[$fname];
	}

	if (($source & self::INPUT_COOKIE) && isset($_COOKIE[$fname])) {
	$value = $_COOKIE[$fname];
	}

	return self::parse_input_value($value, $allow_html, $charset);
	}

	/**
	* Parse/validate input value. See self::get_input_value()
	* Performs stripslashes() and charset conversion if necessary
	*
	* @param string $value Input value
	* @param bool $allow_html Allow HTML tags in field value
	* @param string $charset Charset to convert into
	*
	* @return string Parsed value
	*/
	public static function parse_input_value($value, $allow_html = false, $charset = null)
	{
	global $OUTPUT;

	if (empty($value)) {
	return $value;
	}

	if (is_array($value)) {
	foreach ($value as $idx => $val) {
	$value[$idx] = self::parse_input_value($val, $allow_html, $charset);
	}
	return $value;
	}

	// remove HTML tags if not allowed
	if (!$allow_html) {
	$value = strip_tags($value);
	}

	$output_charset = is_object($OUTPUT) ? $OUTPUT->get_charset() : null;

	// remove invalid characters (#1488124)
	if ($output_charset == 'UTF-8') {
	$value = rcube_charset::clean($value);
	}

	// convert to internal charset
	if ($charset && $output_charset) {
	$value = rcube_charset::convert($value, $output_charset, $charset);
	}

	return $value;
	}

	/**
	* Convert array of request parameters (prefixed with _)
	* to a regular array with non-prefixed keys.
	*
	* @param int $mode Source to get value from (GPC)
	* @param string $ignore PCRE expression to skip parameters by name
	* @param bool $allow_html Allow HTML tags in field value
	*
	* @return array Hash array with all request parameters
	*/
	public static function request2param($mode = null, $ignore = 'task\|action', $allow_html = false)
	{
	$out = array();
	$src = $mode == self::INPUT_GET ? $_GET : ($mode == self::INPUT_POST ? $_POST : $_REQUEST);

	foreach (array_keys($src) as $key) {
	$fname = $key[0] == '_' ? substr($key, 1) : $key;
	if ($ignore && !preg_match('/^(' . $ignore . ')$/', $fname)) {
	$out[$fname] = self::get_input_value($key, $mode, $allow_html);
	}
	}

	return $out;
	}

	/**
	* Convert the given string into a valid HTML identifier
	* Same functionality as done in app.js with rcube_webmail.html_identifier()
	*
	* @param string $str String input
	* @param bool $encode Use base64 encoding
	*
	* @param string Valid HTML identifier
	*/
	public static function html_identifier($str, $encode = false)
	{
	if ($encode) {
	return rtrim(strtr(base64_encode($str), '+/', '-_'), '=');
	}

	return asciiwords($str, true, '_');
	}

	/**
	* Replace all css definitions with #container [def]
	* and remove css-inlined scripting, make position style safe
	*
	* @param string $source CSS source code
	* @param string $container_id Container ID to use as prefix
	* @param bool $allow_remote Allow remote content
	* @param string $prefix Prefix to be added to id/class identifier
	*
	* @return string Modified CSS source
	*/
	public static function mod_css_styles($source, $container_id, $allow_remote = false, $prefix = '')
	{
	$last_pos = 0;
	$replacements = new rcube_string_replacer;

	// ignore the whole block if evil styles are detected
	$source = self::xss_entity_decode($source);
	$stripped = preg_replace('/[^a-z\(:;]/i', '', $source);
	$evilexpr = 'expression\|behavior\|javascript:\|import[^a]' . (!$allow_remote ? '\|url\((?!data:image)' : '');

	if (preg_match("/$evilexpr/i", $stripped)) {
	return '/* evil! */';
	}

	$strict_url_regexp = '!url\s$\s["\']?(https?:)//[a-z0-9/._+-]+["\']?\s*$!Uims';

	// cut out all contents between { and }
	while (($pos = strpos($source, '{', $last_pos)) && ($pos2 = strpos($source, '}', $pos))) {
	$nested = strpos($source, '{', $pos+1);
	if ($nested && $nested < $pos2) { // when dealing with nested blocks (e.g. @media), take the inner one
	$pos = $nested;
	}
	$length = $pos2 - $pos - 1;
	$styles = substr($source, $pos+1, $length);

	// Convert position:fixed to position:absolute (#5264)
	$styles = preg_replace('/position[^a-z]:[\s\r\n]fixed/i', 'position: absolute', $styles);

	// Remove 'page' attributes (#7604)
	$styles = preg_replace('/(^\|[\n\s;])page:[^;]+;*/im', '', $styles);

	// check every line of a style block...
	if ($allow_remote) {
	$a_styles = preg_split('/;[\r\n]*/', $styles, -1, PREG_SPLIT_NO_EMPTY);

	for ($i=0, $len=count($a_styles); $i < $len; $i++) {
	if (!isset($a_styles[$i])) {
	continue;
	}

	$line = $a_styles[$i];
	$stripped = preg_replace('/[^a-z\(:;]/i', '', $line);

	// allow data:image uri, join with continuation
	if (stripos($stripped, 'url(data:image')) {
	$a_styles[$i] .= ';' . $a_styles[$i+1];
	unset($a_styles[$i+1]);
	}
	// allow strict url() values only
	else if (stripos($stripped, 'url(') && !preg_match($strict_url_regexp, $line)) {
	$a_styles = array('/* evil! */');
	break;
	}
	}

	$styles = implode(";\n", $a_styles);
	}

	$key = $replacements->add($styles);
	$repl = $replacements->get_replacement($key);
	$source = substr_replace($source, $repl, $pos+1, $length);
	$last_pos = $pos2 - ($length - strlen($repl));
	}

	// remove html comments
	$source = preg_replace('/(^\s<\!--)\|(-->\s$)/m', '', $source);

	// add #container to each tag selector and prefix to id/class identifiers
	if ($container_id \|\| $prefix) {
	// (?!##str) below is to not match with ##str_replacement_0##
	// from rcube_string_replacer used above, this is needed for
	// cases like @media { body { position: fixed; } } (#5811)
	$regexp = '/(^\s\|,\s\|\}\s\|\{\s)((?!##str):?[a-z0-9\._#\\[][a-z0-9\._:#=~ \[\]"\\|\>\+\$\^-])/im';
	$callback = function($matches) use ($container_id, $prefix) {
	$replace = $matches[2];

	if (stripos($replace, ':root') === 0) {
	$replace = substr($replace, 5);
	}

	if ($prefix) {
	$replace = str_replace(array('.', '#'), array(".$prefix", "#$prefix"), $replace);
	}

	if ($container_id) {
	$replace = "#$container_id " . $replace;
	}

	// Remove redundant spaces (for simpler testing)
	$replace = preg_replace('/\s+/', ' ', $replace);

	return str_replace($matches[2], $replace, $matches[0]);
	};

	$source = preg_replace_callback($regexp, $callback, $source);
	}

	// replace body definition because we also stripped off the <body> tag
	if ($container_id) {
	$regexp = '/#' . preg_quote($container_id, '/') . '\s+body/i';
	$source = preg_replace($regexp, "#$container_id", $source);
	}

	// put block contents back in
	$source = $replacements->resolve($source);

	return $source;
	}

	/**
	* Generate CSS classes from mimetype and filename extension
	*
	* @param string $mimetype Mimetype
	* @param string $filename Filename
	*
	* @return string CSS classes separated by space
	*/
	public static function file2class($mimetype, $filename)
	{
	$mimetype = strtolower($mimetype);
	$filename = strtolower($filename);

	if (strpos($mimetype, '/')) {
	list($primary, $secondary) = explode('/', $mimetype);
	}
	else {
	$primary = $mimetype;
	}

	$classes = array($primary ?: 'unknown');

	if (!empty($secondary)) {
	$classes[] = $secondary;
	}

	if (preg_match('/\.([a-z0-9]+)$/', $filename, $m)) {
	if (!in_array($m[1], $classes)) {
	$classes[] = $m[1];
	}
	}

	return implode(' ', $classes);
	}

	/**
	* Decode escaped entities used by known XSS exploits.
	* See http://downloads.securityfocus.com/vulnerabilities/exploits/26800.eml for examples
	*
	* @param string $content CSS content to decode
	*
	* @return string Decoded string
	*/
	public static function xss_entity_decode($content)
	{
	$callback = function($matches) { return chr(hexdec($matches[1])); };

	$out = html_entity_decode(html_entity_decode($content));
	$out = trim(preg_replace('/(^<!--\|-->$)/', '', trim($out)));
	$out = preg_replace_callback('/\\\([0-9a-f]{2,6})\s*/i', $callback, $out);
	$out = preg_replace('/\\\([^0-9a-f])/i', '\\1', $out);
	$out = preg_replace('#/\.\*/#Ums', '', $out);
	$out = strip_tags($out);

	return $out;
	}

	/**
	* Check if we can process not exceeding memory_limit
	*
	* @param integer $need Required amount of memory
	*
	* @return bool True if memory won't be exceeded, False otherwise
	*/
	public static function mem_check($need)
	{
	$mem_limit = parse_bytes(ini_get('memory_limit'));
	$memory = function_exists('memory_get_usage') ? memory_get_usage() : 1610241024; // safe value: 16MB

	return $mem_limit > 0 && $memory + $need > $mem_limit ? false : true;
	}

	/**
	* Check if working in SSL mode
	*
	* @param int $port HTTPS port number
	* @param bool $use_https Enables 'use_https' option checking
	*
	* @return bool True in SSL mode, False otherwise
	*/
	public static function https_check($port = null, $use_https = true)
	{
	if (!empty($_SERVER['HTTPS']) && strtolower($_SERVER['HTTPS']) != 'off') {
	return true;
	}

	if (!empty($_SERVER['HTTP_X_FORWARDED_PROTO'])
	&& strtolower($_SERVER['HTTP_X_FORWARDED_PROTO']) == 'https'
	&& in_array($_SERVER['REMOTE_ADDR'], rcube::get_instance()->config->get('proxy_whitelist', array()))
	) {
	return true;
	}

	if ($port && $_SERVER['SERVER_PORT'] == $port) {
	return true;
	}

	if ($use_https && rcube::get_instance()->config->get('use_https')) {
	return true;
	}

	return false;
	}

	/**
	* Replaces hostname variables.
	*
	* @param string $name Hostname
	* @param string $host Optional IMAP hostname
	*
	* @return string Hostname
	*/
	public static function parse_host($name, $host = '')
	{
	if (!is_string($name)) {
	return $name;
	}

	// %n - host
	$n = self::server_name();
	// %t - host name without first part, e.g. %n=mail.domain.tld, %t=domain.tld
	// If %n=domain.tld then %t=domain.tld as well (remains valid)
	$t = preg_replace('/^[^.]+\.(?![^.]+$)/', '', $n);
	// %d - domain name without first part (up to domain.tld)
	$d = preg_replace('/^[^.]+\.(?![^.]+$)/', '', self::server_name('HTTP_HOST'));
	// %h - IMAP host
	$h = !empty($_SESSION['storage_host']) ? $_SESSION['storage_host'] : $host;
	// %z - IMAP domain without first part, e.g. %h=imap.domain.tld, %z=domain.tld
	// If %h=domain.tld then %z=domain.tld as well (remains valid)
	$z = preg_replace('/^[^.]+\.(?![^.]+$)/', '', $h);
	// %s - domain name after the '@' from e-mail address provided at login screen.
	// Returns FALSE if an invalid email is provided
	$s = '';
	if (strpos($name, '%s') !== false) {
	$user_email = self::idn_to_ascii(self::get_input_value('_user', self::INPUT_POST));
	$matches = preg_match('/(.*)@([a-z0-9\.\-\[\]\:]+)/i', $user_email, $s);
	if ($matches < 1 \|\| filter_var($s[1]."@".$s[2], FILTER_VALIDATE_EMAIL) === false) {
	return false;
	}
	$s = $s[2];
	}

	return str_replace(array('%n', '%t', '%d', '%h', '%z', '%s'), array($n, $t, $d, $h, $z, $s), $name);
	}

	/**
	* Returns the server name after checking it against trusted hostname patterns.
	*
	* Returns 'localhost' and logs a warning when the hostname is not trusted.
	*
	* @param string $type The $_SERVER key, e.g. 'HTTP_HOST', Default: 'SERVER_NAME'.
	* @param bool $strip_port Strip port from the host name
	*
	* @return string Server name
	*/
	public static function server_name($type = null, $strip_port = true)
	{
	if (!$type) {
	$type = 'SERVER_NAME';
	}

	$name = isset($_SERVER[$type]) ? $_SERVER[$type] : null;
	$rcube = rcube::get_instance();
	$patterns = (array) $rcube->config->get('trusted_host_patterns');

	if ($strip_port) {
	$name = preg_replace('/:\d+$/', '', $name);
	}

	if (empty($patterns) \|\| in_array_nocase($name, $patterns)) {
	return $name;
	}

	if (!empty($name)) {
	foreach ($patterns as $pattern) {
	if (preg_match("/$pattern/", $name)) {
	return $name;
	}
	}

	$rcube->raise_error(array('file' => __FILE__, 'line' => __LINE__,
	'message' => "Specified host is not trusted. Using 'localhost'."), true, false);
	}

	return 'localhost';
	}

	/**
	* Returns remote IP address and forwarded addresses if found
	*
	* @return string Remote IP address(es)
	*/
	public static function remote_ip()
	{
	$address = $_SERVER['REMOTE_ADDR'];

	// append the NGINX X-Real-IP header, if set
	if (!empty($_SERVER['HTTP_X_REAL_IP']) && $_SERVER['HTTP_X_REAL_IP'] != $address) {
	$remote_ip[] = 'X-Real-IP: ' . $_SERVER['HTTP_X_REAL_IP'];
	}

	// append the X-Forwarded-For header, if set
	if (!empty($_SERVER['HTTP_X_FORWARDED_FOR'])) {
	$remote_ip[] = 'X-Forwarded-For: ' . $_SERVER['HTTP_X_FORWARDED_FOR'];
	}

	if (!empty($remote_ip)) {
	$address .= ' (' . implode(',', $remote_ip) . ')';
	}

	return $address;
	}

	/**
	* Returns the real remote IP address
	*
	* @return string Remote IP address
	*/
	public static function remote_addr()
	{
	// Check if any of the headers are set first to improve performance
	if (!empty($_SERVER['HTTP_X_FORWARDED_FOR']) \|\| !empty($_SERVER['HTTP_X_REAL_IP'])) {
	$proxy_whitelist = rcube::get_instance()->config->get('proxy_whitelist', array());
	if (in_array($_SERVER['REMOTE_ADDR'], $proxy_whitelist)) {
	if (!empty($_SERVER['HTTP_X_FORWARDED_FOR'])) {
	foreach (array_reverse(explode(',', $_SERVER['HTTP_X_FORWARDED_FOR'])) as $forwarded_ip) {
	$forwarded_ip = trim($forwarded_ip);
	if (!in_array($forwarded_ip, $proxy_whitelist)) {
	return $forwarded_ip;
	}
	}
	}

	if (!empty($_SERVER['HTTP_X_REAL_IP'])) {
	return $_SERVER['HTTP_X_REAL_IP'];
	}
	}
	}

	if (!empty($_SERVER['REMOTE_ADDR'])) {
	return $_SERVER['REMOTE_ADDR'];
	}

	return '';
	}

	/**
	* Read a specific HTTP request header.
	*
	* @param string $name Header name
	*
	* @return string\|null Header value or null if not available
	*/
	public static function request_header($name)
	{
	if (function_exists('apache_request_headers')) {
	$headers = apache_request_headers();
	$key = strtoupper($name);
	}
	else {
	$headers = $_SERVER;
	$key = 'HTTP_' . strtoupper(strtr($name, '-', '_'));
	}

	if (!empty($headers)) {
	$headers = array_change_key_case($headers, CASE_UPPER);

	- return $headers[$key];
	+ return isset($headers[$key]) ? $headers[$key] : null;
	}
	}

	/**
	* Explode quoted string
	*
	* @param string $delimiter Delimiter expression string for preg_match()
	* @param string $string Input string
	*
	* @return array String items
	*/
	public static function explode_quoted_string($delimiter, $string)
	{
	$result = array();
	$strlen = strlen($string);

	for ($q=$p=$i=0; $i < $strlen; $i++) {
	if ($string[$i] == "\"" && $string[$i-1] != "\\") {
	$q = $q ? false : true;
	}
	else if (!$q && preg_match("/$delimiter/", $string[$i])) {
	$result[] = substr($string, $p, $i - $p);
	$p = $i + 1;
	}
	}

	$result[] = (string) substr($string, $p);

	return $result;
	}

	/**
	* Improved equivalent to strtotime()
	*
	* @param string $date Date string
	* @param DateTimeZone $timezone Timezone to use for DateTime object
	*
	* @return int Unix timestamp
	*/
	public static function strtotime($date, $timezone = null)
	{
	$date = self::clean_datestr($date);
	$tzname = $timezone ? ' ' . $timezone->getName() : '';

	// unix timestamp
	if (is_numeric($date)) {
	return (int) $date;
	}

	// It can be very slow when provided string is not a date and very long
	if (strlen($date) > 128) {
	$date = substr($date, 0, 128);
	}

	// if date parsing fails, we have a date in non-rfc format.
	// remove token from the end and try again
	while (($ts = @strtotime($date . $tzname)) === false \|\| $ts < 0) {
	if (($pos = strrpos($date, ' ')) === false) {
	break;
	}

	$date = rtrim(substr($date, 0, $pos));
	}

	return (int) $ts;
	}

	/**
	* Date parsing function that turns the given value into a DateTime object
	*
	* @param string $date Date string
	* @param DateTimeZone $timezone Timezone to use for DateTime object
	*
	* @return DateTime\|false DateTime object or False on failure
	*/
	public static function anytodatetime($date, $timezone = null)
	{
	if ($date instanceof DateTime) {
	return $date;
	}

	$dt = false;
	$date = self::clean_datestr($date);

	// try to parse string with DateTime first
	if (!empty($date)) {
	try {
	$_date = preg_match('/^[0-9]+$/', $date) ? "@$date" : $date;
	$dt = $timezone ? new DateTime($_date, $timezone) : new DateTime($_date);
	}
	catch (Exception $e) {
	// ignore
	}
	}

	// try our advanced strtotime() method
	if (!$dt && ($timestamp = self::strtotime($date, $timezone))) {
	try {
	$dt = new DateTime("@".$timestamp);
	if ($timezone) {
	$dt->setTimezone($timezone);
	}
	}
	catch (Exception $e) {
	// ignore
	}
	}

	return $dt;
	}

	/**
	* Clean up date string for strtotime() input
	*
	* @param string $date Date string
	*
	* @return string Date string
	*/
	public static function clean_datestr($date)
	{
	$date = trim($date);

	// check for MS Outlook vCard date format YYYYMMDD
	if (preg_match('/^([12][90]\d\d)([01]\d)([0123]\d)$/', $date, $m)) {
	return sprintf('%04d-%02d-%02d 00:00:00', intval($m[1]), intval($m[2]), intval($m[3]));
	}

	// Clean malformed data
	$date = preg_replace(
	array(
	'/$.*$/', // remove RFC comments
	'/GMT\s*([+-][0-9]+)/', // support non-standard "GMTXXXX" literal
	'/[^a-z0-9\x20\x09:\/\.+-]/i', // remove any invalid characters
	'/\s(Mon\|Tue\|Wed\|Thu\|Fri\|Sat\|Sun)\s/i', // remove weekday names
	),
	array(
	'',
	'\\1',
	'',
	'',
	), $date);

	$date = trim($date);

	// try to fix dd/mm vs. mm/dd discrepancy, we can't do more here
	if (preg_match('/^(\d{1,2})[.\/-](\d{1,2})[.\/-](\d{4})(\s.*)?$/', $date, $m)) {
	$mdy = $m[2] > 12 && $m[1] <= 12;
	$day = $mdy ? $m[2] : $m[1];
	$month = $mdy ? $m[1] : $m[2];
	$date = sprintf('%04d-%02d-%02d%s', $m[3], $month, $day, isset($m[4]) ? $m[4]: ' 00:00:00');
	}
	// I've found that YYYY.MM.DD is recognized wrong, so here's a fix
	else if (preg_match('/^(\d{4})\.(\d{1,2})\.(\d{1,2})(\s.*)?$/', $date, $m)) {
	$date = sprintf('%04d-%02d-%02d%s', $m[1], $m[2], $m[3], isset($m[4]) ? $m[4]: ' 00:00:00');
	}

	return $date;
	}

	/**
	* Turns the given date-only string in defined format into YYYY-MM-DD format.
	*
	* Supported formats: 'Y/m/d', 'Y.m.d', 'd-m-Y', 'd/m/Y', 'd.m.Y', 'j.n.Y'
	*
	* @param string $date Date string
	* @param string $format Input date format
	*
	* @return string Date string in YYYY-MM-DD format, or the original string
	* if format is not supported
	*/
	public static function format_datestr($date, $format)
	{
	$format_items = preg_split('/[.-\/\\\\]/', $format);
	$date_items = preg_split('/[.-\/\\\\]/', $date);
	$iso_format = '%04d-%02d-%02d';

	if (count($format_items) == 3 && count($date_items) == 3) {
	if ($format_items[0] == 'Y') {
	$date = sprintf($iso_format, $date_items[0], $date_items[1], $date_items[2]);
	}
	else if (strpos('dj', $format_items[0]) !== false) {
	$date = sprintf($iso_format, $date_items[2], $date_items[1], $date_items[0]);
	}
	else if (strpos('mn', $format_items[0]) !== false) {
	$date = sprintf($iso_format, $date_items[2], $date_items[0], $date_items[1]);
	}
	}

	return $date;
	}

	/**
	* Wrapper for idn_to_ascii with support for e-mail address.
	*
	* Warning: Domain names may be lowercase'd.
	* Warning: An empty string may be returned on invalid domain.
	*
	* @param string $str Decoded e-mail address
	*
	* @return string Encoded e-mail address
	*/
	public static function idn_to_ascii($str)
	{
	return self::idn_convert($str, true);
	}

	/**
	* Wrapper for idn_to_utf8 with support for e-mail address
	*
	* @param string $str Decoded e-mail address
	*
	* @return string Encoded e-mail address
	*/
	public static function idn_to_utf8($str)
	{
	return self::idn_convert($str, false);
	}

	/**
	* Convert a string to ascii or utf8 (using IDNA standard)
	*
	* @param string $input Decoded e-mail address
	* @param boolean $is_utf Convert by idn_to_ascii if true and idn_to_utf8 if false
	*
	* @return string Encoded e-mail address
	*/
	public static function idn_convert($input, $is_utf = false)
	{
	if ($at = strpos($input, '@')) {
	$user = substr($input, 0, $at);
	$domain = substr($input, $at + 1);
	}
	else {
	$user = '';
	$domain = $input;
	}

	// Note that in PHP 7.2/7.3 calling idn_to_* functions with default arguments
	// throws a warning, so we have to set the variant explicitely (#6075)
	$variant = defined('INTL_IDNA_VARIANT_UTS46') ? INTL_IDNA_VARIANT_UTS46 : null;
	$options = 0;

	// Because php-intl extension lowercases domains and return false
	// on invalid input (#6224), we skip conversion when not needed
	// for compatibility with our Net_IDNA2 wrappers in bootstrap.php

	if ($is_utf) {
	if (preg_match('/[^\x20-\x7E]/', $domain)) {
	$options = defined('IDNA_NONTRANSITIONAL_TO_ASCII') ? IDNA_NONTRANSITIONAL_TO_ASCII : 0;
	$domain = idn_to_ascii($domain, $options, $variant);
	}
	}
	else if (preg_match('/(^\|\.)xn--/i', $domain)) {
	$options = defined('IDNA_NONTRANSITIONAL_TO_UNICODE') ? IDNA_NONTRANSITIONAL_TO_UNICODE : 0;
	$domain = idn_to_utf8($domain, $options, $variant);
	}

	if ($domain === false) {
	return '';
	}

	return $at ? $user . '@' . $domain : $domain;
	}

	/**
	* Split the given string into word tokens
	*
	* @param string $str Input to tokenize
	* @param int $minlen Minimum length of a single token
	*
	* @return array List of tokens
	*/
	public static function tokenize_string($str, $minlen = 2)
	{
	$expr = array('/[\s;,"\'\/+-]+/ui', '/(\d)[-.\s]+(\d)/u');
	$repl = array(' ', '\\1\\2');

	if ($minlen > 1) {
	$minlen--;
	$expr[] = "/(^\|\s+)\w{1,$minlen}(\s+\|$)/u";
	$repl[] = ' ';
	}

	return array_filter(explode(" ", preg_replace($expr, $repl, $str)));
	}

	/**
	* Normalize the given string for fulltext search.
	* Currently only optimized for ISO-8859-1 and ISO-8859-2 characters; to be extended
	*
	* @param string $str Input string (UTF-8)
	* @param bool $as_array True to return list of words as array
	* @param int $minlen Minimum length of tokens
	*
	* @return string\|array Normalized string or a list of normalized tokens
	*/
	public static function normalize_string($str, $as_array = false, $minlen = 2)
	{
	// replace 4-byte unicode characters with '?' character,
	// these are not supported in default utf-8 charset on mysql,
	// the chance we'd need them in searching is very low
	$str = preg_replace('/('
	. '\xF0[\x90-\xBF][\x80-\xBF]{2}'
	. '\|[\xF1-\xF3][\x80-\xBF]{3}'
	. '\|\xF4[\x80-\x8F][\x80-\xBF]{2}'
	. ')/', '?', $str);

	// split by words
	$arr = self::tokenize_string($str, $minlen);

	// detect character set
	if (utf8_encode(utf8_decode($str)) == $str) {
	// ISO-8859-1 (or ASCII)
	preg_match_all('/./u', 'äâàåáãæçéêëèïîìíñöôòøõóüûùúýÿ', $keys);
	preg_match_all('/./', 'aaaaaaaceeeeiiiinoooooouuuuyy', $values);

	$mapping = array_combine($keys[0], $values[0]);
	$mapping = array_merge($mapping, array('ß' => 'ss', 'ae' => 'a', 'oe' => 'o', 'ue' => 'u'));
	}
	else if (rcube_charset::convert(rcube_charset::convert($str, 'UTF-8', 'ISO-8859-2'), 'ISO-8859-2', 'UTF-8') == $str) {
	// ISO-8859-2
	preg_match_all('/./u', 'ąáâäćçčéęëěíîłľĺńňóôöŕřśšşťţůúűüźžżý', $keys);
	preg_match_all('/./', 'aaaaccceeeeiilllnnooorrsssttuuuuzzzy', $values);

	$mapping = array_combine($keys[0], $values[0]);
	$mapping = array_merge($mapping, array('ß' => 'ss', 'ae' => 'a', 'oe' => 'o', 'ue' => 'u'));
	}

	foreach ($arr as $i => $part) {
	$part = mb_strtolower($part);

	if (!empty($mapping)) {
	$part = strtr($part, $mapping);
	}

	$arr[$i] = $part;
	}

	return $as_array ? $arr : implode(' ', $arr);
	}

	/**
	* Compare two strings for matching words (order not relevant)
	*
	* @param string $haystack Haystack
	* @param string $needle Needle
	*
	* @return bool True if match, False otherwise
	*/
	public static function words_match($haystack, $needle)
	{
	$a_needle = self::tokenize_string($needle, 1);
	$_haystack = implode(' ', self::tokenize_string($haystack, 1));
	$valid = strlen($_haystack) > 0;
	$hits = 0;

	foreach ($a_needle as $w) {
	if ($valid) {
	if (stripos($_haystack, $w) !== false) {
	$hits++;
	}
	}
	else if (stripos($haystack, $w) !== false) {
	$hits++;
	}
	}

	return $hits >= count($a_needle);
	}

	/**
	* Parse commandline arguments into a hash array
	*
	* @param array $aliases Argument alias names
	*
	* @return array Argument values hash
	*/
	public static function get_opt($aliases = array())
	{
	$args = array();
	$bool = array();

	// find boolean (no value) options
	foreach ($aliases as $key => $alias) {
	if ($pos = strpos($alias, ':')) {
	$aliases[$key] = substr($alias, 0, $pos);
	$bool[] = $key;
	$bool[] = $aliases[$key];
	}
	}

	for ($i=1; $i < count($_SERVER['argv']); $i++) {
	$arg = $_SERVER['argv'][$i];
	$value = true;
	$key = null;

	if ($arg[0] == '-') {
	$key = preg_replace('/^-+/', '', $arg);
	$sp = strpos($arg, '=');

	if ($sp > 0) {
	$key = substr($key, 0, $sp - 2);
	$value = substr($arg, $sp+1);
	}
	else if (in_array($key, $bool)) {
	$value = true;
	}
	else if (strlen($_SERVER['argv'][$i+1]) && $_SERVER['argv'][$i+1][0] != '-') {
	$value = $_SERVER['argv'][++$i];
	}

	$args[$key] = is_string($value) ? preg_replace(array('/^["\']/', '/["\']$/'), '', $value) : $value;
	}
	else {
	$args[] = $arg;
	}

	if ($alias = $aliases[$key]) {
	$args[$alias] = $args[$key];
	}
	}

	return $args;
	}

	/**
	* Safe password prompt for command line
	* from http://blogs.sitepoint.com/2009/05/01/interactive-cli-password-prompt-in-php/
	*
	* @param string $prompt Prompt text
	*
	* @return string Password
	*/
	public static function prompt_silent($prompt = "Password:")
	{
	if (preg_match('/^win/i', PHP_OS)) {
	$vbscript = sys_get_temp_dir() . 'prompt_password.vbs';
	$vbcontent = 'wscript.echo(InputBox("' . addslashes($prompt) . '", "", "password here"))';
	file_put_contents($vbscript, $vbcontent);

	$command = "cscript //nologo " . escapeshellarg($vbscript);
	$password = rtrim(shell_exec($command));
	unlink($vbscript);

	return $password;
	}

	$command = "/usr/bin/env bash -c 'echo OK'";

	if (rtrim(shell_exec($command)) !== 'OK') {
	echo $prompt;
	$pass = trim(fgets(STDIN));
	echo chr(8)."\r" . $prompt . str_repeat("*", strlen($pass))."\n";

	return $pass;
	}

	$command = "/usr/bin/env bash -c 'read -s -p \"" . addslashes($prompt) . "\" mypassword && echo \$mypassword'";
	$password = rtrim(shell_exec($command));
	echo "\n";

	return $password;
	}

	/**
	* Find out if the string content means true or false
	*
	* @param string $str Input value
	*
	* @return bool Boolean value
	*/
	public static function get_boolean($str)
	{
	$str = strtolower($str);

	return !in_array($str, array('false', '0', 'no', 'off', 'nein', ''), true);
	}

	/**
	* OS-dependent absolute path detection
	*
	* @param string $path File path
	*
	* @return bool True if the path is absolute, False otherwise
	*/
	public static function is_absolute_path($path)
	{
	if (strtoupper(substr(PHP_OS, 0, 3)) == 'WIN') {
	return (bool) preg_match('!^[a-z]:[\\\\/]!i', $path);
	}

	return isset($path[0]) && $path[0] == '/';
	}

	/**
	* Resolve relative URL
	*
	* @param string $url Relative URL
	*
	* @return string Absolute URL
	*/
	public static function resolve_url($url)
	{
	// prepend protocol://hostname:port
	if (!preg_match('\|^https?://\|', $url)) {
	$schema = 'http';
	$default_port = 80;

	if (self::https_check()) {
	$schema = 'https';
	$default_port = 443;
	}

	$prefix = $schema . '://' . preg_replace('/:\d+$/', '', $_SERVER['HTTP_HOST']);
	if ($_SERVER['SERVER_PORT'] != $default_port && $_SERVER['SERVER_PORT'] != 80) {
	$prefix .= ':' . $_SERVER['SERVER_PORT'];
	}

	$url = $prefix . ($url[0] == '/' ? '' : '/') . $url;
	}

	return $url;
	}

	/**
	* Generate a random string
	*
	* @param int $length String length
	* @param bool $raw Return RAW data instead of ascii
	*
	* @return string The generated random string
	*/
	public static function random_bytes($length, $raw = false)
	{
	$hextab = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
	$tabsize = strlen($hextab);

	// Use PHP7 true random generator
	if ($raw && function_exists('random_bytes')) {
	return random_bytes($length);
	}

	if (!$raw && function_exists('random_int')) {
	$result = '';
	while ($length-- > 0) {
	$result .= $hextab[random_int(0, $tabsize - 1)];
	}

	return $result;
	}

	$random = openssl_random_pseudo_bytes($length);

	if ($random === false && $length > 0) {
	throw new Exception("Failed to get random bytes");
	}

	if (!$raw) {
	for ($x = 0; $x < $length; $x++) {
	$random[$x] = $hextab[ord($random[$x]) % $tabsize];
	}
	}

	return $random;
	}

	/**
	* Convert binary data into readable form (containing a-zA-Z0-9 characters)
	*
	* @param string $input Binary input
	*
	* @return string Readable output (Base62)
	* @deprecated since 1.3.1
	*/
	public static function bin2ascii($input)
	{
	$hextab = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
	$result = '';

	for ($x = 0; $x < strlen($input); $x++) {
	$result .= $hextab[ord($input[$x]) % 62];
	}

	return $result;
	}

	/**
	* Format current date according to specified format.
	* This method supports microseconds (u).
	*
	* @param string $format Date format (default: 'd-M-Y H:i:s O')
	*
	* @return string Formatted date
	*/
	public static function date_format($format = null)
	{
	if (empty($format)) {
	$format = 'd-M-Y H:i:s O';
	}

	if (strpos($format, 'u') !== false) {
	$dt = number_format(microtime(true), 6, '.', '');
	$dt .= '.' . date_default_timezone_get();

	if ($date = date_create_from_format('U.u.e', $dt)) {
	return $date->format($format);
	}
	}

	return date($format);
	}

	/**
	* Parses socket options and returns options for specified hostname.
	*
	* @param array &$options Configured socket options
	* @param string $host Hostname
	*/
	public static function parse_socket_options(&$options, $host = null)
	{
	if (empty($host) \|\| empty($options)) {
	return;
	}

	// get rid of schema and port from the hostname
	$host_url = parse_url($host);
	if (isset($host_url['host'])) {
	$host = $host_url['host'];
	}

	// find per-host options
	if ($host && array_key_exists($host, $options)) {
	$options = $options[$host];
	}
	}

	/**
	* Get maximum upload size
	*
	* @return int Maximum size in bytes
	*/
	public static function max_upload_size()
	{
	// 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 $max_filesize;
	}

	/**
	* Detect and log last PREG operation error
	*
	* @param array $error Error data (line, file, code, message)
	* @param bool $terminate Stop script execution
	*
	* @return bool True on error, False otherwise
	*/
	public static function preg_error($error = array(), $terminate = false)
	{
	if (($preg_error = preg_last_error()) != PREG_NO_ERROR) {
	$errstr = "PCRE Error: $preg_error.";

	if ($preg_error == PREG_BACKTRACK_LIMIT_ERROR) {
	$errstr .= " Consider raising pcre.backtrack_limit!";
	}
	if ($preg_error == PREG_RECURSION_LIMIT_ERROR) {
	$errstr .= " Consider raising pcre.recursion_limit!";
	}

	$error = array_merge(array('code' => 620, 'line' => __LINE__, 'file' => __FILE__), $error);

	if (!empty($error['message'])) {
	$error['message'] .= ' ' . $errstr;
	}
	else {
	$error['message'] = $errstr;
	}

	rcube::raise_error($error, true, $terminate);

	return true;
	}

	return false;
	}

	/**
	* Generate a temporary file path in the Roundcube temp directory
	*
	* @param string $file_name String identifier for the type of temp file
	* @param bool $unique Generate unique file names based on $file_name
	* @param bool $create Create the temp file or not
	*
	* @return string temporary file path
	*/
	public static function temp_filename($file_name, $unique = true, $create = true)
	{
	$temp_dir = rcube::get_instance()->config->get('temp_dir');

	// Fall back to system temp dir if configured dir is not writable
	if (!is_writable($temp_dir)) {
	$temp_dir = sys_get_temp_dir();
	}

	// On Windows tempnam() uses only the first three characters of prefix so use uniqid() and manually add the prefix
	// Full prefix is required for garbage collection to recognise the file
	$temp_file = $unique ? str_replace('.', '', uniqid($file_name, true)) : $file_name;
	$temp_path = unslashify($temp_dir) . '/' . RCUBE_TEMP_FILE_PREFIX . $temp_file;

	// Sanity check for unique file name
	if ($unique && file_exists($temp_path)) {
	return self::temp_filename($file_name, $unique, $create);
	}

	// Create the file to prevent possible race condition like tempnam() does
	if ($create) {
	touch($temp_path);
	}

	return $temp_path;
	}
	}
	diff --git a/program/steps/mail/func.inc b/program/steps/mail/func.inc
	index d9f90f62d..3f8a07f86 100644
	--- a/program/steps/mail/func.inc
	+++ b/program/steps/mail/func.inc
	@@ -1,1892 +1,1902 @@
	<?php

	/**
	+-----------------------------------------------------------------------+
	\| This file is part of the Roundcube Webmail client \|
	\| \|
	\| Copyright (C) The Roundcube Dev Team \|
	\| \|
	\| Licensed under the GNU General Public License version 3 or \|
	\| any later version with exceptions for skins & plugins. \|
	\| See the README file for a full license statement. \|
	\| \|
	\| PURPOSE: \|
	\| Provide webmail functionality and GUI objects \|
	+-----------------------------------------------------------------------+
	\| Author: Thomas Bruederli <roundcube@gmail.com> \|
	\| Author: Aleksander Machniak <alec@alec.pl> \|
	+-----------------------------------------------------------------------+
	*/

	// always instantiate storage object (but not connect to server yet)
	$RCMAIL->storage_init();

	// init environment - set current folder, page, list mode
	rcmail_init_env();

	// set message set for search result
	if (!empty($_REQUEST['_search']) && isset($_SESSION['search'])
	&& $_SESSION['search_request'] == $_REQUEST['_search']
	) {
	$RCMAIL->storage->set_search_set($_SESSION['search']);

	$OUTPUT->set_env('search_request', $_REQUEST['_search']);
	$OUTPUT->set_env('search_text', $_SESSION['last_text_search']);
	}

	// remove mbox part from _uid
	if (($_uid = rcube_utils::get_input_value('_uid', rcube_utils::INPUT_GPC)) && !is_array($_uid) && preg_match('/^\d+-.+/', $_uid)) {
	list($_uid, $mbox) = explode('-', $_uid, 2);
	if (isset($_GET['_uid'])) $_GET['_uid'] = $_uid;
	if (isset($_POST['_uid'])) $_POST['_uid'] = $_uid;
	$_REQUEST['_uid'] = $_uid;
	unset($_uid);

	// override mbox
	if (!empty($mbox)) {
	$_GET['_mbox'] = $mbox;
	$_POST['_mbox'] = $mbox;
	$RCMAIL->storage->set_folder($_SESSION['mbox'] = $mbox);
	}
	}

	if (!empty($_SESSION['browser_caps']) && !$OUTPUT->ajax_call) {
	$OUTPUT->set_env('browser_capabilities', $_SESSION['browser_caps']);
	}

	// set main env variables, labels and page title
	if (empty($RCMAIL->action) \|\| $RCMAIL->action == 'list') {
	// connect to storage server and trigger error on failure
	$RCMAIL->storage_connect();

	$mbox_name = $RCMAIL->storage->get_folder();

	if (empty($RCMAIL->action)) {
	$OUTPUT->set_env('search_mods', rcmail_search_mods());

	- $scope = rcube_utils::get_input_value('_scope', rcube_utils::INPUT_GET) ?: $_SESSION['search_scope'];
	+ $scope = rcube_utils::get_input_value('_scope', rcube_utils::INPUT_GET);
	+ if (!$scope && isset($_SESSION['search_scope'])) {
	+ $scope = $_SESSION['search_scope'];
	+ }
	+
	if ($scope && preg_match('/^(all\|sub)$/i', $scope)) {
	$OUTPUT->set_env('search_scope', strtolower($scope));
	}

	rcmail_list_pagetitle();
	}

	$threading = (bool) $RCMAIL->storage->get_threading();
	$delimiter = $RCMAIL->storage->get_hierarchy_delimiter();

	// set current mailbox and some other vars in client environment
	$OUTPUT->set_env('mailbox', $mbox_name);
	$OUTPUT->set_env('pagesize', $RCMAIL->storage->get_pagesize());
	$OUTPUT->set_env('current_page', max(1, $_SESSION['page']));
	$OUTPUT->set_env('delimiter', $delimiter);
	$OUTPUT->set_env('threading', $threading);
	$OUTPUT->set_env('threads', $threading \|\| $RCMAIL->storage->get_capability('THREAD'));
	$OUTPUT->set_env('reply_all_mode', (int) $RCMAIL->config->get('reply_all_mode'));
	$OUTPUT->set_env('layout', $RCMAIL->config->get('layout') ?: 'widescreen');

	if ($RCMAIL->storage->get_capability('QUOTA')) {
	$OUTPUT->set_env('quota', true);
	}

	// set special folders
	foreach (array('drafts', 'trash', 'junk') as $mbox) {
	if ($folder = $RCMAIL->config->get($mbox . '_mbox')) {
	$OUTPUT->set_env($mbox . '_mailbox', $folder);
	}
	}

	if (!empty($_GET['_uid'])) {
	$OUTPUT->set_env('list_uid', $_GET['_uid']);
	}

	// set configuration
	$RCMAIL->set_env_config(array('delete_junk', 'flag_for_deletion', 'read_when_deleted',
	'skip_deleted', 'display_next', 'message_extwin', 'forward_attachment'));

	if (!$OUTPUT->ajax_call) {
	$OUTPUT->add_label('checkingmail', 'deletemessage', 'movemessagetotrash',
	'movingmessage', 'copyingmessage', 'deletingmessage', 'markingmessage',
	'copy', 'move', 'quota', 'replyall', 'replylist', 'stillsearching',
	'flagged', 'unflagged', 'unread', 'deleted', 'replied', 'forwarded',
	'priority', 'withattachment', 'fileuploaderror', 'mark', 'markallread',
	'folders-cur', 'folders-sub', 'folders-all', 'cancel', 'bounce', 'bouncemsg',
	'sendingmessage');
	}
	}

	// register UI objects
	$OUTPUT->add_handlers(array(
	'mailboxlist' => array($RCMAIL, 'folder_list'),
	'quotadisplay' => array($RCMAIL, 'quota_display'),
	'messages' => 'rcmail_message_list',
	'messagecountdisplay' => 'rcmail_messagecount_display',
	'listmenulink' => 'rcmail_options_menu_link',
	'mailboxname' => 'rcmail_mailbox_name_display',
	'messageimportform' => 'rcmail_message_import_form',
	'searchfilter' => 'rcmail_search_filter',
	'searchinterval' => 'rcmail_search_interval',
	'searchform' => array($OUTPUT, 'search_form'),
	));

	// register action aliases
	$RCMAIL->register_action_map(array(
	'refresh' => 'check_recent.inc',
	'preview' => 'show.inc',
	'print' => 'show.inc',
	'move' => 'move_del.inc',
	'delete' => 'move_del.inc',
	'send' => 'sendmail.inc',
	'expunge' => 'folders.inc',
	'purge' => 'folders.inc',
	'remove-attachment' => 'attachments.inc',
	'rename-attachment' => 'attachments.inc',
	'display-attachment' => 'attachments.inc',
	'upload' => 'attachments.inc',
	'group-expand' => 'autocomplete.inc',
	));


	/**
	* Sets storage properties and session
	*/
	function rcmail_init_env()
	{
	global $RCMAIL;

	$default_threading = $RCMAIL->config->get('default_list_mode', 'list') == 'threads';
	$a_threading = $RCMAIL->config->get('message_threading', array());
	$message_sort_col = $RCMAIL->config->get('message_sort_col');
	$message_sort_order = $RCMAIL->config->get('message_sort_order');

	// set imap properties and session vars
	if (!strlen($mbox = rcube_utils::get_input_value('_mbox', rcube_utils::INPUT_GPC, true))) {
	$mbox = isset($_SESSION['mbox']) && strlen($_SESSION['mbox']) ? $_SESSION['mbox'] : 'INBOX';
	}

	// we handle 'page' argument on 'list' and 'getunread' to prevent from
	// race condition and unintentional page overwrite in session
	if ($RCMAIL->action == 'list' \|\| $RCMAIL->action == 'getunread') {
	- if (!($page = intval($_GET['_page']))) {
	- $page = $_SESSION['page'] ?: 1;
	+ $page = isset($_GET['_page']) ? intval($_GET['_page']) : 0;
	+ if (!$page) {
	+ $page = !empty($_SESSION['page']) ? $_SESSION['page'] : 1;
	}

	$_SESSION['page'] = $page;
	}

	$RCMAIL->storage->set_folder($_SESSION['mbox'] = $mbox);
	$RCMAIL->storage->set_page(isset($_SESSION['page']) ? $_SESSION['page'] : 1);

	// set default sort col/order to session
	if (!isset($_SESSION['sort_col'])) {
	$_SESSION['sort_col'] = $message_sort_col ?: '';
	}
	if (!isset($_SESSION['sort_order'])) {
	$_SESSION['sort_order'] = strtoupper($message_sort_order) == 'ASC' ? 'ASC' : 'DESC';
	}

	// set threads mode
	if (isset($_GET['_threads'])) {
	if ($_GET['_threads']) {
	// re-set current page number when listing mode changes
	if (!$a_threading[$_SESSION['mbox']]) {
	$RCMAIL->storage->set_page($_SESSION['page'] = 1);
	}

	$a_threading[$_SESSION['mbox']] = true;
	}
	else {
	// re-set current page number when listing mode changes
	if ($a_threading[$_SESSION['mbox']]) {
	$RCMAIL->storage->set_page($_SESSION['page'] = 1);
	}

	$a_threading[$_SESSION['mbox']] = false;
	}

	$RCMAIL->user->save_prefs(array('message_threading' => $a_threading));
	}

	$threading = isset($a_threading[$_SESSION['mbox']]) ? $a_threading[$_SESSION['mbox']] : $default_threading;

	$RCMAIL->storage->set_threading($threading);
	}

	/**
	* Sets page title
	*/
	function rcmail_list_pagetitle()
	{
	global $RCMAIL;

	if ($RCMAIL->output->get_env('search_request')) {
	$pagetitle = $RCMAIL->gettext('searchresult');
	}
	else {
	$mbox_name = $RCMAIL->output->get_env('mailbox') ?: $RCMAIL->storage->get_folder();
	$delimiter = $RCMAIL->storage->get_hierarchy_delimiter();
	$pagetitle = $RCMAIL->localize_foldername($mbox_name, true);
	$pagetitle = str_replace($delimiter, " \xC2\xBB ", $pagetitle);
	}

	$RCMAIL->output->set_pagetitle($pagetitle);
	}

	/**
	* Returns default search mods
	*/
	function rcmail_search_mods()
	{
	global $RCMAIL;

	$mods = $RCMAIL->config->get('search_mods');

	if (empty($mods)) {
	$mods = array('*' => array('subject' => 1, 'from' => 1));

	foreach (array('sent', 'drafts') as $mbox) {
	if ($mbox = $RCMAIL->config->get($mbox . '_mbox')) {
	$mods[$mbox] = array('subject' => 1, 'to' => 1);
	}
	}
	}

	return $mods;
	}

	/**
	* Returns 'to' if current folder is configured Sent or Drafts
	* or their subfolders, otherwise returns 'from'.
	*
	* @return string Column name
	*/
	function rcmail_message_list_smart_column_name()
	{
	global $RCMAIL;

	$delim = $RCMAIL->storage->get_hierarchy_delimiter();
	$mbox = $RCMAIL->output->get_env('mailbox') ?: $RCMAIL->storage->get_folder();
	$sent_mbox = $RCMAIL->config->get('sent_mbox');
	$drafts_mbox = $RCMAIL->config->get('drafts_mbox');

	if ((strpos($mbox.$delim, $sent_mbox.$delim) === 0 \|\| strpos($mbox.$delim, $drafts_mbox.$delim) === 0)
	&& strtoupper($mbox) != 'INBOX'
	) {
	return 'to';
	}

	return 'from';
	}

	/**
	* Returns configured messages list sorting column name
	* The name is context-sensitive, which means if sorting is set to 'fromto'
	* it will return 'from' or 'to' according to current folder type.
	*
	* @return string Column name
	*/
	function rcmail_sort_column()
	{
	global $RCMAIL;

	if (isset($_SESSION['sort_col'])) {
	$column = $_SESSION['sort_col'];
	}
	else {
	$column = $RCMAIL->config->get('message_sort_col');
	}

	// get name of smart From/To column in folder context
	if ($column == 'fromto') {
	$column = rcmail_message_list_smart_column_name();
	}

	return $column;
	}

	/**
	* Returns configured message list sorting order
	*
	* @return string Sorting order (ASC\|DESC)
	*/
	function rcmail_sort_order()
	{
	global $RCMAIL;

	if (isset($_SESSION['sort_order'])) {
	return $_SESSION['sort_order'];
	}

	return $RCMAIL->config->get('message_sort_order');
	}

	/**
	* return the message list as HTML table
	*/
	function rcmail_message_list($attrib)
	{
	global $RCMAIL, $OUTPUT;

	// add some labels to client
	$OUTPUT->add_label('from', 'to');

	// add id to message list table if not specified
	if (!strlen($attrib['id'])) {
	$attrib['id'] = 'rcubemessagelist';
	}

	// define list of cols to be displayed based on parameter or config
	if (empty($attrib['columns'])) {
	$list_cols = $RCMAIL->config->get('list_cols');
	$a_show_cols = !empty($list_cols) && is_array($list_cols) ? $list_cols : array('subject');

	$OUTPUT->set_env('col_movable', !in_array('list_cols', (array)$RCMAIL->config->get('dont_override')));
	}
	else {
	$a_show_cols = preg_split('/[\s,;]+/', str_replace(array("'", '"'), '', $attrib['columns']));
	$attrib['columns'] = $a_show_cols;
	}

	// save some variables for use in ajax list
	$_SESSION['list_attrib'] = $attrib;

	// make sure 'threads' and 'subject' columns are present
	if (!in_array('subject', $a_show_cols))
	array_unshift($a_show_cols, 'subject');
	if (!in_array('threads', $a_show_cols))
	array_unshift($a_show_cols, 'threads');

	$listcols = $a_show_cols;

	// set client env
	$OUTPUT->add_gui_object('messagelist', $attrib['id']);
	$OUTPUT->set_env('autoexpand_threads', intval($RCMAIL->config->get('autoexpand_threads')));
	$OUTPUT->set_env('sort_col', $_SESSION['sort_col']);
	$OUTPUT->set_env('sort_order', $_SESSION['sort_order']);
	$OUTPUT->set_env('messages', array());
	$OUTPUT->set_env('listcols', $listcols);
	$OUTPUT->set_env('listcols_widescreen', array('threads', 'subject', 'fromto', 'date', 'flag', 'attachment'));

	$OUTPUT->include_script('list.js');

	$table = new html_table($attrib);

	- if (!$attrib['noheader']) {
	+ if (empty($attrib['noheader'])) {
	$allcols = array_merge($listcols, array('threads', 'subject', 'fromto', 'date', 'flag', 'attachment'));
	$allcols = array_unique($allcols);

	foreach (rcmail_message_list_head($attrib, $allcols) as $col => $cell) {
	if (in_array($col, $listcols)) {
	$table->add_header(array('class' => $cell['className'], 'id' => $cell['id']), $cell['html']);
	}
	}
	}

	return $table->show();
	}

	/**
	* return javascript commands to add rows to the message list
	*/
	function rcmail_js_message_list($a_headers, $insert_top=false, $a_show_cols=null)
	{
	global $RCMAIL, $OUTPUT;

	if (empty($a_show_cols)) {
	if (!empty($_SESSION['list_attrib']['columns']))
	$a_show_cols = $_SESSION['list_attrib']['columns'];
	else {
	$list_cols = $RCMAIL->config->get('list_cols');
	$a_show_cols = !empty($list_cols) && is_array($list_cols) ? $list_cols : array('subject');
	}
	}
	else {
	if (!is_array($a_show_cols)) {
	$a_show_cols = preg_split('/[\s,;]+/', str_replace(array("'", '"'), '', $a_show_cols));
	}
	$head_replace = true;
	}

	$delimiter = $RCMAIL->storage->get_hierarchy_delimiter();
	$search_set = $RCMAIL->storage->get_search_set();
	$multifolder = $search_set && $search_set[1]->multi;

	// add/remove 'folder' column to the list on multi-folder searches
	if ($multifolder && !in_array('folder', $a_show_cols)) {
	$a_show_cols[] = 'folder';
	$head_replace = true;
	}
	else if (!$multifolder && ($found = array_search('folder', $a_show_cols)) !== false) {
	unset($a_show_cols[$found]);
	$head_replace = true;
	}

	$mbox = $RCMAIL->output->get_env('mailbox') ?: $RCMAIL->storage->get_folder();

	// make sure 'threads' and 'subject' columns are present
	if (!in_array('subject', $a_show_cols))
	array_unshift($a_show_cols, 'subject');
	if (!in_array('threads', $a_show_cols))
	array_unshift($a_show_cols, 'threads');

	// Make sure there are no duplicated columns (#1486999)
	$a_show_cols = array_unique($a_show_cols);
	$_SESSION['list_attrib']['columns'] = $a_show_cols;

	// Plugins may set header's list_cols/list_flags and other rcube_message_header variables
	// and list columns
	$plugin = $RCMAIL->plugins->exec_hook('messages_list',
	array('messages' => $a_headers, 'cols' => $a_show_cols));

	$a_show_cols = $plugin['cols'];
	$a_headers = $plugin['messages'];

	// make sure minimum required columns are present (needed for widescreen layout)
	$allcols = array_merge($a_show_cols, array('threads', 'subject', 'fromto', 'date', 'flag', 'attachment'));
	$allcols = array_unique($allcols);

	- $thead = $head_replace ? rcmail_message_list_head($_SESSION['list_attrib'], $allcols) : NULL;
	+ $thead = !empty($head_replace) ? rcmail_message_list_head($_SESSION['list_attrib'], $allcols) : NULL;

	// get name of smart From/To column in folder context
	$smart_col = rcmail_message_list_smart_column_name();
	$OUTPUT->command('set_message_coltypes', array_values($a_show_cols), $thead, $smart_col);

	if ($multifolder && $_SESSION['search_scope'] == 'all') {
	$OUTPUT->command('select_folder', '');
	}

	$OUTPUT->set_env('multifolder_listing', $multifolder);

	if (empty($a_headers)) {
	return;
	}

	// remove 'threads', 'attachment', 'flag', 'status' columns, we don't need them here
	foreach (array('threads', 'attachment', 'flag', 'status', 'priority') as $col) {
	if (($key = array_search($col, $allcols)) !== FALSE) {
	unset($allcols[$key]);
	}
	}

	$sort_col = $_SESSION['sort_col'];

	// loop through message headers
	foreach ($a_headers as $header) {
	if (empty($header) \|\| !$header->size) {
	continue;
	}

	// make message UIDs unique by appending the folder name
	if ($multifolder) {
	$header->uid .= '-'.$header->folder;
	$header->flags['skip_mbox_check'] = true;
	if ($header->parent_uid)
	$header->parent_uid .= '-'.$header->folder;
	}

	$a_msg_cols = array();
	$a_msg_flags = array();

	// format each col; similar as in rcmail_message_list()
	foreach ($allcols as $col) {
	$col_name = $col == 'fromto' ? $smart_col : $col;

	if (in_array($col_name, array('from', 'to', 'cc', 'replyto'))) {
	$cont = rcmail_address_string($header->$col_name, 3, false, null, $header->charset);
	if (empty($cont)) $cont = ' '; // for widescreen mode
	}
	else if ($col == 'subject') {
	$cont = trim(rcube_mime::decode_header($header->$col, $header->charset));
	if (!$cont) $cont = $RCMAIL->gettext('nosubject');
	$cont = rcube::SQ($cont);
	}
	else if ($col == 'size')
	$cont = $RCMAIL->show_bytes($header->$col);
	else if ($col == 'date')
	$cont = $RCMAIL->format_date($sort_col == 'arrival' ? $header->internaldate : $header->date);
	else if ($col == 'folder') {
	if ($last_folder !== $header->folder) {
	$last_folder = $header->folder;
	$last_folder_name = $RCMAIL->localize_foldername($last_folder, true);
	$last_folder_name = str_replace($delimiter, " \xC2\xBB ", $last_folder_name);
	}

	$cont = rcube::SQ($last_folder_name);
	}
	else
	$cont = rcube::SQ($header->$col);

	$a_msg_cols[$col] = $cont;
	}

	$a_msg_flags = array_change_key_case(array_map('intval', (array) $header->flags));
	- if ($header->depth)
	+ if (!empty($header->depth))
	$a_msg_flags['depth'] = $header->depth;
	- else if ($header->has_children)
	+ else if (!empty($header->has_children))
	$roots[] = $header->uid;
	- if ($header->parent_uid)
	+ if (!empty($header->parent_uid))
	$a_msg_flags['parent_uid'] = $header->parent_uid;
	- if ($header->has_children)
	+ if (!empty($header->has_children))
	$a_msg_flags['has_children'] = $header->has_children;
	- if ($header->unread_children)
	+ if (!empty($header->unread_children))
	$a_msg_flags['unread_children'] = $header->unread_children;
	- if ($header->flagged_children)
	+ if (!empty($header->flagged_children))
	$a_msg_flags['flagged_children'] = $header->flagged_children;
	- if ($header->others['list-post'])
	+ if (!empty($header->others['list-post']))
	$a_msg_flags['ml'] = 1;
	- if ($header->priority)
	+ if (!empty($header->priority))
	$a_msg_flags['prio'] = (int) $header->priority;

	$a_msg_flags['ctype'] = rcube::Q($header->ctype);
	$a_msg_flags['mbox'] = $header->folder;

	// merge with plugin result (Deprecated, use $header->flags)
	if (!empty($header->list_flags) && is_array($header->list_flags))
	$a_msg_flags = array_merge($a_msg_flags, $header->list_flags);
	if (!empty($header->list_cols) && is_array($header->list_cols))
	$a_msg_cols = array_merge($a_msg_cols, $header->list_cols);

	$OUTPUT->command('add_message_row', $header->uid, $a_msg_cols, $a_msg_flags, $insert_top);
	}

	if ($RCMAIL->storage->get_threading()) {
	$OUTPUT->command('init_threads', (array) $roots, $mbox);
	}
	}

	/*
	* Creates <THEAD> for message list table
	*/
	function rcmail_message_list_head($attrib, $a_show_cols)
	{
	global $RCMAIL;

	// check to see if we have some settings for sorting
	$sort_col = $_SESSION['sort_col'];
	$sort_order = $_SESSION['sort_order'];

	$dont_override = (array) $RCMAIL->config->get('dont_override');
	$disabled_sort = in_array('message_sort_col', $dont_override);
	$disabled_order = in_array('message_sort_order', $dont_override);

	$RCMAIL->output->set_env('disabled_sort_col', $disabled_sort);
	$RCMAIL->output->set_env('disabled_sort_order', $disabled_order);

	// define sortable columns
	if ($disabled_sort)
	$a_sort_cols = $sort_col && !$disabled_order ? array($sort_col) : array();
	else
	$a_sort_cols = array('subject', 'date', 'from', 'to', 'fromto', 'size', 'cc');

	if (!empty($attrib['optionsmenuicon'])) {
	$params = array();
	foreach ($attrib as $key => $val) {
	if (preg_match('/^optionsmenu(.+)$/', $key, $matches)) {
	$params[$matches[1]] = $val;
	}
	}

	$list_menu = rcmail_options_menu_link($params);
	}

	$cells = $coltypes = array();

	// get name of smart From/To column in folder context
	if (array_search('fromto', $a_show_cols) !== false) {
	$smart_col = rcmail_message_list_smart_column_name();
	}

	foreach ($a_show_cols as $col) {
	$label = '';
	$sortable = false;
	$rel_col = $col == 'date' && $sort_col == 'arrival' ? 'arrival' : $col;

	// get column name
	switch ($col) {
	case 'flag':
	$col_name = html::span('flagged', $RCMAIL->gettext('flagged'));
	break;
	case 'attachment':
	case 'priority':
	$col_name = html::span($col, $RCMAIL->gettext($col));
	break;
	case 'status':
	$col_name = html::span($col, $RCMAIL->gettext('readstatus'));
	break;
	case 'threads':
	- $col_name = (string) $list_menu;
	+ $col_name = !empty($list_menu) ? $list_menu : '';
	break;
	case 'fromto':
	$label = $RCMAIL->gettext($smart_col);
	$col_name = rcube::Q($label);
	break;
	default:
	$label = $RCMAIL->gettext($col);
	$col_name = rcube::Q($label);
	}

	// make sort links
	if (in_array($col, $a_sort_cols)) {
	$sortable = true;
	$col_name = html::a(array(
	'href' => "./#sort",
	'class' => 'sortcol',
	'rel' => $rel_col,
	'title' => $RCMAIL->gettext('sortby')
	), $col_name);
	}
	- else if ($col_name[0] != '<') {
	+ else if (empty($col_name) \|\| $col_name[0] != '<') {
	$col_name = '<span class="' . $col .'">' . $col_name . '</span>';
	}

	$sort_class = $rel_col == $sort_col && !$disabled_order ? " sorted$sort_order" : '';
	$class_name = $col.$sort_class;

	// put it all together
	$cells[$col] = array('className' => $class_name, 'id' => "rcm$col", 'html' => $col_name);
	$coltypes[$col] = array('className' => $class_name, 'id' => "rcm$col", 'label' => $label, 'sortable' => $sortable);
	}

	$RCMAIL->output->set_env('coltypes', $coltypes);
	return $cells;
	}

	function rcmail_options_menu_link($attrib = array())
	{
	global $RCMAIL;

	- $onclick = 'return ' . rcmail_output::JS_OBJECT_NAME . ".command('menu-open', '" . ($attrib['ref'] ?: 'messagelistmenu') ."', this, event)";
	- $inner = $title = $RCMAIL->gettext($attrib['label'] ?: 'listoptions');
	+ $title = $RCMAIL->gettext(!empty($attrib['label']) ? $attrib['label'] : 'listoptions');
	+ $inner = $title;
	+ $onclick = sprintf(
	+ "return %s.command('menu-open', '%s', this, event)",
	+ rcmail_output::JS_OBJECT_NAME,
	+ !empty($attrib['ref']) ? $attrib['ref'] : 'messagelistmenu'
	+ );

	// Backwards compatibility, attribute renamed in v1.5
	if (isset($attrib['optionsmenuicon'])) {
	$attrib['icon'] = $attrib['optionsmenuicon'];
	}

	- if (is_string($attrib['icon']) && $attrib['icon'] != 'true') {
	+ if (isset($attrib['icon']) && $attrib['icon'] != 'true') {
	$inner = html::img(array('src' => $RCMAIL->output->asset_url($attrib['icon'], true), 'alt' => $title));
	}
	- else if ($attrib['innerclass']) {
	+ else if (!empty($attrib['innerclass'])) {
	$inner = html::span($attrib['innerclass'], $inner);
	}

	return html::a(array(
	'href' => '#list-options',
	'onclick' => $onclick,
	'class' => isset($attrib['class']) ? $attrib['class'] : 'listmenu',
	'id' => isset($attrib['id']) ? $attrib['id'] : 'listmenulink',
	'title' => $title,
	'tabindex' => '0',
	), $inner);
	}

	function rcmail_messagecount_display($attrib)
	{
	global $RCMAIL;

	- if (!$attrib['id']) {
	+ if (empty($attrib['id'])) {
	$attrib['id'] = 'rcmcountdisplay';
	}

	$RCMAIL->output->add_gui_object('countdisplay', $attrib['id']);

	$content = $RCMAIL->action != 'show' ? rcmail_get_messagecount_text() : $RCMAIL->gettext('loading');

	return html::span($attrib, $content);
	}

	function rcmail_get_messagecount_text($count = null, $page = null)
	{
	global $RCMAIL;

	if ($page === null) {
	$page = $RCMAIL->storage->get_page();
	}

	$page_size = $RCMAIL->storage->get_pagesize();
	$start_msg = ($page-1) * $page_size + 1;
	$max = $count;

	if ($max === null && $RCMAIL->action) {
	$max = $RCMAIL->storage->count(null, $RCMAIL->storage->get_threading() ? 'THREADS' : 'ALL');
	}

	if (!$max) {
	$out = $RCMAIL->storage->get_search_set() ? $RCMAIL->gettext('nomessages') : $RCMAIL->gettext('mailboxempty');
	}
	else {
	$out = $RCMAIL->gettext(array('name' => $RCMAIL->storage->get_threading() ? 'threadsfromto' : 'messagesfromto',
	'vars' => array('from' => $start_msg,
	'to' => min($max, $start_msg + $page_size - 1),
	'count' => $max)));
	}

	return rcube::Q($out);
	}

	function rcmail_mailbox_name_display($attrib)
	{
	global $RCMAIL;

	if (!$attrib['id']) {
	$attrib['id'] = 'rcmmailboxname';
	}

	$RCMAIL->output->add_gui_object('mailboxname', $attrib['id']);

	return html::span($attrib, rcmail_get_mailbox_name_text());
	}

	function rcmail_get_mailbox_name_text()
	{
	global $RCMAIL;
	return $RCMAIL->localize_foldername($RCMAIL->output->get_env('mailbox') ?: $RCMAIL->storage->get_folder());
	}

	function rcmail_send_unread_count($mbox_name, $force=false, $count=null, $mark='')
	{
	global $RCMAIL;

	$old_unseen = rcmail_get_unseen_count($mbox_name);
	$unseen = $count;

	if ($unseen === null) {
	$unseen = $RCMAIL->storage->count($mbox_name, 'UNSEEN', $force);
	}

	if ($unseen !== $old_unseen \|\| ($mbox_name == 'INBOX')) {
	$RCMAIL->output->command('set_unread_count', $mbox_name, $unseen,
	($mbox_name == 'INBOX'), $unseen && $mark ? $mark : '');
	}

	rcmail_set_unseen_count($mbox_name, $unseen);

	return $unseen;
	}

	function rcmail_set_unseen_count($mbox_name, $count)
	{
	// @TODO: this data is doubled (session and cache tables) if caching is enabled

	// Make sure we have an array here (#1487066)
	if (!is_array($_SESSION['unseen_count'])) {
	$_SESSION['unseen_count'] = array();
	}

	$_SESSION['unseen_count'][$mbox_name] = $count;
	}

	function rcmail_get_unseen_count($mbox_name)
	{
	if (is_array($_SESSION['unseen_count']) && array_key_exists($mbox_name, $_SESSION['unseen_count'])) {
	return $_SESSION['unseen_count'][$mbox_name];
	}
	}

	/**
	* Sets message is_safe flag according to 'show_images' option value
	*
	* @param object rcube_message Message
	*/
	function rcmail_check_safe($message)
	{
	global $RCMAIL;

	if (!$message->is_safe
	&& ($show_images = $RCMAIL->config->get('show_images'))
	&& $message->has_html_part()
	) {
	switch ($show_images) {
	case 1: // all my contacts
	case 3: // trusted senders only
	if (!empty($message->sender['mailto'])) {
	$type = rcube_addressbook::TYPE_TRUSTED_SENDER;

	if ($show_images == 1) {
	$type \|= rcube_addressbook::TYPE_RECIPIENT \| rcube_addressbook::TYPE_WRITEABLE;
	}

	if ($RCMAIL->contact_exists($message->sender['mailto'], $type)) {
	$message->set_safe(true);
	}
	}

	$RCMAIL->plugins->exec_hook('message_check_safe', array('message' => $message));
	break;

	case 2: // always
	$message->set_safe(true);
	break;
	}
	}

	return !empty($message->is_safe);
	}

	/**
	* Cleans up the given message HTML Body (for displaying)
	*
	* @param string HTML
	* @param array Display parameters
	* @param array CID map replaces (inline images)
	* @return string Clean HTML
	*/
	function rcmail_wash_html($html, $p, $cid_replaces = array())
	{
	global $REMOTE_OBJECTS, $RCMAIL;

	$p += array('safe' => false, 'inline_html' => true, 'css_prefix' => null, 'container_id' => null);

	// charset was converted to UTF-8 in rcube_storage::get_message_part(),
	// change/add charset specification in HTML accordingly,
	// washtml's DOMDocument methods cannot work without that
	$meta = '<meta charset="'.RCUBE_CHARSET.'" />';

	// remove old meta tag and add the new one, making sure that it is placed in the head (#3510, #7116)
	$html = preg_replace('/<meta[^>]+charset=[a-z0-9_"-]+[^>]*>/Ui', '', $html);
	$html = preg_replace('/(<head[^>]*>)/Ui', '\\1'.$meta, $html, -1, $rcount);

	if (!$rcount) {
	// Note: HTML without <html> tag may still be a valid input (#6713)
	if (($pos = stripos($html, '<html')) === false) {
	$html = '<html><head>' . $meta . '</head>' . $html;
	}
	else {
	$pos = strpos($html, '>', $pos);
	$html = substr_replace($html, '<head>' . $meta . '</head>', $pos + 1, 0);
	}
	}

	// clean HTML with washhtml by Frederic Motte
	$wash_opts = array(
	'show_washed' => false,
	'allow_remote' => $p['safe'],
	'blocked_src' => $RCMAIL->output->asset_url('program/resources/blocked.gif'),
	'charset' => RCUBE_CHARSET,
	'cid_map' => $cid_replaces,
	'html_elements' => array('body'),
	'css_prefix' => $p['css_prefix'],
	'container_id' => $p['container_id'],
	);

	if (empty($p['inline_html'])) {
	$wash_opts['html_elements'] = array('html','head','title','body','link');
	}
	if (!empty($p['safe'])) {
	$wash_opts['html_attribs'] = array('rel','type');
	}

	// overwrite washer options with options from plugins
	if (isset($p['html_elements'])) {
	$wash_opts['html_elements'] = $p['html_elements'];
	}
	if (isset($p['html_attribs'])) {
	$wash_opts['html_attribs'] = $p['html_attribs'];
	}

	// initialize HTML washer
	$washer = new rcube_washtml($wash_opts);

	if (empty($p['skip_washer_form_callback'])) {
	$washer->add_callback('form', 'rcmail_washtml_callback');
	}

	// allow CSS styles, will be sanitized by rcmail_washtml_callback()
	if (empty($p['skip_washer_style_callback'])) {
	$washer->add_callback('style', 'rcmail_washtml_callback');
	}

	// modify HTML links to open a new window if clicked
	if (empty($p['skip_washer_link_callback'])) {
	$washer->add_callback('a', 'rcmail_washtml_link_callback');
	$washer->add_callback('area', 'rcmail_washtml_link_callback');
	$washer->add_callback('link', 'rcmail_washtml_link_callback');
	}

	// Remove non-UTF8 characters (#1487813)
	$html = rcube_charset::clean($html);

	$html = $washer->wash($html);
	$REMOTE_OBJECTS = $washer->extlinks;

	return $html;
	}

	/**
	* Convert the given message part to proper HTML
	* which can be displayed the message view
	*
	* @param string Message part body
	* @param rcube_message_part Message part
	* @param array Display parameters array
	*
	* @return string Formatted HTML string
	*/
	function rcmail_print_body($body, $part, $p = array())
	{
	global $RCMAIL;

	// trigger plugin hook
	$data = $RCMAIL->plugins->exec_hook('message_part_before',
	array('type' => $part->ctype_secondary, 'body' => $body, 'id' => $part->mime_id)
	+ $p + array('safe' => false, 'plain' => false, 'inline_html' => true));

	// convert html to text/plain
	if ($data['plain'] && ($data['type'] == 'html' \|\| $data['type'] == 'enriched')) {
	if ($data['type'] == 'enriched') {
	$data['body'] = rcube_enriched::to_html($data['body']);
	}

	$body = $RCMAIL->html2text($data['body']);
	$part->ctype_secondary = 'plain';
	}
	// text/html
	else if ($data['type'] == 'html') {
	$body = rcmail_wash_html($data['body'], $data, $part->replaces);
	$part->ctype_secondary = $data['type'];
	}
	// text/enriched
	else if ($data['type'] == 'enriched') {
	$body = rcube_enriched::to_html($data['body']);
	$body = rcmail_wash_html($body, $data, $part->replaces);
	$part->ctype_secondary = 'html';
	}
	else {
	// assert plaintext
	$body = $data['body'];
	$part->ctype_secondary = $data['type'] = 'plain';
	}

	// free some memory (hopefully)
	unset($data['body']);

	// plaintext postprocessing
	if ($part->ctype_secondary == 'plain') {
	$flowed = isset($part->ctype_parameters['format']) && $part->ctype_parameters['format'] == 'flowed';
	$delsp = isset($part->ctype_parameters['delsp']) && $part->ctype_parameters['delsp'] == 'yes';
	$body = rcmail_plain_body($body, $flowed, $delsp);
	}

	// allow post-processing of the message body
	$data = $RCMAIL->plugins->exec_hook('message_part_after',
	array('type' => $part->ctype_secondary, 'body' => $body, 'id' => $part->mime_id) + $data);

	return $data['body'];
	}

	/**
	* Handle links and citation marks in plain text message
	*
	* @param string Plain text string
	* @param boolean Set to True if the source text is in format=flowed
	*
	* @return string Formatted HTML string
	*/
	function rcmail_plain_body($body, $flowed = false, $delsp = false)
	{
	$options = array('flowed' => $flowed, 'wrap' => !$flowed, 'replacer' => 'rcmail_string_replacer',
	'delsp' => $delsp);
	$text2html = new rcube_text2html($body, false, $options);
	$body = $text2html->get_html();

	return $body;
	}

	/**
	* Callback function for washtml cleaning class
	*/
	function rcmail_washtml_callback($tagname, $attrib, $content, $washtml)
	{
	switch ($tagname) {
	case 'form':
	$out = html::div('form', $content);
	break;

	case 'style':
	// Crazy big styles may freeze the browser (#1490539)
	// remove content with more than 5k lines
	if (substr_count($content, "\n") > 5000) {
	$out = '';
	break;
	}

	// decode all escaped entities and reduce to ascii strings
	$decoded = rcube_utils::xss_entity_decode($content);
	$stripped = preg_replace('/[^a-zA-Z\(:;]/', '', $decoded);

	// now check for evil strings like expression, behavior or url()
	if (!preg_match('/expression\|behavior\|javascript:\|import[^a]/i', $stripped)) {
	if (!$washtml->get_config('allow_remote') && preg_match('/url\((?!data:image)/', $stripped)) {
	$washtml->extlinks = true;
	}
	else {
	$out = html::tag('style', array('type' => 'text/css'), $decoded);
	}
	break;
	}

	default:
	$out = '';
	}

	return $out;
	}

	function rcmail_part_image_type($part)
	{
	$mimetype = strtolower($part->mimetype);

	// Skip TIFF/WEBP images if browser doesn't support this format
	// ...until we can convert them to JPEG
	$tiff_support = !empty($_SESSION['browser_caps']) && !empty($_SESSION['browser_caps']['tiff']);
	$tiff_support = $tiff_support \|\| rcube_image::is_convertable('image/tiff');
	$webp_support = !empty($_SESSION['browser_caps']) && !empty($_SESSION['browser_caps']['webp']);
	$webp_support = $webp_support \|\| rcube_image::is_convertable('image/webp');

	if ((!$tiff_support && $mimetype == 'image/tiff') \|\| (!$webp_support && $mimetype == 'image/webp')) {
	return;
	}

	// Content-Type: image/*...
	if (strpos($mimetype, 'image/') === 0) {
	return $mimetype;
	}

	// Many clients use application/octet-stream, we'll detect mimetype
	// by checking filename extension

	// Supported image filename extensions to image type map
	$types = array(
	'jpg' => 'image/jpeg',
	'jpeg' => 'image/jpeg',
	'png' => 'image/png',
	'gif' => 'image/gif',
	'bmp' => 'image/bmp',
	);
	if ($tiff_support) {
	$types['tif'] = 'image/tiff';
	$types['tiff'] = 'image/tiff';
	}
	if ($webp_support) {
	$types['webp'] = 'image/webp';
	}

	if ($part->filename
	&& $mimetype == 'application/octet-stream'
	&& preg_match('/\.([^.]+)$/i', $part->filename, $m)
	&& ($extension = strtolower($m[1]))
	&& isset($types[$extension])
	) {
	return $types[$extension];
	}
	}

	/**
	* Modify a HTML message that it can be displayed inside a HTML page
	*/
	function rcmail_html4inline($body, &$args)
	{
	$last_pos = 0;
	$cont_id = $args['container_id'] . (!empty($args['body_class']) ? ' div.' . $args['body_class'] : '');
	$is_safe = !empty($args['safe']);
	$prefix = isset($args['css_prefix']) ? $args['css_prefix'] : null;

	// find STYLE tags
	while (($pos = stripos($body, '<style', $last_pos)) !== false && ($pos2 = stripos($body, '</style>', $pos+1))) {
	$pos = strpos($body, '>', $pos) + 1;
	$len = $pos2 - $pos;

	// replace all css definitions with #container [def]
	$styles = substr($body, $pos, $len);
	$styles = rcube_utils::mod_css_styles($styles, $cont_id, $is_safe, $prefix);

	$body = substr_replace($body, $styles, $pos, $len);
	$last_pos = $pos2 + strlen($styles) - $len;
	}

	$replace = array(
	// add comments around html and other tags
	'/(<!DOCTYPE[^>]*>)/i' => '<!--\\1-->',
	'/(<\?xml[^>]*>)/i' => '<!--\\1-->',
	'/(<\/?html[^>]*>)/i' => '<!--\\1-->',
	'/(<\/?head[^>]*>)/i' => '<!--\\1-->',
	'/(<title[^>]>.<\/title>)/Ui' => '<!--\\1-->',
	'/(<\/?meta[^>]*>)/i' => '<!--\\1-->',
	// quote <? of php and xml files that are specified as text/html
	'/<\?/' => '<?',
	'/\?>/' => '?>',
	);

	$regexp = '/<body([^>]*)/';

	// Handle body attributes that doesn't play nicely with div elements
	if (preg_match($regexp, $body, $m)) {
	$style = array();
	$attrs = $m[0];

	// Get bgcolor, we'll set it as background-color of the message container
	if ($m[1] && preg_match('/bgcolor=["\']([a-z0-9#]+)["\']/i', $attrs, $mb)) {
	$style['background-color'] = $mb[1];
	$attrs = preg_replace('/\s?bgcolor=["\'][a-z0-9#]+["\']/i', '', $attrs);
	}

	// Get text color, we'll set it as font color of the message container
	if ($m[1] && preg_match('/text=["\']([a-z0-9#]+)["\']/i', $attrs, $mb)) {
	$style['color'] = $mb[1];
	$attrs = preg_replace('/\s?text=["\'][a-z0-9#]+["\']/i', '', $attrs);
	}

	// Get background, we'll set it as background-image of the message container
	if ($m[1] && preg_match('/background=["\']([^"\'>\s]+)["\']/', $attrs, $mb)) {
	$style['background-image'] = 'url('.$mb[1].')';
	$attrs = preg_replace('/\s?background=["\']([^"\'>\s]+)["\']/', '', $attrs);
	}

	if (!empty($style)) {
	$body = preg_replace($regexp, rtrim($attrs), $body, 1);
	}

	// handle body styles related to background image
	if (!empty($style['background-image'])) {
	// get body style
	if (preg_match('/#'.preg_quote($cont_id, '/').'\s+\{([^}]+)}/i', $body, $m)) {
	// get background related style
	$regexp = '/(background-position\|background-repeat)\s:\s([^;]+);/i';
	if (preg_match_all($regexp, $m[1], $matches, PREG_SET_ORDER)) {
	foreach ($matches as $m) {
	$style[$m[1]] = $m[2];
	}
	}
	}
	}

	if (!empty($style)) {
	foreach ($style as $idx => $val) {
	$style[$idx] = $idx . ': ' . $val;
	}

	$args['container_attrib']['style'] = implode('; ', $style);
	}

	// replace <body> with <div>
	if (!empty($args['body_class'])) {
	$replace['/<body([^>]*)>/i'] = '<div class="' . $args['body_class'] . '"\\1>';
	}
	else {
	$replace['/<body/i'] = '<div';
	}

	$replace['/<\/body>/i'] = '</div>';
	}
	// make sure there's 'rcmBody' div, we need it for proper css modification
	// its name is hardcoded in rcmail_message_body() also
	else if (!empty($args['body_class'])) {
	$body = '<div class="' . $args['body_class'] . '">' . $body . '</div>';
	}

	// Clean up, and replace <body> with <div>
	$body = preg_replace(array_keys($replace), array_values($replace), $body);

	return $body;
	}

	/**
	* Parse link (a, link, area) attributes and set correct target
	*/
	function rcmail_washtml_link_callback($tag, $attribs, $content, $washtml)
	{
	global $RCMAIL;

	$attrib = html::parse_attrib_string($attribs);

	// Remove non-printable characters in URL (#1487805)
	if (isset($attrib['href'])) {
	$attrib['href'] = preg_replace('/[\x00-\x1F]/', '', $attrib['href']);

	if ($tag == 'link' && preg_match('/^https?:\/\//i', $attrib['href'])) {
	$tempurl = 'tmp-' . md5($attrib['href']) . '.css';
	$_SESSION['modcssurls'][$tempurl] = $attrib['href'];
	$attrib['href'] = $RCMAIL->url(array(
	'task' => 'utils',
	'action' => 'modcss',
	'u' => $tempurl,
	'c' => $washtml->get_config('container_id'),
	'p' => $washtml->get_config('css_prefix'),
	));
	$content = null;
	}
	else if (preg_match('/^mailto:(.+)/i', $attrib['href'], $mailto)) {
	$url_parts = explode('?', html_entity_decode($mailto[1], ENT_QUOTES, 'UTF-8'), 2);
	$mailto = $url_parts[0];
	$url = isset($url_parts[1]) ? $url_parts[1] : '';

	// #6020: use raw encoding for correct "+" character handling as specified in RFC6068
	$url = rawurldecode($url);
	$mailto = rawurldecode($mailto);
	$addresses = rcube_mime::decode_address_list($mailto, null, true);
	$mailto = array();

	// do sanity checks on recipients
	foreach ($addresses as $idx => $addr) {
	if (rcube_utils::check_email($addr['mailto'], false)) {
	$addresses[$idx] = $addr['mailto'];
	$mailto[] = $addr['string'];
	}
	else {
	unset($addresses[$idx]);
	}
	}

	if (!empty($addresses)) {
	$attrib['href'] = 'mailto:' . implode(',', $addresses);
	$attrib['onclick'] = sprintf(
	"return %s.command('compose','%s',this)",
	rcmail_output::JS_OBJECT_NAME,
	rcube::JQ(implode(',', $mailto) . ($url ? "?$url" : '')));
	}
	else {
	$attrib['href'] = '#NOP';
	$attrib['onclick'] = '';
	}
	}
	else if (!empty($attrib['href']) && $attrib['href'][0] != '#') {
	$attrib['target'] = '_blank';
	}

	// Better security by adding rel="noreferrer" (#1484686)
	if (($tag == 'a' \|\| $tag == 'area') && $attrib['href'] && $attrib['href'][0] != '#') {
	$attrib['rel'] = 'noreferrer';
	}
	}

	// allowed attributes for a\|link\|area tags
	$allow = array('href','name','target','onclick','id','class','style','title',
	'rel','type','media','alt','coords','nohref','hreflang','shape');

	return html::tag($tag, $attrib, $content, $allow);
	}

	/**
	* Decode address string and re-format it as HTML links
	*/
	function rcmail_address_string($input, $max=null, $linked=false, $addicon=null, $default_charset=null, $title=null)
	{
	global $RCMAIL, $PRINT_MODE;

	$a_parts = rcube_mime::decode_address_list($input, null, true, $default_charset);

	if (!count($a_parts)) {
	return $input;
	}

	$c = count($a_parts);
	$j = 0;
	$out = '';
	$allvalues = array();
	$shown_addresses = array();
	$show_email = $RCMAIL->config->get('message_show_email');

	if ($addicon && !isset($_SESSION['writeable_abook'])) {
	$_SESSION['writeable_abook'] = $RCMAIL->get_address_sources(true) ? true : false;
	}

	foreach ($a_parts as $part) {
	$j++;

	$name = $part['name'];
	$mailto = $part['mailto'];
	$string = $part['string'];
	$valid = rcube_utils::check_email($mailto, false);

	// phishing email prevention (#1488981), e.g. "valid@email.addr <phishing@email.addr>"
	if (!$show_email && $valid && $name && $name != $mailto && strpos($name, '@')) {
	$name = '';
	}

	// IDNA ASCII to Unicode
	if ($name == $mailto)
	$name = rcube_utils::idn_to_utf8($name);
	if ($string == $mailto)
	$string = rcube_utils::idn_to_utf8($string);
	$mailto = rcube_utils::idn_to_utf8($mailto);

	if ($PRINT_MODE) {
	$address = sprintf('%s <%s>', rcube::SQ($name), rcube::Q($mailto));
	}
	else if ($valid) {
	if ($linked) {
	$attrs = array(
	'href' => 'mailto:' . $mailto,
	'class' => 'rcmContactAddress',
	'onclick' => sprintf("return %s.command('compose','%s',this)",
	rcmail_output::JS_OBJECT_NAME, rcube::JQ(format_email_recipient($mailto, $name))),
	);

	if ($show_email && $name && $mailto) {
	$content = rcube::SQ($name ? sprintf('%s <%s>', $name, $mailto) : $mailto);
	}
	else {
	$content = rcube::SQ($name ?: $mailto);
	$attrs['title'] = $mailto;
	}

	$address = html::a($attrs, $content);
	}
	else {
	$address = html::span(array('title' => $mailto, 'class' => "rcmContactAddress"),
	rcube::SQ($name ?: $mailto));
	}

	if ($addicon && $_SESSION['writeable_abook']) {
	$label = $RCMAIL->gettext('addtoaddressbook');
	$icon = html::img(array(
	'src' => $RCMAIL->output->asset_url($addicon, true),
	'alt' => $label,
	'class' => 'noselect',
	));
	$address .= html::a(array(
	'href' => "#add",
	'title' => $label,
	'class' => 'rcmaddcontact',
	'onclick' => sprintf("return %s.command('add-contact','%s',this)",
	rcmail_output::JS_OBJECT_NAME, rcube::JQ($string)),
	),
	$addicon == 'virtual' ? '' : $icon
	);
	}
	}
	else {
	$address = $name ? rcube::Q($name) : '';
	if ($mailto) {
	$address = trim($address . ' ' . rcube::Q($name ? sprintf('<%s>', $mailto) : $mailto));
	}
	}

	$address = html::span('adr', $address);
	$allvalues[] = $address;

	- if (!$moreadrs) {
	+ if (empty($moreadrs)) {
	$out .= ($out ? ', ' : '') . $address;
	$shown_addresses[] = $address;
	}

	if ($max && $j == $max && $c > $j) {
	if ($linked) {
	$moreadrs = $c - $j;
	}
	else {
	$out .= '...';
	break;
	}
	}
	}

	- if ($moreadrs) {
	+ if (!empty($moreadrs)) {
	$label = rcube::Q($RCMAIL->gettext(array('name' => 'andnmore', 'vars' => array('nr' => $moreadrs))));

	if ($PRINT_MODE) {
	$out .= ' ' . html::a(array(
	'href' => '#more',
	'class' => 'morelink',
	'onclick' => '$(this).hide().next().show()',
	), $label)
	. html::span(array('style' => 'display:none'), join(', ', array_diff($allvalues, $shown_addresses)));
	}
	else {
	$out .= ' ' . html::a(array(
	'href' => '#more',
	'class' => 'morelink',
	'onclick' => sprintf("return %s.simple_dialog('%s','%s',null,{cancel_button:'close'})",
	rcmail_output::JS_OBJECT_NAME,
	rcube::JQ(join(', ', $allvalues)),
	rcube::JQ($title))
	), $label);
	}
	}

	return $out;
	}

	/**
	* Wrap text to a given number of characters per line
	* but respect the mail quotation of replies messages (>).
	* Finally add another quotation level by prepending the lines
	* with >
	*
	* @param string Text to wrap
	* @param int The line width
	* @param bool Enable quote indentation
	* @return string The wrapped text
	*/
	function rcmail_wrap_and_quote($text, $length = 72, $quote = true)
	{
	// Rebuild the message body with a maximum of $max chars, while keeping quoted message.
	$max = max(75, $length + 8);
	$lines = preg_split('/\r?\n/', trim($text));
	$out = '';

	foreach ($lines as $line) {
	// don't wrap already quoted lines
	if ($line[0] == '>') {
	$line = rtrim($line);
	if ($quote) {
	$line = '>' . $line;
	}
	}
	// wrap lines above the length limit, but skip these
	// special lines with links list created by rcube_html2text
	else if (mb_strlen($line) > $max && !preg_match('\|^\[[0-9]+\] https?://\S+$\|', $line)) {
	$newline = '';

	foreach (explode("\n", rcube_mime::wordwrap($line, $length - 2)) as $l) {
	if ($quote) {
	$newline .= strlen($l) ? "> $l\n" : ">\n";
	}
	else {
	$newline .= "$l\n";
	}
	}

	$line = rtrim($newline);
	}
	else if ($quote) {
	$line = '> ' . $line;
	}

	// Append the line
	$out .= $line . "\n";
	}

	return rtrim($out, "\n");
	}

	/**
	* Send the MDN response
	*
	* @param mixed $message Original message object (rcube_message) or UID
	* @param array\|string $smtp_error SMTP error array or (deprecated) string
	*
	* @return boolean Send status
	*/
	function rcmail_send_mdn($message, &$smtp_error)
	{
	global $RCMAIL;

	if (!is_object($message) \|\| !is_a($message, 'rcube_message')) {
	$message = new rcube_message($message);
	}

	if ($message->headers->mdn_to && empty($message->headers->flags['MDNSENT']) &&
	($RCMAIL->storage->check_permflag('MDNSENT') \|\| $RCMAIL->storage->check_permflag('*'))
	) {
	$identity = rcmail_sendmail::identity_select($message);
	$sender = format_email_recipient($identity['email'], $identity['name']);
	$recipient = array_shift(rcube_mime::decode_address_list(
	$message->headers->mdn_to, 1, true, $message->headers->charset));
	$mailto = $recipient['mailto'];

	$compose = new Mail_mime("\r\n");

	$compose->setParam('text_encoding', 'quoted-printable');
	$compose->setParam('html_encoding', 'quoted-printable');
	$compose->setParam('head_encoding', 'quoted-printable');
	$compose->setParam('head_charset', RCUBE_CHARSET);
	$compose->setParam('html_charset', RCUBE_CHARSET);
	$compose->setParam('text_charset', RCUBE_CHARSET);

	// compose headers array
	$headers = array(
	'Date' => $RCMAIL->user_date(),
	'From' => $sender,
	'To' => $message->headers->mdn_to,
	'Subject' => $RCMAIL->gettext('receiptread') . ': ' . $message->subject,
	'Message-ID' => $RCMAIL->gen_message_id($identity['email']),
	'X-Sender' => $identity['email'],
	'References' => trim($message->headers->references . ' ' . $message->headers->messageID),
	'In-Reply-To' => $message->headers->messageID,
	);

	$report = "Final-Recipient: rfc822; {$identity['email']}\r\n"
	. "Original-Message-ID: {$message->headers->messageID}\r\n"
	. "Disposition: manual-action/MDN-sent-manually; displayed\r\n";

	if ($message->headers->to) {
	$report .= "Original-Recipient: {$message->headers->to}\r\n";
	}

	if ($agent = $RCMAIL->config->get('useragent')) {
	$headers['User-Agent'] = $agent;
	$report .= "Reporting-UA: $agent\r\n";
	}

	$to = rcube_mime::decode_mime_string($message->headers->to, $message->headers->charset);
	$date = $RCMAIL->format_date($message->headers->date, $RCMAIL->config->get('date_long'));
	$body = $RCMAIL->gettext("yourmessage") . "\r\n\r\n" .
	"\t" . $RCMAIL->gettext("to") . ": {$to}\r\n" .
	"\t" . $RCMAIL->gettext("subject") . ": {$message->subject}\r\n" .
	"\t" . $RCMAIL->gettext("date") . ": {$date}\r\n" .
	"\r\n" . $RCMAIL->gettext("receiptnote");

	$compose->headers(array_filter($headers));
	$compose->setContentType('multipart/report', array('report-type'=> 'disposition-notification'));
	$compose->setTXTBody(rcube_mime::wordwrap($body, 75, "\r\n"));
	$compose->addAttachment($report, 'message/disposition-notification', 'MDNPart2.txt', false, '7bit', 'inline');

	// SMTP options
	$options = array('mdn_use_from' => (bool) $RCMAIL->config->get('mdn_use_from'));

	$sent = $RCMAIL->deliver_message($compose, $identity['email'], $mailto, $smtp_error, $body_file, $options, true);

	if ($sent) {
	$RCMAIL->storage->set_flag($message->uid, 'MDNSENT');
	return true;
	}
	}

	return false;
	}

	/**
	* Detect recipient identity from specified message
	* @deprecated Use rcmail_sendmail::identity_select()
	*/
	function rcmail_identity_select($MESSAGE, $identities = null, $compose_mode = 'reply')
	{
	return rcmail_sendmail::identity_select($MESSAGE, $identities, $compose_mode);
	}

	// return attachment filename, handle empty filename case
	function rcmail_attachment_name($attachment, $display = false)
	{
	global $RCMAIL;

	$filename = (string) $attachment->filename;
	$filename = str_replace(array("\r", "\n"), '', $filename);

	if ($filename === '') {
	if ($attachment->mimetype == 'text/html') {
	$filename = $RCMAIL->gettext('htmlmessage');
	}
	else {
	$ext = (array) rcube_mime::get_mime_extensions($attachment->mimetype);
	$ext = array_shift($ext);
	$filename = $RCMAIL->gettext('messagepart') . ' ' . $attachment->mime_id;
	if ($ext) {
	$filename .= '.' . $ext;
	}
	}
	}

	// Display smart names for some known mimetypes
	if ($display) {
	if (preg_match('/application\/(pgp\|pkcs7)-signature/i', $attachment->mimetype)) {
	$filename = $RCMAIL->gettext('digitalsig');
	}
	}

	return $filename;
	}

	function rcmail_search_filter($attrib)
	{
	global $RCMAIL;

	if (!strlen($attrib['id'])) {
	$attrib['id'] = 'rcmlistfilter';
	}

	if (!rcube_utils::get_boolean($attrib['noevent'])) {
	$attrib['onchange'] = rcmail_output::JS_OBJECT_NAME.'.filter_mailbox(this.value)';
	}

	// Content-Type values of messages with attachments
	// the same as in app.js:add_message_row()
	$ctypes = array('application/', 'multipart/m', 'multipart/signed', 'multipart/report');

	// Build search string of "with attachment" filter
	$attachment = trim(str_repeat(' OR', count($ctypes)-1));
	foreach ($ctypes as $type) {
	$attachment .= ' HEADER Content-Type ' . rcube_imap_generic::escape($type);
	}

	$select = new html_select($attrib);
	$select->add($RCMAIL->gettext('all'), 'ALL');
	$select->add($RCMAIL->gettext('unread'), 'UNSEEN');
	$select->add($RCMAIL->gettext('flagged'), 'FLAGGED');
	$select->add($RCMAIL->gettext('unanswered'), 'UNANSWERED');
	if (!$RCMAIL->config->get('skip_deleted')) {
	$select->add($RCMAIL->gettext('deleted'), 'DELETED');
	$select->add($RCMAIL->gettext('undeleted'), 'UNDELETED');
	}
	$select->add($RCMAIL->gettext('withattachment'), $attachment);
	$select->add($RCMAIL->gettext('priority').': '.$RCMAIL->gettext('highest'), 'HEADER X-PRIORITY 1');
	$select->add($RCMAIL->gettext('priority').': '.$RCMAIL->gettext('high'), 'HEADER X-PRIORITY 2');
	$select->add($RCMAIL->gettext('priority').': '.$RCMAIL->gettext('normal'), 'NOT HEADER X-PRIORITY 1 NOT HEADER X-PRIORITY 2 NOT HEADER X-PRIORITY 4 NOT HEADER X-PRIORITY 5');
	$select->add($RCMAIL->gettext('priority').': '.$RCMAIL->gettext('low'), 'HEADER X-PRIORITY 4');
	$select->add($RCMAIL->gettext('priority').': '.$RCMAIL->gettext('lowest'), 'HEADER X-PRIORITY 5');

	$RCMAIL->output->add_gui_object('search_filter', $attrib['id']);

	$selected = rcube_utils::get_input_value('_filter', rcube_utils::INPUT_GET);

	- if (!$selected && $_REQUEST['_search']) {
	+ if (!$selected && !empty($_REQUEST['_search'])) {
	$selected = $_SESSION['search_filter'];
	}

	return $select->show($selected ?: 'ALL');
	}

	function rcmail_search_interval($attrib)
	{
	global $RCMAIL;

	if (!strlen($attrib['id'])) {
	$attrib['id'] = 'rcmsearchinterval';
	}

	$select = new html_select($attrib);
	$select->add('', '');

	foreach (array('1W', '1M', '1Y', '-1W', '-1M', '-1Y') as $value) {
	$select->add($RCMAIL->gettext('searchinterval' . $value), $value);
	}

	$RCMAIL->output->add_gui_object('search_interval', $attrib['id']);

	- return $select->show($_REQUEST['_search'] ? $_SESSION['search_interval'] : '');
	+ return $select->show(!empty($_REQUEST['_search']) ? $_SESSION['search_interval'] : '');
	}

	function rcmail_message_error()
	{
	global $RCMAIL;

	// ... display message error page
	if ($RCMAIL->output->template_exists('messageerror')) {
	// Set env variables for messageerror.html template
	if ($RCMAIL->action == 'show') {
	$mbox_name = $RCMAIL->storage->get_folder();

	$RCMAIL->output->set_env('mailbox', $mbox_name);
	$RCMAIL->output->set_env('uid', null);
	}

	$RCMAIL->output->show_message('messageopenerror', 'error');
	$RCMAIL->output->send('messageerror');
	}
	else {
	$RCMAIL->raise_error(array('code' => 410), false, true);
	}
	}

	function rcmail_message_import_form($attrib = array())
	{
	global $RCMAIL;

	$RCMAIL->output->add_label('selectimportfile', 'importwait', 'importmessages', 'import');

	$description = $RCMAIL->gettext('mailimportdesc');
	$input_attr = array(
	'multiple' => true,
	'name' => '_file[]',
	'accept' => '.eml,.mbox,.msg,message/rfc822,text/*',
	);

	if (class_exists('ZipArchive', false)) {
	$input_attr['accept'] .= '.zip,application/zip,application/x-zip';
	$description .= ' ' . $RCMAIL->gettext('mailimportzip');
	}

	$attrib['prefix'] = html::tag('input', array('type' => 'hidden', 'name' => '_unlock', 'value' => ''))
	. html::tag('input', array('type' => 'hidden', 'name' => '_framed', 'value' => '1'))
	. html::p(null, $description);

	return $RCMAIL->upload_form($attrib, 'importform', 'import-messages', $input_attr);
	}

	/**
	* Add groups from the given address source to the address book widget
	*/
	function rcmail_compose_contact_groups($abook, $source_id, $search = null, $search_mode = 0)
	{
	global $RCMAIL, $OUTPUT;

	$jsresult = array();
	foreach ($abook->list_groups($search, $search_mode) as $group) {
	$abook->reset();
	$abook->set_group($group['ID']);

	// group (distribution list) with email address(es)
	if ($group['email']) {
	foreach ((array)$group['email'] as $email) {
	$row_id = 'G'.$group['ID'];
	$jsresult[$row_id] = format_email_recipient($email, $group['name']);
	$OUTPUT->command('add_contact_row', $row_id, array(
	'contactgroup' => html::span(array('title' => $email), rcube::Q($group['name']))), 'group');
	}
	}
	// make virtual groups clickable to list their members
	else if ($group['virtual']) {
	$row_id = 'G'.$group['ID'];
	$OUTPUT->command('add_contact_row', $row_id, array(
	'contactgroup' => html::a(array(
	'href' => '#list',
	'rel' => $group['ID'],
	'title' => $RCMAIL->gettext('listgroup'),
	'onclick' => sprintf("return %s.command('pushgroup',{'source':'%s','id':'%s'},this,event)",
	rcmail_output::JS_OBJECT_NAME, $source_id, $group['ID']),
	), rcube::Q($group['name']) . ' ' . html::span('action', '»'))),
	'group',
	array('ID' => $group['ID'], 'name' => $group['name'], 'virtual' => true));
	}
	// show group with count
	else if (($result = $abook->count()) && $result->count) {
	$row_id = 'E'.$group['ID'];
	$jsresult[$row_id] = $group['name'];
	$OUTPUT->command('add_contact_row', $row_id, array(
	'contactgroup' => rcube::Q($group['name'] . ' (' . intval($result->count) . ')')), 'group');
	}
	}

	$abook->reset();
	$abook->set_group(0);

	return $jsresult;
	}

	function rcmail_save_attachment($message, $pid, $compose_id, $params = array())
	{
	global $COMPOSE;

	$rcmail = rcmail::get_instance();
	$storage = $rcmail->get_storage();

	if ($pid) {
	// attachment requested
	$part = $message->mime_parts[$pid];
	$size = $part->size;
	$mimetype = $part->ctype_primary . '/' . $part->ctype_secondary;
	$filename = $params['filename'] ?: rcmail_attachment_name($part);
	}
	else if (is_object($message)) {
	// the whole message requested
	$size = $message->size;
	$mimetype = 'message/rfc822';
	$filename = $params['filename'] ?: 'message_rfc822.eml';
	}
	else if (is_string($message)) {
	// the whole message requested
	$size = strlen($message);
	$data = $message;
	$mimetype = $params['mimetype'];
	$filename = $params['filename'];
	}

	if (!isset($data)) {
	// don't load too big attachments into memory
	if (!rcube_utils::mem_check($size)) {
	$path = rcube_utils::temp_filename('attmnt');

	if ($fp = fopen($path, 'w')) {
	if ($pid) {
	// part body
	$message->get_part_body($pid, false, 0, $fp);
	}
	else {
	// complete message
	$storage->get_raw_body($message->uid, $fp);
	}

	fclose($fp);
	}
	else {
	return false;
	}
	}
	else if ($pid) {
	// part body
	$data = $message->get_part_body($pid);
	}
	else {
	// complete message
	$data = $storage->get_raw_body($message->uid);
	}
	}

	$attachment = array(
	'group' => $compose_id,
	'name' => $filename,
	'mimetype' => $mimetype,
	'content_id' => $part ? $part->content_id : null,
	'data' => $data,
	'path' => $path,
	'size' => $path ? filesize($path) : strlen($data),
	'charset' => $part ? $part->charset : $params['charset'],
	);

	$attachment = $rcmail->plugins->exec_hook('attachment_save', $attachment);

	if ($attachment['status']) {
	unset($attachment['data'], $attachment['status'], $attachment['content_id'], $attachment['abort']);

	// rcube_session::append() replaces current session data with the old values
	// (in rcube_session::reload()). This is a problem in 'compose' action, because before
	// the first append() use we set some important data in the session.
	// It also overwrites attachments list. Fixing reload() is not so simple if possible
	// as we don't really know what has been added and what removed in meantime.
	// So, for now we'll do not use append() on 'compose' action (#1490608).

	if ($rcmail->action == 'compose') {
	$COMPOSE['attachments'][$attachment['id']] = $attachment;
	}
	else {
	$rcmail->session->append('compose_data_' . $compose_id . '.attachments', $attachment['id'], $attachment);
	}

	return $attachment;
	}
	else if ($path) {
	@unlink($path);
	}

	return false;
	}

	// Return mimetypes supported by the browser
	function rcmail_supported_mimetypes()
	{
	$rcmail = rcube::get_instance();

	// mimetypes supported by the browser (default settings)
	$mimetypes = (array) $rcmail->config->get('client_mimetypes');

	// Remove unsupported types, which makes that attachment which cannot be
	// displayed in a browser will be downloaded directly without displaying an overlay page
	if (empty($_SESSION['browser_caps']['pdf']) && ($key = array_search('application/pdf', $mimetypes)) !== false) {
	unset($mimetypes[$key]);
	}

	if (empty($_SESSION['browser_caps']['flash']) && ($key = array_search('application/x-shockwave-flash', $mimetypes)) !== false) {
	unset($mimetypes[$key]);
	}

	// We cannot securely preview XML files as we do not have a proper parser
	if (($key = array_search('text/xml', $mimetypes)) !== false) {
	unset($mimetypes[$key]);
	}

	foreach (array('tiff', 'webp') as $type) {
	if (empty($_SESSION['browser_caps'][$type]) && ($key = array_search('image/' . $type, $mimetypes)) !== false) {
	// can we convert it to jpeg?
	if (!rcube_image::is_convertable('image/' . $type)) {
	unset($mimetypes[$key]);
	}
	}
	}

	// @TODO: support mail preview for compose attachments
	if ($rcmail->action != 'compose' && !in_array('message/rfc822', $mimetypes)) {
	$mimetypes[] = 'message/rfc822';
	}

	return array_values($mimetypes);
	}
	diff --git a/program/steps/mail/getunread.inc b/program/steps/mail/getunread.inc
	index f7909db10..0b3cb9960 100644
	--- a/program/steps/mail/getunread.inc
	+++ b/program/steps/mail/getunread.inc
	@@ -1,54 +1,54 @@
	<?php

	/**
	+-----------------------------------------------------------------------+
	\| This file is part of the Roundcube Webmail client \|
	\| \|
	\| Copyright (C) The Roundcube Dev Team \|
	\| \|
	\| Licensed under the GNU General Public License version 3 or \|
	\| any later version with exceptions for skins & plugins. \|
	\| See the README file for a full license statement. \|
	\| \|
	\| PURPOSE: \|
	\| Check all mailboxes for unread messages and update GUI \|
	+-----------------------------------------------------------------------+
	\| Author: Thomas Bruederli <roundcube@gmail.com> \|
	+-----------------------------------------------------------------------+
	*/

	$a_folders = $RCMAIL->storage->list_folders_subscribed('', '*', 'mail');

	if (!empty($a_folders)) {
	$current = $RCMAIL->storage->get_folder();
	$inbox = ($current == 'INBOX');
	$trash = $RCMAIL->config->get('trash_mbox');
	$check_all = (bool)$RCMAIL->config->get('check_all_folders');

	foreach ($a_folders as $mbox) {
	$unseen_old = rcmail_get_unseen_count($mbox);

	if (!$check_all && $unseen_old !== null && $mbox != $current) {
	$unseen = $unseen_old;
	}
	else {
	$unseen = $RCMAIL->storage->count($mbox, 'UNSEEN', $unseen_old === null);
	}

	// call it always for current folder, so it can update counter
	// after possible message status change when opening a message
	// not in preview frame
	if ($unseen \|\| $unseen_old === null \|\| $mbox == $current) {
	- $OUTPUT->command('set_unread_count', $mbox, $unseen, $inbox && $mbox_row == 'INBOX');
	+ $OUTPUT->command('set_unread_count', $mbox, $unseen, $inbox && $mbox == 'INBOX');
	}

	rcmail_set_unseen_count($mbox, $unseen);

	// set trash folder state
	if ($mbox === $trash) {
	$OUTPUT->command('set_trash_count', $RCMAIL->storage->count($mbox, 'EXISTS'));
	}
	}
	}

	$OUTPUT->send();
	diff --git a/program/steps/mail/list.inc b/program/steps/mail/list.inc
	index 28d97039d..0547d6307 100644
	--- a/program/steps/mail/list.inc
	+++ b/program/steps/mail/list.inc
	@@ -1,146 +1,150 @@
	<?php

	/**
	+-----------------------------------------------------------------------+
	\| This file is part of the Roundcube Webmail client \|
	\| \|
	\| Copyright (C) The Roundcube Dev Team \|
	\| \|
	\| Licensed under the GNU General Public License version 3 or \|
	\| any later version with exceptions for skins & plugins. \|
	\| See the README file for a full license statement. \|
	\| \|
	\| PURPOSE: \|
	\| Send message list to client (as remote response) \|
	+-----------------------------------------------------------------------+
	\| Author: Thomas Bruederli <roundcube@gmail.com> \|
	+-----------------------------------------------------------------------+
	*/

	if (!$OUTPUT->ajax_call) {
	return;
	}

	$save_arr = array();
	$dont_override = (array) $RCMAIL->config->get('dont_override');
	+$cols = null;

	// is there a sort type for this request?
	if ($sort = rcube_utils::get_input_value('_sort', rcube_utils::INPUT_GET)) {
	// yes, so set the sort vars
	list($sort_col, $sort_order) = explode('_', $sort);

	// set session vars for sort (so next page and task switch know how to sort)
	if (!in_array('message_sort_col', $dont_override)) {
	$_SESSION['sort_col'] = $save_arr['message_sort_col'] = $sort_col;
	}
	if (!in_array('message_sort_order', $dont_override)) {
	$_SESSION['sort_order'] = $save_arr['message_sort_order'] = $sort_order;
	}
	}

	// is there a set of columns for this request?
	if ($cols = rcube_utils::get_input_value('_cols', rcube_utils::INPUT_GET)) {
	$_SESSION['list_attrib']['columns'] = explode(',', $cols);
	if (!in_array('list_cols', $dont_override)) {
	$save_arr['list_cols'] = explode(',', $cols);
	}
	}

	// register layout change
	if ($layout = rcube_utils::get_input_value('_layout', rcube_utils::INPUT_GET)) {
	$OUTPUT->set_env('layout', $layout);
	$save_arr['layout'] = $layout;
	// force header replace on layout change
	- $cols = $_SESSION['list_attrib']['columns'];
	+ if (!empty($_SESSION['list_attrib']['columns'])) {
	+ $cols = $_SESSION['list_attrib']['columns'];
	+ }
	}

	if (!empty($save_arr)) {
	$RCMAIL->user->save_prefs($save_arr);
	}

	$mbox_name = $RCMAIL->storage->get_folder();
	$threading = (bool) $RCMAIL->storage->get_threading();

	// Synchronize mailbox cache, handle flag changes
	$RCMAIL->storage->folder_sync($mbox_name);

	// fetch message headers
	if ($count = $RCMAIL->storage->count($mbox_name, $threading ? 'THREADS' : 'ALL', !empty($_REQUEST['_refresh']))) {
	$a_headers = $RCMAIL->storage->list_messages($mbox_name, NULL, rcmail_sort_column(), rcmail_sort_order());
	}

	// update search set (possible change of threading mode)
	if (!empty($_REQUEST['_search']) && isset($_SESSION['search'])
	&& $_SESSION['search_request'] == $_REQUEST['_search']
	) {
	$search_request = $_REQUEST['_search'];
	$_SESSION['search'] = $RCMAIL->storage->get_search_set();
	+ $multifolder = !empty($_SESSION['search']) && !empty($_SESSION['search'][1]->multi);
	}
	// remove old search data
	else if (empty($_REQUEST['_search']) && isset($_SESSION['search'])) {
	$RCMAIL->session->remove('search');
	}

	rcmail_list_pagetitle();

	// update mailboxlist
	if (empty($search_request)) {
	rcmail_send_unread_count($mbox_name, !empty($_REQUEST['_refresh']), empty($a_headers) ? 0 : null);
	}

	// update message count display
	$pages = ceil($count/$RCMAIL->storage->get_pagesize());
	$page = $count ? $RCMAIL->storage->get_page() : 1;
	$exists = $RCMAIL->storage->count($mbox_name, 'EXISTS', true);

	$OUTPUT->set_env('messagecount', $count);
	$OUTPUT->set_env('pagecount', $pages);
	$OUTPUT->set_env('threading', $threading);
	$OUTPUT->set_env('current_page', $page);
	$OUTPUT->set_env('exists', $exists);
	$OUTPUT->command('set_rowcount', rcmail_get_messagecount_text($count), $mbox_name);

	// remove old message rows if commanded by the client
	if (!empty($_REQUEST['_clear'])) {
	$OUTPUT->command('clear_message_list');
	}

	// add message rows
	rcmail_js_message_list($a_headers, false, $cols);

	if (isset($a_headers) && count($a_headers)) {
	- if ($search_request) {
	+ if (!empty($search_request)) {
	$OUTPUT->show_message('searchsuccessful', 'confirmation', array('nr' => $count));
	}

	// remember last HIGHESTMODSEQ value (if supported)
	// we need it for flag updates in check-recent
	$data = $RCMAIL->storage->folder_data($mbox_name);
	if (!empty($data['HIGHESTMODSEQ'])) {
	$_SESSION['list_mod_seq'] = $data['HIGHESTMODSEQ'];
	}
	}
	else {
	// handle IMAP errors (e.g. #1486905)
	if ($err_code = $RCMAIL->storage->get_error_code()) {
	$RCMAIL->display_server_error();
	}
	else if ($search_request) {
	$OUTPUT->show_message('searchnomatch', 'notice');
	}
	else {
	$OUTPUT->show_message('nomessagesfound', 'notice');
	}
	}

	// set trash folder state
	if ($mbox_name === $RCMAIL->config->get('trash_mbox')) {
	$OUTPUT->command('set_trash_count', $exists);
	}

	if ($page == 1) {
	- $OUTPUT->command('set_quota', $RCMAIL->quota_content(null, $multifolder ? 'INBOX' : $mbox_name));
	+ $OUTPUT->command('set_quota', $RCMAIL->quota_content(null, !empty($multifolder) ? 'INBOX' : $mbox_name));
	}

	// send response
	$OUTPUT->send();

File Metadata

Mime Type: text/x-diff
Expires: Fri, Jan 30, 11:36 PM (7 h, 17 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 426075
Default Alt Text: (870 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions