No OneTemporary
Actions

Size

147 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/program/include/rcmail.php b/program/include/rcmail.php
	index be44cf4cc..2708db559 100644
	--- a/program/include/rcmail.php
	+++ b/program/include/rcmail.php
	@@ -1,2557 +1,2557 @@
	<?php

	/**
	+-----------------------------------------------------------------------+
	\| program/include/rcmail.php \|
	\| \|
	\| This file is part of the Roundcube Webmail client \|
	\| Copyright (C) 2008-2014, The Roundcube Dev Team \|
	\| Copyright (C) 2011-2014, 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','dummy');

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

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

	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')) {
	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);

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

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

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

	// 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)) {
	$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 ($_SERVER['REMOTE_ADDR']) {
	$GLOBALS['OUTPUT'] = $this->load_gui(!empty($_REQUEST['_framed']));
	}

	// 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';
	}

	$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);

	$lang = $this->language_prop($this->config->get('language', $_SESSION['language']));
	$_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 (-1 for 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');

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

	// 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 === '0') {
	$contacts = new rcube_contacts($this->db, $this->get_user_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 = (string) $this->config->get('address_book_type');
	$ldap_config = (array) $this->config->get('ldap_public');
	$autocomplete = (array) $this->config->get('autocomplete_addressbooks');
	$list = array();

	// We are using the DB address book or a plugin address book
	if (!empty($abook_type) && strtolower($abook_type) != 'ldap') {
	if (!isset($this->address_books['0'])) {
	$this->address_books['0'] = new rcube_contacts($this->db, $this->get_user_id());
	}

	$list['0'] = array(
	'id' => '0',
	'name' => $this->gettext('personaladrbook'),
	'groups' => $this->address_books['0']->groups,
	'readonly' => $this->address_books['0']->readonly,
	'undelete' => $this->address_books['0']->undelete && $this->config->get('undo_timeout'),
	'autocomplete' => in_array('sql', $autocomplete),
	);
	}

	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'],
	'autocomplete' => in_array($id, $autocomplete)
	);
	}
	}

	$plugin = $this->plugins->exec_hook('addressbooks_list', array('sources' => $list));
	$list = $plugin['sources'];

	foreach ($list as $idx => $item) {
	// register source for shutdown function
	if (!is_object($this->address_books[$item['id']])) {
	$this->address_books[$item['id']] = $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', 'close', 'save', 'cancel',
	+ '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 (!$_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;
	}

	$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);
	$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 input for security (#1490500)
	if (($username_maxlen && strlen($username) > $username_maxlen)
	\|\| ($username_filter && !preg_match($username_filter, $username))
	\|\| ($password_maxlen && strlen($password) > $password_maxlen)
	) {
	$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);
	if ($a_host['host']) {
	$host = $a_host['host'];
	$ssl = (isset($a_host['scheme']) && in_array($a_host['scheme'], array('ssl','imaps','tls'))) ? $a_host['scheme'] : null;

	if (!empty($a_host['port']))
	$port = $a_host['port'];
	else if ($ssl && $ssl != 'tls' && (!$default_port \|\| $default_port == 143))
	$port = 993;
	}

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

	// 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;
	}
	}

	/**
	* 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 an 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));
	}

	$pre = array();
	$task = $p['_task'] ?: ($p['task'] ?: $this->task);
	$pre['_task'] = $task;
	unset($p['task'], $p['_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 = strval($_SERVER['REDIRECT_SCRIPT_URL'] ?: $_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')) {
	// 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 = $this->show_bytes(memory_get_usage());
	}
	if (function_exists('memory_get_peak_usage')) {
	$mem .= '/'.$this->show_bytes(memory_get_peak_usage());
	}

	$log = $this->task . ($this->action ? '/'.$this->action : '') . ($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);
	}

	// check referer if configured
	if ($this->config->get('referer_check') && !rcube_utils::check_referer()) {
	$error = array('code' => 403, 'message' => "Referer check failed");
	self::raise_error($error, true, 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);
	}
	}
	}

	/**
	* 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;
	}

	// 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);
	}

	/**
	* 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 ($stz) {
	date_default_timezone_set($stz);
	}
	return $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 ($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 ($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';
	unset($attrib['type']);

	if ($type == 'ul' && !$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();

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

	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']) {
	$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']);
	}
	else {
	$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('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);
	}

	$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) {
	$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', 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' => join(' ', $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']))) {
	$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;
	}

	/**
	* Return internal name for the given folder if it matches the configured special folders
	*/
	public function folder_classname($folder_id)
	{
	if ($folder_id == 'INBOX') {
	return 'inbox';
	}

	// for these mailboxes we have localized labels and css classes
	foreach (array('sent', 'drafts', 'trash', 'junk') as $smbx)
	{
	if ($folder_id === $this->config->get($smbx.'_mbox')) {
	return $smbx;
	}
	}
	}

	/**
	* 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))) {
	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));
	if ($folder_class = $this->folder_classname($folder)) {
	$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']) {
	$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']) {
	$quota_result['width'] = $attrib['width'];
	}
	if ($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 ($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');
	}
	}

	/**
	* 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;

	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' => $this->output->get_skin_path(),
	'spellcheck' => $spellcheck, // deprecated
	'spelldict' => $spelldict,
	'disabled_plugins' => $hook['disabled_plugins'],
	'disabled_buttons' => $hook['disabled_buttons'],
	'extra_plugins' => $hook['extra_plugins'],
	'extra_buttons' => $hook['extra_buttons'],
	);

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

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

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

	/**
	* File upload progress handler.
	*/
	public function upload_progress()
	{
	$params = array(
	'action' => $this->action,
	'name' => rcube_utils::get_input_value('_progress', rcube_utils::INPUT_GET),
	);

	if (function_exists('uploadprogress_get_info')) {
	$status = uploadprogress_get_info($params['name']);

	if (!empty($status)) {
	$params['current'] = $status['bytes_uploaded'];
	$params['total'] = $status['bytes_total'];
	}
	}

	if (!isset($status) && filter_var(ini_get('apc.rfc1867'), FILTER_VALIDATE_BOOLEAN)
	&& ini_get('apc.rfc1867_name')
	) {
	$prefix = ini_get('apc.rfc1867_prefix');
	$status = apc_fetch($prefix . $params['name']);

	if (!empty($status)) {
	$params['current'] = $status['current'];
	$params['total'] = $status['total'];
	}
	}

	if (!isset($status) && filter_var(ini_get('session.upload_progress.enabled'), FILTER_VALIDATE_BOOLEAN)
	&& ini_get('session.upload_progress.name')
	) {
	$key = ini_get('session.upload_progress.prefix') . $params['name'];

	$params['total'] = $_SESSION[$key]['content_length'];
	$params['current'] = $_SESSION[$key]['bytes_processed'];
	}

	if (!empty($params['total'])) {
	$total = $this->show_bytes($params['total'], $unit);
	switch ($unit) {
	case 'GB':
	$gb = $params['current']/1073741824;
	$current = sprintf($gb >= 10 ? "%d" : "%.1f", $gb);
	break;
	case 'MB':
	$mb = $params['current']/1048576;
	$current = sprintf($mb >= 10 ? "%d" : "%.1f", $mb);
	break;
	case 'KB':
	$current = round($params['current']/1024);
	break;
	case 'B':
	default:
	$current = $params['current'];
	break;
	}

	$params['percent'] = round($params['current']/$params['total']*100);
	$params['text'] = $this->gettext(array(
	'name' => 'uploadprogress',
	'vars' => array(
	'percent' => $params['percent'] . '%',
	'current' => $current,
	'total' => $total
	)
	));
	}

	$this->output->command('upload_progress_update', $params);
	$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)
	{
	// Enable upload progress bar
	if ($seconds = $this->config->get('upload_progress')) {
	if (function_exists('uploadprogress_get_info')) {
	$field_name = 'UPLOAD_IDENTIFIER';
	}
	if (!$field_name && filter_var(ini_get('apc.rfc1867'), FILTER_VALIDATE_BOOLEAN)) {
	$field_name = ini_get('apc.rfc1867_name');
	}
	if (!$field_name && filter_var(ini_get('session.upload_progress.enabled'), FILTER_VALIDATE_BOOLEAN)) {
	$field_name = ini_get('session.upload_progress.name');
	}

	if ($field_name) {
	$this->output->set_env('upload_progress_name', $field_name);
	$this->output->set_env('upload_progress_time', (int) $seconds);
	}
	}

	// 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))));
	}

	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
	*
	* @return string HTML output
	*/
	public function upload_form($attrib, $name, $action, $input_attr = array())
	{
	// Get filesize, enable upload progress bar
	$max_filesize = $this->upload_init();

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

	if ($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[]',
	);

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

	if ($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') {
	$content = html::div(null, $content);
	$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'])) {
	$temp_dir = $this->config->get('temp_dir');
	$thumbnail_size = 80;
	$mimetype = $file['mimetype'];
	$file_ident = $file['id'] . ':' . $file['mimetype'] . ':' . $file['size'];
	$cache_basename = $temp_dir . '/' . md5($file_ident . ':' . $this->user->ID . ':' . $thumbnail_size);
	$cache_file = $cache_basename . '.thumb';

	// render thumbnail image if not done yet
	if (!is_file($cache_file)) {
	if (!$file['path']) {
	$orig_name = $filename = $cache_basename . '.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 ($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));

	$unit = $plugin['unit'];

	if ($plugin['result'] !== null) {
	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/steps/mail/compose.inc b/program/steps/mail/compose.inc
	index 775f6160c..6488ebeb0 100644
	--- a/program/steps/mail/compose.inc
	+++ b/program/steps/mail/compose.inc
	@@ -1,1377 +1,1377 @@
	<?php

	/**
	+-----------------------------------------------------------------------+
	\| program/steps/mail/compose.inc \|
	\| \|
	\| This file is part of the Roundcube Webmail client \|
	\| Copyright (C) 2005-2017, 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: \|
	\| Compose a new mail message with all headers and attachments \|
	\| \|
	+-----------------------------------------------------------------------+
	\| Author: Thomas Bruederli <roundcube@gmail.com> \|
	+-----------------------------------------------------------------------+
	*/

	$COMPOSE_ID = rcube_utils::get_input_value('_id', rcube_utils::INPUT_GET);
	$COMPOSE = null;

	if ($COMPOSE_ID && $_SESSION['compose_data_'.$COMPOSE_ID]) {
	$COMPOSE =& $_SESSION['compose_data_'.$COMPOSE_ID];
	}

	// give replicated session storage some time to synchronize
	$retries = 0;
	while ($COMPOSE_ID && !is_array($COMPOSE) && $RCMAIL->db->is_replicated() && $retries++ < 5) {
	usleep(500000);
	$RCMAIL->session->reload();
	if ($_SESSION['compose_data_'.$COMPOSE_ID]) {
	$COMPOSE =& $_SESSION['compose_data_'.$COMPOSE_ID];
	}
	}

	// Nothing below is called during message composition, only at "new/forward/reply/draft" initialization or
	// if a compose-ID is given (i.e. when the compose step is opened in a new window/tab).
	if (!is_array($COMPOSE)) {
	// Infinite redirect prevention in case of broken session (#1487028)
	if ($COMPOSE_ID) {
	// if we know the message with specified ID was already sent
	// we can ignore the error and compose a new message (#1490009)
	if ($COMPOSE_ID != $_SESSION['last_compose_session']) {
	rcube::raise_error(array('code' => 450), false, true);
	}
	}

	$COMPOSE_ID = uniqid(mt_rand());
	$params = rcube_utils::request2param(rcube_utils::INPUT_GET, 'task\|action', true);

	$_SESSION['compose_data_'.$COMPOSE_ID] = array(
	'id' => $COMPOSE_ID,
	'param' => $params,
	'mailbox' => $params['mbox'] ?: $RCMAIL->storage->get_folder(),
	);
	$COMPOSE =& $_SESSION['compose_data_'.$COMPOSE_ID];
	rcmail_process_compose_params($COMPOSE);

	// check if folder for saving sent messages exists and is subscribed (#1486802)
	if ($sent_folder = $COMPOSE['param']['sent_mbox']) {
	rcmail_sendmail::check_sent_folder($sent_folder, true);
	}

	// redirect to a unique URL with all parameters stored in session
	$OUTPUT->redirect(array(
	'_action' => 'compose',
	'_id' => $COMPOSE['id'],
	'_search' => $_REQUEST['_search'],
	));
	}


	// add some labels to client
	$OUTPUT->add_label('notuploadedwarning', 'savingmessage', 'siginserted', 'responseinserted',
	- 'messagesaved', 'converting', 'editorwarning', 'uploading', 'uploadingmany',
	+ 'messagesaved', 'converting', 'editorwarning', 'discard',
	'fileuploaderror', 'sendmessage', 'newresponse', 'responsename', 'responsetext', 'save',
	'savingresponse', 'restoresavedcomposedata', 'restoremessage', 'delete', 'restore', 'ignore',
	'selectimportfile', 'messageissent', 'loadingdata', 'nopubkeyfor', 'nopubkeyforsender',
	'encryptnoattachments','encryptedsendialog','searchpubkeyservers', 'importpubkeys',
	'encryptpubkeysfound', 'search', 'close', 'import', 'keyid', 'keylength', 'keyexpired',
	- 'keyrevoked', 'keyimportsuccess', 'keyservererror', 'attaching', 'namex', 'attachmentrename', 'discard'
	+ 'keyrevoked', 'keyimportsuccess', 'keyservererror', 'attaching', 'namex', 'attachmentrename'
	);

	$OUTPUT->set_pagetitle($RCMAIL->gettext('compose'));

	$OUTPUT->set_env('compose_id', $COMPOSE['id']);
	$OUTPUT->set_env('session_id', session_id());
	$OUTPUT->set_env('mailbox', $RCMAIL->storage->get_folder());
	$OUTPUT->set_env('top_posting', intval($RCMAIL->config->get('reply_mode')) > 0);
	$OUTPUT->set_env('sig_below', $RCMAIL->config->get('sig_below'));
	$OUTPUT->set_env('save_localstorage', (bool)$RCMAIL->config->get('compose_save_localstorage'));
	$OUTPUT->set_env('is_sent', false);
	$OUTPUT->set_env('mimetypes', rcmail_supported_mimetypes());

	$drafts_mbox = $RCMAIL->config->get('drafts_mbox');
	$config_show_sig = $RCMAIL->config->get('show_sig', 1);

	// add config parameters to client script
	if (strlen($drafts_mbox)) {
	$OUTPUT->set_env('drafts_mailbox', $drafts_mbox);
	$OUTPUT->set_env('draft_autosave', $RCMAIL->config->get('draft_autosave'));
	}

	// default font for HTML editor
	$font = rcmail::font_defs($RCMAIL->config->get('default_font'));
	if ($font && !is_array($font)) {
	$OUTPUT->set_env('default_font', $font);
	}

	// default font size for HTML editor
	if ($font_size = $RCMAIL->config->get('default_font_size')) {
	$OUTPUT->set_env('default_font_size', $font_size);
	}

	// get reference message and set compose mode
	if ($msg_uid = $COMPOSE['param']['draft_uid']) {
	$compose_mode = rcmail_sendmail::MODE_DRAFT;
	$OUTPUT->set_env('draft_id', $msg_uid);
	$RCMAIL->storage->set_folder($drafts_mbox);
	}
	else if ($msg_uid = $COMPOSE['param']['reply_uid']) {
	$compose_mode = rcmail_sendmail::MODE_REPLY;
	}
	else if ($msg_uid = $COMPOSE['param']['forward_uid']) {
	$compose_mode = rcmail_sendmail::MODE_FORWARD;
	$COMPOSE['forward_uid'] = $msg_uid;
	$COMPOSE['as_attachment'] = !empty($COMPOSE['param']['attachment']);
	}
	else if ($msg_uid = $COMPOSE['param']['uid']) {
	$compose_mode = rcmail_sendmail::MODE_EDIT;
	}

	if ($compose_mode) {
	$COMPOSE['mode'] = $compose_mode;
	$OUTPUT->set_env('compose_mode', $compose_mode);
	}

	if ($compose_mode == rcmail_sendmail::MODE_EDIT \|\| $compose_mode == rcmail_sendmail::MODE_DRAFT) {
	// don't add signature in draft/edit mode, we'll also not remove the old-one
	// but only on page display, later we should be able to change identity/sig (#1489229)
	if ($config_show_sig == 1 \|\| $config_show_sig == 2) {
	$OUTPUT->set_env('show_sig_later', true);
	}
	}
	else if ($config_show_sig == 1)
	$OUTPUT->set_env('show_sig', true);
	else if ($config_show_sig == 2 && empty($compose_mode))
	$OUTPUT->set_env('show_sig', true);
	else if ($config_show_sig == 3 && ($compose_mode == rcmail_sendmail::MODE_REPLY \|\| $compose_mode == rcmail_sendmail::MODE_FORWARD))
	$OUTPUT->set_env('show_sig', true);

	// set line length for body wrapping
	$LINE_LENGTH = $RCMAIL->config->get('line_length', 72);

	if (!empty($msg_uid) && empty($COMPOSE['as_attachment'])) {
	$mbox_name = $RCMAIL->storage->get_folder();

	// set format before rcube_message construction
	// use the same format as for the message view
	if (isset($_SESSION['msg_formats'][$mbox_name.':'.$msg_uid])) {
	$RCMAIL->config->set('prefer_html', $_SESSION['msg_formats'][$mbox_name.':'.$msg_uid]);
	}
	else {
	$prefer_html = $RCMAIL->config->get('prefer_html') \|\| $RCMAIL->config->get('htmleditor')
	\|\| $compose_mode == rcmail_sendmail::MODE_DRAFT \|\| $compose_mode == rcmail_sendmail::MODE_EDIT;

	$RCMAIL->config->set('prefer_html', $prefer_html);
	}

	$MESSAGE = new rcube_message($msg_uid);

	// make sure message is marked as read
	if ($MESSAGE->headers && $MESSAGE->context === null && empty($MESSAGE->headers->flags['SEEN'])) {
	$RCMAIL->storage->set_flag($msg_uid, 'SEEN');
	}

	if (!empty($MESSAGE->headers->charset)) {
	$RCMAIL->storage->set_charset($MESSAGE->headers->charset);
	}

	if (!$MESSAGE->headers) {
	// error
	}
	else if ($compose_mode == rcmail_sendmail::MODE_FORWARD \|\| $compose_mode == rcmail_sendmail::MODE_REPLY) {
	if ($compose_mode == rcmail_sendmail::MODE_REPLY) {
	$COMPOSE['reply_uid'] = $MESSAGE->context === null ? $msg_uid : null;

	if (!empty($COMPOSE['param']['all'])) {
	$MESSAGE->reply_all = $COMPOSE['param']['all'];
	}
	}
	else {
	$COMPOSE['forward_uid'] = $msg_uid;
	}

	$COMPOSE['reply_msgid'] = $MESSAGE->headers->messageID;
	$COMPOSE['references'] = trim($MESSAGE->headers->references . " " . $MESSAGE->headers->messageID);

	// Save the sent message in the same folder of the message being replied to
	if ($RCMAIL->config->get('reply_same_folder') && ($sent_folder = $COMPOSE['mailbox'])
	&& rcmail_sendmail::check_sent_folder($sent_folder, false)
	) {
	$COMPOSE['param']['sent_mbox'] = $sent_folder;
	}
	}
	else if ($compose_mode == rcmail_sendmail::MODE_DRAFT \|\| $compose_mode == rcmail_sendmail::MODE_EDIT) {
	if ($compose_mode == rcmail_sendmail::MODE_DRAFT) {
	if ($draft_info = $MESSAGE->headers->get('x-draft-info')) {
	// get reply_uid/forward_uid to flag the original message when sending
	$info = rcmail_sendmail::draftinfo_decode($draft_info);

	if ($info['type'] == 'reply')
	$COMPOSE['reply_uid'] = $info['uid'];
	else if ($info['type'] == 'forward')
	$COMPOSE['forward_uid'] = $info['uid'];

	$COMPOSE['mailbox'] = $info['folder'];

	// Save the sent message in the same folder of the message being replied to
	if ($RCMAIL->config->get('reply_same_folder') && ($sent_folder = $info['folder'])
	&& rcmail_sendmail::check_sent_folder($sent_folder, false)
	) {
	$COMPOSE['param']['sent_mbox'] = $sent_folder;
	}
	}

	$COMPOSE['param']['message-id'] = $MESSAGE->headers->get('message-id');

	// use message UID as draft_id
	$OUTPUT->set_env('draft_id', $msg_uid);
	}

	if ($in_reply_to = $MESSAGE->headers->get('in-reply-to')) {
	$COMPOSE['reply_msgid'] = '<' . $in_reply_to . '>';
	}

	$COMPOSE['references'] = $MESSAGE->headers->references;
	}
	}
	else {
	$MESSAGE = new stdClass();

	// apply mailto: URL parameters
	if (!empty($COMPOSE['param']['in-reply-to'])) {
	$COMPOSE['reply_msgid'] = '<' . $COMPOSE['param']['in-reply-to'] . '>';
	}

	if (!empty($COMPOSE['param']['references'])) {
	$COMPOSE['references'] = $COMPOSE['param']['references'];
	}
	}

	if (!empty($COMPOSE['reply_msgid'])) {
	$OUTPUT->set_env('reply_msgid', $COMPOSE['reply_msgid']);
	}

	// Initialize helper class to build the UI
	$SENDMAIL = new rcmail_sendmail($COMPOSE, array('message' => $MESSAGE));

	// process $MESSAGE body/attachments, set $MESSAGE_BODY/$HTML_MODE vars and some session data
	$MESSAGE_BODY = rcmail_prepare_message_body();

	// register UI objects (Note: some objects are registered by rcmail_sendmail above)
	$OUTPUT->add_handlers(array(
	'composebody' => 'rcmail_compose_body',
	'composeattachmentlist' => 'rcmail_compose_attachment_list',
	'composeattachmentform' => 'rcmail_compose_attachment_form',
	'composeattachment' => 'rcmail_compose_attachment_field',
	'filedroparea' => 'rcmail_compose_file_drop_area',
	'editorselector' => 'rcmail_editor_selector',
	'addressbooks' => 'rcmail_addressbook_list',
	'addresslist' => 'rcmail_contacts_list',
	'responseslist' => 'rcmail_compose_responses_list',
	));

	$OUTPUT->include_script('publickey.js');

	$OUTPUT->send('compose');


	/**** compose mode functions ******/

	// process compose request parameters
	function rcmail_process_compose_params(&$COMPOSE)
	{
	if ($COMPOSE['param']['to']) {
	$mailto = explode('?', $COMPOSE['param']['to'], 2);

	// #1486037: remove "mailto:" prefix
	$COMPOSE['param']['to'] = preg_replace('/^mailto:/i', '', $mailto[0]);
	// #1490346: decode the recipient address
	// #1490510: use raw encoding for correct "+" character handling as specified in RFC6068
	$COMPOSE['param']['to'] = rawurldecode($COMPOSE['param']['to']);

	// Supported case-insensitive tokens in mailto URL
	$url_tokens = array('to', 'cc', 'bcc', 'reply-to', 'in-reply-to', 'references', 'subject', 'body');

	if (!empty($mailto[1])) {
	parse_str($mailto[1], $query);
	foreach ($query as $f => $val) {
	if (($key = array_search(strtolower($f), $url_tokens)) !== false) {
	$f = $url_tokens[$key];
	}

	// merge mailto: addresses with addresses from 'to' parameter
	if ($f == 'to' && !empty($COMPOSE['param']['to'])) {
	$to_addresses = rcube_mime::decode_address_list($COMPOSE['param']['to'], null, true, null, true);
	$add_addresses = rcube_mime::decode_address_list($val, null, true);

	foreach ($add_addresses as $addr) {
	if (!in_array($addr['mailto'], $to_addresses)) {
	$to_addresses[] = $addr['mailto'];
	$COMPOSE['param']['to'] = (!empty($to_addresses) ? ', ' : '') . $addr['string'];
	}
	}
	}
	else {
	$COMPOSE['param'][$f] = $val;
	}
	}
	}
	}

	// resolve _forward_uid=* to an absolute list of messages from a search result
	if ($COMPOSE['param']['forward_uid'] == '*' && is_object($_SESSION['search'][1])) {
	$COMPOSE['param']['forward_uid'] = $_SESSION['search'][1]->get();
	}

	// clean HTML message body which can be submitted by URL
	if (!empty($COMPOSE['param']['body'])) {
	if ($COMPOSE['param']['html'] = strpos($COMPOSE['param']['body'], '<') !== false) {
	$wash_params = array('safe' => false, 'inline_html' => true);
	$COMPOSE['param']['body'] = rcmail_wash_html($COMPOSE['param']['body'], $wash_params, array());
	$COMPOSE['param']['body'] = preg_replace('/<!--[^>\n]+>/', '', $COMPOSE['param']['body']);
	$COMPOSE['param']['body'] = preg_replace('/<\/?body>/', '', $COMPOSE['param']['body']);
	}
	}

	$RCMAIL = rcmail::get_instance();

	// select folder where to save the sent message
	$COMPOSE['param']['sent_mbox'] = $RCMAIL->config->get('sent_mbox');

	// pipe compose parameters thru plugins
	$plugin = $RCMAIL->plugins->exec_hook('message_compose', $COMPOSE);
	$COMPOSE['param'] = array_merge($COMPOSE['param'], $plugin['param']);

	// add attachments listed by message_compose hook
	if (is_array($plugin['attachments'])) {
	foreach ($plugin['attachments'] as $attach) {
	// we have structured data
	if (is_array($attach)) {
	$attachment = $attach + array('group' => $COMPOSE_ID);
	}
	// only a file path is given
	else {
	$filename = basename($attach);
	$attachment = array(
	'group' => $COMPOSE_ID,
	'name' => $filename,
	'mimetype' => rcube_mime::file_content_type($attach, $filename),
	'size' => filesize($attach),
	'path' => $attach,
	);
	}

	// save attachment if valid
	if (($attachment['data'] && $attachment['name']) \|\| ($attachment['path'] && file_exists($attachment['path']))) {
	$attachment = rcmail::get_instance()->plugins->exec_hook('attachment_save', $attachment);
	}

	if ($attachment['status'] && !$attachment['abort']) {
	unset($attachment['data'], $attachment['status'], $attachment['abort']);
	$COMPOSE['attachments'][$attachment['id']] = $attachment;
	}
	}
	}
	}

	function rcmail_compose_editor_mode()
	{
	global $RCMAIL, $COMPOSE;
	static $useHtml;

	if ($useHtml !== null) {
	return $useHtml;
	}

	$html_editor = intval($RCMAIL->config->get('htmleditor'));
	$compose_mode = $COMPOSE['mode'];

	if (is_bool($COMPOSE['param']['html'])) {
	$useHtml = $COMPOSE['param']['html'];
	}
	else if (isset($_POST['_is_html'])) {
	$useHtml = !empty($_POST['_is_html']);
	}
	else if ($compose_mode == rcmail_sendmail::MODE_DRAFT \|\| $compose_mode == rcmail_sendmail::MODE_EDIT) {
	$useHtml = rcmail_message_is_html();
	}
	else if ($compose_mode == rcmail_sendmail::MODE_REPLY) {
	$useHtml = $html_editor == 1 \|\| ($html_editor >= 2 && rcmail_message_is_html());
	}
	else if ($compose_mode == rcmail_sendmail::MODE_FORWARD) {
	$useHtml = $html_editor == 1 \|\| $html_editor == 4
	\|\| ($html_editor == 3 && rcmail_message_is_html());
	}
	else {
	$useHtml = $html_editor == 1 \|\| $html_editor == 4;
	}

	return $useHtml;
	}

	function rcmail_message_is_html()
	{
	global $RCMAIL, $MESSAGE;

	return $RCMAIL->config->get('prefer_html') && ($MESSAGE instanceof rcube_message) && $MESSAGE->has_html_part(true);
	}

	function rcmail_prepare_message_body()
	{
	global $RCMAIL, $MESSAGE, $COMPOSE, $HTML_MODE;

	// use posted message body
	if (!empty($_POST['_message'])) {
	$body = rcube_utils::get_input_value('_message', rcube_utils::INPUT_POST, true);
	$isHtml = (bool) rcube_utils::get_input_value('_is_html', rcube_utils::INPUT_POST);
	}
	else if ($COMPOSE['param']['body']) {
	$body = $COMPOSE['param']['body'];
	$isHtml = (bool) $COMPOSE['param']['html'];
	}
	// forward as attachment
	else if ($COMPOSE['mode'] == rcmail_sendmail::MODE_FORWARD && $COMPOSE['as_attachment']) {
	$isHtml = rcmail_compose_editor_mode();
	$body = '';

	rcmail_write_forward_attachments();
	}
	// reply/edit/draft/forward
	else if ($COMPOSE['mode'] && ($COMPOSE['mode'] != rcmail_sendmail::MODE_REPLY \|\| intval($RCMAIL->config->get('reply_mode')) != -1)) {
	$isHtml = rcmail_compose_editor_mode();
	$messages = array();

	if (!empty($MESSAGE->parts)) {
	// collect IDs of message/rfc822 parts
	foreach ($MESSAGE->mime_parts() as $part) {
	if ($part->mimetype == 'message/rfc822') {
	$messages[] = $part->mime_id;
	}
	}

	foreach ($MESSAGE->parts as $part) {
	if ($part->realtype == 'multipart/encrypted') {
	// find the encrypted message payload part
	if ($pgp_mime_part = $MESSAGE->get_multipart_encrypted_part()) {
	$RCMAIL->output->set_env('pgp_mime_message', array(
	'_mbox' => $RCMAIL->storage->get_folder(),
	'_uid' => $MESSAGE->uid,
	'_part' => $pgp_mime_part->mime_id,
	));
	}
	continue;
	}

	// skip no-content and attachment parts (#1488557)
	if ($part->type != 'content' \|\| !$part->size \|\| $MESSAGE->is_attachment($part)) {
	continue;
	}

	// skip all content parts inside the message/rfc822 part
	foreach ($messages as $mimeid) {
	if (strpos($part->mime_id, $mimeid . '.') === 0) {
	continue 2;
	}
	}

	if ($part_body = rcmail_compose_part_body($part, $isHtml)) {
	$body .= ($body ? ($isHtml ? '<br/>' : "\n") : '') . $part_body;
	}
	}
	}
	else {
	$body = rcmail_compose_part_body($MESSAGE, $isHtml);
	}

	// compose reply-body
	if ($COMPOSE['mode'] == rcmail_sendmail::MODE_REPLY) {
	$body = rcmail_create_reply_body($body, $isHtml);

	if ($MESSAGE->pgp_mime) {
	$RCMAIL->output->set_env('compose_reply_header', rcmail_get_reply_header($MESSAGE));
	}
	}
	// forward message body inline
	else if ($COMPOSE['mode'] == rcmail_sendmail::MODE_FORWARD) {
	$body = rcmail_create_forward_body($body, $isHtml);
	}
	// load draft message body
	else if ($COMPOSE['mode'] == rcmail_sendmail::MODE_DRAFT \|\| $COMPOSE['mode'] == rcmail_sendmail::MODE_EDIT) {
	$body = rcmail_create_draft_body($body, $isHtml);
	}
	}
	else { // new message
	$isHtml = rcmail_compose_editor_mode();
	}

	$plugin = $RCMAIL->plugins->exec_hook('message_compose_body',
	array('body' => $body, 'html' => $isHtml, 'mode' => $COMPOSE['mode']));

	$body = $plugin['body'];
	unset($plugin);

	// add blocked.gif attachment (#1486516)
	$regexp = '# src="program/resources/blocked\.gif"#';
	if ($isHtml && preg_match($regexp, $body)) {
	$content = $RCMAIL->get_resource_content('blocked.gif');

	if ($content && ($attachment = rcmail_save_image('blocked.gif', 'image/gif', $content))) {
	$COMPOSE['attachments'][$attachment['id']] = $attachment;
	$url = sprintf('%s&_id=%s&_action=display-attachment&_file=rcmfile%s',
	$RCMAIL->comm_path, $COMPOSE['id'], $attachment['id']);
	$body = preg_replace($regexp, ' src="' . $url . '"', $body);
	}
	}

	$HTML_MODE = $isHtml;

	return $body;
	}

	function rcmail_compose_part_body($part, $isHtml = false)
	{
	global $RCMAIL, $COMPOSE, $MESSAGE, $LINE_LENGTH;

	// Check if we have enough memory to handle the message in it
	// #1487424: we need up to 10x more memory than the body
	if (!rcube_utils::mem_check($part->size * 10)) {
	return '';
	}

	// fetch part if not available
	$body = $MESSAGE->get_part_body($part->mime_id, true);

	// message is cached but not exists (#1485443), or other error
	if ($body === false) {
	return '';
	}

	// register this part as pgp encrypted
	if (strpos($body, '-----BEGIN PGP MESSAGE-----') !== false) {
	$MESSAGE->pgp_mime = true;
	$RCMAIL->output->set_env('pgp_mime_message', array(
	'_mbox' => $RCMAIL->storage->get_folder(), '_uid' => $MESSAGE->uid, '_part' => $part->mime_id,
	));
	}

	if ($isHtml) {
	if ($part->ctype_secondary == 'html') {
	}
	else if ($part->ctype_secondary == 'enriched') {
	$body = rcube_enriched::to_html($body);
	}
	else {
	// try to remove the signature
	if ($COMPOSE['mode'] != rcmail_sendmail::MODE_DRAFT && $COMPOSE['mode'] != rcmail_sendmail::MODE_EDIT) {
	if ($RCMAIL->config->get('strip_existing_sig', true)) {
	$body = rcmail_remove_signature($body);
	}
	}

	// add HTML formatting
	$body = rcmail_plain_body($body, $part->ctype_parameters['format'] == 'flowed', $part->ctype_parameters['delsp'] == 'yes');
	}
	}
	else {
	if ($part->ctype_secondary == 'enriched') {
	$body = rcube_enriched::to_html($body);
	$part->ctype_secondary = 'html';
	}

	if ($part->ctype_secondary == 'html') {
	// use html part if it has been used for message (pre)viewing
	// decrease line length for quoting
	$len = $COMPOSE['mode'] == rcmail_sendmail::MODE_REPLY ? $LINE_LENGTH-2 : $LINE_LENGTH;
	$body = $RCMAIL->html2text($body, array('width' => $len));
	}
	else {
	if ($part->ctype_secondary == 'plain' && $part->ctype_parameters['format'] == 'flowed') {
	$body = rcube_mime::unfold_flowed($body, null, $part->ctype_parameters['delsp'] == 'yes');
	}

	// try to remove the signature
	if ($COMPOSE['mode'] != rcmail_sendmail::MODE_DRAFT && $COMPOSE['mode'] != rcmail_sendmail::MODE_EDIT) {
	if ($RCMAIL->config->get('strip_existing_sig', true)) {
	$body = rcmail_remove_signature($body);
	}
	}
	}
	}

	return $body;
	}

	function rcmail_compose_body($attrib)
	{
	global $RCMAIL, $OUTPUT, $HTML_MODE, $MESSAGE_BODY, $SENDMAIL;

	list($form_start, $form_end) = $SENDMAIL->form_tags($attrib);
	unset($attrib['form']);

	if (empty($attrib['id'])) {
	$attrib['id'] = 'rcmComposeBody';
	}

	// If desired, set this textarea to be editable by TinyMCE
	$attrib['data-html-editor'] = true;
	if ($HTML_MODE) {
	$attrib['class'] = trim($attrib['class'] . ' mce_editor');
	}

	$attrib['name'] = '_message';

	$textarea = new html_textarea($attrib);
	$hidden = new html_hiddenfield();

	$hidden->add(array('name' => '_draft_saveid', 'value' => $RCMAIL->output->get_env('draft_id')));
	$hidden->add(array('name' => '_draft', 'value' => ''));
	$hidden->add(array('name' => '_is_html', 'value' => $HTML_MODE ? "1" : "0"));
	$hidden->add(array('name' => '_framed', 'value' => '1'));

	$OUTPUT->set_env('composebody', $attrib['id']);

	// include HTML editor
	$RCMAIL->html_editor();

	// Set language list
	if ($RCMAIL->config->get('enable_spellcheck')) {
	$engine = new rcube_spellchecker();
	$dictionary = (bool) $RCMAIL->config->get('spellcheck_dictionary');
	$spellcheck_langs = $engine->languages();
	$lang = $_SESSION['language'];

	// if not found in the list, try with two-letter code
	if (!$spellcheck_langs[$lang]) {
	$lang = strtolower(substr($lang, 0, 2));
	}

	if (!$spellcheck_langs[$lang]) {
	$lang = 'en';
	}

	$editor_lang_set = array();
	foreach ($spellcheck_langs as $key => $name) {
	$editor_lang_set[] = ($key == $lang ? '+' : '') . rcube::JQ($name).'='.rcube::JQ($key);
	}

	// include GoogieSpell
	$OUTPUT->include_script('googiespell.js');
	$OUTPUT->add_script(sprintf(
	"var googie = new GoogieSpell('%s/images/googiespell/','%s&lang=', %s);\n".
	"googie.lang_chck_spell = \"%s\";\n".
	"googie.lang_rsm_edt = \"%s\";\n".
	"googie.lang_close = \"%s\";\n".
	"googie.lang_revert = \"%s\";\n".
	"googie.lang_no_error_found = \"%s\";\n".
	"googie.lang_learn_word = \"%s\";\n".
	"googie.setLanguages(%s);\n".
	"googie.setCurrentLanguage('%s');\n".
	"googie.setDecoration(false);\n".
	"googie.decorateTextarea('%s');\n",
	$RCMAIL->output->asset_url($RCMAIL->output->get_skin_path()),
	$RCMAIL->url(array('_task' => 'utils', '_action' => 'spell', '_remote' => 1)),
	!empty($dictionary) ? 'true' : 'false',
	rcube::JQ(rcube::Q($RCMAIL->gettext('checkspelling'))),
	rcube::JQ(rcube::Q($RCMAIL->gettext('resumeediting'))),
	rcube::JQ(rcube::Q($RCMAIL->gettext('close'))),
	rcube::JQ(rcube::Q($RCMAIL->gettext('revertto'))),
	rcube::JQ(rcube::Q($RCMAIL->gettext('nospellerrors'))),
	rcube::JQ(rcube::Q($RCMAIL->gettext('addtodict'))),
	rcube_output::json_serialize($spellcheck_langs),
	$lang,
	$attrib['id']), 'foot');

	$OUTPUT->add_label('checking');
	$OUTPUT->set_env('spellcheck_langs', join(',', $editor_lang_set));
	$OUTPUT->set_env('spell_langs', $spellcheck_langs);
	$OUTPUT->set_env('spell_lang', $lang);
	}

	return ($form_start ? "$form_start\n" : '')
	. "\n" . $hidden->show() . "\n" . $textarea->show($MESSAGE_BODY)
	. ($form_end ? "\n$form_end\n" : '');
	}

	function rcmail_create_reply_body($body, $bodyIsHtml)
	{
	global $RCMAIL, $MESSAGE, $LINE_LENGTH;

	$reply_mode = (int) $RCMAIL->config->get('reply_mode');
	$reply_indent = $reply_mode != 2;

	// In top-posting without quoting it's better to use multi-line header
	if ($reply_mode == 2) {
	$prefix = rcmail_get_forward_header($MESSAGE, $bodyIsHtml, false);
	}
	else {
	$prefix = rcmail_get_reply_header($MESSAGE);
	if ($bodyIsHtml) {
	$prefix = '<p id="reply-intro">' . rcube::Q($prefix) . '</p>';
	}
	else {
	$prefix .= "\n";
	}
	}

	if (!$bodyIsHtml) {
	// soft-wrap and quote message text
	$body = rcmail_wrap_and_quote($body, $LINE_LENGTH, $reply_indent);

	if ($reply_mode > 0) { // top-posting
	$prefix = "\n\n\n" . $prefix;
	$suffix = '';
	}
	else {
	$suffix = "\n";
	}
	}
	else {
	// save inline images to files
	$cid_map = rcmail_write_inline_attachments($MESSAGE);
	// set is_safe flag (we need this for html body washing)
	rcmail_check_safe($MESSAGE);
	// clean up html tags
	$body = rcmail_wash_html($body, array('safe' => $MESSAGE->is_safe), $cid_map);

	$suffix = '';

	if ($reply_indent) {
	$prefix .= '<blockquote>';
	$suffix .= '</blockquote>';
	}

	if ($reply_mode == 2) {
	// top-posting, no indent
	}
	else if ($reply_mode > 0) {
	// top-posting
	$prefix = '<br>' . $prefix;
	}
	else {
	$suffix .= '<p><br/></p>';
	}
	}

	return $prefix . $body . $suffix;
	}

	function rcmail_get_reply_header($message)
	{
	global $RCMAIL;

	$from = array_pop(rcube_mime::decode_address_list($message->get_header('from'), 1, false, $message->headers->charset));
	return $RCMAIL->gettext(array(
	'name' => 'mailreplyintro',
	'vars' => array(
	'date' => $RCMAIL->format_date($message->headers->date, $RCMAIL->config->get('date_long')),
	'sender' => $from['name'] ?: rcube_utils::idn_to_utf8($from['mailto']),
	)
	));
	}

	function rcmail_create_forward_body($body, $bodyIsHtml)
	{
	global $RCMAIL, $MESSAGE, $COMPOSE;

	// add attachments
	if (!isset($COMPOSE['forward_attachments']) && is_array($MESSAGE->mime_parts)) {
	$cid_map = rcmail_write_compose_attachments($MESSAGE, $bodyIsHtml);
	}

	if (!$bodyIsHtml) {
	$body = trim($body, "\r\n");
	}
	else {
	// set is_safe flag (we need this for html body washing)
	rcmail_check_safe($MESSAGE);

	// clean up html tags
	$body = rcmail_wash_html($body, array('safe' => $MESSAGE->is_safe), $cid_map);
	}

	return rcmail_get_forward_header($MESSAGE, $bodyIsHtml) . $body;
	}

	function rcmail_get_forward_header($message, $bodyIsHtml = false, $extended = true)
	{
	global $RCMAIL;

	$date = $RCMAIL->format_date($message->headers->date, $RCMAIL->config->get('date_long'));

	if (!$bodyIsHtml) {
	$prefix = "\n\n\n-------- " . $RCMAIL->gettext('originalmessage') . " --------\n";
	$prefix .= $RCMAIL->gettext('subject') . ': ' . $message->subject . "\n";
	$prefix .= $RCMAIL->gettext('date') . ': ' . $date . "\n";
	$prefix .= $RCMAIL->gettext('from') . ': ' . $message->get_header('from') . "\n";
	$prefix .= $RCMAIL->gettext('to') . ': ' . $message->get_header('to') . "\n";

	if ($extended && ($cc = $message->headers->get('cc'))) {
	$prefix .= $RCMAIL->gettext('cc') . ': ' . $cc . "\n";
	}

	if ($extended && ($replyto = $message->headers->get('reply-to')) && $replyto != $message->get_header('from')) {
	$prefix .= $RCMAIL->gettext('replyto') . ': ' . $replyto . "\n";
	}

	$prefix .= "\n";
	}
	else {
	$prefix = sprintf(
	"<br /><p>-------- " . $RCMAIL->gettext('originalmessage') . " --------</p>" .
	"<table border=\"0\" cellpadding=\"0\" cellspacing=\"0\"><tbody>" .
	"<tr><th align=\"right\" nowrap=\"nowrap\" valign=\"baseline\">%s: </th><td>%s</td></tr>" .
	"<tr><th align=\"right\" nowrap=\"nowrap\" valign=\"baseline\">%s: </th><td>%s</td></tr>" .
	"<tr><th align=\"right\" nowrap=\"nowrap\" valign=\"baseline\">%s: </th><td>%s</td></tr>" .
	"<tr><th align=\"right\" nowrap=\"nowrap\" valign=\"baseline\">%s: </th><td>%s</td></tr>",
	$RCMAIL->gettext('subject'), rcube::Q($message->subject),
	$RCMAIL->gettext('date'), rcube::Q($date),
	$RCMAIL->gettext('from'), rcube::Q($message->get_header('from'), 'replace'),
	$RCMAIL->gettext('to'), rcube::Q($message->get_header('to'), 'replace'));

	if ($extended && ($cc = $message->headers->get('cc'))) {
	$prefix .= sprintf("<tr><th align=\"right\" nowrap=\"nowrap\" valign=\"baseline\">%s: </th><td>%s</td></tr>",
	$RCMAIL->gettext('cc'), rcube::Q($cc, 'replace'));
	}

	if ($extended && ($replyto = $message->headers->get('reply-to')) && $replyto != $message->get_header('from')) {
	$prefix .= sprintf("<tr><th align=\"right\" nowrap=\"nowrap\" valign=\"baseline\">%s: </th><td>%s</td></tr>",
	$RCMAIL->gettext('replyto'), rcube::Q($replyto, 'replace'));
	}

	$prefix .= "</tbody></table><br>";
	}

	return $prefix;
	}

	function rcmail_create_draft_body($body, $bodyIsHtml)
	{
	global $MESSAGE, $COMPOSE;

	// add attachments
	// count($MESSAGE->mime_parts) can be 1 - e.g. attachment, but no text!
	if (empty($COMPOSE['forward_attachments'])
	&& is_array($MESSAGE->mime_parts)
	&& count($MESSAGE->mime_parts) > 0
	) {
	$cid_map = rcmail_write_compose_attachments($MESSAGE, $bodyIsHtml);
	}

	// clean up HTML tags - XSS prevention (#1489251)
	if ($bodyIsHtml) {
	$body = rcmail_wash_html($body, array('safe' => 1), $cid_map);

	// cleanup
	$body = preg_replace(array(
	// remove comments (produced by washtml)
	'/<!--[^>]+-->/',
	// remove <body> tags
	'/<body([^>]*)>/i',
	'/<\/body>/i',
	// convert TinyMCE's empty-line sequence (#1490463)
	'/<p>\xC2\xA0<\/p>/',
	),
	array(
	'',
	'',
	'',
	'<p><br /></p>',
	),
	$body
	);

	// replace cid with href in inline images links
	if (!empty($cid_map)) {
	$body = str_replace(array_keys($cid_map), array_values($cid_map), $body);
	}
	}

	return $body;
	}

	// Removes signature from the message body
	function rcmail_remove_signature($body)
	{
	global $RCMAIL;

	$body = str_replace("\r\n", "\n", $body);
	$len = strlen($body);
	$sig_max_lines = $RCMAIL->config->get('sig_max_lines', 15);

	while (($sp = strrpos($body, "-- \n", $sp ? -$len+$sp-1 : 0)) !== false) {
	if ($sp == 0 \|\| $body[$sp-1] == "\n") {
	// do not touch blocks with more that X lines
	if (substr_count($body, "\n", $sp) < $sig_max_lines) {
	$body = substr($body, 0, max(0, $sp-1));
	}
	break;
	}
	}

	return $body;
	}

	function rcmail_write_compose_attachments(&$message, $bodyIsHtml)
	{
	global $RCMAIL, $COMPOSE;

	$loaded_attachments = array();
	foreach ((array)$COMPOSE['attachments'] as $attachment) {
	$loaded_attachments[$attachment['name'] . $attachment['mimetype']] = $attachment;
	}

	$cid_map = array();
	$messages = array();

	if ($message->pgp_mime) {
	return $cid_map;
	}

	foreach ((array) $message->mime_parts() as $pid => $part) {
	if ($part->mimetype == 'message/rfc822') {
	$messages[] = $part->mime_id;
	}

	if ($part->disposition == 'attachment' \|\| ($part->disposition == 'inline' && $bodyIsHtml) \|\| $part->filename) {
	// skip parts that aren't valid attachments
	if ($part->ctype_primary == 'multipart' \|\| $part->mimetype == 'application/ms-tnef') {
	continue;
	}

	// skip message attachments in reply mode
	if ($part->ctype_primary == 'message' && $COMPOSE['mode'] == rcmail_sendmail::MODE_REPLY) {
	continue;
	}

	// skip inline images when forwarding in text mode
	if ($part->content_id && $part->disposition == 'inline' && !$bodyIsHtml && $COMPOSE['mode'] == rcmail_sendmail::MODE_FORWARD) {
	continue;
	}

	// skip version.txt parts of multipart/encrypted messages
	if ($message->pgp_mime && $part->mimetype == 'application/pgp-encrypted' && $part->filename == 'version.txt') {
	continue;
	}

	// skip attachments included in message/rfc822 attachment (#1486487, #1490607)
	foreach ($messages as $mimeid) {
	if (strpos($part->mime_id, $mimeid . '.') === 0) {
	continue 2;
	}
	}

	if (($attachment = $loaded_attachments[rcmail_attachment_name($part) . $part->mimetype])
	\|\| ($attachment = rcmail_save_attachment($message, $pid, $COMPOSE['id']))
	) {
	if ($bodyIsHtml && ($part->content_id \|\| $part->content_location)) {
	$url = sprintf('%s&_id=%s&_action=display-attachment&_file=rcmfile%s',
	$RCMAIL->comm_path, $COMPOSE['id'], $attachment['id']);

	if ($part->content_id)
	$cid_map['cid:'.$part->content_id] = $url;
	else
	$cid_map[$part->content_location] = $url;
	}
	}
	}
	}

	$COMPOSE['forward_attachments'] = true;

	return $cid_map;
	}

	function rcmail_write_inline_attachments(&$message)
	{
	global $RCMAIL, $COMPOSE;

	$cid_map = array();
	$messages = array();

	if ($message->pgp_mime) {
	return $cid_map;
	}

	foreach ((array) $message->mime_parts() as $pid => $part) {
	if ($part->mimetype == 'message/rfc822') {
	$messages[] = $part->mime_id;
	}

	if (($part->content_id \|\| $part->content_location) && $part->filename) {
	// skip attachments included in message/rfc822 attachment (#1486487, #1490607)
	foreach ($messages as $mimeid) {
	if (strpos($part->mime_id, $mimeid . '.') === 0) {
	continue 2;
	}
	}

	if ($attachment = rcmail_save_attachment($message, $pid, $COMPOSE['id'])) {
	$url = sprintf('%s&_id=%s&_action=display-attachment&_file=rcmfile%s',
	$RCMAIL->comm_path, $COMPOSE['id'], $attachment['id']);

	if ($part->content_id)
	$cid_map['cid:'.$part->content_id] = $url;
	else
	$cid_map[$part->content_location] = $url;
	}
	}
	}

	return $cid_map;
	}

	// Creates attachment(s) from the forwarded message(s)
	function rcmail_write_forward_attachments()
	{
	global $RCMAIL, $COMPOSE, $MESSAGE;

	$storage = $RCMAIL->get_storage();
	$names = array();
	$refs = array();

	if ($MESSAGE->pgp_mime) {
	return;
	}

	$loaded_attachments = array();
	foreach ((array)$COMPOSE['attachments'] as $attachment) {
	$loaded_attachments[$attachment['name'] . $attachment['mimetype']] = $attachment;
	}

	if ($COMPOSE['forward_uid'] == '*') {
	$index = $storage->index(null, rcmail_sort_column(), rcmail_sort_order());
	$COMPOSE['forward_uid'] = $index->get();
	}
	else if (!is_array($COMPOSE['forward_uid']) && strpos($COMPOSE['forward_uid'], ':')) {
	$COMPOSE['forward_uid'] = rcube_imap_generic::uncompressMessageSet($COMPOSE['forward_uid']);
	}
	else if (is_string($COMPOSE['forward_uid'])) {
	$COMPOSE['forward_uid'] = explode(',', $COMPOSE['forward_uid']);
	}

	foreach ((array)$COMPOSE['forward_uid'] as $uid) {
	$message = new rcube_message($uid);

	if (empty($message->headers)) {
	continue;
	}

	if (!empty($message->headers->charset)) {
	$storage->set_charset($message->headers->charset);
	}

	if (empty($MESSAGE->subject)) {
	$MESSAGE->subject = $message->subject;
	}

	// generate (unique) attachment name
	$name = strlen($message->subject) ? mb_substr($message->subject, 0, 64) : 'message_rfc822';
	if (!empty($names[$name])) {
	$names[$name]++;
	$name .= '_' . $names[$name];
	}
	$names[$name] = 1;
	$name .= '.eml';

	if (!empty($loaded_attachments[$name . 'message/rfc822'])) {
	continue;
	}

	rcmail_save_attachment($message, null, $COMPOSE['id'], array('filename' => $name));

	if ($message->headers->messageID) {
	$refs[] = $message->headers->messageID;
	}
	}

	// set In-Reply-To and References headers
	if (count($refs) == 1) {
	$COMPOSE['reply_msgid'] = $refs[0];
	}
	if (!empty($refs)) {
	$COMPOSE['references'] = implode(' ', $refs);
	}
	}

	// Saves an image as attachment
	function rcmail_save_image($path, $mimetype = '', $data = null)
	{
	global $COMPOSE;

	// handle attachments in memory
	if (empty($data)) {
	$data = file_get_contents($path);
	$is_file = true;
	}

	$name = rcmail_basename($path);

	if (empty($mimetype)) {
	if ($is_file) {
	$mimetype = rcube_mime::file_content_type($path, $name);
	}
	else {
	$mimetype = rcube_mime::file_content_type($data, $name, 'application/octet-stream', true);
	}
	}

	$attachment = array(
	'group' => $COMPOSE['id'],
	'name' => $name,
	'mimetype' => $mimetype,
	'data' => $data,
	'size' => strlen($data),
	);

	$attachment = rcmail::get_instance()->plugins->exec_hook('attachment_save', $attachment);

	if ($attachment['status']) {
	unset($attachment['data'], $attachment['status'], $attachment['content_id'], $attachment['abort']);
	return $attachment;
	}

	return false;
	}

	// Unicode-safe basename()
	function rcmail_basename($filename)
	{
	// basename() is not unicode safe and locale dependent
	if (stristr(PHP_OS, 'win') \|\| stristr(PHP_OS, 'netware')) {
	return preg_replace('/^.*[\\\\\\/]/', '', $filename);
	}
	else {
	return preg_replace('/^.*[\/]/', '', $filename);
	}
	}

	/**
	* Attachments list object for templates
	*/
	function rcmail_compose_attachment_list($attrib)
	{
	global $RCMAIL, $OUTPUT, $COMPOSE;

	// add ID if not given
	if (!$attrib['id'])
	$attrib['id'] = 'rcmAttachmentList';

	$out = "\n";
	$jslist = array();
	$button = '';

	if ($attrib['icon_pos'] == 'left')
	$COMPOSE['icon_pos'] = 'left';

	if (is_array($COMPOSE['attachments'])) {
	if ($attrib['deleteicon']) {
	$button = html::img(array(
	'src' => $RCMAIL->output->abs_url($attrib['deleteicon'], true),
	'alt' => $RCMAIL->gettext('delete')
	));
	}
	else if (rcube_utils::get_boolean($attrib['textbuttons'])) {
	$button = rcube::Q($RCMAIL->gettext('delete'));
	}

	foreach ($COMPOSE['attachments'] as $id => $a_prop) {
	if (empty($a_prop)) {
	continue;
	}

	$link_content = sprintf('<span class="attachment-name">%s</span> <span class="attachment-size">(%s)</span>',
	rcube::Q($a_prop['name']), $RCMAIL->show_bytes($a_prop['size']));

	$content_link = html::a(array(
	'href' => "#load",
	'class' => 'filename',
	'onclick' => sprintf("return %s.command('load-attachment','rcmfile%s', this, event)", rcmail_output::JS_OBJECT_NAME, $id),
	), $link_content);

	$delete_link = html::a(array(
	'href' => "#delete",
	'title' => $RCMAIL->gettext('delete'),
	'onclick' => sprintf("return %s.command('remove-attachment','rcmfile%s', this, event)", rcmail_output::JS_OBJECT_NAME, $id),
	'class' => 'delete',
	'tabindex' => $attrib['tabindex'] ?: '0',
	'aria-label' => $RCMAIL->gettext('delete') . ' ' . $a_prop['name'],
	), $button);

	$out .= html::tag('li', array(
	'id' => 'rcmfile'.$id,
	'class' => rcube_utils::file2class($a_prop['mimetype'], $a_prop['name']),
	'onmouseover' => "rcube_webmail.long_subject_title_ex(this, 0)",
	),
	$COMPOSE['icon_pos'] == 'left' ? $delete_link.$content_link : $content_link.$delete_link
	);

	$jslist['rcmfile'.$id] = array(
	'name' => $a_prop['name'],
	'complete' => true,
	'mimetype' => $a_prop['mimetype']
	);
	}
	}

	if ($attrib['deleteicon'])
	$COMPOSE['deleteicon'] = $RCMAIL->output->abs_url($attrib['deleteicon'], true);
	else if (rcube_utils::get_boolean($attrib['textbuttons']))
	$COMPOSE['textbuttons'] = true;
	if ($attrib['cancelicon'])
	$OUTPUT->set_env('cancelicon', $RCMAIL->output->abs_url($attrib['cancelicon'], true));
	if ($attrib['loadingicon'])
	$OUTPUT->set_env('loadingicon', $RCMAIL->output->abs_url($attrib['loadingicon'], true));

	$OUTPUT->set_env('attachments', $jslist);
	$OUTPUT->add_gui_object('attachmentlist', $attrib['id']);

	// put tabindex value into data-tabindex attribute
	if (isset($attrib['tabindex'])) {
	$attrib['data-tabindex'] = $attrib['tabindex'];
	unset($attrib['tabindex']);
	}

	return html::tag('ul', $attrib, $out, html::$common_attrib);
	}

	/**
	* Attachment upload form object for templates
	*/
	function rcmail_compose_attachment_form($attrib)
	{
	global $RCMAIL;

	return $RCMAIL->upload_form($attrib, 'uploadform', 'send-attachment', array('multiple' => true));
	}

	/**
	* Register a certain container as active area to drop files onto
	*/
	function rcmail_compose_file_drop_area($attrib)
	{
	global $OUTPUT;

	if ($attrib['id']) {
	$OUTPUT->add_gui_object('filedrop', $attrib['id']);
	$OUTPUT->set_env('filedrop', array('action' => 'upload', 'fieldname' => '_attachments'));
	}
	}

	/**
	* Editor mode selector object for templates
	*/
	function rcmail_editor_selector($attrib)
	{
	global $RCMAIL;

	// determine whether HTML or plain text should be checked
	$useHtml = rcmail_compose_editor_mode();

	if (empty($attrib['editorid']))
	$attrib['editorid'] = 'rcmComposeBody';

	if (empty($attrib['name']))
	$attrib['name'] = 'editorSelect';

	$attrib['onchange'] = "return rcmail.command('toggle-editor', {id: '".$attrib['editorid']."', html: this.value == 'html'}, '', event)";

	$select = new html_select($attrib);

	$select->add(rcube::Q($RCMAIL->gettext('htmltoggle')), 'html');
	$select->add(rcube::Q($RCMAIL->gettext('plaintoggle')), 'plain');

	return $select->show($useHtml ? 'html' : 'plain');
	}

	/**
	* Addressbooks list object for templates
	*/
	function rcmail_addressbook_list($attrib = array())
	{
	global $RCMAIL, $OUTPUT;

	$attrib += array('id' => 'rcmdirectorylist');

	$out = '';
	$line_templ = html::tag('li', array(
	'id' => 'rcmli%s', 'class' => '%s'),
	html::a(array('href' => '#list',
	'rel' => '%s',
	'onclick' => "return ".rcmail_output::JS_OBJECT_NAME.".command('list-addresses','%s',this)"), '%s'));

	foreach ($RCMAIL->get_address_sources(false, true) as $j => $source) {
	$id = strval(strlen($source['id']) ? $source['id'] : $j);
	$js_id = rcube::JQ($id);

	// set class name(s)
	$class_name = 'addressbook';
	if ($source['class_name'])
	$class_name .= ' ' . $source['class_name'];

	$out .= sprintf($line_templ,
	rcube_utils::html_identifier($id,true),
	$class_name,
	$source['id'],
	$js_id, ($source['name'] ?: $id));
	}

	$OUTPUT->add_gui_object('addressbookslist', $attrib['id']);

	return html::tag('ul', $attrib, $out, html::$common_attrib);
	}

	/**
	* Contacts list object for templates
	*/
	function rcmail_contacts_list($attrib = array())
	{
	global $RCMAIL, $OUTPUT;

	$attrib += array('id' => 'rcmAddressList');

	// set client env
	$OUTPUT->add_gui_object('contactslist', $attrib['id']);
	$OUTPUT->set_env('pagecount', 0);
	$OUTPUT->set_env('current_page', 0);
	$OUTPUT->include_script('list.js');

	return $RCMAIL->table_output($attrib, array(), array('name'), 'ID');
	}

	/**
	* Responses list object for templates
	*/
	function rcmail_compose_responses_list($attrib)
	{
	global $RCMAIL, $OUTPUT;

	$attrib += array('id' => 'rcmresponseslist', 'tagname' => 'ul', 'cols' => 1);

	$jsenv = array();
	$list = new html_table($attrib);
	foreach ($RCMAIL->get_compose_responses(true) as $response) {
	$key = $response['key'];
	$item = html::a(array(
	'href' => '#' . urlencode($response['name']),
	'class' => rtrim('insertresponse ' . $attrib['itemclass']),
	'unselectable' => 'on',
	'tabindex' => '0',
	'rel' => $key,
	), rcube::Q($response['name']));

	$jsenv[$key] = $response;
	$list->add(array(), $item);
	}

	// set client env
	$OUTPUT->set_env('textresponses', $jsenv);
	$OUTPUT->add_gui_object('responseslist', $attrib['id']);

	return $list->show();
	}
	diff --git a/program/steps/settings/edit_identity.inc b/program/steps/settings/edit_identity.inc
	index ee22b75f2..71b7c491b 100644
	--- a/program/steps/settings/edit_identity.inc
	+++ b/program/steps/settings/edit_identity.inc
	@@ -1,199 +1,199 @@
	<?php

	/**
	+-----------------------------------------------------------------------+
	\| program/steps/settings/edit_identity.inc \|
	\| \|
	\| This file is part of the Roundcube Webmail client \|
	\| Copyright (C) 2005-2013, 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: \|
	\| Show edit form for a identity record or to add a new one \|
	\| \|
	+-----------------------------------------------------------------------+
	\| Author: Thomas Bruederli <roundcube@gmail.com> \|
	+-----------------------------------------------------------------------+
	*/

	define('IDENTITIES_LEVEL', intval($RCMAIL->config->get('identities_level', 0)));

	// edit-identity
	if (($_GET['_iid'] \|\| $_POST['_iid']) && $RCMAIL->action=='edit-identity') {
	$id = rcube_utils::get_input_value('_iid', rcube_utils::INPUT_GPC);
	$IDENTITY_RECORD = $RCMAIL->user->get_identity($id);

	if (is_array($IDENTITY_RECORD)) {
	$OUTPUT->set_env('iid', $IDENTITY_RECORD['identity_id']);
	}
	else {
	$OUTPUT->show_message('dberror', 'error');
	// go to identities page
	$RCMAIL->overwrite_action('identities');
	return;
	}
	}
	// add-identity
	else {
	if (IDENTITIES_LEVEL > 1) {
	$OUTPUT->show_message('opnotpermitted', 'error');
	// go to identities page
	$RCMAIL->overwrite_action('identities');
	return;
	}
	else if (IDENTITIES_LEVEL == 1) {
	$IDENTITY_RECORD['email'] = $RCMAIL->get_user_email();
	}
	}

	$OUTPUT->include_script('list.js');
	$OUTPUT->add_handler('identityform', 'rcube_identity_form');
	$OUTPUT->set_env('identities_level', IDENTITIES_LEVEL);
	-$OUTPUT->add_label('deleteidentityconfirm', 'uploading', 'generate',
	+$OUTPUT->add_label('deleteidentityconfirm', 'generate',
	'encryptioncreatekey', 'openmailvelopesettings', 'encryptionprivkeysinmailvelope',
	'encryptionnoprivkeysinmailvelope', 'keypaircreatesuccess');

	$OUTPUT->set_pagetitle($RCMAIL->gettext(($RCMAIL->action == 'add-identity' ? 'addidentity' : 'editidentity')));

	if ($RCMAIL->action == 'add-identity' && $OUTPUT->template_exists('identityadd')) {
	$OUTPUT->send('identityadd');
	}

	$OUTPUT->send('identityedit');


	function rcube_identity_form($attrib)
	{
	global $IDENTITY_RECORD, $RCMAIL, $OUTPUT;

	// Add HTML editor script(s)
	$RCMAIL->html_editor('identity');

	// add some labels to client
	$OUTPUT->add_label('noemailwarning', 'converting', 'editorwarning');

	$i_size = $attrib['size'] ?: 40;
	$t_rows = $attrib['textarearows'] ?: 6;
	$t_cols = $attrib['textareacols'] ?: 40;

	// list of available cols
	$form = array(
	'addressing' => array(
	'name' => $RCMAIL->gettext('settings'),
	'content' => array(
	'name' => array('type' => 'text', 'size' => $i_size),
	'email' => array('type' => 'text', 'size' => $i_size),
	'organization' => array('type' => 'text', 'size' => $i_size),
	'reply-to' => array('type' => 'text', 'size' => $i_size),
	'bcc' => array('type' => 'text', 'size' => $i_size),
	'standard' => array('type' => 'checkbox', 'label' => $RCMAIL->gettext('setdefault')),
	)),
	'signature' => array(
	'name' => $RCMAIL->gettext('signature'),
	'content' => array(
	'signature' => array('type' => 'textarea', 'size' => $t_cols, 'rows' => $t_rows,
	'spellcheck' => true, 'data-html-editor' => true),
	'html_signature' => array('type' => 'checkbox',
	'label' => $RCMAIL->gettext('htmlsignature'),
	'onclick' => 'return rcmail.command(\'toggle-editor\', {id: \'rcmfd_signature\', html: this.checked}, \'\', event)'),
	)),
	'encryption' => array(
	'name' => $RCMAIL->gettext('identityencryption'),
	'attrs' => array('class' => 'identity-encryption', 'style' => 'display:none'),
	'content' => html::div('identity-encryption-block', '')
	)
	);

	// Enable TinyMCE editor
	if ($IDENTITY_RECORD['html_signature']) {
	$form['signature']['content']['signature']['class'] = 'mce_editor';
	$form['signature']['content']['signature']['is_escaped'] = true;

	// Correctly handle HTML entities in HTML editor (#1488483)
	$IDENTITY_RECORD['signature'] = htmlspecialchars($IDENTITY_RECORD['signature'], ENT_NOQUOTES, RCUBE_CHARSET);
	}

	// hide "default" checkbox if only one identity is allowed
	if (IDENTITIES_LEVEL > 1) {
	unset($form['addressing']['content']['standard']);
	}

	// disable some field according to access level
	if (IDENTITIES_LEVEL == 1 \|\| IDENTITIES_LEVEL == 3) {
	$form['addressing']['content']['email']['disabled'] = true;
	$form['addressing']['content']['email']['class'] = 'disabled';
	}

	if (IDENTITIES_LEVEL == 4) {
	foreach ($form['addressing']['content'] as $formfield => $value){
	$form['addressing']['content'][$formfield]['disabled'] = true;
	$form['addressing']['content'][$formfield]['class'] = 'disabled';
	}
	}

	$IDENTITY_RECORD['email'] = rcube_utils::idn_to_utf8($IDENTITY_RECORD['email']);

	// Allow plugins to modify identity form content
	$plugin = $RCMAIL->plugins->exec_hook('identity_form', array(
	'form' => $form, 'record' => $IDENTITY_RECORD));

	$form = $plugin['form'];
	$IDENTITY_RECORD = $plugin['record'];

	// Set form tags and hidden fields
	list($form_start, $form_end) = get_form_tags($attrib, 'save-identity',
	intval($IDENTITY_RECORD['identity_id']),
	array('name' => '_iid', 'value' => $IDENTITY_RECORD['identity_id']));

	unset($plugin);
	unset($attrib['form'], $attrib['id']);

	// return the complete edit form as table
	$out = "$form_start\n";

	foreach ($form as $fieldset) {
	if (empty($fieldset['content'])) {
	continue;
	}

	$content = '';
	if (is_array($fieldset['content'])) {
	$table = new html_table(array('cols' => 2));

	foreach ($fieldset['content'] as $col => $colprop) {
	$colprop['id'] = 'rcmfd_'.$col;

	$label = $colprop['label'] ?: $RCMAIL->gettext(str_replace('-', '', $col));
	$value = $colprop['value'] ?: rcube_output::get_edit_field($col, $IDENTITY_RECORD[$col], $colprop, $colprop['type']);

	$table->add('title', html::label($colprop['id'], rcube::Q($label)));
	$table->add(null, $value);
	}

	$content = $table->show($attrib);
	}
	else {
	$content = $fieldset['content'];
	}

	$content = html::tag('legend', null, rcube::Q($fieldset['name'])) . $content;
	$out .= html::tag('fieldset', $fieldset['attrs'], $content) . "\n";
	}

	$out .= $form_end;

	// add image upload form
	$max_filesize = $RCMAIL->upload_init($RCMAIL->config->get('identity_image_size', 64) * 1024);
	$upload_form_id = 'identityImageUpload';

	$out .= '<form id="' . $upload_form_id . '" style="display: none">'
	. html::div('hint', $RCMAIL->gettext(array('name' => 'maxuploadsize', 'vars' => array('size' => $max_filesize))))
	. '</form>';

	$RCMAIL->output->add_gui_object('uploadform', $upload_form_id);

	return $out;
	}

File Metadata

Mime Type: text/x-diff
Expires: Thu, Mar 19, 10:55 PM (1 d, 20 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 458810
Default Alt Text: (147 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions